Control.Monad.Trans.MSF.State

MSFs with a State monadic layer.

This module contains functions to work with MSFs that include a State monadic layer. This includes functions to create new MSFs that include an additional layer, and functions to flatten that layer out of the MSF's transformer stack.

It is based on the _strict_ state monad Strict, so when combining it with other modules such as mtl's, the strict version has to be included, i.e. Strict instead of State or Lazy.

Documentation

newtype 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

Fields

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

Instances

MonadSplit g m => MonadSplit g (StateT s m)

Defined in Control.Monad.Random.Class

Methods

getSplit :: StateT s m g

MonadBase b m => MonadBase b (StateT s m)

Defined in Control.Monad.Base

Methods

liftBase :: b α -> StateT s m α

MonadTrans (StateT s)

Defined in Control.Monad.Trans.State.Strict

Methods

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

MonadInterleave m => MonadInterleave (StateT s m)

Defined in Control.Monad.Random.Class

Methods

interleave :: StateT s m a -> StateT s m a

MonadRandom m => MonadRandom (StateT s m)

Defined in Control.Monad.Random.Class

Methods

getRandomR :: Random a => (a, a) -> StateT s m a

getRandom :: Random a => StateT s m a

getRandomRs :: Random a => (a, a) -> StateT s m [a]

getRandoms :: Random a => StateT s m [a]

MonadFail m => MonadFail (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

fail :: String -> StateT s m a

MonadFix m => MonadFix (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

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

MonadIO m => MonadIO (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

liftIO :: IO a -> StateT s m a

Contravariant m => Contravariant (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

contramap :: (a' -> a) -> StateT s m a -> StateT s m a'

(>$) :: b -> StateT s m b -> StateT s m a

(Functor m, MonadPlus m) => Alternative (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

empty :: StateT s m a

(<|>) :: StateT s m a -> StateT s m a -> StateT s m a

some :: StateT s m a -> StateT s m [a]

many :: StateT s m a -> StateT s m [a]

(Functor m, Monad m) => Applicative (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

pure :: a -> StateT s m a

(<*>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b

liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c

(*>) :: StateT s m a -> StateT s m b -> StateT s m b

(<*) :: StateT s m a -> StateT s m b -> StateT s m a

Functor m => Functor (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

fmap :: (a -> b) -> StateT s m a -> StateT s m b

(<$) :: a -> StateT s m b -> StateT s m a

Monad m => Monad (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

(>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b

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

return :: a -> StateT s m a

MonadPlus m => MonadPlus (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

mzero :: StateT s m a

mplus :: StateT s m a -> StateT s m a -> StateT s m a

Generic (StateT s m a)

Defined in Control.Monad.Trans.State.Strict

Associated Types

type Rep (StateT s m a) :: Type -> Type

Methods

from :: StateT s m a -> Rep (StateT s m a) x

to :: Rep (StateT s m a) x -> StateT s m a

type Rep (StateT s m a)

Defined in Control.Monad.Trans.State.Strict

type Rep (StateT s m a) = D1 ('MetaData "StateT" "Control.Monad.Trans.State.Strict" "transformers-0.6.1.0" 'True) (C1 ('MetaCons "StateT" 'PrefixI 'True) (S1 ('MetaSel ('Just "runStateT") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (s -> m (a, s)))))

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

liftCallCC' :: 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).

get :: forall (m :: Type -> Type) s. Monad m => StateT s m s

Fetch the current value of the state within the monad.

put :: forall (m :: Type -> Type) s. Monad m => s -> StateT s m ()

put s sets the state within the monad to s.

runState

Arguments

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

evalState

Arguments

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

execState

Arguments

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

mapState :: ((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

withState :: (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

evalStateT :: 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)

execStateT :: 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)

mapStateT :: (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

withStateT :: forall s (m :: Type -> Type) a. (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

state

Arguments

:: forall (m :: Type -> Type) s a. 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.)

modify :: forall (m :: Type -> Type) s. 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)

modify' :: forall (m :: Type -> Type) s. 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)

Note that this is only strict in the top level of the state. Lazy components of the state will not be evaluated unless f evaluates them.

gets :: forall (m :: Type -> Type) s a. 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

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

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

State MSF running and wrapping

stateS :: (Functor m, Monad m) => MSF m (s, a) (s, b) -> MSF (StateT s m) a b

Build an MSF in the State monad from one that takes the state as an extra input. This is the opposite of runStateS.

runStateS :: (Functor m, Monad m) => MSF (StateT s m) a b -> MSF m (s, a) (s, b)

Build an MSF that takes a state as an extra input from one on the State monad. This is the opposite of stateS.

runStateS_ :: (Functor m, Monad m) => MSF (StateT s m) a b -> s -> MSF m a (s, b)

Build an MSF function that takes a fixed state as additional input, from an MSF in the State monad, and outputs the new state with every transformation step.

runStateS__ :: (Functor m, Monad m) => MSF (StateT s m) a b -> s -> MSF m a b

Build an MSF function that takes a fixed state as additional input, from an MSF in the State monad.