Îõ³h&*6(Ý      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ (c) Alexey Kuleshevich 2022-2023BSD3(Alexey Kuleshevich  experimental non-portable Safe-Inferred"')*ÁÂÃÄÅ×Üã%FailT%An exception that is produced by the  monad transformer.FailT,Fail monad transformer that plays well with ] type class.FailT transformer with ^ as the base monad.FailTUnwrap the pure À monad and reveal the underlying result of monadic computation.9runFail (fail "Something went wrong") :: Either String ()Left "Something went wrong"1runFail (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 _# instance and delimited by a comma:ÝrunFail (fail "One thing went wrong" <|> fail "Another thing went wrong") :: Either String ()5Left "One thing went wrong, Another thing went wrong"(Failing with one of instances functions ` or a& will yield a no-reason error report:"runFail mempty :: Either String ()Left "No failure reason given"FailTThis is a variant of  ÿ 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. FailT Convert a  monad computation in an b , where the cÆ will contain all failures in the same order they where received, or d 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] StringRight "A good thing" FailTØThrow an error if there was a failure, otherwise return the result of computation. Use Ò in case you'd like to handle an actual exception in some other underlying monad.5errorFail (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" FailTSame as  , 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" FailT Similar to e, but it is not restricted to f. FailT Similar to /, except underlying monad is not restricted to ^. Unwrap the ¾ 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 wrongRight ()FailT Similar to /, except underlying monad is not restricted to ^.FailT Similar to  /, except underlying monad is not restricted to ^.FailT7Change the underlying monad with the hoisting function.FailT9Map a function over the underlying representation of the  monad.FailT*Map a function over the error type in the  monad.FailT5Map a function over the aggregation of errors in the Ù 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"FailT Convert a  computation into an g.=exceptFailT (fail "A bad thing" >> pure () :: Fail String ())%ExceptT (Identity (Left FailException "A bad thing"CallStack (from HasCallStack):...FailTSame as , but works with any h.ÙthrowErrorFailT (fail "A bad thing" >> pure () :: FailT String (Except FailException) ())%ExceptT (Identity (Left FailException "A bad thing"CallStack (from HasCallStack):...FailTUse the i instance to raise a  in the underlying monad.)throwFailT (failT "One thing went wrong")*** Exception: FailException"One thing went wrong"...5throwFailT (failT "One thing went wrong") :: Maybe ()NothingjFailTLift a callCC operation to the new monad.FailTLift a catchE operation to the new monad.FailTLift a k operation to the new monad.FailTLift a l operation to the new monad.FailT/FailTÉExecutes all monadic actions and combines all successful results using a _Ñ instance. Combines together all failures as well, until a successful operation.0FailTÎShort-circuits on the first successful operation, combines failures otherwise.4FailT/Short-circuites on the first failing operation.    (c) Alexey Kuleshevich 2022-2023BSD3(Alexey Kuleshevich  experimental non-portable Safe-InferredÂ×܃9FailT Version of  restricted to f,Fail monad transformer that plays well with ]:FailT Version of  restricted to f;FailT Version of  restricted to f<FailT Version of  restricted to f=FailT Version of   restricted to f>FailT Version of   restricted to fàThrow an error if there was a failure, otherwise return the result of monadic computation. Use J2 in case you'd like to handle an actual exception.?FailT Version of  restricted to fSame as >, 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"@FailT Version of   restricted to fMonomorphic synonym for eAFailT Version of   restricted to fBFailT Version of  restricted to fCFailT Version of  restricted to fDFailT Version of  restricted to f6Change the underlying monad with the hoisting functionEFailT Version of  restricted to f9Map a function over the underlying representation of the 9 monad.FFailT Version of (, where resulting type is restricted to f*Map a function over the error type in the 9 monad.GFailT Version of (, where resulting type is restricted to f5Map a function over the aggregation of errors in the 9Ù 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"HFailT Version of  restricted to fIFailT Version of  restricted to fSame as H, but works with any h.&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):...JFailT Version of  restricted to f9:;<=>?@ABCDEFGHIJ:;<=>?9@ABCDEFGHIJ (c) Alexey Kuleshevich 2022-2023BSD3(Alexey Kuleshevich  experimental non-portable Safe-InferredÂ×Ü'ÞKFailT Version of  restricted to m,Fail monad transformer that plays well with ]LFailT Version of  restricted to mMFailT Version of  restricted to mNFailT Version of  restricted to mOFailT Version of   restricted to mPFailT Version of   restricted to màThrow an error if there was a failure, otherwise return the result of monadic computation. Use \2 in case you'd like to handle an actual exception.QFailT Version of   restricted to mSame as P, 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"RFailT Version of   restricted to mMonomorphic synonym for eSFailT Version of   restricted to mTFailT Version of  restricted to mUFailT Version of  restricted to mVFailT Version of  restricted to m6Change the underlying monad with the hoisting functionWFailT Version of  restricted to m9Map a function over the underlying representation of the K monad.XFailT Version of ' where resulting type is restricted to m*Map a function over the error type in the K monad.YFailT Version of (, where resulting type is restricted to m5Map a function over the aggregation of errors in the KÙ 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"ZFailT Version of  restricted to m[FailT Version of  restricted to mSame as Z, but works with any h.$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):...\FailT Version of  restricted to mKLMNOPQRSTUVWXYZ[\LMNOPQKRSTUVWXYZ[\î       !"#$%&'()*+,-./0123456789:;<=        >?@>AB>CD>CE>CF>GH>GI>GJ>?K>CLMNOPQRSTUVPWXPWYZ[\Ý$FailT-0.1.1.0-KvCCooOvM3d69HJ2HZ4tifControl.Monad.Trans.FailControl.Monad.Trans.Fail.StringControl.Monad.Trans.Fail.TextF mapErrorFail mapErrorsFail FailException failMessages failCallStackFailTFailrunFail runFailLast runFailAgg errorFailerrorFailWithoutStackTracefailTrunFailT runFailLastT runFailAggT hoistFailTmapFailT mapErrorFailTmapErrorsFailT exceptFailTthrowErrorFailT throwFailT liftCatch liftListenliftPass$fMonadContFailT$fMonadRWSrwsFailT$fMonadWriterwFailT$fMonadErroreFailT$fMonadStatesFailT$fMonadReaderrFailT$fMonadThrowFailT $fShowFailT $fReadFailT $fOrdFailT $fEqFailT $fShow1FailT $fRead1FailT $fOrd1FailT $fEq1FailT$fContravariantFailT$fMonadFixFailT$fMonadZipFailT$fMonadTransFailT$fMonadIOFailT $fMonoidFailT$fSemigroupFailT$fAlternativeFailT$fTraversableFailT$fFoldableFailT$fMonadFailFailT $fMonadFailT$fApplicativeFailT$fFunctorFailT$fExceptionFailException$fShowFailExceptionbaseControl.Monad.Fail MonadFailData.Functor.IdentityIdentityGHC.Base Semigroupmemptyempty Data.EitherEitherLeftRightfailStringtransformers-0.5.6.2Control.Monad.Trans.ExceptExceptT mtl-2.2.2Control.Monad.Error.Class MonadErrorexceptions-0.10.4Control.Monad.Catch MonadThrow liftCallCCControl.Monad.Writer.Classlistenpass text-1.2.5.0Data.Text.InternalText