"callbacks" in Haskell

[Robert Vollmert]

Hello,

I've been having a little trouble writing a module that waits for and
handles IO events, e.g. by reading from a pipe. It seemed natural to
use some form of callbacks here, though that may very well be the
wrong approach. I'd be happy to hear of alternatives.

Anyway, I got a callback-based approach to work to some extent, but
am not happy with the callback's type.

The abstract form of this module is as follows. I'd appreciate any
input.


A class that specifies what we expect of the base monad.
> class (Monad m) => MonadReq m

A class that specifies what we provide to the callback.
> class (Monad m) => MonadProv m

The module's main function.
> f :: (MonadReq m) => Callback m a -> m a
> f c = ...

Internally, we wrap the base monad with some monad transformer, say
> data InternalT m a = ...
with
> instance MonadTrans InternalT
so that the callback can access the base monad, and
> instance (MonadReq m) => MonadProv (InternalT m)
so that we can actually provide MonadProv.

A type for callback that works is
> type Callback m a = InternalT m a
What I don't like about this is that we shouldn't really need to
expose what exact monad transformer we use. Also, if we added a second
function that also runs the callback in a MonadProv but that uses a
different transformer (for instance, needing to keep track of some
extra state), we'd need a new callback type.

What seems to be the right type is
> type Callback m a = forall t. (MonadTrans t, MonadProv (t m)) => t m a
which sort of works with '-fglasgow-exts' (what's this extension
called?). However, it seems to cause all kinds of problems, e.g. pairs
of this type appear to be illegal.


Cheers
Robert