h&      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd e f g h i j kl m nopqrstuvwxyz{|}~                                             Safe-Inferred)*/158; 3effectful-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.   Safe-Inferred)*/158;"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 3 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.3effectful-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 ,.8effectful-coreA dummy *.9effectful-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 E the value in not changed in place, so only the new environment will see it.Aeffectful-core*Remove a reference to the replaced effect.Note: after calling this function the input environment is no longer usable.Beffectful-core7Reference an existing effect from the top of the stack.Ceffectful-coreConstruct an environment containing a permutation (with possible duplicates) of a subset of effects from the input environment.Deffectful-core2Extract a specific data type from the environment.Eeffectful-coreReplace the data type in the environment with a new value (in place).Feffectful-coreModify the data type in the environment and return a value (in place).Geffectful-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.Deffectful-coreThe environment.Eeffectful-coreThe environment.Feffectful-coreThe environment.Geffectful-coreThe environment.effectful-core!The representation of the effect.&"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG&34567,-./012*+8'()$%&#"9:;<=>?@ABCDEFG Safe-Inferred)*/158;""*+389:;<=>?DEFG3*+8">?DEFG9:;<= 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.Heffectful-coreLimit setting for the P strategy.Ieffectful-coreBehavior dependent on the K setting.For L, 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 M, 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.Jeffectful-core(Unlimited use of the unlifting function.Keffectful-corePersistence setting for the P strategy.Different functions require different persistence strategies. Examples:Lifting pooledMapConcurrentlyN from the unliftio library requires the L strategy as we don't want jobs to share environment changes made by previous jobs run in the same worker thread.Lifting  requires the M strategy, otherwise the unmasking function would start with a fresh environment each time it's called.Leffectful-coreDon't persist the environment between calls to the unlifting function in threads distinct from its creator.Meffectful-corePersist the environment between calls to the unlifting function within a particular thread.Neffectful-core#The strategy to use when unlifting  computations via ,  or the   family.Oeffectful-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.Peffectful-coreA strategy that makes it possible for the unlifting function to be called in threads distinct from its creator. See K and H settings for more information.Qeffectful-coreSequential unlift.Reffectful-core4Concurrent unlift for various strategies and limits.Seffectful-coreConcurrent unlift that doesn't preserve the environment between calls to the unlifting function in threads other than its creator.Teffectful-coreConcurrent unlift that preserves the environment between calls to the unlifting function within a particular thread.Seffectful-core0Number of permitted uses of the unlift function.Teffectful-core>Number of threads that are allowed to use the unlift function. HIJKLMNOPQRST NOPKLMHIJQRST  Safe-Inferred)*/158;C+beffectful-core:Internal representations of statically dispatched effects.ceffectful-core Require the k effect for running statically dispatched effects whose operations perform side effects.deffectful-coreAn internal representation of dynamically dispatched effects, i.e. the effect handler bundled with its environment.feffectful-core%Type signature of the effect handler.geffectful-coreOpaque representation of the q* 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).ieffectful-core token for q. Used instead of  to prevent the j! effect from executing arbitrary  actions via .jeffectful-coreProvide the ability to perform primitive state-transformer actions.keffectful-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.leffectful-coreProvide the ability to use the  instance of q.neffectful-coreProvide the ability to use the   and  instance of q.qeffectful-coreThe q monad provides the implementation of a computation that performs an arbitrary set of effects. In q 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) => q 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.reffectful-core Run a pure q computation./For running computations with side effects see }.seffectful-corePeel off the constructor of q.teffectful-coreAccess the underlying " monad along with the environment.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure q computations.ueffectful-coreAccess the underlying  monad.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure q computations.veffectful-coreGet the current N.weffectful-coreLocally override the N with the given value.xeffectful-core.Create an unlifting function with the current N.This function is equivalent to  , but has a   constraint for accurate stack traces in case an insufficiently powerful N* is used and the unlifting function fails.yeffectful-core&Create an unlifting function with the O strategy.zeffectful-core&Create an unlifting function with the P strategy.{effectful-core&Create an unlifting function with the O strategy.|effectful-core&Create an unlifting function with the P strategy.}effectful-coreRun an q computation with side effects."For running pure computations see r.~effectful-coreRun an q6 computation with primitive state-transformer actions.effectful-coreLift an q7 computation into an effect stack with one more effect.effectful-coreLift an q 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:}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-core@since: 2.2.0.0effectful-core@since: 2.2.0.0effectful-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 x- if you want accurate stack traces on errors.feffectful-core4Capture of the local environment for handling local q computations when e is a higher order effect.effectful-core.The effect performed in the local environment.xeffectful-core2Continuation with the unlifting function in scope.yeffectful-core2Continuation with the unlifting function in scope.zeffectful-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.;>DEFGHIJKLMNOPbcdefghijklmnopqrstuvwxyz{|}~;qrstunoplmk}ji~NOPKLMHIJvwxyz{|fghdebc>DEFG  Safe-Inferred)*/158;Geffectful-coreUtility for lifting  computations of type  a ->  bto q es a -> q es bThis function is  highly unsafe because:&It can be used to introduce arbitrary  actions into pure q 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 q computations. Unlifted q 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;L effectful-coreUtility for lifting  computations of type  a ->  bto q es a -> q 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 q computations.effectful-core&Create an unlifting function with the O strategy.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure q computations.effectful-core&Create an unlifting function with the P strategy.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure q computations.effectful-core2Continuation with the unlifting function in scope.effectful-core2Continuation with the unlifting function in scope. $%&bcstu{|b$%&c{|stu  Safe-Inferred)*/158;fleffectful-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 r::{% 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 O( strategy. For the general version see .effectful-core+Create a local unlifting function with the O( 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 O( strategy. For the general version see .effectful-core8Create a local lifting function with the given strategy.effectful-coreUtility for lifting q computations of type q es a -> q es bto q localEs a -> q 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 q localEs a -> q 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 q 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. fgfg  Safe-Inferred)*/158;g" #'()HIJKLMNOPkqrvwxyz}"q'()#r}kNOPKLMHIJvwxyz  Safe-Inferred)*/158;keffectful-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;leffectful-coreRun the l effect via .effectful-coreRun the l effect via the  instance for .lmlm Safe-Inferred)*/158;peffectful-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;tseffectful-core(Policy of dealing with modifications to  thread local? state in the environment in branches that end up calling the o operation.Note:  is significantly faster as there is no need to back up the environment on each call to p.effectful-coreKeep modifications on o.effectful-coreRollback modifications on o.effectful-coreRun the n effect with a given .Note: p executes the second computation if (and only if) the first computation calls o.effectful-coreSpecialized version of  with the  # constraint for tracking purposes.effectful-coreSpecialized version of  with the  # constraint for tracking purposes.  nopnop     Safe-Inferred)*/158;tij~ji~ Safe-Inferred)*/158;xeffectful-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;{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)*/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;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)*/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;3effectful-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;meffectful-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(02(03(04(05()6()78989:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWWXXYZ[\]^^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                      (%%&((0(0%&(0(0((((((-effectful-core-2.2.2.0-ESmopo7RCWo4CzONmM3RMgEffectful.Internal.EffectEffectful.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.TypesTypebaseGHC.Stack.Types CallStackControl.Monad.IO.ClassliftIOMonadIO GHC.ExceptionprettyCallStackGHC.Basesomemanyempty<|> Alternative HasCallStack getCallStack,unliftio-core-0.2.0.1-BihYNe8PwN4FRtHKEwT3XsControl.Monad.IO.Unlift MonadUnliftIOIsUnknownSuffixOf KnownPrefix prefixLengthSubsetsubsetFullyKnown reifyIndices:>>:> reifyIndexEffect$f:>e:$f:>e:0$f:>e[]$fKnownPrefixes$fKnownPrefix: $fSubset:es $fSubset[]es$fIsUnknownSuffixOfxs:$fIsUnknownSuffixOfxses $fSubsetxses 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$fSemigroupEffreallyUnsafeLiftMapIOreallyUnsafeUnliftIOunsafeLiftMapIOunsafeSeqUnliftIOunsafeConcUnliftIO interpret reinterpret interposeimposelocalSeqUnliftlocalSeqUnliftIO localUnliftIO localSeqLift localLift withLiftMap withLiftMapIOlocalLiftUnliftlocalLiftUnliftIO$fSharedSuffix[][]$fSharedSuffixes1:$fSharedSuffix:es2$fSharedSuffixesesErrorrunErrorrunErrorNoCallStack throwError catchError handleErrortryError$fExceptionErrorWrapper$fShowErrorWrapper $fEqErrorIdrunFail runFailIO ThrowError CatchError OnEmptyPolicy OnEmptyKeepOnEmptyRollback runNonDetemptyEffsumEff$fEqOnEmptyPolicy$fGenericOnEmptyPolicy$fOrdOnEmptyPolicy$fShowOnEmptyPolicy runReader withReaderaskaskslocalAskLocalrunState evalState execStategetgetsputstatemodifystateMmodifyM runStateMVar evalStateMVar execStateMVarGetPutStateM runStateLocalevalStateLocalexecStateLocalrunStateSharedevalStateSharedexecStateSharedWriter runWriter execWritertelllistenlistensTellListenrunWriterLocalexecWriterLocalrunWriterSharedexecWriterShared ghc-bignumGHC.Num.IntegerInteger getLocation emptyStorage insertEffect deleteEffect relinkEnvdoubleCapacitywriteSmallArray''primitive-0.7.4.0-5Mou7sRsTgfjuEOfjOZOzData.Primitive.SmallArraywriteSmallArray ThreadEntry GHC.Conc.SyncforkIOWithUnmaskControl.Monad.Primitive PrimStateGHC.Prim RealWorldIOioToPrimControl.Monad.Fail MonadFail MonadPlusStringBoolidflip Data.EitherEitherRightLeft newErrorId Data.Foldableasum Data.Functor<$>GHC.MVarMVar