| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
Control.Monad.Except.Catch
Synopsis
- newtype ExceptCatchT e m a = ExceptCatchT {
- unsafeRunExceptCatchT :: m a
- runExceptCatchT :: (Exception e, MonadCatch m) => ExceptCatchT e m a -> m (Either e a)
- class Monad m => MonadError e (m :: Type -> Type) | m -> e where
- throwError :: e -> m a
- catchError :: m a -> (e -> m a) -> m a
- liftEither :: MonadError e m => Either e a -> m a
- tryError :: MonadError e m => m a -> m (Either e a)
- withError :: MonadError e m => (e -> e) -> m a -> m a
- handleError :: MonadError e m => (e -> m a) -> m a -> m a
- mapError :: (MonadError e m, MonadError e' n) => (m (Either e a) -> n (Either e' b)) -> m a -> n b
- modifyError :: (Exception e, MonadCatch m, MonadError e' m) => (e -> e') -> ExceptCatchT e m a -> m a
Documentation
newtype ExceptCatchT e m a Source #
This type is useful for translating a MonadError constraint into
MonadCatch. This type does not have an Either return, which means we can
provide a MonadUnliftIO instance.
Since: 0.1.0.0
Constructors
| ExceptCatchT | |
Fields
| |
Instances
runExceptCatchT :: (Exception e, MonadCatch m) => ExceptCatchT e m a -> m (Either e a) Source #
Run an ExceptCatchT action. This will catch any thrown e exceptions,
regardless of whether you used throwM or throwError.
Any exception that is not mentioned in e will be thrown - this does not
catch all exceptions!
Since: 0.1.0.0
class Monad m => MonadError e (m :: Type -> Type) | m -> e where #
The strategy of combining computations that can throw exceptions by bypassing bound functions from the point an exception is thrown to the point that it is handled.
Is parameterized over the type of error information and
the monad type constructor.
It is common to use Either StringMonadError class.
You can also define your own error type and/or use a monad type constructor
other than Either StringEither IOErrorMonadError
class.
(If you are using the deprecated Control.Monad.Error or
Control.Monad.Trans.Error, you may also have to define an Error instance.)
Methods
throwError :: e -> m a #
Is used within a monadic computation to begin exception processing.
catchError :: m a -> (e -> m a) -> m a #
A handler function to handle previous errors and return to normal execution. A common idiom is:
do { action1; action2; action3 } `catchError` handlerwhere the action functions can call throwError.
Note that handler and the do-block must have the same return type.
Instances
liftEither :: MonadError e m => Either e a -> m a #
Lifts an Either eMonadError e
do { val <- liftEither =<< action1; action2 }where action1 returns an Either to represent errors.
Since: mtl-2.2.2
tryError :: MonadError e m => m a -> m (Either e a) #
MonadError analogue to the try function.
withError :: MonadError e m => (e -> e) -> m a -> m a #
MonadError analogue to the withExceptT function.
Modify the value (but not the type) of an error. The type is
fixed because of the functional dependency m -> e. If you need
to change the type of e use mapError or modifyError.
handleError :: MonadError e m => (e -> m a) -> m a -> m a #
As handle is flipped catch, handleError
is flipped catchError.
mapError :: (MonadError e m, MonadError e' n) => (m (Either e a) -> n (Either e' b)) -> m a -> n b #
MonadError analogue of the mapExceptT function. The
computation is unwrapped, a function is applied to the Either, and
the result is lifted into the second MonadError instance.
modifyError :: (Exception e, MonadCatch m, MonadError e' m) => (e -> e') -> ExceptCatchT e m a -> m a Source #
Like modifyError, but it selects the ExceptCatchT instance for IO
exceptions instead of the ExceptT instance with an Either error.
Since: 0.1.0.0