type Except e = ExceptT e Identity Source

The parameterizable exception monad.

Computations are either exceptions (of any type) or normal values. These computations are plain values, and are unrelated to the Control.Exception mechanism, which is tied to the IO monad.

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.

except :: forall (m :: Type -> Type) e a. Monad m => Either e a -> ExceptT e m a Source

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

runExcept :: Except e a -> Either e a Source

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

mapExcept :: (Either e a -> Either e' b) -> Except e a -> Except e' b Source

Map the unwrapped computation using the given function.

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

withExcept :: (e -> e') -> Except e a -> Except e' a Source

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

newtype ExceptT e (m :: Type -> Type) a Source

A monad transformer that adds exceptions to other monads.

ExceptT constructs a monad parameterized over two things:

• e - An arbitrary exception type.
• m - The inner monad.

The monadic computations are a plain values. They are unrelated to the Control.Exception mechanism, which is tied to the IO monad.

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

runExceptT :: ExceptT e m a -> m (Either e a) Source

The inverse of ExceptT.

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

Map the unwrapped computation using the given function.

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

withExceptT :: forall (m :: Type -> Type) e e' a. Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a Source

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

throwE :: forall (m :: Type -> Type) e a. Monad m => e -> ExceptT e m a Source

Signal an exception value e.

• runExceptT (throwE e) = return (Left e)

• throwE e >>= m = throwE e

catchE Source

Handle an exception.

• catchE (lift m) h = lift m

• catchE (throwE e) h = h e

handleE :: forall (m :: Type -> Type) e e' a. Monad m => (e -> ExceptT e' m a) -> ExceptT e m a -> ExceptT e' m a Source

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

tryE :: forall (m :: Type -> Type) e a. Monad m => ExceptT e m a -> ExceptT e m (Either e a) Source

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.

finallyE :: forall (m :: Type -> Type) e a. Monad m => ExceptT e m a -> ExceptT e m () -> ExceptT e m a Source

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.

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

Lift a callCC operation to the new monad.

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

Lift a listen operation to the new monad.

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

Lift a pass operation to the new monad.