h$XW      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ ] ^_ `a b cdefghijklmn opqrst uvwxyz{|}~                          None'(-/258>? 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'(-/258>?teffectful-core$Internal representations of effects.effectful-coreDispatch types of effects.effectful-coreSignifies whether core operations of a statically dispatched effect perform side effects. If an effect is marked as such, the ' family of functions will require the " effect to be in context via the  type family.effectful-coreA type of dispatch. For more information consult the documentation in Effectful.Dispatch.Dynamic and Effectful.Dispatch.Static.effectful-coreA function for relinking ' objects stored in the handlers and/or making a deep copy of the representation of the effect when cloning the environment.effectful-coreA storage of effects.Shared between all forks of the environment within the same thread.#effectful-core)An array of references to effects in the .'effectful-coreA strict (WHNF),  thread local7, mutable, extensible record indexed by types of kind .Supports forking, i.e. introduction of local branches for encapsulation of effects specific to effect handlers.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(1) (amortized). Shrinking: O(1). Indexing via  : O(1)$Modification of a specific element: O(1). Forking: O(n), where n! is the size of the effect stack. Cloning:  O(N + (n_i)), where N is the size of the  , while i? ranges over handlers of dynamically dispatched effects in the  and n_i$ is the size of the effect stack of i -th handler.,effectful-coreA dummy .-effectful-coreCreate an empty environment..effectful-core6Clone the environment to use it in a different thread./effectful-core!Create a fork of the environment.Forked environment can be updated independently of the original one within the same thread.0effectful-coreCheck that the size of the environment is internally consistent.1effectful-core(Get the current size of the environment.2effectful-core#Access the tail of the environment.3effectful-core7Extend the environment with a new data type (in place).4effectful-core3Shrink the environment by one data type (in place).Note: after calling this function the input environment is no longer usable.5effectful-core8Replace a specific effect in the stack with a new value.6effectful-core*Remove a reference to the replaced effect.Note: after calling this function the input environment is no longer usable.7effectful-coreReference an existing effect from the top of the stack (in place).8effectful-coreRemove a reference to an existing effect from the top of the stack.Note: after calling this function the input environment is no longer usable.9effectful-coreConstruct an environment containing a permutation (with possible duplicates) of a subset of effects from the input environment.:effectful-core2Extract a specific data type from the environment.;effectful-coreReplace the data type in the environment with a new value (in place).<effectful-coreModify the data type in the environment (in place) and return a value.=effectful-core3Modify the data type in the environment (in place).3effectful-core!The representation of the effect.5effectful-core!The representation of the effect.:effectful-coreThe environment.;effectful-coreThe environment.<effectful-coreThe environment.=effectful-coreThe environment.* !"#$%&'()*+,-./0123456789:;<=*'()*+#$%& !",-./1023456789:;<=None'(-/258>? ',-./01234:;<=',34:;<=-./102None'(-/258>?$ >effectful-coreLimit setting for the F strategy.?effectful-coreBehavior dependent on the A setting.For B, 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 C, 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.Aeffectful-corePersistence setting for the F strategy.Different functions require different persistence strategies. Examples:Lifting pooledMapConcurrentlyN from the unliftio library requires the B strategy as we don't want jobs to share environment changes made by previous jobs run in the same worker thread.Lifting  requires the C strategy, otherwise the unmasking function would start with a fresh environment each time it's called.Beffectful-coreDon't persist the environment between calls to the unlifting function in threads distinct from its creator.Ceffectful-corePersist the environment between calls to the unlifting function within a particular thread.Deffectful-core#The strategy to use when unlifting  computations via ,  or the   family.Warning: unlifting functions should not be used outside of continuations that brought them into scope. (The behavior when doing so is undefined.Eeffectful-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.Feffectful-coreA strategy that makes it possible for the unlifting function to be called in threads distinct from its creator. See A and > settings for more information.Geffectful-coreSequential unlift.Heffectful-core4Concurrent unlift for various strategies and limits.Ieffectful-coreConcurrent unlift that doesn't preserve the environment between calls to the unlifting function in threads other than its creator.Jeffectful-coreConcurrent unlift that preserves the environment between calls to the unlifting function within a particular thread.Ieffectful-core0Number of permitted uses of the unlift function.Jeffectful-core>Number of threads that are allowed to use the unlift function. >?@ABCDEFGHIJ DEFABC>?@GHIJNone'(-/258>?=r$Xeffectful-core:Internal representations of statically dispatched effects.Yeffectful-core Require the ` effect for running statically dispatched effects whose operations perform side effects.Zeffectful-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 c* environment at the point of calling the t 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._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.aeffectful-coreProvide the ability to use the  instance of c.ceffectful-coreThe c monad provides the implementation of a computation that performs an arbitrary set of effects. In c 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) => c 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.deffectful-core Run a pure c computation./For running computations with side effects see m.eeffectful-corePeel off the constructor of c.feffectful-coreAccess the underlying " monad along with the environment.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure c computations.geffectful-coreAccess the underlying  monad.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure c computations.heffectful-coreGet the current D.ieffectful-coreLocally override the D with the given value.jeffectful-core.Create an unlifting function with the current D.This function is equivalent to  , but has a  constraint for accurate stack traces in case an insufficiently powerful D* is used and the unlifting function fails.keffectful-core&Create an unlifting function with the E strategy.leffectful-core&Create an unlifting function with the F strategy.meffectful-coreRun an c computation with side effects."For running pure computations see d.neffectful-coreRun an c6 computation with primitive state-transformer actions.oeffectful-coreLift an c7 computation into an effect stack with one more effect.Note: unless you need this function rarely, you're most likely working with monomorphic effect stacks, which is not recommended (see c for more information).peffectful-core>Eliminate a duplicate effect from the top of the effect stack.qeffectful-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 o and p.Note: this function should be needed rarely, usually when you have to cross API boundaries and monomorphic effect stacks are involved. Using monomorphic stacks is discouraged (see c), but sometimes might be necessary due to external constraints.seffectful-core;Run a dynamically dispatched effect with the given handler.teffectful-coreSend an operation of the given effect to its handler for execution.ueffectful-coreRun a statically dispatched effect with the given initial representation and return the final value along with the final representation.veffectful-coreRun a statically dispatched effect with the given initial representation and return the final value, discarding the final representation.weffectful-coreRun a statically dispatched effect with the given initial representation and return the final representation, discarding the final value.xeffectful-core/Fetch the current representation of the effect.yeffectful-coreSet the current representation of the effect to the given value.zeffectful-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-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 j- if you want accurate stack traces on errors. \effectful-core4Capture of the local environment for handling local c computations when e is a higher order effect.effectful-core.The effect performed in the local environment.jeffectful-core2Continuation with the unlifting function in scope.keffectful-coreThe environment.effectful-core2Continuation with the unlifting function in scope.leffectful-coreThe environment.effectful-core2Continuation with the unlifting function in scope.teffectful-core The effect.ueffectful-coreThe initial representation.veffectful-coreThe initial representation.weffectful-coreThe initial representation.zeffectful-core*The function to modify the representation.{effectful-core*The function to modify the representation.|effectful-core6The function to temporarily modify the representation.33:;<=>?@ABCDEFXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|3cdefgab`m_nopqDEFABC>?@hijkl\]^Z[rstXYuvwxyz{|3:;<= None'(-/258>?Ameffectful-coreUtility for lifting  computations of type  a ->  bto c es a -> c es bThis function is  highly unsafe because:&It can be used to introduce arbitrary  actions into pure c 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 c computations. Unlifted c 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.None'(-/258>?Eseffectful-coreUtility for lifting  computations of type  a ->  bto c es a -> c 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 c computations.effectful-core&Create an unlifting function with the E strategy.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure c computations.effectful-core&Create an unlifting function with the F strategy.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure c computations.effectful-core2Continuation with the unlifting function in scope.effectful-core2Continuation with the unlifting function in scope.XYefgkluvwxyz{|XYuvwxyz{|klefg None'(-/258>?X effectful-coreRequire that the second list of effects is a suffix of the first one.In other words,  es baseEs means "a suffix of es is baseEs".effectful-coreInterpret an effect.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 E( strategy. For the general version see .effectful-core+Create a local unlifting function with the E( 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-coreUtility for lifting c computations of type c es a -> c es bto c localEs a -> c 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 c localEs a -> c 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 c 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-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-core>Continuation with the lifting and unlifting function in scope.effectful-coreLocal environment.effectful-core>Continuation with the lifting and unlifting function in scope.\]tt\]None'(-/258>?X >?@ABCDEF`cdhijmopqc dm`DEFABC>?@hijopq None'(-/258>?\effectful-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 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.   None'(-/258>?]effectful-coreRun the a effect via .effectful-coreRun the a effect via the  instance for .abab None'(-/258>?aeffectful-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.   None'(-/258>?b_n_nNone'(-/258>?eeffectful-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.None'(-/258>?ieffectful-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.None'(-/258>?o_ 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.  None'(-/258>?w 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.None'(-/258>?~>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)None'(-/258>? 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   mNone'(-/258>?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   mNone'(-/258>?+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  #$%&'(&)*&)+&,-&'.&'/010123456789:;<=>?@ABCDEFFGGHIJKKLMNNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                          &#$&&#$&&&&&&&-effectful-core-1.1.0.0-JNDsswbT3VSHisX5lwVA45Effectful.Internal.EffectEffectful.Error.Static EffectfulEffectful.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 localUnliftReaderControl.ExceptionmaskData.Bifunctorsecondghc-prim GHC.TypesTypebaseGHC.Stack.Types CallStackControl.Monad.IO.ClassliftIOMonadIO GHC.ExceptionprettyCallStack getCallStack HasCallStack,unliftio-core-0.2.0.1-9GVcmaajsglG88oErAZOTVControl.Monad.IO.Unlift MonadUnliftIOSubset reifyIndices:>>:> reifyIndexEffect$f:>e:$f:>e:0$f:>e[] $fSubset:es $fSubset[]es EffectRep DispatchOf SideEffects NoSideEffectsWithSideEffectsDispatchDynamicStaticRelinkerStoragestSize stEffects stRelinkers ReferencesrefSize refIndicesEnvenvSizeenvRefs envStorage dummyRelinkeremptyEnvcloneEnvforkEnv checkSizeEnvsizeEnvtailEnvconsEnv unconsEnv replaceEnv unreplaceEnv subsumeEnv unsubsumeEnv injectEnvgetEnvputEnvstateEnv modifyEnvLimitLimited Unlimited Persistence Ephemeral PersistentUnliftStrategy SeqUnlift ConcUnlift seqUnlift concUnliftephemeralConcUnliftpersistentConcUnlift $fEqEntryId$fEqUnliftStrategy$fGenericUnliftStrategy$fOrdUnliftStrategy$fShowUnliftStrategy $fEqLimit$fGenericLimit $fOrdLimit $fShowLimit$fEqPersistence$fGenericPersistence$fOrdPersistence$fShowPersistence StaticRepHandler EffectHandlerLocalEnvPrimFail runPureEffunEff unsafeEff unsafeEff_unliftStrategywithUnliftStrategy seqUnliftIO concUnliftIOrunEffrunPrimraisesubsumeinject relinkHandler runHandlersend evalStaticRep execStaticRep getStaticRep putStaticRepstateStaticRepstateStaticRepMlocalStaticRep$fMonadMaskEff$fMonadCatchEff$fMonadThrowEff $fMonadFixEff $fMonadEff$fApplicativeEff $fFunctorEff$fMonadFailEff$fMonadBaseControlIOEff$fMonadBaseIOEff$fMonadUnliftIOEff $fMonadIOEff$fPrimMonadEff $fMonoidEff$fSemigroupEffreallyUnsafeLiftMapIOreallyUnsafeUnliftIOunsafeLiftMapIOunsafeSeqUnliftIOunsafeConcUnliftIOSuffixOf interpret reinterpret interposeimposelocalSeqUnliftlocalSeqUnliftIO localUnliftIO withLiftMap withLiftMapIOlocalLiftUnliftlocalLiftUnliftIOErrorrunErrorrunErrorNoCallStack throwError catchError handleErrortryError$fExceptionErrorWrapper$fShowErrorWrapper $fEqErrorIdrunFail runFailIO ThrowError CatchError runReader withReaderaskaskslocalAskLocalrunState evalState execStategetgetsputstatemodifystateMmodifyM runStateMVar evalStateMVar execStateMVarGetPutStateM runStateLocalevalStateLocalexecStateLocalrunStateSharedevalStateSharedexecStateSharedWriter runWriter execWritertelllistenlistensTellListenrunWriterLocalexecWriterLocalrunWriterSharedexecWriterSharedinteger-wired-inGHC.Integer.TypeInteger GHC.Conc.SyncforkIOWithUnmaskIOControl.Monad.Fail MonadFailGHC.BaseStringBoolidflip Data.EitherEitherRightLeft Data.Functor<$>GHC.MVarMVar