FailT transformer with Identity as the base monad.

Unwrap the pure Fail monad and reveal the underlying result of monadic computation.

>>> runFail (fail "Something went wrong") :: Either String ()
Left "Something went wrong"
>>> runFail (failT "Something went wrong" >> pure ())
Left "Something went wrong"
>>> import Control.Applicative
>>> runFail (failT "Something could have gone wrong" <|> pure ())
Right ()

All errors accrued during the monadic computation will be combined using the Semigroup instance and delimited by a comma:

>>> runFail (fail "One thing went wrong" <|> fail "Another thing went wrong") :: Either String ()
Left "One thing went wrong, Another thing went wrong"

Failing with one of instances functions mempty or empty will yield a no-reason error report:

>>> runFail mempty :: Either String ()
Left "No failure reason given"

This is a variant of runFailAgg where only the error reported for the very last failed computation will be produced and others discarded. This is useful when it is not relevant to retain information about all the attempts and only the last one matters, eg. parsing with backtracking.

Convert a Fail monad computation in an Either, where the Left will contain all failures in the same order they where received, or Right upon a successful computation.

>>> runFailAgg (fail "One bad thing" <|> fail "Another bad thing") :: Either [String] ()
Left ["One bad thing","Another bad thing"]
>>> runFailAgg (fail "A bad thing" <|> pure "A good thing") :: Either [String] String
Right "A good thing"

Throw an error if there was a failure, otherwise return the result of computation. Use throwFailT in case you'd like to handle an actual exception in some other underlying monad.

>>> errorFail (fail "This didn't work" :: Fail String ())
*** Exception: "This didn't work"
CallStack (from HasCallStack):
...
>>> errorFail (fail "This didn't work" <|> pure "That Worked" :: Fail String String)
"That Worked"

Same as errorFail, but without the stack trace:

>>> errorFailWithoutStackTrace (fail "This didn't work" :: Fail String ())
*** Exception: "This didn't work"
>>> errorFailWithoutStackTrace (fail "This didn't work" <|> pure "That Worked" :: Fail String String)
"That Worked"

Fail monad transformer that plays well with MonadFail type class.

An exception that is produced by the FailT monad transformer.

Similar to fail, but it is not restricted to String.

Similar to runFail, except underlying monad is not restricted to Identity.

Unwrap the FailT monad transformer and produce an action that can be executed in the underlying monad and, which will produce either a comma delimited error message upon a failure or the result otherwise.

>>> runFailT (failT "Could have failed" <|> liftIO (putStrLn "Nothing went wrong"))
Nothing went wrong
Right ()

Similar to runFailLast, except underlying monad is not restricted to Identity.

Similar to runFailAgg, except underlying monad is not restricted to Identity.

Change the underlying monad with the hoisting function.

Map a function over the underlying representation of the FailT monad.

Map a function over the error type in the FailT monad.

Map a function over the aggregation of errors in the FailT monad. Could be used for example for clearing our all of the aggregated error messages:

>>> runFail (mapErrorsFailT (const []) $ failT "Something went wrong") :: Either String ()
Left "No failure reason given"

Convert a FailT computation into an ExceptT.

>>> exceptFailT (fail "A bad thing" >> pure () :: Fail String ())
ExceptT (Identity (Left FailException
"A bad thing"
CallStack (from HasCallStack):
...

Use the MonadThrow instance to raise a FailException in the underlying monad.

>>> throwFailT (failT "One thing went wrong")
*** Exception: FailException
"One thing went wrong"
...
>>> throwFailT (failT "One thing went wrong") :: Maybe ()
Nothing

Lift a catchE operation to the new monad.

Lift a listen operation to the new monad.

Lift a pass operation to the new monad.