Portability  MPTCs 

Stability  provisional 
Maintainer  Edward Kmett <ekmett@gmail.com> 
Safe Haskell  Trustworthy 
This module provides a minimalist Either
monad transformer.
 newtype EitherT e m a = EitherT {
 runEitherT :: m (Either e a)
 eitherT :: Monad m => (a > m c) > (b > m c) > EitherT a m b > m c
 bimapEitherT :: Functor m => (e > f) > (a > b) > EitherT e m a > EitherT f m b
 mapEitherT :: (m (Either e a) > n (Either e' b)) > EitherT e m a > EitherT e' n b
 hoistEither :: Monad m => Either e a > EitherT e m a
 left :: Monad m => e > EitherT e m a
 right :: Monad m => a > EitherT e m a
Documentation
EitherT
is a version of ErrorT
that does not
require a spurious Error
instance for the Left
case.
Either
is a perfectly usable Monad
without such a constraint. ErrorT
is
not the generalization of the current Either
monad, it is something else.
This is necessary for both theoretical and practical reasons. For instance an
apomorphism is the generalized anamorphism for this Monad, but it cannot be
written with ErrorT
.
In addition to the combinators here, the errors
package provides a large
number of combinators for working with this type.
EitherT  

Monad m => MonadError e (EitherT e m)  
MonadReader r m => MonadReader r (EitherT e m)  
MonadState s m => MonadState s (EitherT e m)  
MonadWriter s m => MonadWriter s (EitherT e m)  
MonadTrans (EitherT e)  
Monad m => Monad (EitherT e m)  
Monad m => Functor (EitherT e m)  
MonadFix m => MonadFix (EitherT e m)  
(Monad m, Monoid e) => MonadPlus (EitherT e m)  
Monad m => Applicative (EitherT e m)  
Foldable m => Foldable (EitherT e m)  
(Monad f, Traversable f) => Traversable (EitherT e f)  
MonadRandom m => MonadRandom (EitherT e m)  
(Monad m, Monoid e) => Alternative (EitherT e m)  
MonadIO m => MonadIO (EitherT e m)  
MonadCont m => MonadCont (EitherT e m)  
(Monad m, Semigroup e) => Alt (EitherT e m)  
Monad m => Apply (EitherT e m)  
Monad m => Bind (EitherT e m)  
Eq (m (Either e a)) => Eq (EitherT e m a)  
Ord (m (Either e a)) => Ord (EitherT e m a)  
Read (m (Either e a)) => Read (EitherT e m a)  
Show (m (Either e a)) => Show (EitherT e m a)  
Monad m => Semigroup (EitherT e m a) 
eitherT :: Monad m => (a > m c) > (b > m c) > EitherT a m b > m cSource
Given a pair of actions, one to perform in case of failure, and one to perform
in case of success, run an EitherT
and get back a monadic result.
bimapEitherT :: Functor m => (e > f) > (a > b) > EitherT e m a > EitherT f m bSource
Map over both failure and success.
mapEitherT :: (m (Either e a) > n (Either e' b)) > EitherT e m a > EitherT e' n bSource
Map the unwrapped computation using the given function.
runEitherT
(mapEitherT
f m) = f (runEitherT
m)