ModuleFailT-0.1.2.0Haskell2010

Control.Monad.Trans.Fail.String

This module contains a synonym for FailT e m a transformer, where failure type e is restricted to String. 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
SourceString.hs

typetype Fail = Fail String

Version of Fail restricted to String

valuerunFail :: Fail a -> Either String a

Version of runFail restricted to String

valuerunFailLast :: Fail a -> Either String a

Version of runFailLast restricted to String

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

Version of runFailAgg restricted to String

valueerrorFail :: HasCallStack => Fail a -> a

Version of errorFail restricted to String

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 runFail restricted to String

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 String

Version of FailT restricted to String

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 => String -> FailT m a

Version of failT restricted to String

Monomorphic synonym for fail

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

Version of failManyT restricted to String

Property

prop> runFailAgg (foldMap failT xs) == runFailAgg (failManyT xs)

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

Version of runFailT restricted to String

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

Version of runFailLastT restricted to String

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

Version of runFailAggT restricted to String

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

Version of hoistFailT restricted to String

Change the underlying monad with the hoisting function

valuemapFailT

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

Version of mapFailT restricted to String

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

valuemapErrorFailT :: Functor m => (e -> String) -> FailT e m a -> FailT m a

Version of F.mapErrorFail, where resulting type is restricted to String

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

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

Version of F.mapErrorsFail, where resulting type is restricted to String

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 []) $ failT "Something went wrong") :: Either String ()Left "No failure reason given"

valueexceptFailT

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

Version of exceptFailT restricted to String

valuethrowErrorFailT

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

Version of throwErrorFailT restricted to String

Same as exceptFailT, but works with any MonadError.

Example2 expressions

>>> import Control.Monad.Trans.Fail.String>>> 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 String