Control.Effect.State

The state effect, similar to the MonadState type class from the mtl library.

Lazy and strict interpretations of the effect are available here: Control.Effect.State.Lazy and Control.Effect.State.Strict.

Tagged State Effect

class Monad m => State' tag s m | tag m -> s where

An effect that adds a mutable state to a given computation.

Minimal complete definition

get', put' | state'

Methods

get' :: m s

Gets the current state.

put' :: s -> m ()

Replaces the state with a new value.

state' :: (s -> (s, a)) -> m a

Updates the state and produces a value based on the current state.

Instances

Monad m => State' (tag :: k) s (StateT s m)

Defined in Control.Effect.State

Methods

get' :: StateT s m s

put' :: s -> StateT s m ()

state' :: (s -> (s, a)) -> StateT s m a

Monad m => State' (tag :: k) s (StateT s m)

Defined in Control.Effect.State

Methods

get' :: StateT s m s

put' :: s -> StateT s m ()

state' :: (s -> (s, a)) -> StateT s m a

Lift (State' tag s) t m => State' (tag :: k) s (Via eff t m)

Defined in Control.Effect.State

Methods

get' :: Via eff t m s

put' :: s -> Via eff t m ()

state' :: (s -> (s, a)) -> Via eff t m a

Handle (State' tag s) t m => State' (tag :: k) s (Via (State' tag s) t m)

Defined in Control.Effect.State

Methods

get' :: Via (State' tag s) t m s

put' :: s -> Via (State' tag s) t m ()

state' :: (s -> (s, a)) -> Via (State' tag s) t m a

State' new s m => State' (tag :: k2) s (Tagger tag new m)

Defined in Control.Effect.State

Methods

get' :: Tagger tag new m s

put' :: s -> Tagger tag new m ()

state' :: (s -> (s, a)) -> Tagger tag new m a

Untagged State Effect

If you don't require disambiguation of multiple state effects (i.e., you only have one state effect in your monadic context), it is recommended to always use the untagged state effect.

type State s = State' G s

get :: State s m => m s

put :: State s m => s -> m ()

state :: State s m => (s -> (s, a)) -> m a

Convenience Functions

If you don't require disambiguation of multiple state effects (i.e., you only have one state effect in your monadic context), it is recommended to always use the untagged functions.

gets' :: forall tag s m a. State' tag s m => (s -> a) -> m a

Gets a specific component of the state, using the provided projection function.

gets :: State s m => (s -> a) -> m a

The untagged version of gets'.

modify' :: forall tag s m. State' tag s m => (s -> s) -> m ()

Modifies the state, using the provided function.

modify :: State s m => (s -> s) -> m ()

The untagged version of modify'.

modifyStrict' :: forall tag s m. State' tag s m => (s -> s) -> m ()

Modifies the state, using the provided function. The computation is strict in the new state.

modifyStrict :: State s m => (s -> s) -> m ()

The untagged version of modifyStrict'.

Tagging and Untagging

Conversion functions between the tagged and untagged state effect, usually used in combination with type applications, like:

    tagState' @"newTag" program
    retagState' @"oldTag" @"newTag" program
    untagState' @"erasedTag" program

tagState' :: forall new s m a. Via (State' G s) (Tagger G new) m a -> m a

retagState' :: forall tag new s m a. Via (State' tag s) (Tagger tag new) m a -> m a

untagState' :: forall tag s m a. Via (State' tag s) (Tagger tag G) m a -> m a