Module

# Type.Prelude

- Package
- purescript-typelevel-prelude
- Repository
- purescript/purescript-typelevel-prelude

## Re-exports from **Type.**Data.Boolean

### #reifyBoolean Source

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

Use a value level `Boolean`

as a type-level `Boolean`

## Re-exports from **Type.**Data.Ordering

### #Ordering

### #IsOrdering Source

`class IsOrdering :: Ordering -> Constraint`

`class IsOrdering ordering where`

Class for reflecting a type level `Ordering`

at the value level

#### Members

`reflectOrdering :: Proxy ordering -> Ordering`

#### Instances

### #reifyOrdering Source

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

Use a value level `Ordering`

as a type-level `Ordering`

## Re-exports from **Type.**Data.Symbol

### #Append

### #Compare

### #IsSymbol Source

`class IsSymbol :: Symbol -> Constraint`

`class IsSymbol (sym :: Symbol) where`

A class for known symbols

#### Members

`reflectSymbol :: Proxy sym -> String`

### #reifySymbol Source

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

## Re-exports from **Type.**Equality

### #TypeEquals Source

`class TypeEquals :: forall k. k -> k -> Constraint`

`class (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 Source

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

### #from Source

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