[Haskell-cafe] monadic plumbing

[Alberto G. Corona]

Recently I had to navigatate trough data structures chained with mutable
referenes in th STM monad. The problem is that their values are enveloped in
 Either or Maybe results.

functional compositions in the Either of Maybe , or list  monads are not
possible when the values are  embedded inside effect monads (i.e. STM or IO)
. I tried  to find some trick to handle it.

to summarize, given:

 foo, :  a -> m (Maybe b)
 bar :   b -> m (Maybe c)
 baz :  c -> m (Maybe d)

how to compose foo bar and baz? Or, at least,  Are something out there to
handle it in the less painful way?.


I solved the generalized problem  (chaining  any double monadic combination)
with a sort of monadic connector that acts as a " double monadic" operator
>>>>==  so that

return. return (x :: a) >>>>== foo >>>== bar >>>== baz

can be possible. Although I don't know if  it is the best solution. I wonder
why nobody has written about it before:

class (Monad m, Monad n) => Bimonad m n where
 (>>>=)   ::  n a -> (a -> m(n b)) -> m(n b)

(>>>>==) :: (Bimonad m n) => m (n a) -> (a -> m(n b)) -> m (n b)
(>>>>==) x  f =  x >>= \y -> y >>>=  f

x >>>> f = x >>>>== \ _-> f

infixl 1 >>>>==, >>>>

The instance for handling the Maybe monad under any other monad is very
similar to the definition of the "normal" monad:

instance (Monad m) => Bimonad m Maybe where
   Just x  >>>= f = f x
   Nothing >>>= _ = return $ Nothing
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20110222/fdd7bb2c/attachment-0001.htm>