> newtype RanT f g c m m’ = (c -> K m) -> T m’

Should be:

> newtype RanT k t c m m’ = (c -> k m) -> t m’

right?

Fixed the LanT definition. (Woops!)

Re the dinatural transformation piece, I’m not as deep as I used to be in this area, so I’ll go back and see what I can dig up from whatever notes I still have from when I wrote this. I recall it seeming quite obvious at the time, but now I can only barely remember what dinaturality is. :) I’d be quite surprised (and pleased) if you came up with a counterexample, however. ;)

data LanT k t c m m’ = LanT (k m -> c) (t m)

should probably be

data LanT k t c m m’ = LanT (k m -> c) (t m’)

though it makes no difference in the definition of Lan.

On a less trivial level, I still don’t know what theorem I could quote to justify that, say,

type DinaturalFromObject x s = x -> forall a. s a a

defines dinaturals from a constant functor. For a specific choice of s dinaturality is a free theorem. But how do you uniformly prove this for all s, implemented in Haskell, with the right c/contravariance in the arguments?

http://wwwtcs.inf.tu-dresden.de/~voigt/mpc08.pdf

That paper shows that you can substitute a reference to the Codensity monad of a free monad in many places where you’d use the original free monad and change the asymptotic performance of the resulting algorithm because the continuation ‘linearizes’ the cost of repeatedly traversing the tree by piling the cost up in the continuation so you only traverse once.

I’d conjecture that the left Kan extension of a cofree comonad should let us pile up the cost of mapping or extending cofree comonads similarly. Though here I have yet to actually generate any performance results here due to other distractions.

We _can_ however definitely do the same thing with the Yoneda and Coyoneda lemmas. The resulting (co)monads fit very closely to the operational characteristics of the base monad.

If you transform a monad with Yoneda you get a monad that has the same overall costs for return and >>=, but where if your monad had a non constant cost for map (such as in the free monad of anything other than the trivial functor that maps everything to _|_), you can fuse the costs of all of your maps together by accumulating them and applying them all at once during the next (>>=) (or when you extract f from the Yoneda f).

Similarly CoYoneda accumulates maps for comonads, which is a win if map is expensive (such as in the cofree comonad case).

You can get a feel for why this works by looking at:

http://comonad.com/haskell/category-extras/src/Control/Functor/Yoneda.hs

and noting what fmap does and how >>= works for Yoneda. and how fmap and extend work for CoYoneda.

In category-extras I have generalized all of the constructive algorithmic morphisms that use the free monad or cofree comonad (histomorphisms, futumorphisms, dynamorphisms, chronomorphisms) to support the codensity monad of the free monad, density comonad of the cofree comonad, Yoneda of the free monad, Coyoneda of the cofree comonad, etc by defining a couple of extra typeclasses that express their ‘Free-Like’ behavior in the spirit of the above linked paper by Voigtlaender in

http://comonad.com/haskell/category-extras/src/Control/Monad/Free.hs

The generalization can be seen in use here:

http://comonad.com/haskell/category-extras/src/Control/Morphism/Futu.hs

and the instances for Codensity here:

http://comonad.com/haskell/category-extras/src/Control/Monad/Codensity.hs

Care to shed some light on this (and its dual)?