Escape from the ResultT monad.

The type signature of runResultT obliges the library user to deal with errors, with functions such as recover, recoverMany, etc.

Abort the current computation and raise an error to describe the reason

Similarly to, e.g. Nothing for Maybe, abort is a computation shortcut. The rest of the monadic computation is not executed, and the error is transmitted to the caller computation. Using the recover, recoverWhile or recoverMany functions to stop the chain.

Declaratively describe the purpose of a computation.

Using achieve in various places, it becomes possible, once an error is raised, to determine more easily its context. achieve has an operator counterpart: '(?)'. The former should be used to contextualise a do-block, whereas the latter can be prefered for monadic function calls.

achieve "try to get configuration" $ do
    f <- readParseFile "main" <?> "read main file"
    f' <- readParseFile "aux" <?> "read aux file"
    pure $ buildConfiguration f f'

These contextual messages are made available, in addition to the error, when using functions such as recover, recoverMany, repeatUntil etc.

See achieve.

Always execute a given computation (called finally block thereafter) after a first computation (try block) has been completed.

The finally block is executed even if the try block is aborted. This allows to deal with clean-up code that has to be executed no matter what happened.

Temporally allows one given error type by providing an error handler to execute in case of failure.

Combine recover and achieve.

Similarly to recover, but with more than one error type

See +> and eoh to build the Handler.

Similarly to recoverMany, but use the same error handler for every error types.

All the error types has to implement a given typeclass.

Repeat a computation which may fail until it fails with a given error.

Typical use case is reading a file line by line, until reaching its end. If you want to carry some state, you can have a look at foldUntil.

Same as repeatUntil, but without an error handler.

Similarly to repeatUntil, repeat a computation until a given error; in addition, carry an accumulator.

Same as foldUntil, but without the error handler part.

Stands for “end of handler”.