h$54      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW X YZ [\ ] ^_`abcdefghi jklmnop qrstuvwxyz{|}~                              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>?oeffectful-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.%effectful-coreA strict (WHNF),  thread local7, mutable, extensible record indexed by types of kind .Warning: the environment is a mutable data structure and cannot be simultaneously used from multiple threads under any circumstances.In order to pass it to a different thread, you need to perform a deep copy with the , funtion.Offers very good performance characteristics for most often performed operations: Extending: O(n), where n! is the size of the effect stack. Shrinking: O(1). Indexing via  : O(1)$Modification of a specific element: O(1).Getting a tail: O(1). Cloning: O(N), where N is the size of the .*effectful-coreA dummy .+effectful-coreCreate an empty environment.,effectful-core6Clone the environment to use it in a different thread.-effectful-core(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.0effectful-core(Shrink the environment by one data type.Note: after calling this function the input environment is no longer usable.1effectful-core8Replace a specific effect in the stack with a new value.Note: unlike in 6 the value in not changed in place, so only the new environment will see it.2effectful-core*Remove a reference to the replaced effect.Note: after calling this function the input environment is no longer usable.3effectful-core7Reference an existing effect from the top of the stack.4effectful-coreConstruct an environment containing a permutation (with possible duplicates) of a subset of effects from the input environment.5effectful-core2Extract a specific data type from the environment.6effectful-coreReplace the data type in the environment with a new value (in place).7effectful-coreModify the data type in the environment and return a value (in place).8effectful-core3Modify the data type in the environment (in place)./effectful-core!The representation of the effect.1effectful-core!The representation of the effect.5effectful-coreThe environment.6effectful-coreThe environment.7effectful-coreThe environment.8effectful-coreThe environment.% !"#$%&'()*+,-./012345678%%&'() !"#$*+,-./012345678None'(-/258>?%*+,-./05678%*/05678+,-.None'(-/258>?!C 9effectful-coreLimit setting for the A strategy.:effectful-coreBehavior dependent on the < setting.For =, it limits the amount of uses of the unlifting function in threads distinct from its creator to N&. The unlifting function will create N' copies of the environment when called N times and K+1 copies when called K < N times.For >, it limits the amount of threads, distinct from the creator of the unlifting function, it can be called in to N. The amount of calls to the unlifting function within a particular threads is unlimited. The unlifting function will create N+ copies of the environment when called in N threads and K+1 copies when called in K < N threads.;effectful-core(Unlimited use of the unlifting function.<effectful-corePersistence setting for the A strategy.Different functions require different persistence strategies. Examples:Lifting pooledMapConcurrentlyN from the unliftio library requires the = strategy as we don't want jobs to share environment changes made by previous jobs run in the same worker thread.Lifting  requires the > strategy, otherwise the unmasking function would start with a fresh environment each time it's called.=effectful-coreDon't persist the environment between calls to the unlifting function in threads distinct from its creator.>effectful-corePersist the environment between calls to the unlifting function within a particular thread.?effectful-core#The strategy to use when unlifting  computations via ,  or the   family.Note: unlifting functions should not be used outside of continuations that brought them into scope.@effectful-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.Aeffectful-coreA strategy that makes it possible for the unlifting function to be called in threads distinct from its creator. See < and 9 settings for more information.Beffectful-coreSequential unlift.Ceffectful-core4Concurrent unlift for various strategies and limits.Deffectful-coreConcurrent unlift that doesn't preserve the environment between calls to the unlifting function in threads other than its creator.Eeffectful-coreConcurrent unlift that preserves the environment between calls to the unlifting function within a particular thread.Deffectful-core0Number of permitted uses of the unlift function.Eeffectful-core>Number of threads that are allowed to use the unlift function. 9:;<=>?@ABCDE ?@A<=>9:;BCDENone'(-/258>?:%Seffectful-core:Internal representations of statically dispatched effects.Teffectful-core Require the [ effect for running statically dispatched effects whose operations perform side effects.Ueffectful-coreAn internal representation of dynamically dispatched effects, i.e. the effect handler bundled with its environment.Weffectful-core%Type signature of the effect handler.Xeffectful-coreOpaque representation of the ^* environment at the point of calling the p 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).Zeffectful-coreProvide the ability to perform primitive state-transformer actions.[effectful-coreRun arbitrary  computations via  or .Note: it is not recommended to use this effect in application code as it is too liberal. Ideally, this is only used in handlers of more fine-grained effects.\effectful-coreProvide the ability to use the  instance of ^.^effectful-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 h.`effectful-corePeel off the constructor of ^.aeffectful-coreAccess the underlying " monad along with the environment.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure ^ computations.beffectful-coreAccess the underlying  monad.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure ^ computations.ceffectful-coreGet the current ?.deffectful-coreLocally override the ? with the given value.eeffectful-core.Create an unlifting function with the current ?.This function is equivalent to  , but has a  constraint for accurate stack traces in case an insufficiently powerful ?* is used and the unlifting function fails.feffectful-core&Create an unlifting function with the @ strategy.geffectful-core&Create an unlifting function with the A strategy.heffectful-coreRun an ^ computation with side effects."For running pure computations see _.ieffectful-coreRun an ^6 computation with primitive state-transformer actions.jeffectful-coreLift an ^7 computation into an effect stack with one more effect.keffectful-coreLift an ^ computation into an effect stack with one more effect and create an unlifting function with the given strategy.leffectful-core>Eliminate a duplicate effect from the top of the effect stack.meffectful-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 j and l.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 ^), but sometimes might be necessary due to external constraints.oeffectful-core;Run a dynamically dispatched effect with the given handler.peffectful-coreSend an operation of the given effect to its handler for execution.qeffectful-coreRun a statically dispatched effect with the given initial representation and return the final value along with the final representation.reffectful-coreRun a statically dispatched effect with the given initial representation and return the final value, discarding the final representation.seffectful-coreRun a statically dispatched effect with the given initial representation and return the final representation, discarding the final value.teffectful-core/Fetch the current representation of the effect.ueffectful-coreSet the current representation of the effect to the given value.veffectful-coreApply the function to the current representation of the effect and return a value.weffectful-coreApply the monadic function to the current representation of the effect and return a value.xeffectful-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 e- if you want accurate stack traces on errors. Weffectful-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.eeffectful-core2Continuation with the unlifting function in scope.feffectful-coreThe environment.effectful-core2Continuation with the unlifting function in scope.geffectful-coreThe environment.effectful-core2Continuation with the unlifting function in scope.keffectful-core2Continuation with the unlifting function in scope.peffectful-core The effect.qeffectful-coreThe initial representation.reffectful-coreThe initial representation.seffectful-coreThe initial representation.veffectful-core*The function to modify the representation.weffectful-core*The function to modify the representation.xeffectful-core6The function to temporarily modify the representation.4/56789:;<=>?@ASTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx4^_`ab\][hZijklm?@A<=>9:;cdefgWXYUVnopSTqrstuvwx/5678 None'(-/258>?>effectful-coreUtility for lifting  computations of type  a ->  bto ^ es a -> ^ es bThis function is  highly unsafe because:&It can be used to introduce arbitrary  actions into pure ^ computations.The  computation must not run its argument in a different thread, but it's not checked anywhere.=If you disregard the second point, segmentation faults await.effectful-coreCreate an unlifting function.This function is  highly unsafe because:&It can be used to introduce arbitrary  actions into pure ^ computations. Unlifted ^ computations must not be run in a thread distinct from the caller of  , but it's not checked anywhere.=If you disregard the second point, segmentation faults await.None'(-/258>?Beffectful-coreUtility for lifting  computations of type  a ->  bto ^ es a -> ^ es bNote: the computation must not run its argument in a separate thread, attempting to do so will result in a runtime error.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure ^ computations.effectful-core&Create an unlifting function with the @ strategy.This function is unsafe0 because it can be used to introduce arbitrary  actions into pure ^ computations.effectful-core&Create an unlifting function with the A 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.ST`abfgqrstuvwxSTqrstuvwxfg`ab None'(-/258>?Zeffectful-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.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 @( strategy. For the general version see .effectful-core+Create a local unlifting function with the @( strategy. For the general version see .effectful-core:Create a local unlifting function with the given strategy.effectful-core:Create a local unlifting function with the given strategy.effectful-coreUtility for lifting ^ computations of type ^ es a -> ^ es bto ^ localEs a -> ^ localEs bNote: the computation must not run its argument in a different thread, attempting to do so will result in a runtime error.effectful-coreUtility for lifting  computations of type  a ->  bto ^ localEs a -> ^ localEs bNote: the computation must not run its argument in a different thread, attempting to do so will result in a runtime error.3Useful e.g. for lifting the unmasking function in  !-like computations::{data Fork :: Effect where ForkWithUnmask :: ((forall a. m a -> m a) -> m ()) -> Fork m ThreadId'type instance DispatchOf Fork = Dynamic:}:{5runFork :: IOE :> es => Eff (Fork : es) a -> Eff es arunFork = interpret $ \env (ForkWithUnmask m) -> withLiftMapIO env $ \liftMap -> do localUnliftIO env (ConcUnlift Ephemeral $ Limited 1) $ \unlift -> do= forkIOWithUnmask $ \unmask -> unlift $ m $ liftMap unmask:}effectful-coreCreate a local lifting and unlifting function with the given strategy.Useful for lifting complicated ^ computations where the monadic action shows in both positive (as a result) and negative (as an argument) position.Note:- depending on the computation you're lifting  along with ' might be enough and is more efficient.effectful-coreCreate a local unlifting function with the given strategy along with an unrestricted lifting function.Useful for lifting complicated  computations where the monadic action shows in both positive (as a result) and negative (as an argument) position.Note:- depending on the computation you're lifting  along with ' might be enough and is more efficient.effectful-coreThis is always preferred to SharedSuffix es es as it's not incoherent. effectful-coreThe effect handler.effectful-core8Introduction of effects encapsulated within the handler.effectful-coreThe effect handler.effectful-coreThe effect handler.effectful-core8Introduction of effects encapsulated within the handler.effectful-coreThe effect handler.effectful-coreLocal environment.effectful-core2Continuation with the unlifting function in scope.effectful-coreLocal environment.effectful-core2Continuation with the unlifting function in scope.effectful-coreLocal environment.effectful-core2Continuation with the unlifting function in scope.effectful-coreLocal environment.effectful-core2Continuation with the unlifting function in scope.effectful-coreLocal environment.effectful-core0Continuation with the lifting function in scope.effectful-coreLocal environment.effectful-core0Continuation with the lifting function in scope.effectful-coreLocal environment.effectful-core>Continuation with the lifting and unlifting function in scope.effectful-coreLocal environment.effectful-core>Continuation with the lifting and unlifting function in scope.WXppWXNone'(-/258>?[W  9:;<=>?@A[^_cdehjklm ^ _h[?@A<=>9:;cdejklm None'(-/258>?_heffectful-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 \ effect via .effectful-coreRun the \ effect via the  instance for .\]\] None'(-/258>?deffectful-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>?dZiZiNone'(-/258>?heffectful-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>?keffectful-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>?r< 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>?yeffectful-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  $%&'()'*+'*,'-.'(/'(012123456789:;<=>?@ABCDEFGGHHIJKLMNNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{||}~~                              '$%''$%'''''''-effectful-core-2.0.0.0-DA9twcxZSqa2Y7CrVs0uQ8Effectful.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 localUnlift SharedSuffixReaderControl.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 stVersion stVersions stEffects stRelinkersEnv envOffsetenvRefs envStorage dummyRelinkeremptyEnvcloneEnvsizeEnvtailEnvconsEnv 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 EffectHandlerLocalEnvPrimFail runPureEffunEff unsafeEff unsafeEff_unliftStrategywithUnliftStrategy seqUnliftIO concUnliftIOrunEffrunPrimraise raiseWithsubsumeinject relinkHandler runHandlersend evalStaticRep execStaticRep getStaticRep putStaticRepstateStaticRepstateStaticRepMlocalStaticRep$fMonadMaskEff$fMonadCatchEff$fMonadThrowEff $fMonadFixEff $fMonadEff$fApplicativeEff $fFunctorEff$fMonadFailEff$fMonadBaseControlIOEff$fMonadBaseIOEff$fMonadUnliftIOEff $fMonadIOEff$fPrimMonadEff $fMonoidEff$fSemigroupEffreallyUnsafeLiftMapIOreallyUnsafeUnliftIOunsafeLiftMapIOunsafeSeqUnliftIOunsafeConcUnliftIO interpret reinterpret interposeimposelocalSeqUnliftlocalSeqUnliftIO localUnliftIO withLiftMap withLiftMapIOlocalLiftUnliftlocalLiftUnliftIO$fSharedSuffix[][]$fSharedSuffixes1:$fSharedSuffix:es2$fSharedSuffixesesErrorrunErrorrunErrorNoCallStack 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