Module

Type.Prelude

Re-exports from Type.Data.Boolean

#True 

data True :: Boolean

The 'True' boolean type.

#False 

data False :: Boolean

The 'False' boolean type.

#BProxy 

data BProxy bool

Constructors

#IsBoolean 

class IsBoolean bool  where

Members

Instances

#reifyBoolean 

reifyBoolean :: forall r. Boolean -> (forall proxy o. IsBoolean o => proxy o -> r) -> r

Use a value level Boolean as a type-level Boolean

Re-exports from Type.Data.Ordering

#Ordering 

data Ordering :: Type

The Ordering kind represents the three possibilities of comparing two types of the same kind: LT (less than), EQ (equal to), and GT (greater than).

#OProxy 

data OProxy ordering

Constructors

#LT 

data LT :: Ordering

The 'less than' ordering type.

#GT 

data GT :: Ordering

The 'greater than' ordering type.

#EQ 

data EQ :: Ordering

The 'equal to' ordering type.

#IsOrdering 

class IsOrdering ordering  where

Members

Instances

#reifyOrdering 

reifyOrdering :: forall r. Ordering -> (forall proxy o. IsOrdering o => proxy o -> r) -> r

Use a value level Ordering as a type-level Ordering

Re-exports from Type.Data.Symbol

#SProxy 

data SProxy sym

Constructors

#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.

#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

#compare 

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

#append 

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

Re-exports from Type.Equality

#TypeEquals 

class (Coercible a b) <= TypeEquals a b | a -> b, b -> a

Instances

#to 

to :: forall a b. TypeEquals a b => a -> b

#from 

from :: forall a b. TypeEquals a b => b -> a

Re-exports from Type.Proxy

#Proxy 

data Proxy a

Constructors

Re-exports from Type.Row

#RProxy 

data RProxy row

Constructors

#Lacks 

class Lacks (label :: Symbol) (row :: Row k)

The Lacks type class asserts that a label does not occur in a given row.

#Union 

class Union (left :: Row k) (right :: Row k) (union :: Row k) | left right -> union, right union -> left, union left -> right

The Union type class is used to compute the union of two rows of types (left-biased, including duplicates).

The third type argument represents the union of the first two.

Re-exports from Type.RowList

#RLProxy 

data RLProxy rowlist

Constructors

#ListToRow 

class ListToRow list row | list -> row

Instances

#RowToList 

class RowToList (row :: Row k) (list :: RowList k) | row -> list

Compiler solved type class for generating a RowList from a closed row of types. Entries are sorted by label and duplicates are preserved in the order they appeared in the row.

Modules