Type.Prelude

data True :: Boolean

The 'True' boolean type.

data False :: Boolean

The 'False' boolean type.

data BProxy :: Boolean -> Typedata BProxy bool

Value proxy for Boolean types Deprecated: Use Type.Proxy instead

Constructors

• BProxy

class IsBoolean :: Boolean -> Constraintclass IsBoolean bool  where

Class for reflecting a type level Boolean at the value level

Members

• reflectBoolean :: forall proxy. proxy bool -> Boolean

Instances

• IsBoolean True
• IsBoolean False

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

Use a value level Boolean as a type-level Boolean

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

data OProxy :: Ordering -> Typedata OProxy ordering

Value proxy for Ordering types Deprecated: Use Type.Proxy instead

Constructors

• OProxy

data LT :: Ordering

The 'less than' ordering type.

data GT :: Ordering

The 'greater than' ordering type.

data EQ :: Ordering

The 'equal to' ordering type.

class IsOrdering :: Ordering -> Constraintclass IsOrdering ordering  where

Class for reflecting a type level Ordering at the value level

Members

• reflectOrdering :: forall proxy. proxy ordering -> Ordering

Instances

• IsOrdering LT
• IsOrdering EQ
• IsOrdering GT

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

Use a value level Ordering as a type-level Ordering

data SProxy :: Symbol -> Typedata SProxy sym

A value-level proxy for a type-level symbol. Deprecated as of v0.14.0 PureScript release: use Type.Proxy instead.

Constructors

• SProxy

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.

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

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

class IsSymbol :: Symbol -> Constraintclass IsSymbol (sym :: Symbol)  where

A class for known symbols

Members

• reflectSymbol :: forall proxy. proxy sym -> String

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

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

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

class TypeEquals :: forall k. k -> k -> Constraintclass (Coercible a b) <= TypeEquals a b | a -> b, b -> a

This type class asserts that types a and b are equal.

The functional dependencies and the single instance below will force the two type arguments to unify when either one is known.

Note: any instance will necessarily overlap with refl below, so instances of this class should not be defined in libraries.

Instances

• TypeEquals a a

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

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

data Proxy :: forall k. k -> Typedata Proxy a

Proxy type for all kinds.

Constructors

• Proxy

data RProxy :: Row Type -> Typedata RProxy row

A proxy data type whose type parameter is a type of kind Row Type (a row of types).

Deprecated as of v0.14.0 PureScript release: use Type.Proxy instead.

Commonly used for specialising a function with a quantified type. For example, suppose we have an identity function for records of type:

recordIdentity :: forall row . RProxy row -> Record row -> Record row
recordIdentity _ rec = rec

Then applying this function to an RProxy with a specialised type allows us to specify a concrete type for row:

:t recordIdentity (Proxy :: Proxy ( x :: Int, y :: Int ))
{ x :: Int, y :: Int } -> { x :: Int, y :: Int }

Here row has been specialised to ( x :: Int, y :: Int ).

Constructors

• RProxy

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

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

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.

data RLProxy :: RowList Type -> Typedata RLProxy rowlist

A proxy to carry information about a rowlist. Deprecated as of v0.14.0 PureScript release: use Type.Proxy instead.

Constructors

• RLProxy

class ListToRow :: forall k. RowList k -> Row k -> Constraintclass ListToRow list row | list -> row

Convert a RowList to a row of types. The inverse of this operation is RowToList.

Instances

• ListToRow Nil ()
• (ListToRow tail tailRow, Cons label ty tailRow row) => ListToRow (Cons label ty tail) row

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.