h&zз      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc d e f g h i j k l m n o p q r s tuv w x y z { | }~                                             Safe-Inferred)*/158; effectful-core Require that xs is the unknown suffix of es.effectful-core1Calculate length of a statically known prefix of es.effectful-coreProvide evidence that xs 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.  None )*/158; 1#effectful-coreA strict variant of .$effectful-coreA strict variant of .%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.#$%&'()*+,-./01%&'()$*+,#-./01 Safe-Inferred)*/158;4effectful-core$Internal representations of effects.5effectful-coreDispatch types of effects.6effectful-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.9effectful-coreA type of dispatch. For more information consult the documentation in Effectful.Dispatch.Dynamic and Effectful.Dispatch.Static.<effectful-coreA function for relinking E objects stored in the handlers and/or making a deep copy of the representation of the effect when cloning the environment.>effectful-coreA storage of effects.Eeffectful-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 L 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 >.Jeffectful-coreA dummy <.Keffectful-coreCreate an empty environment.Leffectful-core6Clone the environment to use it in a different thread.Meffectful-core'Restore the environment from its clone.Neffectful-core(Get the current size of the environment.Oeffectful-core#Access the tail of the environment.Peffectful-core,Extend the environment with a new data type.Qeffectful-core(Shrink the environment by one data type.Note: after calling this function e1 from the input environment is no longer usable.Reffectful-core8Replace a specific effect in the stack with a new value.Note: unlike in W the value in not changed in place, so only the new environment will see it.Seffectful-core*Remove a reference to the replaced effect.Note: after calling this function the input environment is no longer usable.Teffectful-core7Reference an existing effect from the top of the stack.Ueffectful-coreConstruct an environment containing a permutation (with possible duplicates) of a subset of effects from the input environment.Veffectful-core2Extract a specific data type from the environment.Weffectful-coreReplace the data type in the environment with a new value (in place).Xeffectful-coreModify the data type in the environment and return a value (in place).Yeffectful-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 .Meffectful-core Destination.effectful-coreSource.Peffectful-core!The representation of the effect.Reffectful-core!The representation of the effect.Veffectful-coreThe environment.Weffectful-coreThe environment.Xeffectful-coreThe environment.Yeffectful-coreThe environment.effectful-core!The representation of the effect.&456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY&EFGHI>?@ABCD<=J9:;67854KLMNOPQRSTUVWXY  Safe-Inferred)*/158;'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.Zeffectful-coreLimit setting for the b 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 b 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.aeffectful-core/The fastest strategy and a default setting for . An attempt to call the unlifting function in threads distinct from its creator will result in a runtime error.beffectful-coreA strategy that makes it possible for the unlifting function to be called in threads distinct from its creator. See ] and Z settings for more information.ceffectful-coreSequential unlift.deffectful-core4Concurrent unlift for various strategies and limits.eeffectful-coreConcurrent unlift that doesn't preserve the environment between calls to the unlifting function in threads other than its creator.feffectful-coreConcurrent unlift that preserves the environment between calls to the unlifting function within a particular thread.eeffectful-core0Number of permitted uses of the unlift function.feffectful-core>Number of threads that are allowed to use the unlift function. Z[\]^_`abcdef `ab]^_Z[\cdef  Safe-Inferred)*/158;F/+teffectful-core:Internal representations of statically dispatched effects.ueffectful-core Require the } effect for running statically dispatched effects whose operations perform side effects.veffectful-coreAn internal representation of dynamically dispatched effects, i.e. the effect handler bundled with its environment.xeffectful-core%Type signature of the effect handler.yeffectful-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  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 of .effectful-coreProvide the ability to use the   and  instance of .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 `.effectful-coreLocally override the ` with the given value.effectful-core.Create an unlifting function with the current `.This function is equivalent to  , but has a   constraint for accurate stack traces in case an insufficiently powerful `* is used and the unlifting function fails.effectful-core&Create an unlifting function with the a strategy.effectful-core&Create an unlifting function with the b strategy.effectful-core&Create an unlifting function with the a strategy.effectful-core&Create an unlifting function with the b 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 xs within es as long as xs= 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-coreInstance included for compatibility with existing code, usage of  is preferrable.effectful-coreInstance included for compatibility with existing code, usage of  is preferrable.effectful-coreUse - if you want accurate stack traces on errors.xeffectful-core4Capture of the local environment for handling local  computations when e is a higher order effect.effectful-core.The effect performed in the local environment.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-core2Continuation with the unlifting function in scope.effectful-core The effect.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.;PVWXYZ[\]^_`abtuvwxyz{|}~;~}|{`ab]^_Z[\xyzvwtuPVWXY Safe-Inferred)*/158;Jeffectful-coreUtility for lifting  computations of type  a ->  bto  es a ->  es bThis function is  highly unsafe because:&It can be used to introduce arbitrary  actions into pure  computations.The  computation must not run its argument in a different thread, but it's not checked anywhere.=If you disregard the second point, segmentation faults await.effectful-coreCreate an unlifting function.This function is  highly unsafe because:&It can be used to introduce arbitrary  actions into pure  computations. Unlifted  computations must not be run in a thread distinct from the caller of  , but it's not checked anywhere.=If you disregard the second point, segmentation faults await. Safe-Inferred)*/158;J4<=EJKLMNOPQVWXYE<=J4PQVWXYKLMNO Safe-Inferred)*/158;Oeffectful-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 a 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 b 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. 678tut678u  Safe-Inferred)*/158;O" 59:;Z[\]^_`ab}"9:;5}`ab]^_Z[\  Safe-Inferred)*/158;Tfeffectful-core-Provide the ability to handle errors of type e.effectful-coreHandle errors of type e.effectful-coreHandle errors of type e". In case of an error discard the .effectful-coreThrow an error of type e.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-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)*/158;neffectful-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-coreInterpret an effect.Note:  can be turned into a  with the use of .effectful-core1Interpret an effect using other, private effects.  D  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 Op :: E m ()& type instance DispatchOf E = Dynamic:}:{1 runE :: IOE :> es => Eff (E : es) a -> Eff es a4 runE = interpret $ \_ Op -> liftIO (putStrLn "op"):}runEff . runE $ send Opop:{: augmentE :: (E :> es, IOE :> es) => Eff es a -> Eff es a augmentE = interpose $ \_ Op -> liftIO (putStrLn "augmented op") >> send Op:}"runEff . runE . augmentE $ send Op augmented opopeffectful-coreReplace the handler of an existing effect with a new one that uses other, private effects.  D  effectful-core+Create a local unlifting function with the a( strategy. For the general version see .effectful-core+Create a local unlifting function with the a( 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 a( 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-coreThis is always preferred to SharedSuffix es es as it's not incoherent.effectful-coreThe effect handler.effectful-core8Introduction of effects encapsulated within the handler.effectful-coreThe effect 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. xyxy  Safe-Inferred)*/158;oeffectful-coreRun the ~ effect via .effectful-coreRun the ~ effect via the  instance for .~~ Safe-Inferred)*/158;teffectful-core-Provide the ability to handle errors of type e.effectful-coreHandle errors of type e (via Effectful.Error.Static).effectful-coreHandle errors of type e (via Effectful.Error.Static$). In case of an error discard the .effectful-coreThrow an error of type e.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 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)*/158;weffectful-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 .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)*/158;x'{||{ Safe-Inferred)*/158;{effectful-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)*/158;3effectful-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)*/158; 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)*/158;Oeffectful-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)*/158;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)*/158;jeffectful-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 $% f   m Safe-Inferred)*/158; 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 $% f   m Safe-Inferred)*/158;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 $% f   m  &'(&')*+,*-.*-/*01*23*24*25*26*27*+8*+9:;:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijjkklmnopqqrstuvwxyz{|}~                                                                                                            !!** *&&'**2*2&'*2****2**-effectful-core-2.2.2.2-3ZnPMiMlFXL41oNodyVfObEffectful.Internal.EffectEffectful.Internal.UtilsEffectful.Error.Static EffectfulEffectful.NonDetEffectful.Dispatch.Static#Effectful.Dispatch.Static.PrimitiveEffectful.Internal.EnvEffectful.Internal.UnliftEffectful.Internal.MonadEffectful.Dispatch.DynamicEffectful.PrimEffectful.Fail Effectful.Dispatch.Static.UnsafeEffectful.Error.DynamicEffectful.Reader.StaticEffectful.Reader.DynamicEffectful.State.Static.LocalEffectful.State.Static.SharedEffectful.State.DynamicEffectful.Writer.Static.LocalEffectful.Writer.Static.SharedEffectful.Writer.DynamicEffState runStaticRepIOEMaybeIOE withEffToIO withRunInIO localUnlift SharedSuffixReaderControl.ExceptionmaskData.Bifunctorsecondghc-prim GHC.TypesTypeAnybaseGHC.Stack.Types CallStackControl.Monad.IO.ClassliftIOMonadIO GHC.ExceptionprettyCallStackGHC.Basesomemanyempty<|> Alternative HasCallStack getCallStack,unliftio-core-0.2.1.0-LnlI9cWUdXt7RBg3vurrUqControl.Monad.IO.Unlift MonadUnliftIOIsUnknownSuffixOf KnownPrefix prefixLengthSubsetsubsetFullyKnown reifyIndices:>>:> reifyIndexEffect$f:>e:$f:>e:0$f:>e[]$fKnownPrefixes$fKnownPrefix: $fSubset:es $fSubset[]es$fIsUnknownSuffixOfxs:$fIsUnknownSuffixOfxses $fSubsetxsesMVar'IORef' inlineBracket weakThreadId eqThreadIdtoAnyfromAny newIORef' readIORef' writeIORef'toMVar'newMVar' readMVar' modifyMVar' modifyMVar_' $fEqMVar' $fEqIORef' EffectRep DispatchOf SideEffects NoSideEffectsWithSideEffectsDispatchDynamicStaticRelinkerStoragestSize stVersion stVersions stEffects stRelinkersEnv envOffsetenvRefs envStorage dummyRelinkeremptyEnvcloneEnv restoreEnvsizeEnvtailEnvconsEnv unconsEnv replaceEnv unreplaceEnv subsumeEnv injectEnvgetEnvputEnvstateEnv modifyEnvLimitLimited Unlimited Persistence Ephemeral PersistentUnliftStrategy SeqUnlift ConcUnlift seqUnlift concUnliftephemeralConcUnliftpersistentConcUnlift $fEqEntryId$fEqUnliftStrategy$fGenericUnliftStrategy$fOrdUnliftStrategy$fShowUnliftStrategy $fEqLimit$fGenericLimit $fOrdLimit $fShowLimit$fEqPersistence$fGenericPersistence$fOrdPersistence$fShowPersistence StaticRepHandler EffectHandlerLocalEnv PrimStateEffPrimFailNonDetEmpty:<|>: runPureEffunEff unsafeEff unsafeEff_unliftStrategywithUnliftStrategywithSeqEffToIOwithConcEffToIO seqUnliftIO concUnliftIOrunEffrunPrimraise raiseWithsubsumeinject relinkHandler runHandlersend evalStaticRep execStaticRep getStaticRep putStaticRepstateStaticRepstateStaticRepMlocalStaticRep$fMonadMaskEff$fMonadCatchEff$fMonadThrowEff $fMonadFixEff $fMonadEff$fApplicativeEff $fFunctorEff$fMonadPlusEff$fAlternativeEff$fMonadFailEff$fMonadBaseControlIOEff$fMonadBaseIOEff$fMonadUnliftIOEff $fMonadIOEff$fPrimMonadEff $fMonoidEff$fSemigroupEffreallyUnsafeLiftMapIOreallyUnsafeUnliftIOunsafeLiftMapIOunsafeSeqUnliftIOunsafeConcUnliftIOErrorrunErrorrunErrorNoCallStack throwError catchError handleErrortryError$fExceptionErrorWrapper$fShowErrorWrapper $fEqErrorId interpret reinterpret interposeimposelocalSeqUnliftlocalSeqUnliftIO localUnliftIO localSeqLift localLift withLiftMap withLiftMapIOlocalLiftUnliftlocalLiftUnliftIO$fSharedSuffix[][]$fSharedSuffixes1:$fSharedSuffix:es2$fSharedSuffixesesrunFail runFailIO ThrowError CatchError OnEmptyPolicy OnEmptyKeepOnEmptyRollback runNonDetemptyEffsumEff$fEqOnEmptyPolicy$fGenericOnEmptyPolicy$fOrdOnEmptyPolicy$fShowOnEmptyPolicy runReader withReaderaskaskslocalAskLocalrunState evalState execStategetgetsputstatemodifystateMmodifyM runStateMVar evalStateMVar execStateMVarGetPutStateM runStateLocalevalStateLocalexecStateLocalrunStateSharedevalStateSharedexecStateSharedWriter runWriter execWritertelllistenlistensTellListenrunWriterLocalexecWriterLocalrunWriterSharedexecWriterShared ghc-bignumGHC.Num.IntegerIntegerGHC.MVarMVar GHC.IORefIORef getLocation emptyStorage insertEffect deleteEffect relinkEnvdoubleCapacitywriteSmallArray'(primitive-0.8.0.0-LlRUNeadwzL5iUsmiOkRZ1Data.Primitive.SmallArraywriteSmallArray ThreadEntry GHC.Conc.SyncforkIOWithUnmaskControl.Monad.Primitive PrimStateGHC.Prim RealWorldIOioToPrimControl.Monad.Fail MonadFail MonadPlusStringBoolflip Data.EitherEitherRightLeft newErrorIdid Data.Foldableasum Data.Functor<$>