Data.Functor.Transformer

Functor from indexed-types to indexed-types. Instances of FunctorT should satisfy the following laws:

tmap id = id
tmap f . tmap g = tmap (f . g)

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

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

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

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

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

This class is the categorical dual of TraversableT, with tdistribute the dual of tsequence and tcotraverse the dual of ttraverse. As such, instances need to satisfy these laws:

tdistribute . h = tmap (Compose . h . getCompose) . tdistribute    -- naturality
tdistribute . Identity = tmap (Compose . Identity)                 -- identity
tdistribute . Compose = fmap (Compose . Compose . fmap getCompose . getCompose) . tdistribute . fmap distribute -- composition

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

tdecompose :: DistributiveT b => (a -> b Identity) -> b ((->) a)
tdecompose = tmap (fmap runIdentity . getCompose) . tdistribute

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

trecompose . tdecompose = id
tdecompose . trecompose = 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 tdistribute 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 tdistribute with g specialized to Identity.

Dual of ttraverse

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

Recompose a decomposed function.

A FunctorT with application, providing operations to:

• embed an "empty" value (tpure)

• align and combine values (tprod)

It should satisfy the following laws:

Naturality of tprod

tmap ((Pair a b) -> Pair (f a) (g b)) (u `tprod' v) = tmap f u `tprod' tmap g v

Left and right identity

tmap ((Pair _ b) -> b) (tpure e `tprod' v) = v
tmap ((Pair a _) -> a) (u `tprod' tpure e) = u

Associativity

tmap ((Pair a (Pair b c)) -> Pair (Pair a b) c) (u `tprod' (v `tprod' w)) = (u `tprod' v) `tprod' w

It is to FunctorT in the same way is 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 tprod and tpure based on Generic. Intuitively, it works on types where the value of tpure is uniquely defined. This corresponds rougly to record types (in the presence of sums, there would be several candidates for tpure), where every field is either a Monoid or covered by the argument f.

Some endo-functors on indexed-types are monads. Common examples would be "functor-transformers", like Compose or ReaderT. In that sense, MonadT is similar to MonadTrans but with additional structure (see also mmorph's MMonad class).

Notice though that while lift assumes a Monad instance of the value to be lifted, tlift has no such constraint. This means we cannot have instances for most "monad transformers", since lifting typically involves an fmap.

MonadT also corresponds to the indexed-monad of Kleisli arrows of outrageous fortune.

Instances of this class should to satisfy the monad laws. They laws can stated either in terms of (tlift, tjoin) or (tlift, tembed). In the former:

tmap h . tlift = tlift . h
tmap h . tjoin = tjoin . tmap (tmap h)
tjoin . tlift  = id
tjoin . 'tmap tlift' = id
tjoin . tjoin = tjoin . tmap tjoin

In the latter:

tembed f . tlift = f
tembed tlift = id
tembed f . tembed g = tembed (tembed f . g)

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

A manual definition would look like this:

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

instance ConstraintsT T where
  type AllT c T = (c Int, c String, c Bool)

  taddDicts 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:

taddDicts :: AllT Show t => t f -> t (Dict Show `Product' f)

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

derive instance Generic (T f a)
instance ConstraintsT T

Similar to AllT but will put the functor argument f between the constraint c and the type a.