State package:polysemy

module Polysemy.State
polysemy
data State s m a
polysemy Polysemy.State
An effect for providing statefulness. Note that unlike mtl's StateT, there is no restriction that the State effect corresponds necessarily to local state. It could could just as well be interrpeted in terms of HTTP requests or database access. Interpreters which require statefulness can reinterpret themselves in terms of State, and subsequently call runState.
stateful :: (forall x m . e m x -> s -> Sem r (s, x)) -> s -> Sem (e ': r) a -> Sem r (s, a)
polysemy Polysemy.Internal.Combinators
Like interpret, but with access to an intermediate state s.
stateToIO :: forall s r a . Member (Embed IO) r => s -> Sem (State s ': r) a -> Sem r (s, a)
polysemy Polysemy.State
Run an State effect in terms of operations in IO. Internally, this simply creates a new IORef, passes it to runStateIORef, and then returns the result and the final value of the IORef. Note: This is not safe in a concurrent setting, as modify isn't atomic. If you need operations over the state to be atomic, use atomicStateToIO instead. Beware: As this uses an IORef internally, all other effects will have local state semantics in regards to State effects interpreted this way. For example, throw and catch will never revert puts, even if runError is used after stateToIO.
stateToST :: forall s st r a . Member (Embed (ST st)) r => s -> Sem (State s ': r) a -> Sem r (s, a)
polysemy Polysemy.State
Run an State effect in terms of operations in ST. Internally, this simply creates a new STRef, passes it to runStateSTRef, and then returns the result and the final value of the STRef. Beware: As this uses an STRef internally, all other effects will have local state semantics in regards to State effects interpreted this way. For example, throw and catch will never revert puts, even if runError is used after stateToST. When not using the plugin, one must introduce the existential st type to stateToST, so that the resulting type after runM can be resolved into forall st. ST st (s, a) for use with runST. Doing so requires -XScopedTypeVariables. 
stResult :: forall s a. (s, a)
stResult = runST ( (runM $ stateToST @_ @st undefined $ pure undefined) :: forall st. ST st (s, a) )
getInitialStateT :: forall f m r e . Sem (WithTactics e f m r) (f ())
polysemy Polysemy Polysemy.Internal.Tactics
Get the stateful environment of the world at the moment the effect e is to be run. Prefer pureT, runT or bindT instead of using this function directly.
module Polysemy.AtomicState
polysemy
data AtomicState s m a
polysemy Polysemy.AtomicState
A variant of State that supports atomic operations.
AtomicState :: (s -> (s, a)) -> AtomicState s m a
polysemy Polysemy.AtomicState
Run a state action.
atomicState :: forall s a r . Member (AtomicState s) r => (s -> (s, a)) -> Sem r a
polysemy Polysemy.AtomicState
Run a state action.
atomicState' :: forall s a r . Member (AtomicState s) r => (s -> (s, a)) -> Sem r a
polysemy Polysemy.AtomicState
A variant of atomicState in which the computation is strict in the new state and return value.
atomicStateToIO :: forall s r a . Member (Embed IO) r => s -> Sem (AtomicState s ': r) a -> Sem r (s, a)
polysemy Polysemy.AtomicState
Run an AtomicState effect in terms of atomic operations in IO. Internally, this simply creates a new IORef, passes it to runAtomicStateIORef, and then returns the result and the final value of the IORef. Beware: As this uses an IORef internally, all other effects will have local state semantics in regards to AtomicState effects interpreted this way. For example, throw and catch will never revert atomicModifys, even if runError is used after atomicStateToIO.
atomicStateToState :: Member (State s) r => Sem (AtomicState s ': r) a -> Sem r a
polysemy Polysemy.AtomicState
Transform an AtomicState effect to a State effect, discarding the notion of atomicity.
evalAtomicStateViaState :: s -> Sem (AtomicState s ': r) a -> Sem r a
polysemy Polysemy.AtomicState
Evaluate an AtomicState with local state semantics, discarding the notion of atomicity, by transforming it into State and running it with the provided initial state. @since v1.7.0.0
execAtomicStateViaState :: s -> Sem (AtomicState s ': r) a -> Sem r s
polysemy Polysemy.AtomicState
Execute an AtomicState with local state semantics, discarding the notion of atomicity, by transforming it into State and running it with the provided initial state. @since v1.7.0.0
runAtomicStateIORef :: forall s r a . Member (Embed IO) r => IORef s -> Sem (AtomicState s ': r) a -> Sem r a
polysemy Polysemy.AtomicState
Run an AtomicState effect by transforming it into atomic operations over an IORef.
runAtomicStateTVar :: Member (Embed IO) r => TVar s -> Sem (AtomicState s ': r) a -> Sem r a
polysemy Polysemy.AtomicState
Run an AtomicState effect by transforming it into atomic operations over a TVar.
runAtomicStateViaState :: s -> Sem (AtomicState s ': r) a -> Sem r (s, a)
polysemy Polysemy.AtomicState
Run an AtomicState with local state semantics, discarding the notion of atomicity, by transforming it into State and running it with the provided initial state. @since v1.7.0.0
getInitialStateS :: forall m f n . Sem (WithStrategy m f n) (f ())
polysemy Polysemy.Final Polysemy.Internal.Strategy
Get the stateful environment of the world at the moment the Strategy is to be run. Prefer pureS, liftS, runS, or bindS instead of using this function directly.
lazilyStateful :: (forall x m . e m x -> s -> Sem r (s, x)) -> s -> Sem (e ': r) a -> Sem r (s, a)
polysemy Polysemy.Internal.Combinators
Like interpret, but with access to an intermediate state s.
GetInitialState :: Strategy m f n z (f ())
polysemy Polysemy.Internal.Strategy
GetInitialState :: Tactics f n r m (f ())
polysemy Polysemy.Internal.Tactics
evalLazyState :: s -> Sem (State s ': r) a -> Sem r a
polysemy Polysemy.State
Run a State effect with local state, lazily.
evalState :: s -> Sem (State s ': r) a -> Sem r a
polysemy Polysemy.State
Run a State effect with local state.
execLazyState :: s -> Sem (State s ': r) a -> Sem r s
polysemy Polysemy.State
Run a State effect with local state, lazily.