Control.Monad.Trans.Fail.Text

This module contains a synonym for FailT e m a transformer, where failure type e is restricted to Text. All functions in this module have the same names and are a drop-in replacement for Control.Monad.Trans.Fail module, except with monomorphic failure type.

Documentation

type Fail = Fail Text

Version of Fail restricted to Text

runFail :: Fail a -> Either Text a

Version of runFail restricted to Text

runFailLast :: Fail a -> Either Text a

Version of runFailLast restricted to Text

runFailAgg :: Fail a -> Either [Text] a

Version of runFailAgg restricted to Text

errorFail :: HasCallStack => Fail a -> a

Version of errorFail restricted to Text

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

errorFailWithoutStackTrace :: Fail a -> a

Version of errorFailWithoutStackTrace restricted to Text

Same as errorFail, but without the stack trace:

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

type FailT = FailT Text

Version of FailT restricted to Text

Fail monad transformer that plays well with MonadFail

data FailException where

An exception that is produced by the FailT monad transformer.

Constructors

FailException

Fields

• :: (Typeable e, Show e)
• => { failMessages :: [e]
•    , failCallStack :: CallStack
•    } -> FailException

Instances

Exception FailException

Defined in Control.Monad.Trans.Fail

Methods

toException :: FailException -> SomeException

fromException :: SomeException -> Maybe FailException

displayException :: FailException -> String

Show FailException

Defined in Control.Monad.Trans.Fail

Methods

showsPrec :: Int -> FailException -> ShowS

show :: FailException -> String

showList :: [FailException] -> ShowS

failT :: Applicative m => Text -> FailT m a

Version of failT restricted to Text

Monomorphic synonym for fail

failManyT :: Applicative m => [Text] -> FailT m a

Version of failManyT restricted to Text

Since: 0.1.2

runFailT :: Functor m => FailT m a -> m (Either Text a)

Version of runFailT restricted to Text

runFailLastT :: Functor m => FailT m a -> m (Either Text a)

Version of runFailLastT restricted to Text

runFailAggT :: FailT m a -> m (Either [Text] a)

Version of runFailAggT restricted to Text

hoistFailT :: (forall a. m a -> n a) -> FailT m b -> FailT n b

Version of hoistFailT restricted to Text

Change the underlying monad with the hoisting function

mapFailT :: (m (Either [Text] a) -> n (Either [Text] b)) -> FailT m a -> FailT n b

Version of mapFailT restricted to Text

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

mapErrorFailT :: Functor m => (e -> Text) -> FailT e m a -> FailT m a

Version of mapErrorFailT where resulting type is restricted to Text

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

mapErrorsFailT :: Functor m => ([e] -> [Text]) -> FailT e m a -> FailT m a

Version of mapErrorsFail, where resulting type is restricted to Text

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 [] :: [Text] -> [Text]) $ fail "Something went wrong" >> pure ())
Left "No failure reason given"

exceptFailT :: (HasCallStack, Monad m) => FailT m a -> ExceptT FailException m a

Version of exceptFailT restricted to Text

throwErrorFailT :: (HasCallStack, MonadError FailException m) => FailT m a -> m a

Version of throwErrorFailT restricted to Text

Same as exceptFailT, but works with any MonadError.

>>> import Control.Monad.Trans.Fail.Text
>>> throwErrorFailT (fail "A bad thing" >> pure () :: FailT (Except FailException) ())
ExceptT (Identity (Left FailException
"A bad thing"
CallStack (from HasCallStack):
...

throwFailT :: (HasCallStack, MonadThrow m) => FailT m a -> m a

Version of throwFailT restricted to Text