RIO.State · rio-0.1.22.0 · horizon-platform

classclass Monad m => MonadState s (m :: Type -> Type) | m -> s where

#

Minimal definition is either both of get and put or just state

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.

Instances17MonadState, …

MonadState s m => MonadState s (CatchT m)Defined in exceptions-0.10.9 · Control.Monad.Catch.Pure
MonadState s m => MonadState s (MaybeT m)Defined in mtl-2.3.1 · Control.Monad.State.Class
HasStateRef s env => MonadState s (RIO env)Defined in rio-0.1.22.0 · RIO.Prelude.RIO
Monad m => MonadState s (StateT s m)Defined in mtl-2.3.1 · Control.Monad.State.Class
Monad m => MonadState s (StateT s m)Defined in mtl-2.3.1 · Control.Monad.State.Class
MonadState s m => MonadState s (ExceptT e m)Defined in mtl-2.3.1 · Control.Monad.State.Class
MonadState s m => MonadState s (IdentityT m)Defined in mtl-2.3.1 · Control.Monad.State.Class
MonadState s m => MonadState s (ReaderT r m)Defined in mtl-2.3.1 · Control.Monad.State.Class
MonadState s m => MonadState s (SelectT r m)Defined in mtl-2.3.1 · Control.Monad.State.Class
(Monoid w, MonadState s m) => MonadState s (AccumT w m)Defined in mtl-2.3.1 · Control.Monad.State.Class
(Monoid w, MonadState s m) => MonadState s (WriterT w m)Defined in mtl-2.3.1 · Control.Monad.State.Class
(Monoid w, MonadState s m) => MonadState s (WriterT w m)Defined in mtl-2.3.1 · Control.Monad.State.Class
(Monoid w, MonadState s m) => MonadState s (WriterT w m)Defined in mtl-2.3.1 · Control.Monad.State.Class
MonadState s m => MonadState s (ContT r m)Defined in mtl-2.3.1 · Control.Monad.State.Class
(Monad m, Monoid w) => MonadState s (RWST r w s m)Defined in mtl-2.3.1 · Control.Monad.State.Class
(Monad m, Monoid w) => MonadState s (RWST r w s m)Defined in mtl-2.3.1 · Control.Monad.State.Class
(Monad m, Monoid w) => MonadState s (RWST r w s m)Defined in mtl-2.3.1 · Control.Monad.State.Class

valuegets :: MonadState s m => (s -> a) -> m a

#

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

valuemodify :: MonadState s m => (s -> s) -> m ()

#

Monadic state transformer.

Maps an old state to a new state inside a state monad. The old state is thrown away.

     Main> :t modify ((+1) :: Int -> Int)
     modify (...) :: (MonadState Int a) => a ()

This says that modify (+1) acts over any Monad that is a member of the MonadState class, with an Int state.

valuemodify' :: MonadState s m => (s -> s) -> m ()

#

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

typetype State s = StateT s Identity

#

A state monad parameterized by the type s of the state to carry.

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

valuerunState

:: State s a
state-passing computation to execute
-> s
initial state
-> (a, s)
return value and final state

#

Unwrap a state monad computation as a function. (The inverse of state.)

valueevalState

:: State s a
state-passing computation to execute
-> s
initial value
-> a
return value of the state computation

#

Evaluate a state computation with the given initial state and return the final value, discarding the final state.

```
evalState m s = fst (runState m s)
```

valueexecState

:: State s a
state-passing computation to execute
-> s
initial value
-> s
final state

#

Evaluate a state computation with the given initial state and return the final state, discarding the final value.

```
execState m s = snd (runState m s)
```

valuemapState :: ((a, s) -> (b, s)) -> State s a -> State s b

#

Map both the return value and final state of a computation using the given function.

runState (mapState f m) = f . runState m

valuewithState :: (s -> s) -> State s a -> State s a

#

withState f m executes action m on a state modified by applying f.

```
withState f m = modify f >> m
```

newtypenewtype StateT s (m :: Type -> Type) a

#

A state transformer monad parameterized by:

s - The state.
m - The inner monad.

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

Constructors

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

Instances26MonadAccum, MonadError, MonadReader, MonadState, MonadWriter, MonadSelect, …

MonadAccum w m => MonadAccum w (StateT s m)Defined in mtl-2.3.1 · Control.Monad.Accum
MonadError e m => MonadError e (StateT s m)Defined in mtl-2.3.1 · Control.Monad.Error.Class
MonadReader r m => MonadReader r (StateT s m)Defined in mtl-2.3.1 · Control.Monad.Reader.Class
Monad m => MonadState s (StateT s m)Defined in mtl-2.3.1 · Control.Monad.State.Class
MonadWriter w m => MonadWriter w (StateT s m)Defined in mtl-2.3.1 · Control.Monad.Writer.Class
MonadSelect w m => MonadSelect w (StateT s m)Defined in mtl-2.3.1 · Control.Monad.Select
'Readerizes' the state: the 'ranking' function can see a value of type s, but not modify it. Effectively, can be thought of as 'extending' the 'ranking' by all values in s, but which s gets given to any rank calls is predetermined by the 'outer state' (and cannot change).
MonadTrans (StateT s)Defined in transformers-0.6.1.1 · Control.Monad.Trans.State.Lazy
Monad m => Monad (StateT s m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.State.Lazy
Functor m => Functor (StateT s m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.State.Lazy
MonadFix m => MonadFix (StateT s m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.State.Lazy
MonadFail m => MonadFail (StateT s m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.State.Lazy
(Functor m, Monad m) => Applicative (StateT s m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.State.Lazy
(Functor m, MonadPlus m) => Alternative (StateT s m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.State.Lazy
MonadPlus m => MonadPlus (StateT s m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.State.Lazy
MonadIO m => MonadIO (StateT s m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.State.Lazy
Contravariant m => Contravariant (StateT s m)Defined in transformers-0.6.1.1 · Control.Monad.Trans.State.Lazy
MonadCont m => MonadCont (StateT s m)Defined in mtl-2.3.1 · Control.Monad.Cont.Class
MonadCatch m => MonadCatch (StateT s m)Defined in exceptions-0.10.9 · Control.Monad.Catch
MonadMask m => MonadMask (StateT s m)Defined in exceptions-0.10.9 · Control.Monad.Catch
MonadThrow m => MonadThrow (StateT s m)Defined in exceptions-0.10.9 · Control.Monad.Catch
PrimMonad m => PrimMonad (StateT s m)Defined in primitive-0.9.1.0 · Control.Monad.Primitive
Monad z => Zoom (StateT s z) (StateT t z) s tDefined in microlens-mtl-0.2.1.0 · Lens.Micro.Mtl.Internal
Generic (StateT s m a)Defined in transformers-0.6.1.1 · Control.Monad.Trans.State.Lazy
type Rep (StateT s m a) = D1 ('MetaData "StateT" "Control.Monad.Trans.State.Lazy" "transformers-0.6.1.1-a11a" 'True) (C1 ('MetaCons "StateT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runStateT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (s -> m (a, s)))))Defined in transformers-0.6.1.1 · Control.Monad.Trans.State.Lazy
type PrimState (StateT s m) = PrimState mDefined in primitive-0.9.1.0 · Control.Monad.Primitive
type Zoomed (StateT s z) = Focusing zDefined in microlens-mtl-0.2.1.0 · Lens.Micro.Mtl.Internal

valueevalStateT :: Monad m => StateT s m a -> s -> m a

#

Evaluate a state computation with the given initial state and return the final value, discarding the final state.

evalStateT m s = liftM fst (runStateT m s)

valueexecStateT :: Monad m => StateT s m a -> s -> m s

#

Evaluate a state computation with the given initial state and return the final state, discarding the final value.

execStateT m s = liftM snd (runStateT m s)

valuemapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b

#

Map both the return value and final state of a computation using the given function.

runStateT (mapStateT f m) = f . runStateT m

valuewithStateT :: (s -> s) -> StateT s m a -> StateT s m a

#

withStateT f m executes action m on a state modified by applying f.

```
withStateT f m = modify f >> m
```