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

The variant type.

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

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

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

A quick constructor to create a singleton variant.

A quick destructor for singleton variants.

Initialize a variant from a producer function that accepts labels. If this function returns more than one possibility, then one is chosen arbitrarily to be the value in the variant.

Initialize a variant over a Map.

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

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

The minimum join of the two rows.

Make the variant arbitrarily more diverse.

A weaker version of diversify, but it's helpful for metamorph as it explicitly uses Extend.

Type level Row append

If the variant exists at the given label, update it to the given value. Otherwise, do nothing.

If the variant exists at the given label, focus on the value associated with it. Otherwise, do nothing.

Type level Row modification

Rename the given label.

Type level row renaming

A Variant with no options is uninhabited.

Convert a variant into either the value at the given label or a variant without that label. This is the basic variant destructor.

A version of trial that ignores the leftover variant.

A trial over multiple types

A convenient function for using view patterns when dispatching variants. For example:

 myShow :: Var ("y" '::= String :| "x" '::= Int :| Empty) -> String
 myShow (view x -> Just n) = "Int of "++show n
 myShow (view y -> Just s) = "String of "++s

Is the first row a subset of the second? Or, does the second row contain every binding that the first one does?

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

Split a variant into two sub-variants.

Type level label fetching

Type level Row element removal

Type level Row difference. That is, l .\\ r is the row remaining after removing any matching elements of r from l.

A type level way to create a singleton Row.

Convert a variant to a native Haskell type.

Convert a Haskell variant to a row-types Var.

Convert a Haskell variant to a row-types Var.

Map a type level function over a Row.

A function to map over a variant given a constraint.

A function to map over a variant given no constraint.

Lifts a natrual transformation over a variant. In other words, it acts as a variant transformer to convert a variant of f a values to a variant of g a values. If no constraint is needed, instantiate the first type argument with Unconstrained1.

A form of transformC that doesn't have a constraint on a

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 variants at once. A call eraseZipGeneral f x y will return f (Left (show l, a, b)) when x and y both have values at the same label l and will return f (Right ((show l1, a), (show l2, b))) when they have values at different labels l1 and l2 respectively.

A simpler fold over two variants at once

Traverse a function over a variant.

Traverse a function over a Mapped variant.

Applicative sequencing over a variant

Convert from a variant 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 variant 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.

Return a list of the labels in a row type.

A version of erase that works even when the row-type of the variant argument is of the form ApSingle fs x.

Performs a functorial-like map over an ApSingle variant. In other words, it acts as a variant transformer to convert a variant of f x values to a variant of f y values. If no constraint is needed, instantiate the first type argument with Unconstrained1.

Like mapSingle, but works over a functor.

A version of eraseZip that works even when the row-types of the variant arguments are of the form ApSingle fs x.

Coerce a variant to a coercible representation. The BiForall in the context indicates that the type of any option in r1 can be coerced to the type of the corresponding option in r2.

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

newtype ConstV a b = ConstV { unConstV :: Var a }
newtype ConstV a b = FlipConstV { unFlipConstV :: Var b }
coerceVar :: forall r1 r2. BiForall r1 r2 Coercible => Var r1 -> Var r2
coerceVar = unFlipConstV . biMetamorph @_ @_ @r1 @r2 @Coercible @Either @ConstV @FlipConstV @Const Proxy doNil doUncons doCons . ConstV
  where
    doNil = impossible . unConstV
    doUncons l = bimap ConstV Const . flip trial l . unConstV
    doCons :: forall ℓ τ1 τ2 ρ1 ρ2. (KnownSymbol ℓ, Coercible τ1 τ2, AllUniqueLabels (Extend ℓ τ2 ρ2))
           => Label ℓ -> Either (FlipConstV ρ1 ρ2) (Const τ1 τ2)
           -> FlipConstV (Extend ℓ τ1 ρ1) (Extend ℓ τ2 ρ2)
    doCons l (Left (FlipConstV v)) = FlipConstV $ extend @τ2 l v
    doCons l (Right (Const x)) = FlipConstV $ IsJust l (coerce @τ1 @τ2 x)
      \\ extendHas @ρ2 @ℓ @τ2