h*A'      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                            2.4.0.0 Safe-Inferred)*/0169< effectful-core,Calculate length of a list of known effects.effectful-core%Append two type-level lists together.effectful-core Require that subEs is the unknown suffix of es.effectful-core1Calculate length of a statically known prefix of es.effectful-coreProvide evidence that subEs is a known subset of es.effectful-coreProvide evidence that subEs is a subset of es.effectful-coreConvenience operator for expressing that a function uses multiple effects in a more concise way than enumerating them all with . [E1, E2, ..., En]  es D (E1  es, E2  es, ..., En :> es)effectful-core4A constraint that requires that a particular effect e% is a member of the type-level list es". This is used to parameterize an !< computation over an arbitrary list of effects, so long as e is  somewhere in the list.For example, a computation that only needs access to a mutable value of type  would have the following type: "   es => ! es () effectful-coreGet the position of e in es.Note: GHC is kind enough to cache these values as they're top level CAFs, so the lookup is amortized O(1)# without any language level tricks.effectful-coreThe kind of effects.5None  )*/0169<effectful-core0A unique with no possibility for CAS contention.$Credits for this go to Edward Kmett.effectful-core9Version of bracket with an INLINE pragma to work around  1https://gitlab.haskell.org/ghc/ghc/-/issues/22824.effectful-coreGet an id of a thread that doesn't prevent its garbage collection.    Safe-Inferred")*/0169<!"effectful-core$Internal representations of effects.effectful-coreDispatch types of effects.effectful-coreSignifies whether core operations of a statically dispatched effect perform side effects. If an effect is marked as such, the #' family of functions will require the $" effect to be in context via the % type family.effectful-coreA type of dispatch. For more information consult the documentation in Effectful.Dispatch.Dynamic and Effectful.Dispatch.Static.effectful-coreA function for relinking  objects stored in the handlers and/or making a deep copy of the representation of the effect when cloning the environment.effectful-core Relinker in .effectful-core Effect in .effectful-coreA storage of effects.effectful-coreVersion of the effect.effectful-coreReference to the effect in .effectful-coreA strict (WHNF),  thread local7, mutable, extensible record indexed by types of kind .Warning: the environment is a mutable data structure and cannot be simultaneously used from multiple threads under any circumstances.In order to pass it to a different thread, you need to perform a deep copy with the  funtion.Offers very good performance characteristics for most often performed operations: Extending: O(n), where n! is the size of the effect stack. Shrinking: O(1). Indexing via : O(1)$Modification of a specific element: O(1).Getting a tail: O(1). Cloning: O(N), where N is the size of the .effectful-coreA dummy .effectful-coreCreate an empty environment.effectful-core6Clone the environment to use it in a different thread.effectful-core'Restore the environment from its clone.effectful-core(Get the current size of the environment.effectful-core#Access the tail of the environment.effectful-core,Extend the environment with a new data type.effectful-core(Shrink the environment by one data type.Note: after calling this function e1 from the input environment is no longer usable.effectful-core8Replace a specific effect in the stack with a new value.Note: unlike in  the value in not changed in place, so only the new environment will see it.effectful-core*Remove a reference to the replaced effect.Note: after calling this function the input environment is no longer usable.effectful-core7Reference an existing effect from the top of the stack.effectful-coreConstruct an environment containing a permutation (with possible duplicates) of a subset of effects from the input environment.effectful-core2Extract a specific data type from the environment.effectful-coreReplace the data type in the environment with a new value (in place).effectful-coreModify the data type in the environment and return a value (in place).effectful-core3Modify the data type in the environment (in place).effectful-core4Determine location of the effect in the environment.effectful-coreCreate an empty storage.effectful-core;Insert an effect into the storage and return its reference.effectful-coreGiven a reference to an effect from the top of the stack, delete it from the storage.effectful-core.Relink the environment to use the new storage.effectful-core Double the capacity of an array.effectful-coreA strict version of .effectful-core Destination.effectful-coreSource.effectful-core!The representation of the effect.effectful-core!The representation of the effect.effectful-coreThe environment.effectful-coreThe environment.effectful-coreThe environment.effectful-coreThe environment.effectful-core!The representation of the effect.//  Safe-Inferred!)*/0169<3X effectful-coreIn GHC < 9 weak thread ids are 32bit long, while ThreadIdS are 64bit long, so there is potential for collisions. This is solved by keeping, for a particular weak thread id, a list of ThreadIdS with unique EntryIdS.effectful-coreLimit setting for the  strategy.effectful-coreBehavior dependent on the  setting.For , it limits the amount of uses of the unlifting function in threads distinct from its creator to N&. The unlifting function will create N' copies of the environment when called N times and K+1 copies when called K < N times.For , it limits the amount of threads, distinct from the creator of the unlifting function, it can be called in to N. The amount of calls to the unlifting function within a particular threads is unlimited. The unlifting function will create N+ copies of the environment when called in N threads and K+1 copies when called in K < N threads.effectful-core(Unlimited use of the unlifting function.effectful-corePersistence setting for the  strategy.Different functions require different persistence strategies. Examples:Lifting pooledMapConcurrentlyN from the unliftio library requires the  strategy as we don't want jobs to share environment changes made by previous jobs run in the same worker thread.Lifting  requires the  strategy, otherwise the unmasking function would start with a fresh environment each time it's called.effectful-coreDon't persist the environment between calls to the unlifting function in threads distinct from its creator.effectful-corePersist the environment between calls to the unlifting function within a particular thread.effectful-core#The strategy to use when unlifting ! computations via & or the  ' family.effectful-coreThe sequential strategy is the fastest and a default setting for $. Any attempt of calling the unlifting function in threads distinct from its creator will result in a runtime error.effectful-coreLike , but all unlifted actions will be executed in a cloned environment.The main consequence is that thread local state is forked at the point of creation of the unlifting function and its modifications in unlifted actions will not affect the main thread of execution (and vice versa):import Effectfulimport Effectful.State.Dynamic:{4 action :: (IOE :> es, State Int :> es) => Eff es () action = do modify @Int (+1) withEffToIO SeqForkUnlift $ \unlift -> unlift $ modify @Int (+2) modify @Int (+4):}'runEff . execStateLocal @Int 0 $ action5(runEff . execStateShared @Int 0 $ action7Because of this it's possible to safely use the unlifting function outside of the scope of effects it captures, e.g. by creating an IO action that executes effectful operations and running it later::{- delayed :: UnliftStrategy -> IO (IO String)7 delayed strategy = runEff . evalStateLocal "Hey" $ do< r <- withEffToIO strategy $ \unlift -> pure $ unlift get modify (++ "!!!") pure r:}This doesn't work with the 2 strategy because when the returned action runs, State is no longer in scope:join $ delayed SeqUnlift2*** Exception: version (...) /= storageVersion (0)...However, it does with the  strategy:join $ delayed SeqForkUnlift"Hey"effectful-coreThe concurrent strategy makes it possible for the unlifting function to be called in threads distinct from its creator. See  and  settings for more information.effectful-coreConcurrent unlift that doesn't preserve the environment between calls to the unlifting function in threads other than its creator.effectful-coreConcurrent unlift that preserves the environment between calls to the unlifting function within a particular thread.effectful-core0Number of permitted uses of the unlift function.effectful-core>Number of threads that are allowed to use the unlift function.    Safe-Inferred)*/0169<Uk,effectful-core:Internal representations of statically dispatched effects.effectful-core Require the  effect for running statically dispatched effects whose operations perform side effects.effectful-coreAn internal representation of dynamically dispatched effects, i.e. the effect handler bundled with its environment.effectful-core%Type signature of the effect handler.effectful-coreOpaque representation of the * environment at the point of calling the  function, i.e. right before the control is passed to the effect handler.The second type variable represents effects of a handler and is needed for technical reasons to guarantee soundness (see  ( for more information).effectful-core token for . Used instead of  to prevent the ! effect from executing arbitrary  actions via .effectful-coreProvide the ability to perform primitive state-transformer actions.effectful-coreRun arbitrary  computations via E or .Note: it is not recommended to use this effect in application code as it is too liberal. Ideally, this is only used in handlers of more fine-grained effects.effectful-coreProvide the ability to use the  instance for .effectful-coreProvide the ability to use the  and  instance for .effectful-coreThe  monad provides the implementation of a computation that performs an arbitrary set of effects. In  es a, es is a type-level list that contains all the effects that the computation may perform. For example, a computation that produces an  by consuming a  from the global environment and acting upon a single mutable value of type  would have the following type: ()   es, "   es) =>  es  *Abstracting over the list of effects with :Allows the computation to be used in functions that may perform other effects..Allows the effects to be handled in any order.effectful-core Run a pure  computation./For running computations with side effects see .effectful-corePeel off the constructor of .effectful-coreAccess the underlying " monad along with the environment.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure  computations.effectful-coreAccess the underlying  monad.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure  computations.effectful-coreGet the current .Note:) this strategy is implicitly used by the  and  instance for .effectful-coreLocally override the current  with the given value.effectful-core&Create an unlifting function with the ( strategy. For the general version see .Note:* usage of this function is preferrable to * because of explicit unlifting strategy and better error reporting.effectful-core5Create an unlifting function with the given strategy.Note:* usage of this function is preferrable to * because of explicit unlifting strategy and better error reporting.effectful-core&Create an unlifting function with the  strategy.effectful-core&Create an unlifting function with the  strategy.effectful-core&Create an unlifting function with the  strategy.effectful-core&Create an unlifting function with the  strategy.effectful-coreRun an  computation with side effects."For running pure computations see .effectful-coreRun an 6 computation with primitive state-transformer actions.effectful-coreLift an 7 computation into an effect stack with one more effect.effectful-coreLift an  computation into an effect stack with one more effect and create an unlifting function with the given strategy.effectful-core>Eliminate a duplicate effect from the top of the effect stack.effectful-core"Allow for running an effect stack subEs within es as long as subEs= is a permutation (with possible duplicates) of a subset of es. Generalizes  and .data E1 :: Effectdata E2 :: Effectdata E3 :: EffectIt makes it possible to rearrange the effect stack however you like::{ shuffle :: Eff (E3 : E1 : E2 : es) a -> Eff (E1 : E2 : E3 : es) a shuffle = inject:}It can also turn a monomorphic effect stack into a polymorphic one::{ toPoly :: (E1 :> es, E2 :> es, E3 :> es) => Eff [E1, E2, E3] a -> Eff es a toPoly = inject:}Moreover, it allows for hiding specific effects from downstream::{8 onlyE1 :: Eff (E1 : es) a -> Eff (E1 : E2 : E3 : es) a onlyE1 = inject:}:{8 onlyE2 :: Eff (E2 : es) a -> Eff (E1 : E2 : E3 : es) a onlyE2 = inject:}:{8 onlyE3 :: Eff (E3 : es) a -> Eff (E1 : E2 : E3 : es) a onlyE3 = inject:}However, it's not possible to inject a computation into an incompatible effect stack::{$ coerceEs :: Eff es1 a -> Eff es2 a coerceEs = inject:}...'...Couldn't match type @es1@ with @es2@...effectful-core;Run a dynamically dispatched effect with the given handler.effectful-coreSend an operation of the given effect to its handler for execution.effectful-coreRun a statically dispatched effect with the given initial representation and return the final value along with the final representation.effectful-coreRun a statically dispatched effect with the given initial representation and return the final value, discarding the final representation.effectful-coreRun a statically dispatched effect with the given initial representation and return the final representation, discarding the final value.effectful-core/Fetch the current representation of the effect.effectful-coreSet the current representation of the effect to the given value.effectful-coreApply the function to the current representation of the effect and return a value.effectful-coreApply the monadic function to the current representation of the effect and return a value.effectful-coreExecute a computation with a temporarily modified representation of the effect.effectful-coreeffectful-coreeffectful-core7Instance included for compatibility with existing code. Usage of - is preferrable as it allows specifying the 8 on a case-by-case basis and has better error reporting.Note: the unlifting strategy for  is taken from the  context (see ).effectful-core7Instance included for compatibility with existing code. Usage of F# is preferrable as it's a standard.effectful-core7Instance included for compatibility with existing code. Usage of - is preferrable as it allows specifying the 8 on a case-by-case basis and has better error reporting.Note: the unlifting strategy for  is taken from the  context (see ).effectful-core4Capture of the local environment for handling local  computations when e is a higher order effect.effectful-coreThe operation.effectful-core2Continuation with the unlifting function in scope.effectful-core2Continuation with the unlifting function in scope.effectful-core2Continuation with the unlifting function in scope.effectful-coreThe environment.effectful-core2Continuation with the unlifting function in scope.effectful-coreThe environment.effectful-core2Continuation with the unlifting function in scope.effectful-coreThe environment.effectful-core2Continuation with the unlifting function in scope.effectful-core2Continuation with the unlifting function in scope.effectful-coreThe operation.effectful-coreThe initial representation.effectful-coreThe initial representation.effectful-coreThe initial representation.effectful-core*The function to modify the representation.effectful-core*The function to modify the representation.effectful-core6The function to temporarily modify the representation.88 Safe-Inferred)*/0169<\teffectful-coreUtility for lifting  computations of type  a ->  bto  es a ->  es bThis function is  really unsafe because:&It can be used to introduce arbitrary  actions into pure  computations.The  computation must run its argument in a way that's perceived as sequential to the outside observer, e.g. in the same thread or in a worker thread that finishes before the argument is run again.Warning: if you disregard the second point, you will experience weird bugs, data races or internal consistency check failures.When in doubt, use +, especially since this version saves only a simple safety check per call of reallyUnsafeLiftMapIO f.effectful-coreCreate an unlifting function.This function is  really unsafe because:&It can be used to introduce arbitrary  actions into pure  computations. Unlifted  computations must be run in a way that's perceived as sequential to the outside observer, e.g. in the same thread as the caller of  or in a worker thread that finishes before another unlifted computation is run.Warning: if you disregard the second point, you will experience weird bugs, data races or internal consistency check failures.When in doubt, use ,, especially since this version saves only a simple safety check per call of the unlifting function.  Safe-Inferred)*/0169<\ Safe-Inferred)*/0169<a%effectful-coreUtility for lifting  computations of type  a ->  bto  es a ->  es bNote: the computation must not run its argument in a separate thread, attempting to do so will result in a runtime error.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure  computations.effectful-core&Create an unlifting function with the  strategy.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure  computations.effectful-core&Create an unlifting function with the  strategy.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure  computations.effectful-core2Continuation with the unlifting function in scope.effectful-core2Continuation with the unlifting function in scope. Safe-Inferred)*/0169<a#EF#EF Safe-Inferred)*/0169<c&effectful-coreLifted version of .effectful-coreDeeply evaluate a value using  and .ST][\QR^U_`abcdeVfghijklmnopqGH~MNOPIJKLrtuvswxyYZzWX{|}  '(;9:%& !"#$34785612/0+,)*-.ST][\QR^U_`abcdeVfghijklmnopqGH~MNOPIJKLrtuvswxyYZzWX{|}  '(;9:%& !"#$34785612/0+,)*-. Safe-Inferred)*/0169<k< effectful-core-Provide the ability to handle errors of type e.effectful-coreHandle errors of type e.effectful-coreHandle errors of type e with a specific error handler.effectful-coreHandle errors of type e". In case of an error discard the .effectful-coreHandle errors of type e with a specific error handler. In case of an error discard the .effectful-coreThrow an error of type e and specify a display function in case a third-party code catches the internal exception and s it.effectful-coreThrow an error of type e with  as a display function.effectful-coreThrow an error of type e with no display function.effectful-coreHandle an error of type e.effectful-core The same as  , which is useful in situations where the code for the handler is shorter.effectful-core Similar to , but returns an  result which is a  if no error was thrown and a  otherwise.effectful-core$A unique is picked so that distinct  handlers for the same type don't catch each other's exceptions.effectful-coreThe error handler.effectful-coreThe error handler.effectful-coreThe display function.effectful-core The error.effectful-core The error.effectful-core The error.effectful-coreThe inner computation.effectful-core.A handler for errors in the inner computation.effectful-core.A handler for errors in the inner computation.effectful-coreThe inner computation.effectful-coreThe inner computation.  Safe-Inferred )*/0169<!effectful-core7Require that both effect stacks share an opaque suffix.Functions from the  family utilize this constraint to guarantee sensible usage of unlifting functions.:As an example, consider the following higher order effect::{ data E :: Effect where E :: m a -> E m a& type instance DispatchOf E = Dynamic:}=Running local actions in a more specific environment is fine::{$ runE1 :: Eff (E : es) a -> Eff es a" runE1 = interpret $ \env -> \case E m -> runReader () $ do- localSeqUnlift env $ \unlift -> unlift m:} Eff es a3 runE2 = reinterpret (runReader ()) $ \env -> \case E m -> raise $ do- localSeqUnlift env $ \unlift -> unlift m:}However, running local actions in an unrelated environment is not fine as this would make it possible to run anything within ::{$ runE3 :: Eff (E : es) a -> Eff es a3 runE3 = reinterpret (runReader ()) $ \env -> \case E m -> pure . runPureEff $ do- localSeqUnlift env $ \unlift -> unlift m:}...-...Could not deduce ...SharedSuffix '[] es......Running local actions in a monomorphic effect stack is also not fine as this makes a special case of the above possible::{( runE4 :: Eff [E, IOE] a -> Eff '[IOE] a" runE4 = interpret $ \env -> \case E m -> pure . runPureEff $ do- localSeqUnlift env $ \unlift -> unlift m:}......Running local actions in monomorphic effect stacks is not supported......effectful-core/Type signature of a first order effect handler.effectful-coreInterpret an effect.Note:  can be turned into a  with the use of .effectful-core. with the effect handler as the last argument.effectful-core1Interpret an effect using other, private effects.  D  effectful-core. with the effect handler as the last argument.effectful-core9Replace the handler of an existing effect with a new one.Note: this function allows for augmenting handlers with a new functionality as the new handler can send operations to the old one.:{ data E :: Effect where Op1 :: E m () Op2 :: E m ()& type instance DispatchOf E = Dynamic:}:{1 runE :: IOE :> es => Eff (E : es) a -> Eff es a runE = interpret_ $ \case" Op1 -> liftIO (putStrLn "op1")" Op2 -> liftIO (putStrLn "op2"):}$runEff . runE $ send Op1 >> send Op2op1op2:{< augmentOp2 :: (E :> es, IOE :> es) => Eff es a -> Eff es a! augmentOp2 = interpose_ $ \case Op1 -> send Op18 Op2 -> liftIO (putStrLn "augmented op2") >> send Op2:}1runEff . runE . augmentOp2 $ send Op1 >> send Op2op1 augmented op2op2Note: when using  to modify only specific operations of the effect, your first instinct might be to match on them, then handle the rest with a generic match. Unfortunately, this doesn't work out of the box::{ genericAugmentOp2 :: (E :> es, IOE :> es) => Eff es a -> Eff es a( genericAugmentOp2 = interpose_ $ \case8 Op2 -> liftIO (putStrLn "augmented op2") >> send Op2 op -> send op:}...*...Couldn't match type @localEs@ with @es@...*This is because within the generic match,  expects  Op (Eff es) a, but op has a type Op (Eff localEs) a6. If the effect in question is first order (i.e. its m) type parameter is phantom), you can use coerce:import Data.Coerce:{ genericAugmentOp2 :: (E :> es, IOE :> es) => Eff es a -> Eff es a( genericAugmentOp2 = interpose_ $ \case8 Op2 -> liftIO (putStrLn "augmented op2") >> send Op2 op -> send @E (coerce op):}8runEff . runE . genericAugmentOp2 $ send Op1 >> send Op2op1 augmented op2op2On the other hand, when dealing with higher order effects you need to pattern match on each operation and unlift where necessary.effectful-core. with the effect handler as the last argument.effectful-coreReplace the handler of an existing effect with a new one that uses other, private effects.  D  effectful-core. with the effect handler as the last argument.effectful-core for first order effects.effectful-core for first order effects.effectful-core for first order effects.effectful-core for first order effects.effectful-core for first order effects.effectful-core for first order effects.effectful-core for first order effects.effectful-core for first order effects.effectful-core+Create a local unlifting function with the ( strategy. For the general version see .effectful-core+Create a local unlifting function with the ( strategy. For the general version see .effectful-core:Create a local unlifting function with the given strategy.effectful-core:Create a local unlifting function with the given strategy.effectful-core)Create a local lifting function with the ( strategy. For the general version see .effectful-core8Create a local lifting function with the given strategy.effectful-coreUtility for lifting  computations of type  es a ->  es bto  localEs a ->  localEs bNote: the computation must not run its argument in a different thread, attempting to do so will result in a runtime error.effectful-coreUtility for lifting  computations of type  a ->  bto  localEs a ->  localEs bNote: the computation must not run its argument in a different thread, attempting to do so will result in a runtime error.3Useful e.g. for lifting the unmasking function in -.-like computations::{data Fork :: Effect where ForkWithUnmask :: ((forall a. m a -> m a) -> m ()) -> Fork m ThreadId'type instance DispatchOf Fork = Dynamic:}:{5runFork :: IOE :> es => Eff (Fork : es) a -> Eff es arunFork = interpret $ \env (ForkWithUnmask m) -> withLiftMapIO env $ \liftMap -> do localUnliftIO env (ConcUnlift Ephemeral $ Limited 1) $ \unlift -> do= forkIOWithUnmask $ \unmask -> unlift $ m $ liftMap unmask:}effectful-coreCreate a local lifting and unlifting function with the given strategy.Useful for lifting complicated  computations where the monadic action shows in both positive (as a result) and negative (as an argument) position.Note:- depending on the computation you're lifting  along with ' might be enough and is more efficient.effectful-coreCreate a local unlifting function with the given strategy along with an unrestricted lifting function.Useful for lifting complicated  computations where the monadic action shows in both positive (as a result) and negative (as an argument) position.Note:- depending on the computation you're lifting  along with ' might be enough and is more efficient.effectful-core&Lend effects to the local environment.Consider the following effect::{ data D :: Effect where D :: D m ()& type instance DispatchOf D = Dynamic:}+and an auxiliary effect that requires both IOE and D to run::{ data E :: Effect< runE :: (IOE :> es, D :> es) => Eff (E : es) a -> Eff es a runE = error "runE":}Trying to use runE inside the handler of D doesn't work out of the box::{ 1 runD :: IOE :> es => Eff (D : es) a -> Eff es a" runD = interpret $ \env -> \case+ D -> localSeqUnlift env $ \unlift -> do unlift . runE $ pure ():}......Could not deduce ...IOE :> localEs... arising from a use of @runE@...from the context: IOE :> es...The problem is that runE needs IOE :> localEs , but only  IOE :> es: is available. This function allows us to bridge the gap::{1 runD :: IOE :> es => Eff (D : es) a -> Eff es a" runD = interpret $ \env -> \case+ D -> localSeqUnlift env $ \unlift -> do. localSeqLend @'[IOE] env $ \useIOE -> do( unlift . useIOE . runE $ pure ():}effectful-coreLend effects to the local environment with a given unlifting strategy. Generalizes .effectful-core*Borrow effects from the local environment.effectful-coreBorrow effects from the local environment with a given unlifting strategy. Generalizes .effectful-coreThis is always preferred to SharedSuffix es es as it's not incoherent.effectful-coreThe operation.effectful-coreThe effect handler.effectful-coreThe effect handler.effectful-core8Introduction of effects encapsulated within the handler.effectful-coreThe effect handler.effectful-core8Introduction of effects encapsulated within the handler.effectful-coreThe effect handler.effectful-coreThe effect handler.effectful-coreThe effect handler.effectful-core8Introduction of effects encapsulated within the handler.effectful-coreThe effect handler.effectful-core8Introduction of effects encapsulated within the handler.effectful-coreThe effect handler.effectful-coreThe effect handler.effectful-coreThe effect handler.effectful-core8Introduction of effects encapsulated within the handler.effectful-coreThe effect handler.effectful-core8Introduction of effects encapsulated within the handler.effectful-coreThe effect handler.effectful-coreThe effect handler.effectful-coreThe effect handler.effectful-core8Introduction of effects encapsulated within the handler.effectful-coreThe effect handler.effectful-core8Introduction of effects encapsulated within the handler.effectful-coreThe effect handler.effectful-coreLocal environment.effectful-core2Continuation with the unlifting function in scope.effectful-coreLocal environment.effectful-core2Continuation with the unlifting function in scope.effectful-coreLocal environment.effectful-core2Continuation with the unlifting function in scope.effectful-coreLocal environment.effectful-core2Continuation with the unlifting function in scope.effectful-coreLocal environment.effectful-core0Continuation with the lifting function in scope.effectful-coreLocal environment.effectful-core0Continuation with the lifting function in scope.effectful-coreLocal environment.effectful-core0Continuation with the lifting function in scope.effectful-coreLocal environment.effectful-core0Continuation with the lifting function in scope.effectful-coreLocal environment.effectful-core>Continuation with the lifting and unlifting function in scope.effectful-coreLocal environment.effectful-core>Continuation with the lifting and unlifting function in scope.effectful-core,Continuation with the lent handler in scope.effectful-core,Continuation with the lent handler in scope.effectful-core0Continuation with the borrowed handler in scope.effectful-core0Continuation with the borrowed handler in scope.%% Safe-Inferred)*/0169<2effectful-coreRun the  effect via .effectful-coreRun the  effect via the  instance for . Safe-Inferred)*/0169< effectful-core-Provide the ability to handle errors of type e.effectful-coreeffectful-coreHandle errors of type e (via Effectful.Error.Static).effectful-coreHandle errors of type e (via Effectful.Error.Static!) with a specific error handler.effectful-coreHandle errors of type e (via Effectful.Error.Static$). In case of an error discard the .effectful-coreHandle errors of type e (via Effectful.Error.Static) with a specific error handler. In case of an error discard the  CallStack.effectful-coreThrow an error of type e and specify a display function in case a third-party code catches the internal exception and s it.effectful-coreThrow an error of type e with  as a display function.effectful-coreThrow an error of type e with no display function.effectful-coreHandle an error of type e.effectful-core The same as  , which is useful in situations where the code for the handler is shorter.effectful-core Similar to , but returns an  result which is a  if no error was thrown and a  otherwise.effectful-coreThe error handler.effectful-coreThe error handler.effectful-coreThe display function.effectful-core The error.effectful-core The error.effectful-core The error.effectful-coreThe inner computation.effectful-core.A handler for errors in the inner computation.effectful-core.A handler for errors in the inner computation.effectful-coreThe inner computation.effectful-coreThe inner computation. Safe-Inferred)*/0169<effectful-coreAssign a label to an effect.The constructor is for sending labeled operations of a dynamically dispatched effect to the handler:!import Effectful.Dispatch.Dynamic:{ data X :: Effect where X :: X m Int& type instance DispatchOf X = Dynamic:}:{ runPureEff . runLabeled @"x" (interpret_ $ \X -> pure 333) $ do send $ Labeled @"x" X:}333effectful-coreeffectful-coreRun a $ effect with a given effect handler.effectful-core+Bring an effect into scope without a label.Useful for running code written with the non-labeled effect in mind.effectful-coreThe effect handler.effectful-coreThe action using the effect. Safe-Inferred)*/0169< effectful-coreHandle errors of type e (via Effectful.Error.Static).effectful-coreHandle errors of type e (via Effectful.Error.Static!) with a specific error handler.effectful-coreHandle errors of type e (via Effectful.Error.Static$). In case of an error discard the .effectful-coreHandle errors of type e (via Effectful.Error.Static) with a specific error handler. In case of an error discard the  CallStack.effectful-coreThrow an error of type e and specify a display function in case a third-party code catches the internal exception and s it.effectful-coreThrow an error of type e with  as a display function.effectful-coreThrow an error of type e with no display function.effectful-coreHandle an error of type e.effectful-core The same as  , which is useful in situations where the code for the handler is shorter.effectful-core Similar to , but returns an  result which is a  if no error was thrown and a  otherwise.effectful-coreThe error handler.effectful-coreThe error handler.effectful-coreThe display function.effectful-core The error.effectful-core The error.effectful-core The error.effectful-coreThe inner computation.effectful-core.A handler for errors in the inner computation.effectful-core.A handler for errors in the inner computation.effectful-coreThe inner computation.effectful-coreThe inner computation. Safe-Inferred)*/0169<effectful-core6Internal error type for the Empty action. Better than ()" in case it escapes the scope of  and shows up in error messages.effectful-core(Policy of dealing with modifications to  thread local? state in the environment in branches that end up calling the  operation.Note:  is significantly faster as there is no need to back up the environment on each call to .effectful-coreKeep modifications on .effectful-coreRollback modifications on .Note:( state modifications are rolled back on  only. In particular, they are not rolled back on exceptions.effectful-coreRun the  effect with a given .Note:  executes the second computation if (and only if) the first computation calls .effectful-coreSpecialized version of  with the # constraint for tracking purposes.effectful-coreSpecialized version of  with the # constraint for tracking purposes.   Safe-Inferred)*/0169<< Safe-Inferred)*/0169<ueffectful-coreA restricted variant of 3 with unchanged return type of the effect handler.effectful-core"Provide a way to run a handler of e with a given input.Note: f can be used to alter the return type of the effect handler. If that's unnecessary, use .effectful-coreRun the $ effect with a given effect handler.effectful-coreRun the  effect with a given effect handler that doesn't change its return type.effectful-coreRun the effect handler.effectful-core2Run the effect handler with unchanged return type.effectful-core*Run the effect handler with a given input.effectful-coreRun the effect handler that doesn't change its return type with a given input.effectful-coreThe effect handler.effectful-coreThe effect handler.effectful-core The input to the effect handler.effectful-core The input to the effect handler. Safe-Inferred)*/0169<effectful-coreA restricted variant of , with unchanged return type of the handler.effectful-core+Provide a way to run a handler of multiple  providedEs with a given input.Note: f can be used to alter the return type of the handler. If that's unnecessary, use .effectful-coreRun the  effect with a given handler.effectful-coreRun the Provider effect with a given handler that doesn't change its return type.effectful-coreRun the handler.effectful-core+Run the handler with unchanged return type.effectful-core#Run the handler with a given input.effectful-coreRun the handler that doesn't change its return type with a given input.effectful-core The handler.effectful-core The handler.effectful-coreThe input to the handler.effectful-coreThe input to the handler.   Safe-Inferred)*/0169<Leffectful-coreProvide access to a strict (WHNF), thread local, read only value of type r.effectful-coreRun a + effect with the given initial environment.effectful-core0Execute a computation in a modified environment.effectful-core#Fetch the value of the environment.effectful-core/Retrieve a function of the current environment.  f D f  effectful-core0Execute a computation in a modified environment.  r ( f m) D  (f r) meffectful-coreThe initial environment.effectful-core'The function to modify the environment.effectful-core/Computation to run in the modified environment.effectful-core)The function to apply to the environment.effectful-core'The function to modify the environment. Safe-Inferred)*/0169<effectful-coreRun the 1 effect with the given initial environment (via Effectful.Reader.Static).effectful-core0Execute a computation in a modified environment.effectful-core#Fetch the value of the environment.effectful-core/Retrieve a function of the current environment.  f D f  effectful-core0Execute a computation in a modified environment.  r ( f m) D  (f r) meffectful-coreThe initial environment.effectful-core'The function to modify the environment.effectful-core/Computation to run in the modified environment.effectful-core)The function to apply to the environment.effectful-core'The function to modify the environment. Safe-Inferred)*/0169<keffectful-coreRun the 1 effect with the given initial environment (via Effectful.Reader.Static).effectful-core#Fetch the value of the environment.effectful-core/Retrieve a function of the current environment.  f D f  effectful-core0Execute a computation in a modified environment.  r ( f m) D  (f r) meffectful-coreThe initial environment.effectful-core)The function to apply to the environment.effectful-core'The function to modify the environment. Safe-Inferred)*/0169< effectful-coreProvide access to a strict (WHNF), thread local, mutable value of type s.effectful-coreRun the  effect with the given initial state and return the final value along with the final state.effectful-coreRun the  effect with the given initial state and return the final value, discarding the final state.effectful-coreRun the  effect with the given initial state and return the final state, discarding the final value.effectful-core%Fetch the current value of the state.effectful-core$Get a function of the current state.  f D f  effectful-core)Set the current state to the given value.effectful-core;Apply the function to the current state and return a value.effectful-core(Apply the function to the current state.  f D  (\s -> ((), f s))effectful-coreApply the monadic function to the current state and return a value.effectful-core0Apply the monadic function to the current state.  f D  (\s -> ((), )  f s)effectful-coreThe initial state.effectful-coreThe initial state.effectful-coreThe initial state.effectful-core#The function to apply to the state.effectful-core!The function to modify the state.effectful-core!The function to modify the state.effectful-core!The function to modify the state.effectful-core)The monadic function to modify the state.   Safe-Inferred)*/0169<эeffectful-coreProvide access to a strict (WHNF), shared, mutable value of type s.effectful-coreRun the  effect with the given initial state and return the final value along with the final state.effectful-coreRun the  effect with the given initial state and return the final value, discarding the final state.effectful-coreRun the  effect with the given initial state and return the final state, discarding the final value.effectful-coreRun the % effect with the given initial state 8 and return the final value along with the final state.effectful-coreRun the % effect with the given initial state 9 and return the final value, discarding the final state.effectful-coreRun the % effect with the given initial state 9 and return the final state, discarding the final value.effectful-core%Fetch the current value of the state.effectful-core$Get a function of the current state.  f D f  effectful-core)Set the current state to the given value.effectful-core;Apply the function to the current state and return a value.Note: this function gets an exclusive access to the state for its duration.effectful-core(Apply the function to the current state.  f D  (\s -> ((), f s))Note: this function gets an exclusive access to the state for its duration.effectful-coreApply the monadic function to the current state and return a value.Note: this function gets an exclusive access to the state for its duration.effectful-core0Apply the monadic function to the current state.  f D  (\s -> ((), )  f s)Note: this function gets an exclusive access to the state for its duration. Safe-Inferred)*/0169<effectful-core*Provide access to a mutable value of type s.effectful-coreRun the  effect with the given initial state and return the final value along with the final state (via Effectful.State.Static.Local).effectful-coreRun the  effect with the given initial state and return the final value, discarding the final state (via Effectful.State.Static.Local).effectful-coreRun the  effect with the given initial state and return the final state, discarding the final value (via Effectful.State.Static.Local).effectful-coreRun the  effect with the given initial state and return the final value along with the final state (via Effectful.State.Static.Shared).effectful-coreRun the  effect with the given initial state and return the final value, discarding the final state (via Effectful.State.Static.Shared).effectful-coreRun the  effect with the given initial state and return the final state, discarding the final value (via Effectful.State.Static.Shared).effectful-core%Fetch the current value of the state.effectful-core$Get a function of the current state.  f D f  effectful-core)Set the current state to the given value.effectful-core;Apply the function to the current state and return a value.effectful-core(Apply the function to the current state.  f D  (\s -> ((), f s))effectful-coreApply the monadic function to the current state and return a value.effectful-core0Apply the monadic function to the current state.  f D  (\s -> ((), )  f s) Safe-Inferred)*/0169<w effectful-coreRun the  effect with the given initial state and return the final value along with the final state (via Effectful.State.Static.Local).effectful-coreRun the  effect with the given initial state and return the final value, discarding the final state (via Effectful.State.Static.Local).effectful-coreRun the  effect with the given initial state and return the final state, discarding the final value (via Effectful.State.Static.Local).effectful-coreRun the  effect with the given initial state and return the final value along with the final state (via Effectful.State.Static.Shared).effectful-coreRun the  effect with the given initial state and return the final value, discarding the final state (via Effectful.State.Static.Shared).effectful-coreRun the  effect with the given initial state and return the final state, discarding the final value (via Effectful.State.Static.Shared).effectful-core%Fetch the current value of the state.effectful-core$Get a function of the current state.  f D f  effectful-core)Set the current state to the given value.effectful-core;Apply the function to the current state and return a value.effectful-core(Apply the function to the current state.  f D  (\s -> ((), f s))effectful-coreApply the monadic function to the current state and return a value.effectful-core0Apply the monadic function to the current state.  f D  (\s -> ((), )  f s) effectful-coreThe initial state.effectful-coreThe initial state.effectful-coreThe initial state.effectful-coreThe initial state.effectful-coreThe initial state.effectful-coreThe initial state.effectful-core.effectful-core.effectful-core.effectful-core.effectful-core.effectful-core. Safe-Inferred)*/0169<Teffectful-coreProvide access to a strict (WHNF), thread local, write only value of type w.effectful-coreRun a  effect and return the final value along with the final output.effectful-coreRun a  effect and return the final output, discarding the final value.effectful-core5Append the given output to the overall output of the .effectful-coreExecute an action and append its output to the overall output of the .Note: if an exception is received while the action is executed, the partial output of the action will still be appended to the overall output of the ::{ " runEff . execWriter @String $ do tell "Hi"2 handle (\(_::ErrorCall) -> pure ((), "")) $ do tell " there" listen $ do tell "!" error "oops":} "Hi there!"effectful-coreExecute an action and append its output to the overall output of the , then return the final value along with a function of the recorded output.  f m D /0 f   m Safe-Inferred)*/0169<effectful-coreProvide access to a strict (WHNF), shared, write only value of type w.effectful-coreRun a  effect and return the final value along with the final output.effectful-coreRun a  effect and return the final output, discarding the final value.effectful-core5Append the given output to the overall output of the .effectful-coreExecute an action and append its output to the overall output of the .Note: if an exception is received while the action is executed, the partial output of the action will still be appended to the overall output of the ::{ " runEff . execWriter @String $ do tell "Hi"2 handle (\(_::ErrorCall) -> pure ((), "")) $ do tell " there" listen $ do tell "!" error "oops":} "Hi there!"effectful-coreExecute an action and append its output to the overall output of the , then return the final value along with a function of the recorded output.  f m D /0 f   m Safe-Inferred)*/0169<effectful-core-Provide access to a write only value of type w.effectful-coreRun the  effect and return the final value along with the final output (via Effectful.Writer.Static.Local).effectful-coreRun a  effect and return the final output, discarding the final value (via Effectful.Writer.Static.Local).effectful-coreRun the  effect and return the final value along with the final output (via Effectful.Writer.Static.Shared).effectful-coreRun the  effect and return the final output, discarding the final value (via Effectful.Writer.Static.Shared).effectful-core5Append the given output to the overall output of the .effectful-coreExecute an action and append its output to the overall output of the .effectful-coreExecute an action and append its output to the overall output of the , then return the final value along with a function of the recorded output.  f m D /0 f   m   Safe-Inferred)*/0169<effectful-coreRun the  effect and return the final value along with the final output (via Effectful.Writer.Static.Local).effectful-coreRun a  effect and return the final output, discarding the final value (via Effectful.Writer.Static.Local).effectful-coreRun the  effect and return the final value along with the final output (via Effectful.Writer.Static.Shared).effectful-coreRun the  effect and return the final output, discarding the final value (via Effectful.Writer.Static.Shared).effectful-core5Append the given output to the overall output of the .effectful-coreExecute an action and append its output to the overall output of the .effectful-coreExecute an action and append its output to the overall output of the , then return the final value along with a function of the recorded output.  f m D /0 f   m  12345645718918:18;1<=12>12?12@12A12B1<C1<D1<E1<F1<G1<H1<I1<J1<K1<L1<M1<=1NO1NP1NO1NQ1RS1RT1RU1RV1RW1RX1RY1RZ1R[1R\1R\1R]1R]1R^1R^1R_1R_1R`1R`1Ra1Ra1Rb1Rb1Rc1Rd1ef1ef1eg1eg1eh1eh1ei1ei1ej1ej1ek1ek1el1el1em1em1no1npqrsqrsqrtqruqrvqrwqrxqr.qryqrzqr{qr|qr}qr~qrqr*                                                                               % s s      $      !        &              #                        +, (                    '               ))""""        1445112124511121111211-effectful-core-2.4.0.0-AChGPUBEiEJCiCVtIxyXC4Effectful.ExceptionEffectful.Internal.EffectEffectful.Internal.UtilsEffectful.Error.StaticEffectful.Dispatch.StaticEffectful.NonDet EffectfulEffectful.Provider.ListEffectful.Dispatch.Dynamic#Effectful.Dispatch.Static.PrimitiveEffectful.Internal.EnvEffectful.Internal.UnliftEffectful.Internal.MonadEffectful.PrimEffectful.Fail Effectful.Dispatch.Static.UnsafeEffectful.Error.DynamicEffectful.LabeledEffectful.Labeled.ErrorEffectful.ProviderEffectful.Reader.StaticEffectful.Reader.DynamicEffectful.Labeled.ReaderEffectful.State.Static.LocalEffectful.State.Static.SharedEffectful.State.DynamicEffectful.Labeled.StateEffectful.Writer.Static.LocalEffectful.Writer.Static.SharedEffectful.Writer.DynamicEffectful.Labeled.Writereffectful-coreEffState runStaticRepIOEMaybeIOE withEffToIO localUnlift SharedSuffixReader withRunInIOunsafeLiftMapIOunsafeSeqUnliftIOControl.ExceptionmaskData.BifunctorsecondbaseGHC.Baseassertghc-prim GHC.TypesTypeAnyGHC.Stack.Types CallStack HasCallStack getCallStackGHC.Exception.Type SomeException Alternativeempty<|>somemanyArithExceptionOverflow UnderflowLossOfPrecision DivideByZeroDenormalRatioZeroDenominator Exception toException fromExceptiondisplayException GHC.Exception ErrorCallErrorCallWithLocationprettyCallStackGHC.IO.Exception IOExceptionArrayExceptionIndexOutOfBoundsUndefinedElementAsyncException StackOverflow HeapOverflow ThreadKilled UserInterruptSomeAsyncExceptionAssertionFailedCompactionFailedAllocationLimitExceededDeadlockBlockedIndefinitelyOnSTMBlockedIndefinitelyOnMVarasyncExceptionToExceptionasyncExceptionFromExceptionControl.Exception.BaseNestedAtomicallyNonTermination TypeError NoMethodError RecUpdError RecConError RecSelErrorPatternMatchFailControl.Monad.IO.ClassMonadIOliftIOexceptions-0.10.7Control.Monad.CatchHandlerExitCaseExitCaseSuccessExitCaseException ExitCaseAbort MonadMaskuninterruptibleMaskgeneralBracket MonadCatchcatch MonadThrowthrowM catchIOError handleIOError.safe-exceptions-0.1.7.4-24KZT8FH3V23Q1o5W8bHMFControl.Exception.SafeAsyncExceptionWrapperSyncExceptionWrapperStringException throwStringcatchIOcatchAny catchDeep catchAnyDeep catchAsync catchJusthandlehandleIO handleAny handleDeep handleAnyDeep handleAsync handleJusttrytryIOtryAnytryDeep tryAnyDeeptryAsynctryJust onException withExceptionbracketbracket_finallybracketOnErrorbracketOnError_bracketWithErrortoSyncExceptiontoAsyncExceptionisSyncExceptionisAsyncExceptioncatches catchesDeep catchesAsync,unliftio-core-0.2.1.0-C9JgChpS9UyE1Qndi71slPControl.Monad.IO.Unlift MonadUnliftIO KnownEffectsknownEffectsLength++IsUnknownSuffixOf KnownPrefix prefixLength KnownSubsetSubsetsubsetFullyKnown reifyIndices:>>:> reifyIndexEffect$f:>e:$f:>e:0$f:>e[]$fKnownPrefixes$fKnownPrefix: $fSubset:es $fSubset[]es$fKnownSubset:es$fKnownSubset[]es$fIsUnknownSuffixOfsubEs:$fIsUnknownSuffixOfsubEses$fSubsetsubEses$fKnownEffects[]$fKnownEffects:Unique inlineBracket weakThreadId eqThreadIdtoAnyfromAny newUnique thawCallStack $fEqUnique EffectRep DispatchOf SideEffects NoSideEffectsWithSideEffectsDispatchDynamicStaticRelinker AnyRelinker AnyEffectStoragestSize stVersion stVersions stEffects stRelinkersVersionRefEnv envOffsetenvRefs envStorage toAnyEffect fromAnyEffect toAnyRelinkerfromAnyRelinker dummyRelinkeremptyEnvcloneEnv restoreEnvsizeEnvtailEnvconsEnv unconsEnv replaceEnv unreplaceEnv subsumeEnv injectEnvgetEnvputEnvstateEnv modifyEnv $fPrimRef $fEqVersion $fOrdVersion $fPrimVersion $fShowVersionLimitLimited Unlimited Persistence Ephemeral PersistentUnliftStrategy SeqUnlift SeqForkUnlift ConcUnliftephemeralConcUnliftpersistentConcUnlift $fEqEntryId$fEqUnliftStrategy$fGenericUnliftStrategy$fOrdUnliftStrategy$fShowUnliftStrategy $fEqLimit$fGenericLimit $fOrdLimit $fShowLimit$fEqPersistence$fGenericPersistence$fOrdPersistence$fShowPersistence StaticRep EffectHandlerLocalEnv PrimStateEffPrimFailNonDetEmpty:<|>: runPureEffunEff unsafeEff unsafeEff_unliftStrategywithUnliftStrategywithSeqEffToIOwithConcEffToIO seqUnliftIOseqForkUnliftIO concUnliftIOrunEffrunPrimraise raiseWithsubsumeinject relinkHandler runHandlersend evalStaticRep execStaticRep getStaticRep putStaticRepstateStaticRepstateStaticRepMlocalStaticRep$fMonadMaskEff$fMonadCatchEff$fMonadThrowEff $fMonadFixEff $fMonadEff$fApplicativeEff $fFunctorEff$fMonadPlusEff$fAlternativeEff$fMonadFailEff$fMonadBaseControlIOEff$fMonadBaseIOEff$fMonadUnliftIOEff $fMonadIOEff$fPrimMonadEff $fMonoidEff$fSemigroupEffreallyUnsafeLiftMapIOreallyUnsafeUnliftIOunsafeConcUnliftIOevaluate evaluateDeepErrorrunError runErrorWithrunErrorNoCallStackrunErrorNoCallStackWiththrowErrorWith throwError throwError_ catchError handleErrortryError$fExceptionErrorWrapper$fShowErrorWrapper $fEqErrorIdEffectHandler_ interpret interpretWith reinterpretreinterpretWith interpose interposeWithimpose imposeWith interpret_interpretWith_ reinterpret_reinterpretWith_ interpose_interposeWith_impose_ imposeWith_localSeqUnliftlocalSeqUnliftIO localUnliftIO localSeqLift localLift withLiftMap withLiftMapIOlocalLiftUnliftlocalLiftUnliftIO localSeqLend localLendlocalSeqBorrow localBorrow$fSharedSuffix[][]$fSharedSuffixes1:$fSharedSuffix:es2$fSharedSuffixesesrunFail runFailIOThrowErrorWith CatchErrorLabeled runLabeledlabeled OnEmptyPolicy OnEmptyKeepOnEmptyRollback runNonDetemptyEffsumEff$fShowErrorEmpty$fEqOnEmptyPolicy$fGenericOnEmptyPolicy$fOrdOnEmptyPolicy$fShowOnEmptyPolicy Provider_Provider runProvider runProvider_provideprovide_ provideWith provideWith_ ProviderList_ ProviderListrunProviderListrunProviderList_ provideList provideList_provideListWithprovideListWith_ runReader withReaderaskaskslocalAskLocalrunState evalState execStategetgetsputstatemodifystateMmodifyM runStateMVar evalStateMVar execStateMVarGetPutStateM runStateLocalevalStateLocalexecStateLocalrunStateSharedevalStateSharedexecStateSharedWriter runWriter execWritertelllistenlistensTellListenrunWriterLocalexecWriterLocalrunWriterSharedexecWriterShared ghc-bignumGHC.Num.IntegerInteger getLocation emptyStorage insertEffect deleteEffect relinkEnvdoubleCapacitywriteSmallArray'(primitive-0.9.0.0-2Ut0u6h4ou624O572IFc4SData.Primitive.SmallArraywriteSmallArray ThreadEntry GHC.Conc.SyncforkIOWithUnmaskControl.Monad.Primitive PrimStateGHC.Prim RealWorldIOioToPrimControl.Monad.Fail MonadFail MonadPlusStringBool,monad-control-1.0.3.1-DKyOmS56PHbCrvUBWNZtoJControl.Monad.Trans.ControlMonadBaseControl liftBaseWithGHC.IOdeepseq-1.4.8.1Control.DeepSeqNFDataGHC.Showshowflip Data.EitherEitherRightLeft newErrorIdid ErrorEmpty Data.Foldableasum Data.Functor<$>2strict-mutable-base-1.1.0.0-5WG4sRbF3hXEM8SVpIIGy7Control.Concurrent.MVar.StrictMVar'