Control.Monad.Trans.Either

either-4.4.1: An either monad transformer

Copyright | (C) 2008-2014 Edward Kmett
License | BSD-style (see the file LICENSE)
Maintainer | Edward Kmett <ekmett@gmail.com>
Stability | provisional
Portability | MPTCs
Safe Haskell | Trustworthy
Language | Haskell98

Control.Monad.Trans.Either

Description

This module provides a minimalist `Either` monad transformer.

Synopsis

- 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
- bracketEitherT :: Monad m => EitherT e m a -> (a -> EitherT e m b) -> (a -> EitherT e m c) -> EitherT e m c
- bracketEitherT_ :: Monad m => EitherT e m a -> EitherT e m b -> EitherT e m c -> EitherT e m c
- left :: Monad m => e -> EitherT e m a
- right :: Monad m => a -> EitherT e m a
- swapEitherT :: Functor m => EitherT e m a -> EitherT a m e

# Documentation

newtype EitherT e m a

`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.

Constructors

EitherT |
Fields runEitherT :: m (Either e a)

Instances

(Functor f, MonadFree f m) => MonadFree f (EitherT e m) |
MonadBase b m => MonadBase b (EitherT e m) |
MonadBaseControl b m => MonadBaseControl b (EitherT e m) |
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) |
MFunctor (EitherT e) |
MonadTrans (EitherT e) |
MonadTransControl (EitherT e) |
Monad m => Monad (EitherT e m) |
Monad m => Functor (EitherT e m) |
MonadFix m => MonadFix (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) |
(Monad m, Monoid e) => MonadPlus (EitherT e m) |
MonadThrow m => MonadThrow (EitherT e m) | Throws exceptions into the base monad.
MonadCatch m => MonadCatch (EitherT e m) | Catches exceptions from the base monad.
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) |
type StT (EitherT e) a = Either e a |
type StM (EitherT e m) a = StM m (StT (EitherT e) a) |

eitherT :: Monad m => (a -> m c) -> (b -> m c) -> EitherT a m b -> m c

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 b

Map over both failure and success.

mapEitherT :: (m (Either e a) -> n (Either e' b)) -> EitherT e m a -> EitherT e' n b

Map the unwrapped computation using the given function.

    runEitherT (mapEitherT f m) = f (runEitherT m)

hoistEither :: Monad m => Either e a -> EitherT e m a

Lift an `Either` into an `EitherT`

bracketEitherT :: Monad m => EitherT e m a -> (a -> EitherT e m b) -> (a -> EitherT e m c) -> EitherT e m c

Acquire a resource in `EitherT` and then perform an action with it, cleaning up afterwards regardless of error. Like `bracket`, but acting only in `EitherT`.

bracketEitherT_ :: Monad m => EitherT e m a -> EitherT e m b -> EitherT e m c -> EitherT e m c

Version of `bracketEitherT` which discards the result from the initial action.

left :: Monad m => e -> EitherT e m a

Analogous to `Left`. Equivalent to `throwError`.

right :: Monad m => a -> EitherT e m a

Analogous to `Right`. Equivalent to `return`.

swapEitherT :: Functor m => EitherT e m a -> EitherT a m e

Monad transformer version of `swapEither`.