Module

Type.Data.Symbol

#append 

append :: forall proxy l r o. Append l r o => proxy l -> proxy r -> Proxy o

#compare 

compare :: forall proxy l r o. Compare l r o => proxy l -> proxy r -> Proxy o

#uncons 

uncons :: forall proxy h t s. Cons h t s => proxy s -> { head :: Proxy h, tail :: Proxy t }

#Equals 

class Equals lhs rhs out | lhs rhs -> out

Instances

#equals 

equals :: forall proxy l r o. Equals l r o => proxy l -> proxy r -> Proxy o

Re-exports from Data.Symbol

#SProxy 

data SProxy sym

Constructors

#IsSymbol 

class IsSymbol (sym :: Symbol)  where

A class for known symbols

Members

#reifySymbol 

reifySymbol :: forall proxy r. String -> (forall sym. IsSymbol sym => proxy sym -> r) -> r

Re-exports from Prim.Symbol

#Append 

class Append (left :: Symbol) (right :: Symbol) (appended :: Symbol) | left right -> appended, right appended -> left, appended left -> right

Compiler solved type class for appending Symbols together.

#Compare 

class Compare (left :: Symbol) (right :: Symbol) (ordering :: Ordering) | left right -> ordering

Compiler solved type class for comparing two Symbols. Produces an Ordering.

#Cons 

class Cons (head :: Symbol) (tail :: Symbol) (symbol :: Symbol) | head tail -> symbol, symbol -> head tail

Compiler solved type class for either splitting up a symbol into its head and tail or for combining a head and tail into a new symbol. Requires the head to be a single character and the combined string cannot be empty.

Modules