[Haskell-beginners] Constrained polymorphic functions as natural transformations

[Matt R]

I read this excellent blog article on natural transformations[1], which
helped me gain one intuition as to what they are: "functions that don't
make too many assumptions about their arguments". In the article, natural
transformations make "no assumptions at all" about their arguments.
However, it's often the case that a Haskell function will require a type
argument constrained by a type class, e.g. show :: Show a => a -> String. I
wondered if it was possible to characterise these functions using category
theory too. Below is my attempt, and I'm hoping people can tell me whether
I'm in the right ballpark (or point me in the direction of a better
ball-park...)

For a particular type class T, we can form a subcategory Hask_T of Hask
consisting of all the instances of the type class as objects, with the
arrows just those functions that "commute" with the signature of the type
class. For example, in Hask_Show, the arrows would be all the functions f:
A -> B such that:

  show == show . f

Or for Data.Monoid, all the monoid homomorphisms f:

  mappend (f x) (f y) == f (mappend x y)
  mempty == f mempty

In general, for any type class, we can formulate two functors f and g and a
function sig :: f a -> g a that captures the operations in the type class,
and then the condition is that:

  fmap f . sig == sig . fmap f.

Then we have that the polymorphic functions with a type class constraint of
T are just the same thing as natural transformations in this subcategory
Hask_T.

Is the above correct / along the right lines?

Thanks,

-- Matt

[1] "You Could Have Defined Natural Transformations",
http://blog.sigfpe.com/2008/05/you-could-have-defined-natural.html
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/beginners/attachments/20131030/090b430c/attachment.html>