Monad transformer from Comonad.

This module provides the CoT monad transformer, which adds a "comonadic context" to another monad.

What does CoT do?

For any Comonad f and Monad g, CoT f g is a monad that combines the original effect of the monad g with the ability to use the comonad f as a context. For example:

• CoT (Env e) g is a monad with the g effect and access to a value of type e.

  • This is exactly what ReaderT e g provides, and in fact, CoT (Env e) g is isomorphic to ReaderT e g: see fromReaderT and toReaderT.

• CoT (Store s) g is a monad with the g effect and access to a context that holds a store of s values, which can be queried or updated.

  • This corresponds exactly to what StateT s g provides, and indeed, CoT (Store s) g is isomorphic to StateT s g: see fromStateT and toStateT.
• Similarly, CoT (Traced m) g is isomorphic to WriterT m g.

The "contextual" effects introduced by CoT can be composed freely. Any nested use of the CoT monad transformer can be flattened into a single layer using the Day functor to combine the contexts:

uncurryCoT :: Functor g => CoT f1 (CoT f2 g) ~> CoT (Day f1 f2) g
curryCoT   :: Functor g => CoT (Day f1 f2) g ~> CoT f1 (CoT f2 g)

Relation to other types

As a Functor, CoT f g is isomorphic to the Curried f g type. However, since Curried has an Applicative instance that is not compatible with the Monad instance of CoT, a new type was necessary to support the monad behavior described here.

The non-transformer version, Co f, is isomorphic to the Co f type from the Control.Monad.Co module (which is actually the source of inspiration for this module!).

The name collision is unfortunate — the author has not yet decided on a final name for this monad transformer. Suggestions are welcome!

For category theory nerds

The construction of monad CoT f g, given Comonad f and Monad g, can be explained via Kleisli category.

Recall that providing a Monad instance for a functor m is equivalent to providing a Category (Kleisli m) instance.

-- The type of Kleisli category morphisms
newtype Kleisli m a b = Kl { runKl :: a -> m b }

-- Derive Category (Kleisli m) from Monad m
instance Monad m => Category (Kleisli m) where
  id :: Kleisli m a a
  id = Kl return
  (.) :: Kleisli m b c -> Kleisli m a b -> Kleisli m a c
  Kl f . Kl g = Kl (f <=< g)

-- Derive Monad m from Category (Kleisli m)
-- (pseudocode, can't be real Haskell)
instance Category (Kleisli m) => Monad m where
  return = runKl id
  ma >>= k = runKl (Kl k . Kl (const ma)) ()

Kleisli (CoT f g) is isomorphic to the following Arr f g.

type Arr f g a b = forall r. (a, f r) -> g (b, r)

Here's the transformations showing the isomorphism between Kleisli (CoT f g) and Arr f g.

Kleisli (CoT f g) a b
 ≅ a -> CoT f g b
 ≅ a -> ∀r. f r -> g (b, r)
 ≅ ∀r. a -> f r -> g (b, r)
 ≅ ∀r. (a, f r) -> g (b, r)
 ~ Arr f g a b

Arr f g can be made into Category with the following identity and composition. The Monad (CoT f g) instance is the one derived from this construction.

idArr :: (Comonad f, Monad g) => Arr f g a a
idArr (a, fr) = pure (a, extract fr)

compArr :: (Comonad f, Monad g) => Arr f g a b -> Arr f g b c -> Arr f g a c
compArr t u (a, fr) =
  t (a, duplicate fr) >>= u

Diagramatically, idArr is the following composite

\[ \require{AMScd} \begin{CD} (a, \_) \circ f @>>{\mathop{\mathtt{fmap}} \mathop{\mathtt{extract}}}> (a, \_) @>>{\mathtt{pure}}> g \circ (a, \_) \end{CD} \]

and compArr t u is the following composite.

\[ \require{AMScd} \begin{CD} (a, \_) \circ f @>>{\mathop{\mathtt{fmap}} \mathop{\mathtt{duplicate}}}> (a, \_) \circ f \circ f @>>{t}> g \circ (b, \_) \circ f @>>{\mathop{\mathtt{fmap}} u}> g \circ g \circ (c, \_) @>>{\mathop{\mathtt{join}}}> g \circ (c, \_) \end{CD} \]

Proving category laws for (idArr, compArr) will be simple enough.