type RowApply :: forall k. (Row k -> Row k) -> Row k -> Row ktype RowApply f a = f a

Type application for rows.

#type (+)

Operator alias for Type.Row.RowApply (right-associative / precedence 0)

Applies a type alias of open rows to a set of rows. The primary use case this operator is as convenient sugar for combining open rows without parentheses.

type Rows1 r = (a :: Int, b :: String | r)
type Rows2 r = (c :: Boolean | r)
type Rows3 r = (Rows1 + Rows2 + r)
type Rows4 r = (d :: String | Rows1 + Rows2 + r)

Re-exports from Prim.Row


class Cons (label :: Symbol) (a :: k) (tail :: Row k) (row :: Row k) | label a tail -> row, label row -> a tail

The Cons type class is a 4-way relation which asserts that one row of types can be obtained from another by inserting a new label/type pair on the left.


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

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


class Nub (original :: Row k) (nubbed :: Row k) | original -> nubbed

The Nub type class is used to remove duplicate labels from rows.


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.Data.Row


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