I just discovered Control.Monad.Error, and all sorts of questions and
ideas came to mind. I would be happy for any comments or pointers.
- Monad and MonadError are uncannily similar, especially if you ignore
that ugly duckling fail:
class (Monad m) => MonadError e m | m -> e where
throwError :: e -> m a
catchError :: m a -> (e -> m a) -> m a
The instances for Either are exactly symmetrical. Is there some more
general way to look at this that makes the symmetry stand out?
- The instance MonadError IOError IO is problematic, because one might
have preferred to use Control.Exception.Exception as the error type.
I've been told that the latter is generally preferred, and it's what I
usually want. Any chance of the instance being changed?
- It's a shame that the utility functions in Control.Exception aren't
defined in terms of MonadError. Maybe they should at least be
duplicated in Control.Monad.Error.
- Why not
instance MonadError () Maybe where
throwError x = Nothing
Nothing `catchError` f = f ()
Just x `catchError` f = Just x
instance Error () where
noMsg = ()
strMsg s = ()
? This would seem to facilitate a variation of the "NotJustMaybe"
pattern, using MonadError instead of Monad. What I'm getting at is
that it might be nice to see MonadError used more in preference to
Monad. Then we can get rid of fail. ;-)
- I found this function terribly useful:
liftError :: (MonadError e m, MonadTrans t, MonadError e (t m)) =>
m a -> t m a
liftError m = join (lift (liftM return m
`catchError`
(return . throwError)))
However, I'm not sure exactly how to describe it (or what to call
it--maybe liftTry). It basically pulls errors from the inner monad to
the outer monad. One application is
try :: MonadError e m => m a -> m (Either e a)
try m = runErrorT (liftError m)
The really nice thing for me is that I can use it with StateT to
prevent errors from disturbing the state, as normally happens when you
mix StateT with, say, IO:
test1 = execStateT test 0 >>= print where
test :: StateT Int IO ()
test = do put 2
lift (fail "foo")
`catchError` \e -> modify (+1)
This prints 1, because the IOError obliterates all state changes in
the first argument to catchError. However,
test2 = execStateT (runErrorT test) 0 >>= print where
test :: ErrorT IOError (StateT Int IO) ()
test = do put 2
liftError (fail "foo")
`catchError` \e -> modify (+1)
prints 3, because the IOError was caught by liftError, then passed
down along with the state change. Oh, and
test2 = execStateT (runErrorT test) 0 >>= print where
test :: ErrorT IOError (StateT Int IO) ()
test = do put 2
lift (fail "foo")
`catchError` \e -> modify (+1)
raises an IOError, because the error is never seen by the outer monad
(and catchError).
Andrew
