| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
Control.Monad.Except.IO
Synopsis
- newtype ExceptIOT e m a = ExceptIOT {
- unsafeRunExceptIOT :: m a
- runExceptIOT :: (Exception e, MonadUnliftIO m) => ExceptIOT 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, MonadUnliftIO m, MonadError e' m) => (e -> e') -> ExceptIOT e m a -> m a
Documentation
newtype ExceptIOT e m a Source #
This type is useful for providing a MonadError constraint to an IO
action for a given type. It can replace ExceptT.
Note that catchError will use the behavior from UnliftIO - so catch won't
catch an asynchronous exception.
Since: 0.1.0.0
Constructors
| ExceptIOT | |
Fields
| |
Instances
runExceptIOT :: (Exception e, MonadUnliftIO m) => ExceptIOT e m a -> m (Either e a) Source #
Run an ExceptIOT action. This catches the thrown exception, but only if
it is the e that the type mentions. All other exceptions will remain
uncaught.
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, MonadUnliftIO m, MonadError e' m) => (e -> e') -> ExceptIOT e m a -> m a Source #
Like modifyError, but it selects the ExceptIOT instance for IO
exceptions instead of the ExceptT instance with an Either error.
Since: 0.1.0.0