[Haskell-cafe] Re: Parsers are monadic?

[Claus Reinke]

>  class Monad m => MonadError e m | m -> e where
>    throwError :: e -> m a
>    catchError :: m a -> (e -> m a) -> m a
>..
> power of TwoCont? I mean, it still seems like there's an operation
> missing that supplies new left and right continuations at once.

i guess, instead of one DiMonad with two sets of operations,  i'd 
prefer to have two separate Monads with the ability to connect 
them, so that failure in one is success in the other, but i guess we 
need some way to tell which is which.

using MonadError to handle error continuations on top of a Monad
to handle success continuation is a lot like using a MonadReader to
hold error continuations on top of the base Monad. consider

    class (Monad m) => MonadReader r m | m -> r where
      ask :: m r
      local :: (r -> r) -> m a -> m a

where  r = e -> m a. then

    throwError = \e->ask >>= \h->h e
    catchError m h = local (const h) m

in other words, supplying both continuations is straightforward,
although syntactic sugar only supports supplying one, in line with 
the bias towards one of the two continuations:

    m `doubleBind` (s,f) = m `catchError` f >>= s 

i find myself doing something like this frequently, whenever i use 
constructs like

     m >>= \x-> a x `mplus` b x
    m >>= maybe a b
    m >>= either a b

btw, it might be useful if throwing an error would reverse the roles of 
the two continuations, instead of throwing away the success continuation.

then the error handler itself could either return (abandoning the original
success continuation) or throw (resuming the original  continuation).
that would interfere with the use of throw to pass on unhandled errors,
but then we could be more specific about which direction to throw.

claus