ExnMonadT.hs

module ExnMonadT where

-- Maybe and Either Monad Instances

{- This is predefined:
data Either alpha beta = Left alpha | Right beta
-}

data ExnT m e a = ExnT { runEx :: m (Either e a) }

instance Functor m=> Functor (ExnT m e) where
  fmap f (ExnT a) = ExnT (fmap (fmap f) a)

instance Monad m=> Applicative (ExnT m e) where
  pure   = ExnT . pure . Right
  ExnT fm <*> ExnT ma = ExnT $ do ef<- fm; ea<- ma; return $ ef <*> ea

instance Monad m=> Monad (ExnT m e) where
  return = ExnT . return . Right
  ExnT ma >>= g = ExnT $ do e <- ma
                            case e of Right a -> runEx (g a)
                                      Left err -> return (Left err)


-- Operations:

err :: Monad m=> e-> ExnT m e a
err = ExnT. return. Left