Record

get :: forall proxy r r' l a. IsSymbol l => Cons l a r' r => proxy l -> Record r -> a

Get a property for a label which is specified using a value-level proxy for a type-level string.

For example:

get (Proxy :: Proxy "x") :: forall r a. { x :: a | r } -> a

set :: forall proxy r1 r2 r l a b. IsSymbol l => Cons l a r r1 => Cons l b r r2 => proxy l -> b -> Record r1 -> Record r2

Set a property for a label which is specified using a value-level proxy for a type-level string.

For example:

set (Proxy :: Proxy "x")
  :: forall r a b. a -> { x :: b | r } -> { x :: a | r }

modify :: forall proxy r1 r2 r l a b. IsSymbol l => Cons l a r r1 => Cons l b r r2 => proxy l -> (a -> b) -> Record r1 -> Record r2

Modify a property for a label which is specified using a value-level proxy for a type-level string.

For example:

modify (Proxy :: Proxy "x")
  :: forall r a b. (a -> b) -> { x :: a | r } -> { x :: b | r }

insert :: forall proxy r1 r2 l a. IsSymbol l => Lacks l r1 => Cons l a r1 r2 => proxy l -> a -> Record r1 -> Record r2

Insert a new property for a label which is specified using a value-level proxy for a type-level string.

For example:

insert (Proxy :: Proxy "x")
  :: forall r a. Lacks "x" r => a -> { | r } -> { x :: a | r }

delete :: forall proxy r1 r2 l a. IsSymbol l => Lacks l r1 => Cons l a r1 r2 => proxy l -> Record r2 -> Record r1

Delete a property for a label which is specified using a value-level proxy for a type-level string.

Note that the type of the resulting row must lack the specified property. Since duplicate labels are allowed, this is checked with a type class constraint.

For example:

delete (Proxy :: Proxy "x")
  :: forall r a. Lacks "x" r => { x :: a | r } -> { | r }

rename :: forall proxy prev next ty input inter output. IsSymbol prev => IsSymbol next => Cons prev ty inter input => Lacks prev inter => Cons next ty inter output => Lacks next inter => proxy prev -> proxy next -> Record input -> Record output

Rename a property for a label which is specified using a value-level proxy for a type-level string.

Note that the type of the resulting row must lack the specified property. Since duplicate labels are allowed, this is checked with a type class constraint.

For example:

rename (Proxy :: Proxy "x") (Proxy :: Proxy "y")
  :: forall a r. Lacks "x" r => Lacks "y" r => { x :: a | r} -> { y :: a | r}

equal :: forall r rs. RowToList r rs => EqualFields rs r => Record r -> Record r -> Boolean

Check two records of the same type for equality.

merge :: forall r1 r2 r3 r4. Union r1 r2 r3 => Nub r3 r4 => Record r1 -> Record r2 -> Record r4

Merges two records with the first record's labels taking precedence in the case of overlaps.

For example:

merge { x: 1, y: "y" } { y: 2, z: true }
 :: { x :: Int, y :: String, z :: Boolean }

union :: forall r1 r2 r3. Union r1 r2 r3 => Record r1 -> Record r2 -> Record r3

Merges two records with the first record's labels taking precedence in the case of overlaps. Unlike merge, this does not remove duplicate labels from the resulting record type. This can result in better inference for some pipelines, deferring the need for a Nub constraint.

For example:

union { x: 1, y: "y" } { y: 2, z: true }
 :: { x :: Int, y :: String, y :: Int, z :: Boolean }

disjointUnion :: forall r1 r2 r3. Union r1 r2 r3 => Nub r3 r3 => Record r1 -> Record r2 -> Record r3

Merges two records where no labels overlap. This restriction exhibits better inference than merge when the resulting record type is known, but one argument is not.

For example, hole ?help is inferred to have type { b :: Int } here:

disjointUnion { a: 5 } ?help :: { a :: Int, b :: Int }

nub :: forall r1 r2. Nub r1 r2 => Record r1 -> Record r2

A coercion which removes duplicate labels from a record's type.

class EqualFields :: RowList Type -> Row Type -> Constraintclass EqualFields (rs :: RowList Type) (row :: Row Type) | rs -> row where

Members

• equalFields :: forall rlproxy. rlproxy rs -> Record row -> Record row -> Boolean

Instances

• (IsSymbol name, Eq ty, Cons name ty tailRow row, EqualFields tail row) => EqualFields (Cons name ty tail) row
• EqualFields Nil row