Ether.State

MonadState class

class Monad m => MonadState tag s m | m tag -> s where

Minimal complete definition

state | get, put

Methods

get :: m s

Return the state from the internals of the monad.

put :: s -> m ()

Replace the state inside the monad.

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

Embed a simple state action into the monad.

Instances

(MonadTrans t, Monad (t m), MonadState k tag s m) => MonadState k tag s (t m)

Methods

get :: m (t m)

put :: t m -> m ()

state :: (t m -> (a, t m)) -> m a

(MonadState k1 tag sOuter m, Reifies k z (ReifiedLens' sOuter sInner), (~) ((* -> *) -> * -> *) trans (IdentityT *)) => MonadState k1 tag sInner (TaggedTrans * (* -> *) * (ZOOM k k1 tag z) trans m)

Methods

get :: m (TaggedTrans * (* -> *) * (ZOOM k k1 tag z) trans m)

put :: TaggedTrans * (* -> *) * (ZOOM k k1 tag z) trans m -> m ()

state :: (TaggedTrans * (* -> *) * (ZOOM k k1 tag z) trans m -> (a, TaggedTrans * (* -> *) * (ZOOM k k1 tag z) trans m)) -> m a

(Monad (trans m), MonadState k tag s (TaggedTrans * (Type -> Type) [a] effs trans m)) => MonadState k tag s (TaggedTrans * (Type -> Type) [a] ((:) a eff effs) trans m)

Methods

get :: m (TaggedTrans * (Type -> Type) [a] ((a ': eff) effs) trans m)

put :: TaggedTrans * (Type -> Type) [a] ((a ': eff) effs) trans m -> m ()

state :: (TaggedTrans * (Type -> Type) [a] ((a ': eff) effs) trans m -> (a, TaggedTrans * (Type -> Type) [a] ((a ': eff) effs) trans m)) -> m a

(MonadState k1 tNew s m, (~) ((* -> *) -> * -> *) trans (IdentityT *)) => MonadState k tOld s (TaggedTrans * (* -> *) * (TAG_REPLACE k1 k tOld tNew) trans m)

Methods

get :: m (TaggedTrans * (* -> *) * (TAG_REPLACE k1 k tOld tNew) trans m)

put :: TaggedTrans * (* -> *) * (TAG_REPLACE k1 k tOld tNew) trans m -> m ()

state :: (TaggedTrans * (* -> *) * (TAG_REPLACE k1 k tOld tNew) trans m -> (a, TaggedTrans * (* -> *) * (TAG_REPLACE k1 k tOld tNew) trans m)) -> m a

get :: MonadState tag s m => m s

Return the state from the internals of the monad.

put :: MonadState tag s m => s -> m ()

Replace the state inside the monad.

state :: MonadState tag s m => (s -> (a, s)) -> m a

Embed a simple state action into the monad.

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

Modifies the state inside a state monad.

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

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

The State monad

type State tag r = StateT tag r Identity

The parametrizable state monad.

Computations have access to a mutable state.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

runState :: forall tag s a. State tag s a -> s -> (a, s)

Runs a State with the given initial state and returns both the final value and the final state.

evalState :: forall tag s a. State tag s a -> s -> a

Runs a State with the given initial state and returns the final value, discarding the final state.

execState :: forall tag s a. State tag s a -> s -> s

Runs a State with the given initial state and returns the final state, discarding the final value.

The StateT monad transformer

type StateT tag s = TaggedTrans (TAGGED STATE tag) (StateT s)

The state monad transformer.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

stateT :: forall tag s m a. (s -> m (a, s)) -> StateT tag s m a

Constructor for computations in the state monad transformer.

runStateT :: forall tag s m a. StateT tag s m a -> s -> m (a, s)

Runs a StateT with the given initial state and returns both the final value and the final state.

evalStateT :: forall tag s m a. Monad m => StateT tag s m a -> s -> m a

Runs a StateT with the given initial state and returns the final value, discarding the final state.

execStateT :: forall tag s m a. Monad m => StateT tag s m a -> s -> m s

Runs a StateT with the given initial state and returns the final state, discarding the final value.

The State monad (lazy)

type LazyState tag r = LazyStateT tag r Identity

The parametrizable state monad.

Computations have access to a mutable state.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

runLazyState :: forall tag s a. LazyState tag s a -> s -> (a, s)

Runs a State with the given initial state and returns both the final value and the final state.

evalLazyState :: forall tag s a. LazyState tag s a -> s -> a

Runs a State with the given initial state and returns the final value, discarding the final state.

execLazyState :: forall tag s a. LazyState tag s a -> s -> s

Runs a State with the given initial state and returns the final state, discarding the final value.

The StateT monad transformer (lazy)

type LazyStateT tag s = TaggedTrans (TAGGED STATE tag) (StateT s)

The state monad transformer.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

lazyStateT :: forall tag s m a. (s -> m (a, s)) -> LazyStateT tag s m a

Constructor for computations in the state monad transformer.

runLazyStateT :: forall tag s m a. LazyStateT tag s m a -> s -> m (a, s)

Runs a StateT with the given initial state and returns both the final value and the final state.

evalLazyStateT :: forall tag s m a. Monad m => LazyStateT tag s m a -> s -> m a

Runs a StateT with the given initial state and returns the final value, discarding the final state.

execLazyStateT :: forall tag s m a. Monad m => LazyStateT tag s m a -> s -> m s

Runs a StateT with the given initial state and returns the final state, discarding the final value.

The State monad (flattened)

type States s = StatesT s Identity

runStates :: forall p a. States p a -> p -> (a, p)

The StateT monad transformer (flattened)

type StatesT s = TaggedTrans (STATES (Tags s)) (StateT s)

runStatesT :: forall p m a. StatesT p m a -> p -> m (a, p)

MonadState class (implicit)

type MonadState' s = MonadState s s

get' :: forall s m. MonadState' s m => m s

put' :: forall s m. MonadState' s m => s -> m ()

state' :: forall s m a. MonadState' s m => (s -> (a, s)) -> m a

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

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

The State monad (implicit)

type State' s = State s s

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

evalState' :: State' s a -> s -> a

execState' :: State' s a -> s -> s

The StateT monad transformer (implicit)

type StateT' s = StateT s s

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

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

evalStateT' :: Monad m => StateT' s m a -> s -> m a

execStateT' :: Monad m => StateT' s m a -> s -> m s

The State monad (lazy, implicit)

type LazyState' s = LazyState s s

runLazyState' :: LazyState' s a -> s -> (a, s)

evalLazyState' :: LazyState' s a -> s -> a

execLazyState' :: LazyState' s a -> s -> s

The StateT monad transformer (lazy, implicit)

type LazyStateT' s = LazyStateT s s

lazyStateT' :: (s -> m (a, s)) -> LazyStateT' s m a

runLazyStateT' :: LazyStateT' s m a -> s -> m (a, s)

evalLazyStateT' :: Monad m => LazyStateT' s m a -> s -> m a

execLazyStateT' :: Monad m => LazyStateT' s m a -> s -> m s

Zoom

type ZoomT t z = TaggedTrans (ZOOM t z) IdentityT

zoom :: forall tag sOuter sInner m a. Lens' sOuter sInner -> (forall z. Reifies z (ReifiedLens' sOuter sInner) => ZoomT tag z m a) -> m a

Zoom into a part of a state using a lens.

Internal labels

data TAGGED e t

data STATE

Encode type-level information for StateT.

Instances

Handle * * STATE s (StateT s)

Methods

handling :: Monad m => (HandleConstraint STATE s (StateT s) p trans m -> r) -> r

Handle * * STATE s (StateT s)

Methods

handling :: Monad m => (HandleConstraint STATE s (StateT s) p trans m -> r) -> r

type HandleSuper kp * STATE s trans

type HandleSuper kp * STATE s trans = ()

type HandleConstraint * * STATE s trans m

type HandleConstraint * * STATE s trans m = MonadState s (trans m)

type family STATES (ts :: HList xs) :: [Type] where ...

Equations

STATES HNil = '[]

STATES (HCons t ts) = TAGGED STATE t ': STATES ts

data ZOOM t z

Encode type-level information for zoom.

Instances

(MonadState k1 tag sOuter m, Reifies k z (ReifiedLens' sOuter sInner), (~) ((* -> *) -> * -> *) trans (IdentityT *)) => MonadState k1 tag sInner (TaggedTrans * (* -> *) * (ZOOM k k1 tag z) trans m)

Methods

get :: m (TaggedTrans * (* -> *) * (ZOOM k k1 tag z) trans m)

put :: TaggedTrans * (* -> *) * (ZOOM k k1 tag z) trans m -> m ()

state :: (TaggedTrans * (* -> *) * (ZOOM k k1 tag z) trans m -> (a, TaggedTrans * (* -> *) * (ZOOM k k1 tag z) trans m)) -> m a