extensible-effects-5.0.0.1: An Alternative to Monad Transformers

Control.Eff.State.Strict

Description

Strict state effect

Synopsis

# Documentation

data State s v where Source #

State, strict

Initial design: The state request carries with it the state mutator function We can use this request both for mutating and getting the state. But see below for a better design!

data State s v where
State :: (s->s) -> State s s

In this old design, we have assumed that the dominant operation is modify. Perhaps this is not wise. Often, the reader is most nominant.

The conventional design of State

Constructors

 Get :: State s s Put :: !s -> State s ()
Instances
 (MonadBase m m, LiftedBase m r) => MonadBaseControl m (Eff (State s ': r)) Source # Instance detailsDefined in Control.Eff.State.Strict Associated Typestype StM (Eff (State s ': r)) a :: Type # MethodsliftBaseWith :: (RunInBase (Eff (State s ': r)) m -> m a) -> Eff (State s ': r) a #restoreM :: StM (Eff (State s ': r)) a -> Eff (State s ': r) a # Handle (State s) r a (s -> k) Source # Handle 'State s' requests Instance detailsDefined in Control.Eff.State.Strict Methodshandle :: (Eff r a -> s -> k) -> Arrs r v a -> State s v -> s -> k Source #handle_relay :: (r ~ (State s ': r'), Relay (s -> k) r') => (a -> s -> k) -> (Eff r a -> s -> k) -> Eff r a -> s -> k Source #respond_relay :: (a -> s -> k) -> (Eff r a -> s -> k) -> Eff r a -> s -> k Source # type StM (Eff (State s ': r)) a Source # Instance detailsDefined in Control.Eff.State.Strict type StM (Eff (State s ': r)) a = StM (Eff r) (a, s)

withState :: Monad m => a -> s -> m (a, s) Source #

Embed a pure value in a stateful computation, i.e., given an initial state, how to interpret a pure value in a stateful computation.

get :: Member (State s) r => Eff r s Source #

Return the current value of the state. The signatures are inferred

put :: Member (State s) r => s -> Eff r () Source #

Write a new value of the state.

Arguments

 :: s Initial state -> Eff (State s ': r) a Effect incorporating State -> Eff r (a, s) Effect containing final state and a return value

Run a State effect

modify :: Member (State s) r => (s -> s) -> Eff r () Source #

Transform the state with a function.

evalState :: s -> Eff (State s ': r) a -> Eff r a Source #

Run a State effect, discarding the final state.

execState :: s -> Eff (State s ': r) a -> Eff r s Source #

Run a State effect and return the final state.

data TxState s Source #

An encapsulated State handler, for transactional semantics The global state is updated only if the transactionState finished successfully

Constructors

 TxState

withTxState :: Member (State s) r => a -> s -> Eff r a Source #

Embed Transactional semantics to a stateful computation.

transactionState :: forall s r a. Member (State s) r => TxState s -> Eff r a -> Eff r a Source #

Confer transactional semantics on a stateful computation.

runStateR :: s -> Eff (Writer s ': (Reader s ': r)) a -> Eff r (a, s) Source #

A different representation of State: decomposing State into mutation (Writer) and Reading. We don't define any new effects: we just handle the existing ones. Thus we define a handler for two effects together.