h&      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi j k lmn opqr s t u v w x y z { | } ~                                               (c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None' &'(+-./2:<=>?^cleffA pointer to an effect handler.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 :: . cleff2A pattern synonym for coercing values to and from  =. This is not any less unsafe but prevents possivle misuses. cleff'Magic function that tells the compiler not to inline the argument.   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.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:<=>?#cleffA thread-local variable. It is designed so that any operation originating from existing threads produce no contention; thread contention only occurs when multiple new threads attempt to first-time access the variable at the same time.$cleffCreate a thread variable with a same initial value for each thread.%cleff9Get the variable local to this thread, in the form of an %. It is guaranteed that the returned = will not be read or mutated by other threads inadvertently.#$%#$%(c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None' &'(+-./2:<=>?'&cleffAn efficient vector type, implemented as a radix tree. It has the following time complexities:Lookup:  O(\log n) Update:  O(\log n) Append:  O(\log n) The branching factor (base of log) is 32 therefore the time is close to constant in most cases. Note that in practice, lookup is faster than update, and update is faster than append.'cleff The empty &.(cleff Lookup in a &5 by an index. This does not perform any bounds check.)cleffUpdate a value in a & by an index. The value will be forced before installing. This does not perform any bounds check.*cleffAppend a value to a &. The value will be forced before installing. This does not perform any bounds check.&'()*&'()*(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 0s. 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 operator  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 . A convenient shorthand, +, can also be used to indicate multiple effects being in a stack: '[  ,  ] + es => - es  The reason why you should always use a polymorphic effect stack as opposed to a concrete list of effects are that:it 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.0cleffThe 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.3cleffCreate an empty , with no address allocated.4cleff-Adjust the effect stack via an function over .5cleff'Peek the next address to be allocated.  O(1) .6cleff&Read the handler a pointer points to.  O(1) .7cleff+Overwrite the handler a pointer points to.  O(1) .8cleff7Replace the handler pointer of an effect in the stack.  O(n) .9cleffAdd 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. ; = <  +,-./0123456789:;<012-./,3456789:+;<+0(c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None( &'(+-./2:<=>?'XAcleffFor a datatype T representing an effect, A T generates function defintions for performing the operations of T via ;. For example, A ''Filesystem $generates the following definitions: readFile :: Filesystem  es =>  -> - es  readFile x = ;* (ReadFile x) writeFile :: Filesystem  es =>  ->  -> - es () writeFile x y = ; (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.BcleffLike A, 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 () B; ''Identity -- | Perform nothing at all. noop :: Identity  es => - es () 6Be careful that the function signatures must be added after the B call.ABAB(c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None( &'(+-./2:<=>??Ccleff9The type of a simple transformation function from effect e to e'.DcleffThe 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.EcleffYou should not define instances for this typeclass whatsoever.FcleffAlter the effect environment by a contravariant transformation function over it. This function reveals the profunctorial nature of -; in particular, - is a profunctor [ ] -> , lmap is F, and rmap is .GcleffA specialized version of F$ that only adjusts the effect stack.HcleffLift a computation into a bigger effect stack with one more effect. For a more general version see I.IcleffLift a computation into a bigger effect stack with arbitrarily more effects. This function requires TypeApplications.JcleffLike H, 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  J In other words, S h == R h . J 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 S2, which is both easier to use and more efficient.KcleffLike J, but allows introducing multiple effects. This function requires TypeApplications.LcleffLike J, but allows introducing the effect under multiple effects. This function requires TypeApplications.McleffA generalization of both L and K, 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.NcleffLift a computation with a fixed, known effect stack into some superset of the stack.OcleffEliminate a duplicate effect from the top of the effect stack. For a more general version see P.PcleffEliminate several duplicate effects from the top of the effect stack. This function requires TypeApplications.QcleffGet the send-site ,.RcleffInterpret an effect e) in terms of effects in the effect stack es with an effect handler.ScleffLike R, but adds a new effect e'. to the stack that can be used in the handler.TcleffLike S, but adds two new effects.UcleffLike S, but adds three new effects.VcleffLike S, but adds arbitrarily many new effects. This function requires TypeApplications.WcleffRespond 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.XcleffLike W?, but allows to introduce one new effect to use in the handler.YcleffLike X, but allows introducing arbitrarily many effects. This requires TypeApplications.ZcleffInterpret an effect in terms of another effect in the stack via a simple C. Z trans = R (< \  trans) [cleffLike Z, but instead of using an effect in stack, add a new one to the top of it. [ trans = S (< \  trans) \cleffRun 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 = R/ \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 \, which converts an - esSend a into an - es a: runBracket :: IOE  es => - (Resource : es) a -> - es a runBracket = R/ \case Bracket alloc dealloc use -> UnliftIO.  (\ alloc) (\ . dealloc) (\ . use) ]cleff9Run a computation in the current effect stack, just like \, but takes a D 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 = R' (handle x) where handle :: r -> D ( " 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 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.CDEFGHIJKLMNOPQRSTUVWXYZ[\]^FGHINOPJKLMEQDCRSTUVWXYZ[\]^(c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None' &'(+-./2:<=>?AI_cleffCompatibility instance for MonadComprehensions.`cleffacleffbcleffccleffdcleffeclefffcleff (c) 2021 Xy RenBSD3xy.r@outlook.comunstablenon-portable (GHC only)None( &'(+-./2:<=>?Rp gcleffThe type of an  effect handler0, which is a function that transforms an effect e into ! computations. This is used for o.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 q.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 p.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.ncleffUnwrap a pure - computation into an - computation. You may occasionally need this.ocleff Interpret an effect in terms of !, by transforming an effect into  computations. o f = R (  f) pcleff*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 p: runResource :: h  es => - (Resource : es) a -> - es a runResource = R& \case Bracket alloc dealloc use -> p $ \toIO -> # , (toIO alloc) (toIO . dealloc) (toIO . use) qcleffLift 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 :: h  es => - (Mask : es) a -> - es a runMask = R \case Mask f -> p $ \toIO -> #$ $ \restore -> f (q . restore . toIO) Here, toIO from p takes an - esSend to ", where it can be passed into the restore function, and the returned  computation is recovered into - with q.scleffCompatibility instance; use  if possible.tcleffCompatibility instance; use  if possible. ghijklmnopq hijklmngopq(c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy' &'(+-./2:<=>?S/0 +-;?^zcleffAn 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 z effect.cleff Lift exceptions generated by an  computation into the z effect.cleffLike , but allows to transform the exception into another error type.cleff Lift exceptions generated by an - computation into the z effect.cleffLike , but allows to transform the exception into another error type.cleffTry to extract a value from , throw an error otherwise.cleff A variant of }5 that allows a predicate to choose whether to catch () or rethrow ( ) the error.cleff A variant of }5 that allows a predicate to choose whether to catch () or rethrow ( ) the error.cleffFlipped version of }.cleffFlipped version of .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 z effect.Caveats 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  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 z 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 thrownz|{}~z|{~} (c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy' &'(+-./2:<=>?`cleffAn effect that expresses failure with a message. This effect allows the use of the  class.cleffRun a  effect in terms of z.cleffRun a + effect in terms of throwing exceptions in . (c) 2021 Xy RenBSD3xy.r@outlook.com experimentalnon-portable (GHC only) Trustworthy' &'(+-./2:<=>?pH 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:<=>?scleff8An 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:<=>?~C 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 a 5 effect where each thread has its thread-local state.This means that each thread will have an individual state that has the same initial value. Threfore, state operations on one thread will not change the state for any other thread.7The returned final state is that of the current thread.CaveatsLike , the + operation in this handler is atomic. Like  , and unlike mtl0, any errors will not revert the state changes.Be warned that if you use a thread pool, then when a thread is reused, it may read the state left from the last usage, therefore losing locality. If you use a thread pool, you will want to manually reset the state after each task.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:<=>? 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:<=>?cleffAn 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:<=>?,-./01/023453467789:.;<=>?@ABCDEFGHIJKLMNOPQRSTUAVJWXYZ[[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                    % $          " !     ,-/'/,-,-///////////,-,-////$////,-////////++++++++cleff-0.3.3.0-inplaceCleff.InternalCleffCleff.Internal.RecCleff.Internal.ThreadVarCleff.Internal.VecCleff.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.TraceEffsend reinterpretN toEffWithReaderStateHandlerCleff.Internal.THEffect Data.KindTypeUnliftIObracketLocalAskControl.ExceptionmaskuninterruptibleMask 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 HandlerPtr unHandlerPtr++~>fromAnynoinlineSubset:> KnownListRecemptyconsconcattaildropheadtakeindexpickupdate $fKnownList: $fKnownList[]$f:>e:$f:>e:0$f:>e[] $fSubset:es' $fSubset[]es ThreadVar newThreadVar getThreadVarVeclookupsnoc:>>EnvunEffInternalHandler runHandleremptyEnv adjustEnvpeekEnvreadEnvwriteEnv replaceEnv appendEnv updateEnvsendVia $fMonadFixEff $fMonadEff$fApplicativeEff $fFunctorEff makeEffect makeEffect_ TranslatorHandlingalteradjustraiseraiseN raiseUnder raiseNUnder raiseUnderN raiseNUnderNinjectsubsumesubsumeNesSend interpret reinterpret reinterpret2 reinterpret3 interposeimposeimposeN transform translatetoEff withFromEff $fMonadZipEff $fIsStringEff $fFloatingEff$fFractionalEff$fNumEff $fMonoidEff$fSemigroupEff $fBoundedEff HandlerIOIOE primLiftIO primUnliftIOthisIsPureTrustMerunIOErunPure runPureIO interpretIOwithToIOfromIO$fPrimMonadEff$fMonadBaseControlIOEff$fMonadBaseIOEff$fMonadMaskEff$fMonadCatchEff$fMonadThrowEff$fMonadUnliftIOEff $fMonadIOEffError ThrowError CatchError catchError throwError fromEither fromExceptionfromExceptionViafromExceptionEfffromExceptionEffVianotecatchErrorJust catchErrorIf handleErrorhandleErrorJust handleErrorIftryError tryErrorJustrunErrormapError$fShowErrorExc$fExceptionErrorExcFailrunFail runFailIO$fMonadFailEffMaskUninterruptibleMask OnException onExceptionbracketOnErrormask_uninterruptibleMask_bracket_bracketOnError_onErrorfinallyrunMasklocalaskasks runReadermagnifyGetPutstateputgetgetsmodifyrunState runStateLocal runStateIORef runStateMVar runStateTVarzoomInputinputinputs runInputConstinputToListState inputToReader runInputEffmapInput bindInputFreshfreshfreshEnumToStatefreshIntToStaterunFreshAtomicCounterrunFreshUniqueWriterTellListenlistentelllistens runWriterrunWriterBatchOutputoutputoutputToListStateoutputToWriter ignoreOutput runOutputEff mapOutput bindOutputTracetracerunTraceHandlerunTraceStdoutrunTraceStderr ignoreTrace traceToOutputprimitive-0.7.4.0-3831b74bbd8da677fb5c864de7f5d810c5256eaf1bfeefaf358fad5c322362afData.Primitive.PrimArray PrimArray GHC.IORefGHC.BaseStringBoolinteger-wired-inGHC.Integer.TypeIntegerIOidGHC.IOFilePathfmap.pureControl.Monad.Primitive PrimMonadexceptions-0.10.4Control.Monad.Catch MonadCatch MonadThrow MonadMask System.IOputStrLn GHC.IO.UnsafeunsafeDupablePerformIO Data.EitherEither GHC.MaybeMaybeJustNothingTrueFalseLeftGHC.Exception.Type ExceptionControl.Monad.Fail MonadFailmicrolens-0.4.13.0-30d29fe2927da501a7293b1afc95da8d8c25679b8cce00ffdc1e3e3111e27d11Lens.Micro.TypeLens'atomic-primops-0.8.4-8dc889ab823182fc845e2f527e706e688255dd7ec58025dfc64a5b8f43b637fa Data.AtomicsatomicModifyIORefCASGHC.MVarMVar GHC.Conc.SyncTVarGHC.EnumEnumsuccInt Data.UniqueUniquemaxBound$>>GHC.ListreverseGHC.IO.Handle.TypesHandleGHC.IO.Handle.FDstdoutstderrversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir