Community
Modules 24

Control.Monad.Trans.State

experimental

State monads, passing an updatable state through a computation.

Some computations may not require the full power of state transformers:

  • For a read-only state, see Control.Monad.Trans.Reader.

  • To accumulate a value without using it on the way, see Control.Monad.Trans.Writer.

This version is lazy; for a strict version, see Control.Monad.Trans.State.Strict, which has the same interface.

module Control.Monad.Trans.State.Lazy transformers-0.6.3.0 · 25 declarations

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

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)

state-passing computation to execute

s

initial value

a

return value of the state computation

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)

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

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)

state-passing computation to execute

s

initial value

s

final state

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)

get :: (Monad m) => StateT s m s

Fetch the current value of the state within the monad.

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

lazyToStrictStateT :: StateT s m a -> Strict.StateT s m a

Convert from the lazy version to the strict version

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

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

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

Lift a catchE operation to the new monad. The uniformity property (see Control.Monad.Signatures) implies that the lifted catchE rolls back to the original state on entering the handler.

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

Lift a listen operation to the new monad.

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

Lift a pass operation to the new monad.

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

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

modify :: (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' :: (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)

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

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

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

put s sets the state within the monad to s.

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

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

state-passing computation to execute

s

initial state

(a, s)

return value and final state

state :: (Monad m) => (s -> (a, s)) -> StateT s m a

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

equivalent state-passing computation

(s -> (a, s))

pure state transformer

strictToLazyStateT :: Strict.StateT s m a -> StateT s m a

Convert from the strict version to the lazy version

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

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

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.

newtype StateT s m 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.

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

Maintainer
R.Paterson@city.ac.uk
Portability
portable
Copyright
(c) Andy Gill 2001, (c) Oregon Graduate Institute of Science and Technology, 2001
License
BSD-style (see the file LICENSE)
Build record and source files

Community contribution. The service has not verified this documentation.

Target: Linux on x86-64. Some inferred types and resolved links are not available.

Generator: aihc-haddock-858b1951-web-1

Metadata snapshot: ac77ab7d2b1e88487eeab41661abedb7bfb8bc846deb92e7874c08d166bff65d

Open the dependency plan · Download the documentation model

Import a package

Enter a package name and an exact version from Hackage. The site contains imported versions only.