Safe Haskell | Safe |
---|---|

Language | Haskell2010 |

Exception-producing and exception-handling effects

## Synopsis

- newtype Exc e v = Exc e
- exc :: Monad m => e -> m (Either e a)
- withException :: Monad m => a -> m (Either e a)
- type Fail = Exc ()
- throwError :: Member (Exc e) r => e -> Eff r a
- throwError_ :: Member (Exc e) r => e -> Eff r ()
- die :: Member Fail r => Eff r a
- runError :: Eff (Exc e ': r) a -> Eff r (Either e a)
- runFail :: Eff (Fail ': r) a -> Eff r (Maybe a)
- catchError :: Member (Exc e) r => Eff r a -> (e -> Eff r a) -> Eff r a
- onFail :: Eff (Fail ': r) a -> Eff r a -> Eff r a
- rethrowError :: Member (Exc e') r => (e -> e') -> Eff (Exc e ': r) a -> Eff r a
- liftEither :: Member (Exc e) r => Either e a -> Eff r a
- liftEitherM :: (Member (Exc e) r, Lifted m r) => m (Either e a) -> Eff r a
- liftMaybe :: Member Fail r => Maybe a -> Eff r a
- liftMaybeM :: (Member Fail r, Lifted m r) => m (Maybe a) -> Eff r a
- ignoreFail :: Eff (Fail ': r) a -> Eff r ()

# Documentation

Exceptions

exceptions of the type e; no resumption

Exc e |

## Instances

(MonadBase m m, LiftedBase m r) => MonadBaseControl m (Eff ((Exc e :: Type -> Type) ': r)) Source # | |

Monad m => Handle (Exc e :: Type -> Type) r a (m (Either e a)) Source # | Given a callback, and an |

Defined in Control.Eff.Exception handle :: (Eff r a -> m (Either e a)) -> Arrs r v a -> Exc e v -> m (Either e a) Source # handle_relay :: (r ~ (Exc e ': r'), Relay (m (Either e a)) r') => (a -> m (Either e a)) -> (Eff r a -> m (Either e a)) -> Eff r a -> m (Either e a) Source # respond_relay :: (a -> m (Either e a)) -> (Eff r a -> m (Either e a)) -> Eff r a -> m (Either e a) Source # | |

type StM (Eff ((Exc e :: Type -> Type) ': r)) a Source # | |

withException :: Monad m => a -> m (Either e a) Source #

Embed a pure value

throwError :: Member (Exc e) r => e -> Eff r a Source #

Throw an exception in an effectful computation. The type is inferred.

throwError_ :: Member (Exc e) r => e -> Eff r () Source #

Throw an exception in an effectful computation. The type is unit, which suppresses the ghc-mod warning "A do-notation statement discarded a result of type"

die :: Member Fail r => Eff r a Source #

Makes an effect fail, preventing future effects from happening.

runError :: Eff (Exc e ': r) a -> Eff r (Either e a) Source #

Run a computation that might produce an exception.

catchError :: Member (Exc e) r => Eff r a -> (e -> Eff r a) -> Eff r a Source #

Run a computation that might produce exceptions, and give it a way to deal with the exceptions that come up. The handler is allowed to rethrow the exception

Add a default value (i.e. failure handler) to a fallible computation. This hides the fact that a failure happened.

rethrowError :: Member (Exc e') r => (e -> e') -> Eff (Exc e ': r) a -> Eff r a Source #

Run a computation until it produces an exception, and convert and throw that exception in a new context.

liftEither :: Member (Exc e) r => Either e a -> Eff r a Source #

Treat Lefts as exceptions and Rights as return values.

liftEitherM :: (Member (Exc e) r, Lifted m r) => m (Either e a) -> Eff r a Source #

`liftEither`

in a lifted Monad