Data.Functor.Barbie

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

bmap id = id
bmap f . bmap g = bmap (f . g)

There is a default bmap implementation for Generic types, so instances can derived automatically.

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

 t . btraverse f   = btraverse (t . f)  -- naturality
btraverse Data.Functor.Identity = Data.Functor.Identity           -- identity
btraverse (Compose . fmap g . f) = Compose . fmap (btraverse g) . btraverse f -- composition

There is a default btraverse implementation for Generic types, so instances can derived automatically.

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

This class is the categorical dual of TraversableB, with bdistribute the dual of bsequence and bcotraverse the dual of btraverse. As such, instances need to satisfy these laws:

bdistribute . h = bmap (Compose . h . getCompose) . bdistribute    -- naturality
bdistribute . Identity = bmap (Compose . Identity)                 -- identity
bdistribute . Compose = bmap (Compose . Compose . fmap getCompose . getCompose) . bdistribute . fmap bdistribute -- composition

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

bdecompose :: DistributiveB b => (a -> b Identity) -> b ((->) a)
bdecompose = bmap (fmap runIdentity . getCompose) . bdistribute

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

brecompose . bdecompose = id
bdecompose . brecompose = 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.

There is a default implementation of bdistribute based on Generic. Intuitively, it works on product types where the shape of a pure value is uniquely defined and every field is covered by the argument f.

A version of bdistribute with g specialized to Identity.

Dual of btraverse

Decompose a function returning a distributive barbie, into a collection of simpler functions.

Recompose a decomposed function.

A FunctorB with application, providing operations to:

• embed an "empty" value (bpure)

• align and combine values (bprod)

It should satisfy the following laws:

Naturality of bprod

bmap ((Pair a b) -> Pair (f a) (g b)) (u `bprod' v) = bmap f u `bprod' bmap g v

Left and right identity

bmap ((Pair _ b) -> b) (bpure e `bprod' v) = v
bmap ((Pair a _) -> a) (u `bprod' bpure e) = u

Associativity

bmap ((Pair a (Pair b c)) -> Pair (Pair a b) c) (u `bprod' (v `bprod' w)) = (u `bprod' v) `bprod' w

It is to FunctorB 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.

There is a default implementation of bprod and bpure based on Generic. Intuitively, it works on types where the value of bpure is uniquely defined. This corresponds rougly to record types (in the presence of sums, there would be several candidates for bpure), where every field is either a Monoid or covered by the argument f.

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

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 AllB c T = (c Int, c String, c Bool)

  baddDicts t = case t of
    A x y -> A (Pair Dict x) (Pair Dict y)
    B z w -> B (Pair Dict z) (Pair Dict w)

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

baddDicts :: AllB Show b => b f -> b (Dict Show `Product' f)

There is a default implementation of ConstraintsB for Generic types, so in practice one will simply do:

derive instance Generic (T f)
instance ConstraintsB T

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

  AllB  Show   Person ~ (Show    String,  Show    Int)
  AllBF Show f Person ~ (Show (f String), Show (f Int))