Modulererebase-1.21.2Haskell2010

Control.Monad.Trans.Except

2 types
15 values

Packagererebase-1.21.2
Exports17
LanguageHaskell2010
LicenceMIT
SourceExcept.hs

typetype Except e = ExceptT e Identity

The parameterizable exception monad.

Computations are either exceptions or normal values.

The return function returns a normal value, while >>= exits on the first exception. For a variant that continues after an error and collects all the errors, see Errors.

valueliftCallCC :: CallCC m (Either e a) (Either e b) -> CallCC (ExceptT e m) a b

Lift a callCC operation to the new monad.

valueexcept :: Monad m => Either e a -> ExceptT e m a

Constructor for computations in the exception monad. (The inverse of runExcept).

valuemapExcept :: (Either e a -> Either e' b) -> Except e a -> Except e' b

Map the unwrapped computation using the given function.

runExcept (mapExcept f m) = f (runExcept m)

valuemapExceptT

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

Map the unwrapped computation using the given function.

runExceptT (mapExceptT f m) = f (runExceptT m)

valuerunExcept :: Except e a -> Either e a

Extractor for computations in the exception monad. (The inverse of except).

valuerunExceptT :: ExceptT e m a -> m (Either e a)

The inverse of ExceptT.

valuewithExcept :: (e -> e') -> Except e a -> Except e' a

Transform any exceptions thrown by the computation using the given function (a specialization of withExceptT).

valuewithExceptT :: Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a

Transform any exceptions thrown by the computation using the given function.

newtypenewtype ExceptT e (m :: Type -> Type) a

A monad transformer that adds exceptions to other monads.

ExceptT constructs a monad parameterized over two things:

e - The exception type.
m - The inner monad.

The return function yields a computation that produces the given value, while >>= sequences two subcomputations, exiting on the first exception.

Constructors

ExceptT (m (Either e a))

Instances48MonadRWS, Generic1, MonadAccum, MonadError, MonadReader, MonadState, …

MonadRWS r w s m => MonadRWS r w s (ExceptT e m)Defined in mtl-2.3.1 · Control.Monad.RWS.Class
Functor m => Generic1 (ExceptT e m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
MonadAccum w m => MonadAccum w (ExceptT e m)Defined in mtl-2.3.1 · Control.Monad.Accum
The accumulated value 'survives' an exception: even if the computation fails to deliver a result, we still have an accumulated value.
Monad m => MonadError e (ExceptT e m)Defined in mtl-2.3.1 · Control.Monad.Error.Class
MonadReader r m => MonadReader r (ExceptT e m)Defined in mtl-2.3.1 · Control.Monad.Reader.Class
MonadState s m => MonadState s (ExceptT e m)Defined in mtl-2.3.1 · Control.Monad.State.Class
MonadWriter w m => MonadWriter w (ExceptT e m)Defined in mtl-2.3.1 · Control.Monad.Writer.Class
MonadSelect r m => MonadSelect r (ExceptT e m)Defined in mtl-2.3.1 · Control.Monad.Select
'Extends' the possibilities considered by m to include every value of e; this means that the potential result could be either a Left (making it a choice of type e) or a Right (making it a choice of type a).
MonadBase b m => MonadBase b (ExceptT e m)Defined in transformers-base-0.4.6 · Control.Monad.Base
(Functor f, MonadFree f m) => MonadFree f (ExceptT e m)Defined in free-5.2 · Control.Monad.Free.Class
MonadTrans (ExceptT e)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
Monad m => Monad (ExceptT e m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
Functor m => Functor (ExceptT e m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
MonadFix m => MonadFix (ExceptT e m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
MonadFail m => MonadFail (ExceptT e m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
(Functor m, Monad m) => Applicative (ExceptT e m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
Foldable f => Foldable (ExceptT e f)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
Traversable f => Traversable (ExceptT e f)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
(Monad m, Monoid e) => MonadPlus (ExceptT e m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
MonadIO m => MonadIO (ExceptT e m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
MonadZip m => MonadZip (ExceptT e m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
(Eq e, Eq1 m) => Eq1 (ExceptT e m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
(Ord e, Ord1 m) => Ord1 (ExceptT e m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
(Read e, Read1 m) => Read1 (ExceptT e m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
(Show e, Show1 m) => Show1 (ExceptT e m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
Contravariant m => Contravariant (ExceptT e m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
MonadCont m => MonadCont (ExceptT e m)Defined in mtl-2.3.1 · Control.Monad.Cont.Class
MonadCatch m => MonadCatch (ExceptT e m)Defined in exceptions-0.10.9 · Control.Monad.Catch
Catches exceptions from the base monad.
MonadMask m => MonadMask (ExceptT e m)Defined in exceptions-0.10.9 · Control.Monad.Catch
MonadThrow m => MonadThrow (ExceptT e m)Defined in exceptions-0.10.9 · Control.Monad.Catch
Throws exceptions into the base monad.
PrimMonad m => PrimMonad (ExceptT e m)Defined in primitive-0.9.1.0 · Control.Monad.Primitive
Divisible m => Divisible (ExceptT e m)Defined in contravariant-1.5.5 · Data.Functor.Contravariant.Divisible
(Functor f, Monad f, Semigroup e) => Alt (ExceptT e f)Defined in semigroupoids-6.0.1 · Data.Functor.Alt
(Functor m, Monad m) => Apply (ExceptT e m)Defined in semigroupoids-6.0.1 · Data.Functor.Bind.Class
(Functor m, Monad m) => Bind (ExceptT e m)Defined in semigroupoids-6.0.1 · Data.Functor.Bind.Class
Divise m => Divise (ExceptT e m)Defined in semigroupoids-6.0.1 · Data.Functor.Contravariant.Divise
(Functor f, Monad f, Semigroup e, Monoid e) => Plus (ExceptT e f)Defined in semigroupoids-6.0.1 · Data.Functor.Plus
Invariant m => Invariant (ExceptT e m)Defined in invariant-0.6.4 · Data.Functor.Invariant
from the transformers package
Pointed m => Pointed (ExceptT e m)Defined in pointed-5.0.4 · Data.Pointed
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
(Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
(Read e, Read1 m, Read a) => Read (ExceptT e m a)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
(Show e, Show1 m, Show a) => Show (ExceptT e m a)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
Generic (ExceptT e m a)Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
type Rep (ExceptT e m a) = D1 ('MetaData "ExceptT" "Control.Monad.Trans.Except" "transformers-0.6.1.1-a11a" 'True) (C1 ('MetaCons "ExceptT" 'PrefixI 'False) (S1 ('MetaSel 'Nothing 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (m (Either e a)))))Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
type Rep1 (ExceptT e m) = D1 ('MetaData "ExceptT" "Control.Monad.Trans.Except" "transformers-0.6.1.1-a11a" 'True) (C1 ('MetaCons "ExceptT" 'PrefixI 'False) (S1 ('MetaSel 'Nothing 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (m :.: Rec1 (Either e))))Defined in transformers-0.6.1.1 · Control.Monad.Trans.Except
type PrimState (ExceptT e m) = PrimState mDefined in primitive-0.9.1.0 · Control.Monad.Primitive

valuecatchE

:: Monad m
=> ExceptT e m a
the inner computation
-> (e -> ExceptT e' m a)
a handler for exceptions in the inner computation
-> ExceptT e' m a

Handle an exception.

```
catchE (lift m) h = lift m
```
```
catchE (throwE e) h = h e
```

valuefinallyE :: Monad m => ExceptT e m a -> ExceptT e m () -> ExceptT e m a

finallyE a b executes computation a followed by computation b, even if a exits early by throwing an exception. In the latter case, the exception is re-thrown after b has been executed.

valuehandleE

:: Monad m
=> e -> ExceptT e' m a
-> ExceptT e m a
-> ExceptT e' m a

The same as flip catchE, which is useful in situations where the code for the handler is shorter.

valueliftListen :: Monad m => Listen w m (Either e a) -> Listen w (ExceptT e m) a

Lift a listen operation to the new monad.

valueliftPass :: Monad m => Pass w m (Either e a) -> Pass w (ExceptT e m) a

Lift a pass operation to the new monad.

valuethrowE :: Monad m => e -> ExceptT e m a

Signal an exception value e.

```
runExceptT (throwE e) = return (Left e)
```
```
throwE e >>= m = throwE e
```

valuetryE :: Monad m => ExceptT e m a -> ExceptT e m (Either e a)

Similar to catchE, but returns an Either result which is (Right a) if no exception was thown, or (Left ex) if an exception ex was thrown.