A label

This class gives the string associated with a type-level symbol. There are instances of the class for every concrete literal: "hello", etc.

Since: base-4.7.0.0

Are all of the labels in this Row unique?

A convenient way to provide common, easy constraints

A record with row r.

The kind of rows. This type is only used as a datakind. A row is a typelevel entity telling us which symbols are associated with which types.

Type level version of empty

A lower fixity operator for type equality

The empty record

A type level way to create a singleton Row.

The singleton record

A pattern for the singleton record; can be used to both destruct a record when in a pattern position or construct one in an expression position.

Turns a singleton record into a pair of the label and value.

Initialize a record with a default value at each label.

Initialize a record with a default value at each label; works over an Applicative.

Initialize a record, where each value is determined by the given function over the label at that value.

Initialize a record, where each value is determined by the given function over the label at that value. This function works over an Applicative.

Initialize a record over a Map.

Record extension. The row may already contain the label, in which case the origin value can be obtained after restriction (.-) with the label.

Type level Row extension

Alias for .\. It is a class rather than an alias, so that it can be partially applied.

Does the row lack (i.e. it does not have) the specified label?

Type level Row element removal

Record restriction. Remove the label l from the record.

Removes a label from the record but does not remove the underlying value.

This is faster than regular record removal (.-), but it has two downsides:

1. It may incur a performance penalty during a future merge operation (.+), and
2. It will keep the reference to the value alive, meaning that it will not get garbage collected.

Thus, it's great when one knows ahead of time that no future merges will happen and that the whole record will be GC'd soon, for instance, during the catamorphism function of metamorph.

Arbitrary record restriction. Turn a record into a subset of itself.

Split a record into two sub-records.

Update the value associated with the label.

Focus on the value associated with the label.

Focus on a sub-record

Type level Row modification

Rename a label.

Type level row renaming

Alias for (r .! l) ≈ a. It is a class rather than an alias, so that it can be partially applied.

Type level label fetching

Record selection

Type level Row append

Record disjoint union (commutative)

A type synonym for disjointness.

A pattern version of record union, for use in pattern matching.

The overwriting union, where the left row overwrites the types of the right row where the labels overlap.

Record overwrite.

The operation r .// r' creates a new record such that:

• Any label that is in both r and r' is in the resulting record with the type and value given by the fields in r,
• Any label that is only found in r is in the resulting record.
• Any label that is only found in r' is in the resulting record.

This can be thought of as r "overwriting" r'.

Kind of like curry for functions over records.

This function allows one to do partial application on a function of a record. Note that this also means that arguments can be supplied in arbitrary order. For instance, if one had a function like

xtheny r = (r .! #x) <> (r .! #y)

and a record like

greeting = #x .== "hello " .+ #y .== "world!"

Then all of the following would be possible:

>>> xtheny greeting
"hello world!"

>>> xtheny .$ (#x, greeting) .$ (#y, greeting) $ empty
"hello world!"

>>> xtheny .$ (#y, greeting) .$ (#x, greeting) $ empty
"hello world!"

>>> xtheny .$ (#y, greeting) .$ (#x, #x .== "Goodbye ") $ empty
"Goodbye world!"

Convert a Haskell record to a row-types Rec.

Convert a record to an exactly matching native Haskell type.

Convert a record to a native Haskell type.

Converts a Rec into a HashMap of Dynamics.

Produces a Rec from a HashMap of Dynamics.

Map a type level function over a Row.

A function to map over a record given a constraint.

A function to map over a record given no constraint.

A function to map over a Ap record given constraints.

Lifts a natural transformation over a record. In other words, it acts as a record transformer to convert a record of f a values to a record of g a values. If no constraint is needed, instantiate the first type argument with Unconstrained1 or use transform'.

A version of transform for when there is no constraint.

Zip together two records that are the same up to the type being mapped over them, combining their constituent fields with the given function.

A version of zipTransform for when there is no constraint.

Any structure over two rows in which the elements of each row satisfy some constraints can be metamorphized into another structure over both of the rows.

Any structure over a row in which every element is similarly constrained can be metamorphized into another structure over the same row.

A standard fold

A fold with labels

A fold over two row type structures at once

Turns a record into a HashMap from values representing the labels to the values of the record.

Zips two rows together to create a Row of the pairs. The two rows must have the same set of labels.

Zips together two records that have the same set of labels.

Traverse a function over a record. Note that the fields of the record will be accessed in lexicographic order by the labels.

Traverse a function over a Mapped record. Note that the fields of the record will be accessed in lexicographic order by the labels.

Applicative sequencing over a record.

A version of sequence in which the constraint for Forall can be chosen.

This function acts as the inversion of sequence, allowing one to move a functor level into a record.

Convert from a record where two functors have been mapped over the types to one where the composition of the two functors is mapped over the types.

Convert from a record where the composition of two functors have been mapped over the types to one where the two functors are mapped individually one at a time over the types.

A version of compose in which the constraint for Forall can be chosen.

A version of uncompose in which the constraint for Forall can be chosen.

Return a list of the labels in a row type.

Return a list of the labels in a row type and is specialized to the Unconstrained1 constraint.

Coerce a record to a coercible representation. The BiForall in the context indicates that the type of every field in r1 can be coerced to the type of the corresponding fields in r2.

Internally, this is implemented just with unsafeCoerce, but we provide the following implementation as a proof:

newtype ConstR a b = ConstR (Rec a)
newtype FlipConstR a b = FlipConstR { unFlipConstR :: Rec b }
coerceRec :: forall r1 r2. BiForall r1 r2 Coercible => Rec r1 -> Rec r2
coerceRec = unFlipConstR . biMetamorph @_ @_ @r1 @r2 @Coercible @(,) @ConstR @FlipConstR @Const Proxy doNil doUncons doCons . ConstR
  where
    doNil _ = FlipConstR empty
    doUncons l (ConstR r) = bimap ConstR Const $ lazyUncons l r
    doCons :: forall ℓ τ1 τ2 ρ1 ρ2. (KnownSymbol ℓ, Coercible τ1 τ2)
           => Label ℓ -> (FlipConstR ρ1 ρ2, Const τ1 τ2) -> FlipConstR (Extend ℓ τ1 ρ1) (Extend ℓ τ2 ρ2)
    doCons l (FlipConstR r, Const v) = FlipConstR $ extend l (coerce @τ1 @τ2 v) r