Rebase.Control.Monad.Trans.State · rebase-1.21.2

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.

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)

Instances39MonadAccum, 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).
MonadBase b m => MonadBase b (StateT s m)Defined in transformers-base-0.4.6 · Control.Monad.Base
(Functor f, MonadFree f m) => MonadFree f (StateT s m)Defined in free-5.2 · Control.Monad.Free.Class
MonadTrans (StateT s)Defined in transformers-0.6.1.1 · Control.Monad.Trans.State.Lazy
BindTrans (StateT s)Defined in semigroupoids-6.0.1 · Data.Functor.Bind.Trans
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
Decidable m => Decidable (StateT s m)Defined in contravariant-1.5.5 · Data.Functor.Contravariant.Divisible
Divisible m => Divisible (StateT s m)Defined in contravariant-1.5.5 · Data.Functor.Contravariant.Divisible
Alt f => Alt (StateT e f)Defined in semigroupoids-6.0.1 · Data.Functor.Alt
Bind m => Apply (StateT s m)Defined in semigroupoids-6.0.1 · Data.Functor.Bind.Class
Bind m => Bind (StateT s m)Defined in semigroupoids-6.0.1 · Data.Functor.Bind.Class
Conclude m => Conclude (StateT s m)Defined in semigroupoids-6.0.1 · Data.Functor.Contravariant.Conclude
Decide m => Decide (StateT s m)Defined in semigroupoids-6.0.1 · Data.Functor.Contravariant.Decide
Divise m => Divise (StateT s m)Defined in semigroupoids-6.0.1 · Data.Functor.Contravariant.Divise
Plus f => Plus (StateT e f)Defined in semigroupoids-6.0.1 · Data.Functor.Plus
Invariant m => Invariant (StateT s m)Defined in invariant-0.6.4 · Data.Functor.Invariant
from the transformers package
Monad m => Selective (StateT s m)Defined in selective-0.7.0.1 · Control.Selective
Pointed m => Pointed (StateT s m)Defined in pointed-5.0.4 · Data.Pointed
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

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)
```

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)

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)
```

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)

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

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

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.)

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
```

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
```

valueliftCallCC :: CallCC m (a, s) (b, s) -> CallCC (StateT s m) a b

#

Uniform lifting of a callCC operation to the new monad. This version rolls back to the original state on entering the continuation.

valueget :: Monad m => StateT s m s

#

Fetch the current value of the state within the monad.

valuegets :: Monad m => (s -> a) -> StateT s m a

#

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

```
gets f = liftM f get
```

valuemodify :: Monad m => (s -> s) -> StateT s m ()

#

modify f is an action that updates the state to the result of applying f to the current state.

```
modify f = get >>= (put . f)
```

valuemodify' :: Monad m => (s -> s) -> StateT s m ()

#

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

```
modify' f = get >>= (($!) put . f)
```

valueput :: Monad m => s -> StateT s m ()

#

put s sets the state within the monad to s.

valuestate

:: Monad m
=> (s -> (a, s))
pure state transformer
-> StateT s m a
equivalent state-passing computation

#

Construct a state monad computation from a function. (The inverse of runState.)

valueliftCatch :: Catch e m (a, s) -> Catch e (StateT s m) a

#

Lift a catchE operation to the new monad.

valueliftCallCC' :: CallCC m (a, s) (b, s) -> CallCC (StateT s m) a b

#

In-situ lifting of a callCC operation to the new monad. This version uses the current state on entering the continuation. It does not satisfy the uniformity property (see Control.Monad.Signatures).

valueliftListen :: Monad m => Listen w m (a, s) -> Listen w (StateT s m) a

#

Lift a listen operation to the new monad.

valueliftPass :: Monad m => Pass w m (a, s) -> Pass w (StateT s m) a

#

Lift a pass operation to the new monad.

valuemodifyM :: Monad m => (s -> m s) -> StateT s m ()

#

A variant of modify in which the new state is generated by a monadic action.