h*M      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG H I J K L M NO P Q R STUVWXYZ[ \ ] ^ _`abcdefghijkl m n o p q r s t u v w x y z {|} ~                                                  2.3.1.0 Safe-Inferred)*/169< effectful-core,Calculate length of a list of known effects.effectful-core%Append two type-level lists together.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.5None )*/169< (effectful-core0A unique with no possibility for CAS contention.$Credits for this go to Edward Kmett.)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.+,-./*012)34567(89+,-./*012)34567(89  Safe-Inferred)*/169<B=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.Beffectful-coreA type of dispatch. For more information consult the documentation in Effectful.Dispatch.Dynamic and Effectful.Dispatch.Static.Eeffectful-coreA function for relinking N objects stored in the handlers and/or making a deep copy of the representation of the effect when cloning the environment.Geffectful-coreA storage of effects.Neffectful-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 U 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 G.Seffectful-coreA dummy E.Teffectful-coreCreate an empty environment.Ueffectful-core6Clone the environment to use it in a different thread.Veffectful-core'Restore the environment from its clone.Weffectful-core(Get the current size of the environment.Xeffectful-core#Access the tail of the environment.Yeffectful-core,Extend the environment with a new data type.Zeffectful-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).aeffectful-coreModify the data type in the environment and return a value (in place).beffectful-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 .Veffectful-core Destination.effectful-coreSource.Yeffectful-core!The representation of the effect.[effectful-core!The representation of the effect._effectful-coreThe environment.`effectful-coreThe environment.aeffectful-coreThe environment.beffectful-coreThe environment.effectful-core!The representation of the effect.&NOPQRGHIJKLMEFSBCD?@A>=TUVWXYZ[\]^_`ab&NOPQRGHIJKLMEFSBCD?@A>=TUVWXYZ[\]^_`ab  Safe-Inferred)*/169<)<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.ceffectful-coreLimit setting for the k strategy.deffectful-coreBehavior dependent on the f setting.For g, 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 h, 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.eeffectful-core(Unlimited use of the unlifting function.feffectful-corePersistence setting for the k strategy.Different functions require different persistence strategies. Examples:Lifting pooledMapConcurrentlyN from the unliftio library requires the g strategy as we don't want jobs to share environment changes made by previous jobs run in the same worker thread.Lifting  requires the h strategy, otherwise the unmasking function would start with a fresh environment each time it's called.geffectful-coreDon't persist the environment between calls to the unlifting function in threads distinct from its creator.heffectful-corePersist the environment between calls to the unlifting function within a particular thread.ieffectful-core#The strategy to use when unlifting  computations via ! or the  " family.jeffectful-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.keffectful-coreThe concurrent strategy makes it possible for the unlifting function to be called in threads distinct from its creator. See f and c settings for more information.leffectful-coreSequential unlift.meffectful-coreConcurrent unlift.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. ijkfghcdelm ijkfghcdelm  Safe-Inferred)*/169<J|+{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   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 i.Note:) this strategy is implicitly used by the   and  instance for .effectful-coreLocally override the current i with the given value.effectful-core&Create an unlifting function with the j( 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 k strategy.effectful-core&Create an unlifting function with the j strategy.effectful-core&Create an unlifting function with the k 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-core7Instance included for compatibility with existing code. Usage of - is preferrable as it allows specifying the i8 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  # is preferrable as it's a standard.effectful-core7Instance included for compatibility with existing code. Usage of - is preferrable as it allows specifying the i8 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-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-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.;ijkfghcde}~{|Y_`ab;ijkfghcde}~{|Y_`ab Safe-Inferred)*/169<Qfeffectful-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)*/169<QNEFS=YZ_`abTUVWXNEFS=YZ_`abTUVWX Safe-Inferred)*/169<Ueffectful-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 j 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 k 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.{?@A|{?@A| Safe-Inferred)*/169<V"BCD>ijkfghcde "BCD>ijkfghcde  Safe-Inferred)*/169<\{ 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.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-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)*/169<}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-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 j( strategy. For the general version see .effectful-core+Create a local unlifting function with the j( 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 j( 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 an effect 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 an effect to the local environment with a given unlifting strategy. Generalizes .effectful-core,Borrow an effect from the local environment.effectful-coreBorrow an effect 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 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.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)*/169<~effectful-coreRun the  effect via .effectful-coreRun the  effect via the  instance for . Safe-Inferred)*/169< effectful-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!) 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.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-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<2effectful-coreAssign a label to an effect.effectful-coreRun a $ effect with a given effect handler.effectful-core ((), 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)*/169<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)*/169< 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)*/169<effectful-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)*/169<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)*/169<!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  ,-.,-/01201301405605705805905:0;<0=>0=?@AB@A%CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop q r s t u v w x y y z z { | } ~                                                                      !                                     &' #       "               $$00        0  ,,-00505,-050000500-effectful-core-2.3.1.0-EGxNgHuMuzT2IPf2MGZbuoEffectful.Internal.EffectEffectful.Internal.UtilsEffectful.Error.StaticEffectful.Dispatch.StaticEffectful.NonDet EffectfulEffectful.Provider.List#Effectful.Dispatch.Static.PrimitiveEffectful.Internal.EnvEffectful.Internal.UnliftEffectful.Internal.MonadEffectful.Dispatch.DynamicEffectful.PrimEffectful.Fail Effectful.Dispatch.Static.UnsafeEffectful.Error.DynamicEffectful.LabeledEffectful.ProviderEffectful.Reader.StaticEffectful.Reader.DynamicEffectful.State.Static.LocalEffectful.State.Static.SharedEffectful.State.DynamicEffectful.Writer.Static.LocalEffectful.Writer.Static.SharedEffectful.Writer.Dynamiceffectful-coreEffState runStaticRepIOEMaybeIOE withEffToIO localUnlift SharedSuffixReader withRunInIOunsafeLiftMapIOunsafeSeqUnliftIOControl.ExceptionmaskData.Bifunctorsecondghc-prim GHC.TypesTypeAnybaseGHC.Stack.Types CallStack HasCallStack getCallStackGHC.Base Alternativeempty<|>somemany GHC.ExceptionprettyCallStackControl.Monad.IO.ClassMonadIOliftIO,unliftio-core-0.2.1.0-C9JgChpS9UyE1Qndi71slPControl.Monad.IO.Unlift MonadUnliftIO KnownEffectsknownEffectsLength++IsUnknownSuffixOf KnownPrefix prefixLengthSubsetsubsetFullyKnown reifyIndices:>>:> reifyIndexEffect$f:>e:$f:>e:0$f:>e[]$fKnownPrefixes$fKnownPrefix: $fSubset:es $fSubset[]es$fIsUnknownSuffixOfxs:$fIsUnknownSuffixOfxses $fSubsetxses$fKnownEffects[]$fKnownEffects:UniqueMVar'IORef' inlineBracket weakThreadId eqThreadIdtoAnyfromAny newIORef' readIORef' writeIORef'toMVar'newMVar' readMVar' modifyMVar' modifyMVar_' newUnique thawCallStack $fEqUnique $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 concUnlift $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$fSemigroupEffreallyUnsafeLiftMapIOreallyUnsafeUnliftIOunsafeConcUnliftIOErrorrunError runErrorWithrunErrorNoCallStackrunErrorNoCallStackWith throwError catchError handleErrortryError$fExceptionErrorWrapper$fShowErrorWrapper $fEqErrorId interpret reinterpret interposeimposelocalSeqUnliftlocalSeqUnliftIO localUnliftIO localSeqLift localLift withLiftMap withLiftMapIOlocalLiftUnliftlocalLiftUnliftIO localSeqLend localLendlocalSeqBorrow localBorrow$fSharedSuffix[][]$fSharedSuffixes1:$fSharedSuffix:es2$fSharedSuffixesesrunFail runFailIO ThrowError CatchErrorLabeled runLabeledlabeled OnEmptyPolicy OnEmptyKeepOnEmptyRollback runNonDetemptyEffsumEff$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.IntegerIntegerGHC.MVarMVar GHC.IORefIORef getLocation emptyStorage insertEffect deleteEffect relinkEnvdoubleCapacitywriteSmallArray'(primitive-0.9.0.0-2Ut0u6h4ou624O572IFc4SData.Primitive.SmallArraywriteSmallArray ThreadEntry GHC.Conc.SyncforkIOWithUnmaskephemeralConcUnliftpersistentConcUnliftControl.Monad.Primitive PrimStateGHC.Prim RealWorldIOioToPrimControl.Monad.Fail MonadFail MonadPlusStringBool,monad-control-1.0.3.1-DKyOmS56PHbCrvUBWNZtoJControl.Monad.Trans.ControlMonadBaseControl liftBaseWithflip Data.EitherEitherRightLeft newErrorIdid Data.Foldableasum Data.Functor<$>