Polysemy.State

Effect

data State s m a where

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.

Constructors

Get :: State s m s

Put :: s -> State s m ()

Instances

type DefiningModule (State :: Type -> k -> Type -> Type)

Defined in Polysemy.State

type DefiningModule (State :: Type -> k -> Type -> Type) = "Polysemy.State"

Actions

get :: forall s r. MemberWithError (State s) r => Sem r s

gets :: forall s a r. Member (State s) r => (s -> a) -> Sem r a

put :: forall s r. MemberWithError (State s) r => s -> Sem r ()

modify :: Member (State s) r => (s -> s) -> Sem r ()

modify' :: Member (State s) r => (s -> s) -> Sem r ()

A variant of modify in which the computation is strict in the new state.

Interpretations

runState :: s -> Sem (State s ': r) a -> Sem r (s, a)

Run a State effect with local state.

evalState :: s -> Sem (State s ': r) a -> Sem r a

Run a State effect with local state.

Since: 1.0.0.0

runLazyState :: s -> Sem (State s ': r) a -> Sem r (s, a)

Run a State effect with local state, lazily.

evalLazyState :: s -> Sem (State s ': r) a -> Sem r a

Run a State effect with local state, lazily.

Since: 1.0.0.0

runStateIORef :: forall s r a. Member (Embed IO) r => IORef s -> Sem (State s ': r) a -> Sem r a

Run a State effect by transforming it into operations over an 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 runAtomicStateIORef or runAtomicStateTVar instead.

Since: 1.0.0.0

stateToIO :: forall s r a. Member (Embed IO) r => s -> Sem (State s ': r) a -> Sem r (s, a)

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.

Since: 1.2.0.0

Interoperation with MTL

hoistStateIntoStateT :: Sem (State s ': r) a -> StateT s (Sem r) a

Hoist a State effect into a StateT monad transformer. This can be useful when writing interpreters that need to interop with MTL.

Since: 0.1.3.0