h&~dx      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv w x y z { | } ~                                               (c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None$'(+-./2:<=>? cleffCoerce any boxed value into . cleffCoerce  to a boxed value. This is generally unsafe and it is your responsibility to ensure that the type you're coercing into is the original type that the  is coerced from.  (c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None%'(+-./2:<=>? cleff A pointer to  in an  . cleffThe effect environment; that corresponds effects in the stack to their respective s. This structure simulates memory: handlers are retrieved via pointers ( s), and for each effect in the stack we can either change what pointer it uses or change the handler the pointer points to. The former is used for global effect interpretation (+) and the latter for local interpretation () in order to retain correct HO semantics. For more details on this see  (https://github.com/re-xyr/cleff/issues/5. cleff(The extensible effects monad. The monad   es, is capable of performing any effect in the  effect stack es, which is a type-level list that holds all effects available. However, most of the times, for flexibility, es should be a polymorphic type variable, and you should use the  and  operators in constraints to indicate what effects are in the stack. For example, (    es,     es) =>   es  (means you can perform operations of the    effect and the   ' effect in a computation returning an .cleff0The effect monad receives an effect environment  3 that contains all effect handlers and produces an  action.cleffThe internal representation of effect handlers. This is just a natural transformation from the effect type e (  es) to the effect monad   es for any effect stack es.In interpreting functions (see Cleff.Internal.Interpret), the user-facing % type is transformed into this type.cleffxs  es means the list of effects xs% are all present in the effect stack es'. This is a convenient type alias for (e1  es, ..., en  es).cleffe  es means the effect e is present in the effect stack es#, and therefore can be used in an  es computation.cleffThe type of effects. An effect e m a takes an effect monad type m ::  ->  and a result type a :: .cleffCreate an empty   with no address allocated.cleff-Adjust the effect stack via an function over .cleff-Allocate a new, empty address for a handler.  O(1) .cleff&Read the handler a pointer points to.  O(1) .cleff+Overwrite the handler a pointer points to.  O(1) .cleff7Replace the handler pointer of an effect in the stack.  O(n) .cleffAdd a new effect to the stack with its corresponding handler pointer.  O(n) .cleff1Use the state of LHS as a newer version for RHS.  O(1) .cleffPerform an effect operation, i.e. a value of an effect type e :: . This requires e to be in the effect stack.cleffPerform an action in another effect stack via a transformation to that stack; in other words, this function "maps" the effect operation from effect stack es to es'+. This is a largely generalized version of 9; only use this if you are sure about what you're doing.  =      00(c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None&'(+-./2:<=>?&$cleff9The type of a simple transformation function from effect e to e'.%cleffThe type of an effect handler0, which is a function that transforms an effect e from an arbitrary effect stack into computations in the effect stack es.&cleffYou should not define instances for this typeclass whatsoever.'cleffAdjust the effect stack by a contravariant transformation function over the stack. This function reveals the profunctorial nature of  ; in particular,   is a profunctor [] -> , lmap is ', and rmap is .(cleffLift a computation into a bigger effect stack with one more effect. For a more general version see ).)cleffLift a computation into a bigger effect stack with arbitrarily more effects. This function requires TypeApplications.*cleffLike (, but adds the new effect under the top effect. This is useful for transforming an interpreter e'  es =>   (e ': es)    es into a reinterpreter   (e ': es)    (e' ': es): myInterpreter :: Bar  es =>   (Foo ': es)   , es myInterpreter = ... myReinterpreter ::   (Foo ': es)   - (Bar ': es) myReinterpreter = myInterpreter  * In other words, 3 h == 2 h . * However, note that this function is suited for transforming an existing interpreter into a reinterpreter; if you want to define a reinterpreter from scratch, you should still prefer 32, which is both easier to use and more efficient.+cleffLike *, but allows introducing multiple effects. This function requires TypeApplications.,cleffLike *, but allows introducing the effect under multiple effects. This function requires TypeApplications.-cleffA generalization of both , and +, allowing introducing multiple effects under multiple effects. This function requires TypeApplications and is subject to serious type ambiguity; you most likely will need to supply all three type variables explicitly..cleffLift a computation with a fixed, known effect stack into some superset of the stack./cleffEliminate a duplicate effect from the top of the effect stack. For a more general version see 0.0cleffEliminate several duplicate effects from the top of the effect stack. This function requires TypeApplications.1cleffGet the send-site  .2cleffInterpret an effect e) in terms of effects in the effect stack es with an effect handler.3cleffLike 2, but adds a new effect e'! that can be used in the handler.4cleffLike 3, but adds two new effects.5cleffLike 3, but adds three new effects.6cleffLike 3, but adds arbitrarily many new effects. This function requires TypeApplications.7cleffRespond to an effect while being able to leave it unhandled (i.e. you can resend the effects in the handler).8cleffLike 7?, but allows to introduce one new effect to use in the handler.9cleffLike 8, but allows introducing arbitrarily many effects. This requires TypeApplications.:cleffInterpret an effect in terms of another effect in the stack via a simple $. : trans = 2 ( <  trans) ;cleffLike :, but instead of using an effect in stack, add a new one to the top of it. ; trans = 3 ( <  trans) <cleffRun a computation in the current effect stack. This is useful for interpreting higher-order effects, like a bracketing effect: data Resource m a where Bracket :: m a -> (a -> m ()) -> (a -> m b) -> Resource m b Bracket alloc dealloc use ->  (< alloc) (< . dealloc) (< . use) =cleffRun a computation in the current effect stack, but handles the current effect inside the computation differently by providing a new %. This is useful for interpreting effects with local contexts, like  : runReader :: r ->   (  r ': es)    es runReader x = 2' (handle x) where handle :: r -> % ( " r) es handle r = \case   ->  r   f m -> = (handle $ f r) m >cleff*Temporarily gain the ability to lift some   es actions into   esSend. This is useful for dealing with effect operations with the monad type in the negative position, which means it's unlikely that you need to use this function in implementing your effects.$%&'()*+,-./0123456789:;<=>'()./0*+,-&1%$23456789:;<=>(c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None$'(+-./2:<=>?(?cleffCompatibility instance for MonadComprehensions.@cleffAcleffBcleffCcleffDcleffEcleffFcleff(c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None%'(+-./2:<=>?3 GcleffThe type of an  effect handler0, which is a function that transforms an effect e into ! computations. This is used for N.Hcleff0The effect capable of lifting and unlifting the  monad, allowing you to use , , , ,  and  functionalities. This is the "final" effect that most effects eventually are interpreted into. For example, you can do: log :: H :> es =>   es () log =  ( "Test logging") It is not recommended to use this effect directly in application code, as it is too liberal and allows arbitrary IO, therefore making it harder to do proper effect management. Ideally, this is only used in interpreting more fine-grained effects.Technical detailsNote that this is not< a real effect and cannot be interpreted in any way besides K and L. This is mainly for performance concern, but also that there doesn't really exist reasonable interpretations other than the current one, given the underlying implementation of the   monad.H5 can be a real effect though, and you can enable the  dynamic-ioe build flag to have that. However it is only for reference purposes and should not be used in production code.IcleffLift an  computation into  . This function is  highly unsafe& and should not be used directly; use ? instead, or if you're interpreting higher-order effects, use P.Jcleff$Give a runner function a way to run   actions as an  computation. This function is  highly unsafe' and should not be used directly; use ? instead, or if you're interpreting higher-order effects, use O.KcleffUnsafely eliminate an H effect from the top of the effect stack. This is mainly for implementing effects that uses ! but does not do anything really impure (i.e. can be safely used  on), such as a State effect.Lcleff Unwrap an  ' computation with side effects into an 0 computation, given that all effects other than H are interpreted.McleffUnwrap a pure   computation into a pure value, given that all effects are interpreted.Ncleff Interpret an effect in terms of !, by transforming an effect into  computations. N f = 2 (  f) Ocleff*Temporarily gain the ability to unlift an   esSend computation into . This is useful for dealing with higher-order effects that involves .PcleffLift an  computation into   esSend. This is useful for dealing with effect operations with the monad type in the negative position within , like ing.RcleffCompatibility instance; use  if possible.ScleffCompatibility instance; use  if possible. GHIJKLMNOP HIJKLMGNOP(c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None%'(+-./2:<=>?:YcleffFor a datatype T representing an effect, Y T generates functions defintions for performing the operations of T via . The naming rule is changing the first uppercase letter in the constructor name to lowercase or removing the : symbol in the case of operator constructors. Also, this function will preserve any fixity declarations defined on the constructors.Because of the limitations of Template Haskell, all constructors of T should be polymorphic in the monad type, if they are to be used by Y. For example, this is not OK: data Limited ::  where Noop :: Limited (  es) () because the monad type   es* is not a fully polymorphic type variable.$This function is also "weaker" than polysemy's makeSem, because this function cannot properly handle some cases involving complex higher order effects. Those cases are rare, though. See the tests for more details.ZcleffLike Y, but doesn't generate type signatures. This is useful when you want to attach Haddock documentation to the function signature, e.g.: data Identity ::  where Noop :: Identity m () Z; ''Identity -- | Perform nothing at all. noop :: Identity  es =>   es () 6Be careful that the function signatures must be added after the Z call.YZYZ(c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy$'(+-./2:<=>?:0 $%&()*+,-./023456789:;<=>GHLMNOPYZ0 HMLYZ()./0%23456789GN$:;*+,-&<=>OP(c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy%'(+-./2:<=>?F.[cleffAn effect capable of breaking out of current control flow by throwing an error of type e, and handling the errors thrown from computations. This effect roughly corresponds to the  MonadError typeclass and ExceptT monad transformer in mtl.^cleffHandle an error if one is thrown from a computation, and then return to normal control flow._cleff*Throw an error in the current computation.`cleffLift an  value into the [ effect.acleff Lift exceptions generated by an  computation into the [ effect.bcleffLike a, but allows to transform the exception into another error type.ccleff Lift exceptions generated by an   computation into the [ effect.dcleffLike c, but allows to transform the exception into another error type.ecleffTry to extract a value from , throw an error otherwise.fcleff A variant of ^5 that allows a predicate to choose whether to catch () or rethrow ( ) the error.gcleff A variant of ^5 that allows a predicate to choose whether to catch () or rethrow ( ) the error.hcleffFlipped version of ^.icleffFlipped version of f.jcleffFlipped version of g.kcleff Runs a computation, returning a  value if an error was thrown.lcleff A variant of k5 that allows a predicate to choose whether to catch () or rethrow ( ) the error.mcleffRun an [ effect.Caveatsm is implemented with s therefore inherits some of its unexpected behaviors. Errors thrown in forked threads will not be directly caught by ^s in the parent thread. Instead it will incur an exception, and we won't be quite able to display the details of that exception properly at that point. Therefore please properly handle the errors in the forked threads separately.However if you use async and wait for the action in the same effect scope (i.e. they get to be interpreted by the same m handler), the error will be caught in the parent thread even if you don't deal with it in the forked thread. But if you passed the Async# value out of the effect scope and waited for it elsewhere, the error will again not be caught. The best choice is  not to pass Async values around randomly.ncleff Transform an [ into another. This is useful for aggregating multiple errors into one type.^cleff%The computation that may throw errorscleff2The handler that is called when an error is thrown[]\^_`abcdefghijklmn[]\_^`abcdefghijklmn(c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy$'(+-./2:<=>?GqcleffAn effect that expresses failure with a message. This effect allows the use of the  class.scleffRun a q effect in terms of [.tcleffRun a q+ effect in terms of throwing exceptions in .qrstqrst (c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy$'(+-./2:<=>?Wn vcleffAn effect capable of ing and performing cleanup operations when an computation is interrupted. In particular, this effects allows the use of }.Technical detailsRegarding the nuances of }. semantics, this effect uses the semantics of UnliftIO.Exception rather than Control.Exception. They are more sensible defaults and users can implement other semantics out of the primitive operations if they want to.zcleffLike , but without {ing the cleanup action, making it possible that a cleanup action is interrupted. Use  is usually the safer option.{cleffPrevents a computation from receiving asynchronous exceptions, even if there is an interruptible operation (operations that potentially deadlocks or otherwise blocks indefinitely). Therefore this function is potentially dangerous in the sense that it can make a thread both unresponsive and unkillable. See   for details.|cleffPrevents a computation from receiving asynchronous exceptions, i.e. being interrupted by another thread. Also provides a function to restore receiving async exceptions for a computation.0However, some potentially blocking actions like takeMVar can still be interrupted, and for them also not to be interrupted in any case you'll need {. See ! for details.}cleff,Run a computation that acquires a resource (alloc), then a main computation using that resource, then a cleanup computation (dealloc). } guarantees that alloc and dealloc will always run, regardless of whether an exception is thrown in the main computation. Note that if an exception is thrown in the main computation, it will be rethrown after } finishes.Technical detailsNote that this function uses unliftio7 semantics: resource acquiring action is interruptibly |ed while resource cleanup is {ed. Most of the times, this will be what you want. Other functions in this module use unliftio semantics too.~cleffLike }, but only runs cleanup if an exception is thrown in the main computation.cleff Variant of |, that does not provide a restoring function.cleff Variant of {, that does not provide a restoring function.cleff Variant of } that does not pass the allocated resource to the cleanup action.cleff Variant of ~ that does not pass the allocated resource to the cleanup action.cleffAttach an action that runs if the main computation throws an exception. Note that this will rethrow the exception instead of returning to normal control flow.The cleanup action is guaranteed not to be interrupted halfways.cleffAttach a cleanup action that will always run after a potentially throwing computation.cleffInterpret the v effect in terms of primitive  actions.zcleff0The main computation that may throw an exceptioncleff5The computation that runs when an exception is thrown}cleff9The computation to run first, usually acquires a resourcecleffThe computation to run after the main computation, usually cleans upcleff+The main computation that uses the resource~cleff9The computation to run first, usually acquires a resourcecleffThe computation to run when the main computation throws an exception, usually cleans upcleff+The main computation that uses the resourcecleff0The main computation that may throw an exceptioncleff5The computation that runs when an exception is throwncleff0The main computation that may throw an exceptioncleffThe computation that runs after the main computation, regardless of whether an exception is thrownvwxyz{|}~vwxy}~|{z (c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy$'(+-./2:<=>?Zcleff8An effect capable of providing an immutable environment r4 that can be read. This roughly corresponds to the  MonadReader typeclass and ReaderT monad transformer in the mtl library.cleff;Modify the environment value temporarily for a computation.cleffObtain the environment value.cleff"Apply a function to the result of .cleffRun a ' effect with a given environment value.cleffRun a  effect in terms of a larger  via a .cleff*The function that modifies the environmentcleff4The computation to run with the modified environment (c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy$'(+-./2:<=>?br cleff/An effect capable of providing a mutable state s that can be read and written. This roughly corresponds to the  MonadState typeclass and StateT monad transformer in the mtl library.cleffModify the state and/ produce a value from the state via a function.cleff"Update the state with a new value.cleffRead the current state.cleff"Apply a function to the result of .cleff-Modify the value of the state via a function.cleffRun the  effect.CaveatsThe ! interpreter is implemented with "#s and there is no way to do arbitrary atomic transactions. The 7 operation is atomic though and it is implemented with , which can be faster than atomicModifyIORef in contention. For any more complicated cases of atomicity, please build your own effect that uses either MVars or TVars based on your need.Unlike mtl, in cleff the state will not revert when an error is thrown. will stop taking care of state operations done on forked threads as soon as the main thread finishes its computation. Any state operation done before main thread finishes is still taken into account.cleffRun the - effect in terms of operations on a supplied . The  operation is atomic.cleffRun the - effect in terms of operations on a supplied .cleffRun the - effect in terms of operations on a supplied .cleffRun a  effect in terms of a larger  via a .cleffThe function that takes the state and returns a result value together with a modified state (c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy$'(+-./2:<=>?f% cleffAn effect that is capable of reading from some input source, such as an input stream.cleff)Read an input value from an input source.cleff"Apply a function to the result of .cleffRun an ) effect by giving a constant input value.cleffRun an * effect by going through a list of values.cleffRun an  in terms of a .cleffRun an ; effect by performing a computation for each input request.cleff Transform an  effect into another one already in the effect stack, by a pure function.cleff Transform an  effect into another one already in the effect stack, by an effectful computation.   (c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy$'(+-./2:<=>?icleffAn effect capable of generating unique values. This effect can be useful in generating variable indices.cleffObtain a fresh unique value.cleff Interpret a  a in terms of  a for any  . Every time ' is called to generate the next value.cleff Interpret a   effect in terms of  $. This is a specialized version of .cleff Interpret a   effect in terms of a $%. This is usually faster than .cleff Interpret a  4 effect in terms of IO actions. This is slower than , but it won't overflow on  :: .(c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy$'(+-./2:<=>?qcleffAn effect capable of accumulating monoidal outputs. This roughly corresponds to the  MonadWriter typeclass and WriterT monad transformer in the mtl library.(However, note that this does not have a pass operation as we are not sure what its semantics should be. In fact, the pass semantics in mtl is also unclear and will change when handlers are put in different orders. To avoid any confusion we decided it is best that we don't include it because no one seems to be relying on it anyway.cleffMonitor the output of a computation, and return the output alongside the computation's result.cleff=Produces an output that is appended to the accumulated value.cleff.Apply a function to the accumulated output of .cleffRun a monoidal  effect.CaveatsBoth  and s under  will stop taking care of writer operations done on forked threads as soon as the main thread finishes its computation. Any writer operation done before main thread finishes is still taken into account.cleffRun a monoidal  effect, but appends the listened output to the parent value only when the listen operation finishes. This means that when you run two s on two threads, the values ed inside will not be appended to the parent value in real time, but only after the thread finishes ing. For example, this code & (   "1"   "2"   "3") (   "4"   "5"   "6") will produce either "123456" or "456123" with 2, but may produce these digits in any order with ./This version of interpreter can be faster than  in 0-intense code. It is subject to all caveats of .(c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy$'(+-./2:<=>?ucleffAn effect that is capable of producing outputs, for example writing to a log file or an output stream.cleffProduce an output value.cleffRun an  effect by accumulating a list. Note that outputs are being prepended to the head of the list, so in many cases you would want to  the result.cleffRun an ! effect by translating it into a .cleffIgnore outputs of an  effect altogether.cleffRun an 4 effect by performing a computation for each output.cleff Transform an  effect into another one already in the effect stack, by a pure function.cleff Transform an  effect into another one already in the effect stack, by an effectful computation.  (c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy$'(+-./2:<=>?x;cleffAn effect capable of logging messages, mostly for debugging purposes.cleffOutput a trace message.cleffRun the  effect by writing to a .cleffRun the  effect by writing to .cleffRun the  effect by writing to .cleffRun the + effect by ignoring all outputs altogether.cleffTransform the  effect into an   effect.'None%'(+-./2:<=>?x()*+,-+,./01/02/03/045675689:;<=>>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !                                                +()()()/0++++++!++++()()++++!+#++++()++++++++''''''''cleff-0.3.0.0-inplaceCleff.Internal.AnyCleffCleff.Internal.MonadCleff.Internal.InterpretCleff.Internal.InstancesCleff.Internal.Base Cleff.Error Cleff.Fail Cleff.Mask Cleff.Reader Cleff.State Cleff.Input Cleff.Fresh Cleff.Writer Cleff.Output Cleff.Trace reinterpretN toEffWithReaderStateHandlerEff Data.KindTypeUnliftIObracketLocalAskIOECleff.Internal.THControl.ExceptionuninterruptibleMaskmask Data.IORefIORefData.Atomics.Counter AtomicCounter concurrently_ Paths_cleffghc-prim GHC.TypesAnybaseControl.Monad.IO.ClassliftIOMonadIOrec-smallarray-0.1.0.0-e2041873836fced6be1b59bbe77e6999a54b5580d98e0b9559bee7138c51c681Data.Rec.SmallArray++ KnownListSubset~>unliftio-core-0.2.0.1-e01f5ed3511cc7eceebc04c6d661c9994774650ec89a07c164849d97f27e61f8Control.Monad.IO.Unlift withRunInIO MonadUnliftIOtoAnyfromAny HandlerPtrEnvunEffInternalHandler runHandler:>>:>EffectemptyEnv adjustEnv allocaEnvreadEnvwriteEnv replaceEnv appendEnv updateEnvsendsendVia $fMonadFixEff $fMonadEff$fApplicativeEff $fFunctorEff TranslatorHandlingadjustraiseraiseN raiseUnder raiseNUnder raiseUnderN raiseNUnderNinjectsubsumesubsumeNesSend interpret reinterpret reinterpret2 reinterpret3 interposeimposeimposeN transform translatetoEff withFromEff $fMonadZipEff $fIsStringEff $fFloatingEff$fFractionalEff$fNumEff $fMonoidEff$fSemigroupEff $fBoundedEff HandlerIO primLiftIO primUnliftIOthisIsPureTrustMerunIOErunPure interpretIOwithToIOfromIO$fPrimMonadEff$fMonadBaseControlIOEff$fMonadBaseIOEff$fMonadMaskEff$fMonadCatchEff$fMonadThrowEff$fMonadUnliftIOEff $fMonadIOEff makeEffect makeEffect_Error ThrowError CatchError catchError throwError fromEither fromExceptionfromExceptionViafromExceptionEfffromExceptionEffVianotecatchErrorJust catchErrorIf handleErrorhandleErrorJust handleErrorIftryError tryErrorJustrunErrormapError$fShowErrorExc$fExceptionErrorExcFailrunFail runFailIO$fMonadFailEffMaskUninterruptibleMask OnException onExceptionbracketOnErrormask_uninterruptibleMask_bracket_bracketOnError_onErrorfinallyrunMasklocalaskasks runReadermagnifyGetPutstateputgetgetsmodifyrunState runStateIORef runStateMVar runStateTVarzoomInputinputinputs runInputConstinputToListState inputToReader runInputEffmapInput bindInputFreshfreshfreshEnumToStatefreshIntToStaterunFreshAtomicCounterrunFreshUniqueWriterTellListenlistentelllistens runWriterrunWriterBatchOutputoutputoutputToListStateoutputToWriter ignoreOutput runOutputEff mapOutput bindOutputTracetracerunTraceHandlerunTraceStdoutrunTraceStderr ignoreTrace traceToOutputGHC.BaseStringBoolinteger-wired-inGHC.Integer.TypeIntegerIORecidfmap.pureprimitive-0.7.3.0-ab8104f4a6c5bcace27e4a385271dc96d2186f34c091b7c80bfd9bcc6b69faa5Control.Monad.Primitive PrimMonadexceptions-0.10.4Control.Monad.Catch MonadCatch MonadThrow MonadMask System.IOputStrLn GHC.IO.UnsafeunsafeDupablePerformIOunliftio-0.2.20.1-42a8c4186fc60b82c86270fec5ab1031f28e3286907b0ed4370be6f9119ac91dUnliftIO.Exception Data.EitherEither GHC.MaybeMaybeJustNothingTrueFalseLeftGHC.Exception.Type ExceptionControl.Monad.Fail MonadFailGHC.IOmicrolens-0.4.12.0-556412785a6d87023ef2a172dca6dae6480b8d0138d42e9e8b02752ae0ea58dcLens.Micro.TypeLens'atomic-primops-0.8.4-fb800de0513e4ae397d0192bad27b80bfb3cf03afb8816497bd483676969ec91 Data.AtomicsatomicModifyIORefCAS GHC.IORefGHC.MVarMVar GHC.Conc.SyncTVarGHC.EnumEnumsuccInt Data.UniqueUniquemaxBound$>>GHC.ListreverseGHC.IO.Handle.TypesHandleGHC.IO.Handle.FDstdoutstderrversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir