ModuleFailT-0.1.2.0Haskell2010

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.

3 types
17 values

PackageFailT-0.1.2.0
Exports20
LanguageHaskell2010
LicenceBSD-3-Clause
SourceText.hs

typetype Fail = Fail Text

Version of Fail restricted to Text

valuerunFail :: Fail a -> Either Text a

Version of runFail restricted to Text

valuerunFailLast :: Fail a -> Either Text a

Version of runFailLast restricted to Text

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

Version of runFailAgg restricted to Text

valueerrorFail :: 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.

valueerrorFailWithoutStackTrace :: Fail a -> a

Version of errorFailWithoutStackTrace restricted to Text

Same as errorFail, but without the stack trace:

Example3 expressions

>>> 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"

typetype FailT = FailT Text

Version of FailT restricted to Text

Fail monad transformer that plays well with MonadFail

datadata FailException where

An exception that is produced by the FailT monad transformer.

Constructors

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

Instances2Show, Exception

Show FailExceptionDefined in FailT-0.1.2.0 · Control.Monad.Trans.Fail
Exception FailExceptionDefined in FailT-0.1.2.0 · Control.Monad.Trans.Fail

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

Version of failT restricted to Text

Monomorphic synonym for fail

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

Version of failManyT restricted to Text

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

Version of runFailT restricted to Text

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

Version of runFailLastT restricted to Text

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

Version of runFailAggT restricted to Text

valuehoistFailT :: (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

valuemapFailT

:: 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.

valuemapErrorFailT :: 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.

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

Version of F.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:

Example1 expression

>>> runFail (mapErrorsFailT (const [] :: [Text] -> [Text]) $ fail "Something went wrong" >> pure ())Left "No failure reason given"

valueexceptFailT

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

Version of exceptFailT restricted to Text

valuethrowErrorFailT

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

Version of throwErrorFailT restricted to Text

Same as exceptFailT, but works with any MonadError.

Example2 expressions

>>> 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):...

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

Version of throwFailT restricted to Text