h&      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                     (c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None#'(+-./2:<=>?cleffType level list concatenation.cleffA natural transformation from f to g. With this, instead of writing runSomeEffect ::  (SomeEffect : es) a ->  es a you can write: runSomeEffect ::  (SomeEffect : es) ~>  es cleffThe type of effects. An effect e m a takes an effect monad type m ::  ->  and a result type a :: .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.  5(c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None&'(+-./2:<=>?  cleffes is a subset of es', i.e. all elements of es are in es'. cleffe   es means the effect e is present in the effect stack es, and therefore can be  ed in an  es computation. cleff  es means the list es is concrete, i.e. is of the form '[a1, a2, ..., an] instead of a type variable. cleff,Extensible record type supporting efficient  O(1) ) reads. The underlying implementation is  slices.cleffA pointer to an effect handler.cleffCreate an empty record.  O(1) .cleff!Prepend one entry to the record.  O(n) .cleffConcatenate two records.  O(m+n) .cleff0Slice off one entry from the top of the record.  O(1) .cleff6Slice off several entries from the top of the record.  O(1) .cleffGet the head of the record.  O(1) .cleff*Take elements from the top of the record.  O(m) .cleff(Get an element in the record. Amortized  O(1) .cleff&Get a subset of the record. Amortized  O(m) .cleffUpdate an entry in the record.  O(n) .cleff.The element closer to the head takes priority.     0(c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None$'(+-./2:<=>?"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).#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.The best practice is to always use a polymorphic type variable for the effect stack es#, and then use the type operators   and " in constraints to indicate what effects are available in the stack. For example, (     es,      es) => $ es  (means you can perform operations of the    effect and the   ' effect in a computation returning an . The reason why you should always use a polymorphic effect stack as opposed to a concrete list of effects are thatit can contain other effects that are used by computations other than the current one, andit does not require you to run the effects in any particular order.%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.*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) .0cleffAdd a new effect to the stack with its corresponding handler pointer.  O(n) .1cleff1Use the state of LHS as a newer version for RHS.  O(1) .2cleffPerform an effect operation, i.e. a value of an effect type e :: . This requires e to be in the effect stack.3cleffPerform 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 29; only use this if you are sure about what you're doing. 2 = 3   "#$%&'()*+,-./0123'()$%&#*+,-./01 " 23"0(c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None#'(+-./2:<=>?8cleffCompatibility instance for MonadComprehensions.9cleff:cleff;cleff<cleff=cleff>cleff?cleff(c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None%'(+-./2:<=>?3@cleff9The type of a simple transformation function from effect e to e'.AcleffThe 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.BcleffYou should not define instances for this typeclass whatsoever.CcleffAdjust 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 C, and rmap is .DcleffLift a computation into a bigger effect stack with one more effect. For a more general version see E.EcleffLift a computation into a bigger effect stack with arbitrarily more effects. This function requires TypeApplications.FcleffLike D, 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  F In other words, O h == N h . F 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 O2, which is both easier to use and more efficient.GcleffLike F, but allows introducing multiple effects. This function requires TypeApplications.HcleffLike F, but allows introducing the effect under multiple effects. This function requires TypeApplications.IcleffA generalization of both H and G, 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.JcleffLift a computation with a fixed, known effect stack into some superset of the stack.KcleffEliminate a duplicate effect from the top of the effect stack. For a more general version see L.LcleffEliminate several duplicate effects from the top of the effect stack. This function requires TypeApplications.McleffGet the send-site #.NcleffInterpret an effect e) in terms of effects in the effect stack es with an effect handler.OcleffLike N, but adds a new effect e'. to the stack that can be used in the handler.PcleffLike O, but adds two new effects.QcleffLike O, but adds three new effects.RcleffLike O, but adds arbitrarily many new effects. This function requires TypeApplications.ScleffRespond to an effect, but does not eliminate it from the stack. This means you can re-send the operations in the effect handler; it is often useful when you need to "intercept" operations so you can add extra behaviors like logging.TcleffLike S?, but allows to introduce one new effect to use in the handler.UcleffLike T, but allows introducing arbitrarily many effects. This requires TypeApplications.VcleffInterpret an effect in terms of another effect in the stack via a simple @. V trans = N (3 X  trans) WcleffLike V, but instead of using an effect in stack, add a new one to the top of it. W trans = O (3 X  trans) XcleffRun a computation in the current effect stack; this is useful for interpreting higher-order effects. For example, if you want to interpret a bracketing effects in terms of : data Resource m a where Bracket :: m a -> (a -> m ()) -> (a -> m b) -> Resource m b 9You will not be able to simply write this for the effect: runBracket :: IOE   es => $ (Resource : es) a -> $ es a runBracket = N/ \case Bracket alloc dealloc use -> UnliftIO. alloc dealloc use This is because effects are sended from all kinds of stacks that has Resource3 in it, so effect handlers received the effect as Resource esSend a, where esSend is an arbitrary stack with Resource, instead of  Resource es a . This means alloc, dealloc and use are of type $ esSend a, while  can only take and return $ es a. So we need to use X, which converts an $ esSend a into an $ es a: runBracket :: IOE   es => $ (Resource : es) a -> $ es a runBracket = N/ \case Bracket alloc dealloc use -> UnliftIO. (X alloc) (X . dealloc) (X . use) Ycleff9Run a computation in the current effect stack, just like X, but takes a A of the current effect being interpreted, so that inside the computation being ran, the effect is interpreted differently. This is useful for interpreting effects with local contexts, like  : runReader :: r -> $ (  r : es)  $ es runReader x = N' (handle x) where handle :: r -> A ( " r) es handle r = \case   ->  r   f m -> Y (handle $ f r) m Zcleff*Temporarily gain the ability to lift some $ es actions into $ esSend. This is only 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.@ABCDEFGHIJKLMNOPQRSTUVWXYZCDEJKLFGHIBMA@NOPQRSTUVWXYZ(c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None$'(+-./2:<=>?D [cleffThe type of an  effect handler0, which is a function that transforms an effect e into ! computations. This is used for b.\cleff0The 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 :: \ :> 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 _ and `. 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.\5 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.]cleffLift 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 d.^cleff$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 c._cleffUnsafely eliminate an \ 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.`cleff Unwrap an $' computation with side effects into an 0 computation, given that all effects other than \ are interpreted.acleffUnwrap a pure $ computation into a pure value, given that all effects are interpreted.bcleff Interpret an effect in terms of !, by transforming an effect into  computations. b f = N (  f) ccleff*Temporarily gain the ability to unlift an $ esSend computation into . This is analogous to , and is useful in dealing with higher-order effects that involves . For example, the Resource" effect that supports bracketing: data Resource m a where Bracket :: m a -> (a -> m ()) -> (a -> m b) -> Resource m b can be interpreted into  actions in ., by converting all effect computations into  computations via c: runResource :: \   es => $ (Resource : es) a -> $ es a runResource = N& \case Bracket alloc dealloc use -> c $ \toIO -> , (toIO alloc) (toIO . dealloc) (toIO . use) dcleffLift an  computation into $ esSend. This is analogous to , and is only useful in dealing with effect operations with the monad type in the negative position, for example  ing:  data Mask ::  where Mask :: ((m  m) -> m a) -> Mask m a ^ this "m" is in negative position  See how the restore :: IO a -> IO a from   is "wrapped" into $ esSend a -> $ esSend a:  runMask :: \   es => $ (Mask : es) a -> $ es a runMask = N \case Mask f -> c $ \toIO ->   $ \restore -> f (d . restore . toIO) Here, toIO from c takes an $ esSend to ", where it can be passed into the restore function, and the returned  computation is recovered into $ with d.fcleffCompatibility instance; use  if possible.gcleffCompatibility instance; use  if possible. [\]^_`abcd \]^_`a[bcd!(c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None$'(+-./2:<=>?JmcleffFor a datatype T representing an effect, m T generates function defintions for performing the operations of T via 2. For example, m ''Filesystem $generates the following definitions: readFile :: Filesystem   es =>  -> $ es  readFile x = 2* (ReadFile x) writeFile :: Filesystem   es =>  ->  -> $ es () writeFile x y = 2 (WriteFile x y) 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.Technical details$This function is also "weaker" than polysemy's makeSem, because this function cannot properly handle some cases involving ambiguous types. Those cases are rare, though. See the ThSpec test spec for more details.ncleffLike m, 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 () n; ''Identity -- | Perform nothing at all. noop :: Identity   es => $ es () 6Be careful that the function signatures must be added after the n call.mnmn(c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy#'(+-./2:<=>?KR0 "$23@ABDEFGHIJKLNOPQRSTUVWXYZ[\`abcdmn0$ "\a`23mnDEJKL ANOPQRSTU[b@VWFGHIBXYZcd(c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy$'(+-./2:<=>?VocleffAn 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.rcleffHandle an error if one is thrown from a computation, and then return to normal control flow.scleff*Throw an error in the current computation.tcleffLift an  value into the o effect.ucleff Lift exceptions generated by an  computation into the o effect.vcleffLike u, but allows to transform the exception into another error type.wcleff Lift exceptions generated by an $ computation into the o effect.xcleffLike w, but allows to transform the exception into another error type.ycleffTry to extract a value from , throw an error otherwise.zcleff A variant of r5 that allows a predicate to choose whether to catch () or rethrow ( ) the error.{cleff A variant of r5 that allows a predicate to choose whether to catch () or rethrow ( ) the error.|cleffFlipped version of r.}cleffFlipped version of z.~cleffFlipped version of {.cleff Runs a computation, returning a  value if an error was thrown.cleff A variant of 5 that allows a predicate to choose whether to catch () or rethrow ( ) the error.cleffRun an o effect.Caveats is implemented with s therefore inherits some of its unexpected behaviors. Errors thrown in forked threads will not be directly caught by rs 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  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.cleff Transform an o into another. This is useful for aggregating multiple errors into one type.rcleff%The computation that may throw errorscleff2The handler that is called when an error is thrownoqprstuvwxyz{|}~oqpsrtuvwxyz{|}~ (c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy#'(+-./2:<=>?XcleffAn effect that expresses failure with a message. This effect allows the use of the  class.cleffRun a  effect in terms of o.cleffRun a + effect in terms of throwing exceptions in . (c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy#'(+-./2:<=>?h3 cleffAn 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.cleffLike , 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.cleff?Prevents 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  effect in terms of primitive  actions.cleff0The main computation that may throw an exceptioncleff5The computation that runs when an exception is throwncleff9The computation to run first, usually acquires a resourcecleffThe computation to run after the main computation, usually cleans upcleff+The main computation that uses the resourcecleff9The 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 thrown (c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy#'(+-./2:<=>?kcleff8An 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:<=>?sG 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:<=>?v 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:<=>?zcleffAn 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:<=>?cleffAn 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:<=>?~cleffAn 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:<=>?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:<=>?w*+,-./-.012312456"789:;<==>?@ABCDEFGHIJKLMNOPQRSSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!!           #                                         *+-*+*+-----------*+*+---- -%----*+--------))))))))cleff-0.3.2.0-inplaceCleff.InternalCleffCleff.Internal.RecCleff.Internal.MonadCleff.Internal.InstancesCleff.Internal.InterpretCleff.Internal.Base Cleff.Error Cleff.Fail Cleff.Mask Cleff.Reader Cleff.State Cleff.Input Cleff.Fresh Cleff.Writer Cleff.Output Cleff.TraceEffsend reinterpretN toEffWithReaderStateHandler Data.KindTypeUnliftIObracketLocalAskControl.ExceptionmaskCleff.Internal.THEffectuninterruptibleMask Data.IORefIORefData.Atomics.Counter AtomicCounter concurrently_ Paths_cleffghc-prim GHC.TypesAnybaseControl.Monad.IO.ClassliftIOMonadIOunliftio-core-0.2.0.1-e01f5ed3511cc7eceebc04c6d661c9994774650ec89a07c164849d97f27e61f8Control.Monad.IO.Unlift withRunInIO MonadUnliftIO++~>toAnyfromAnySubset:> KnownListRec HandlerPtr unHandlerPtremptyconsconcattaildropheadtakeindexpickupdate $fKnownList: $fKnownList[]$f:>e:$f:>e:0$f:>e[] $fSubset:es' $fSubset[]es:>>EnvunEffInternalHandler runHandleremptyEnv adjustEnv allocaEnvreadEnvwriteEnv replaceEnv appendEnv updateEnvsendVia $fMonadFixEff $fMonadEff$fApplicativeEff $fFunctorEff $fMonadZipEff $fIsStringEff $fFloatingEff$fFractionalEff$fNumEff $fMonoidEff$fSemigroupEff $fBoundedEff TranslatorHandlingadjustraiseraiseN raiseUnder raiseNUnder raiseUnderN raiseNUnderNinjectsubsumesubsumeNesSend interpret reinterpret reinterpret2 reinterpret3 interposeimposeimposeN transform translatetoEff withFromEff HandlerIOIOE 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 traceToOutputprimitive-0.7.3.0-ab8104f4a6c5bcace27e4a385271dc96d2186f34c091b7c80bfd9bcc6b69faa5Data.Primitive.PrimArray PrimArrayGHC.BaseStringBoolinteger-wired-inGHC.Integer.TypeIntegerIOidfmap.pureControl.Monad.Primitive PrimMonadexceptions-0.10.4Control.Monad.Catch MonadCatch MonadThrow MonadMask System.IOputStrLn GHC.IO.UnsafeunsafeDupablePerformIOGHC.IOFilePath Data.EitherEither GHC.MaybeMaybeJustNothingTrueFalseLeftGHC.Exception.Type ExceptionControl.Monad.Fail MonadFailmicrolens-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