Functions that try to convert from f @@ a to some other type don't work without a little help due to injectivity. This class provides that help by providing a function that provides a witness of the type of a for each field of the record.

A type witness for a field of type a.

For convenience, it also carries Typeable evidence and the name of the field.

Obtain a van-laarhoven lens (compatible with the lens library) from LensRec

Record-types that can be mapped over. Instances of FunctorRec should satisfy the following laws:

map id = id
map f . map g = map (f . g)

Record-types that can be traversed from left to right. Instances should satisfy the following laws:

 t . traverse f   = traverse (t . f)  -- naturality
traverse Identity = Identity           -- identity
traverse (fmap g . f) = fmap (traverse g) . traverse f -- composition

traverse with the arguments flipped. Useful when the traversing function is a large lambda:

for someRecord $ fa -> ...

Since: 0.0.1.0

Map each element to a monoid, and combine the results.

Evaluate each action in the structure from left to right, and collect the results.

A version of sequence with f specialized to Pure.

A FunctorRec where the effects can be distributed to the fields: distribute turns an effectful way of building a Record-type into a pure Record-type with effectful ways of computing the values of its fields.

This class is the categorical dual of TraversableRec, with distribute the dual of sequence and cotraverse the dual of traverse. As such, instances need to satisfy these laws:

distribute . h = map h) . distribute    -- naturality
distribute . Identity = map Identity                 -- identity

By specializing f to ((->) a) and g to Identity, we can define a function that decomposes a function on distributive records into a collection of simpler functions:

decompose :: DistributiveRec b => (a -> b Identity) -> b ((->) a)
decompose = map (fmap runIdentity . getCompose) . distribute

Lawful instances of the class can then be characterized as those that satisfy:

recompose . decompose = id
decompose . recompose = id

This means intuitively that instances need to have a fixed shape (i.e. no sum-types can be involved). Typically, this means record types, as long as they don't contain fields where the functor argument is not applied.

A version of distribute with g specialized to Pure.

Decompose a function returning a distributive record into a collection of simpler functions.

Recompose a decomposed function.

A FunctorRec with application, providing operations to:

• embed an "empty" value (pure)
• align and combine values (prod)

It should satisfy the following laws:

Naturality of prod

map ((a, b) -> (f a, g b)) (u `prod' v) = map f u `prod' map g v

Left and right identity

map ((_, b) -> b) (pure e `prod' v) = v
map ((a, _) -> a) (u `prod' pure e) = u

Associativity

map ((a, (b, c)) -> ((a, b), c) (u `prod' (v `prod' w)) = (u `prod' v) `prod' w

It is to FunctorRec in the same way as Applicative relates to Functor. For a presentation of Applicative as a monoidal functor, see Section 7 of Applicative Programming with Effects.

A first-class-families version of Product.

When used with Eval, it resolves in a tuple of the applied type-level functions.

An alias of prod, since this is like a zip.

An equivalent of unzip.

An equivalent of zipWith.

An equivalent of zipWith3.

An equivalent of zipWith4.

Instances of this class provide means to talk about constraints, both at compile-time, using AllRec, and at run-time, in the form of Dict, via addDicts.

A manual definition would look like this:

data T f = A (f Int) (f String) | B (f Bool) (f Int)

instance ConstraintsB T where
  type AllRec c T = (c Int, c String, c Bool)

  addDicts t = case t of
    A x y -> A (Dict, x) (Dict, y)
    B z w -> B (Dict, z) (Dict, w)

Now, when we given a T f, if we need to use the Show instance of their fields, we can use:

addDicts' :: AllRec Show b => b f -> b (Dict Show `Tuple2' f)

Similar to AllRec but will put the functor argument f between the constraint c and the type a. For example:

 AllRec  Show   Person ~ (Show    String,  Show    Int)
 AllRecF Show f Person ~ (Show (f @ String), Show (f @ Int))
 

ClassF has one universal instance that makes ClassF c f a equivalent to c (f a). However, we have

'ClassF c f :: k -> Constraint

This is useful since it allows to define constraint-constructors like ClassF Monoid 'Pure1 Maybe'

Like ClassF but for binary relations.

Dict c a is evidence that there exists an instance of c a.

It is essentially equivalent to Dict (c a) from the constraints package, but because of its kind, it allows us to define things like Dict Show.

Similar to addDicts but can produce the instance dictionaries "out of the blue".

Turn a constrained-function into an unconstrained one that uses the packed instance dictionary instead.

Like map but a constraint is allowed to be required on each element of rec

E.g. If all fields of rec are Showable then you could store each shown value in it's slot using 'ConstFn String':

showFields :: (AllRec Show rec, ConstraintsRec rec) => b Pure -> b (ConstFn String)
showFields = mapC @Show showField
  where
    showField :: forall a. Show a => Metadata a -> a -> String
    showField _ = show

Notice that one can use the (&) class as a way to require several constraints to hold simultaneously:

map @(Show & Eq & Enum) r

Like traverse but with a constraint on the elements of b.

traverseC with the arguments flipped. Useful when the traversing function is a large lambda:

forC someRec $ fa -> ...

Since: 0.0.1.0

Like zipWith but with a constraint on the elements of b.

Like zipWith3 but with a constraint on the elements of b.

Like zipWith4 but with a constraint on the elements of b.

Like pure but a constraint is allowed to be required on each element of b.

Builds a b f, by applying mempty on every field of b.