Safe Haskell	Safe
Language	Haskell2010

Control.Monad.Trans.MSF.State

Contents

State MSF runningwrappingunwrapping

Description

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.

Synopsis

newtype StateT s (m :: * -> *) a = StateT {
- runStateT :: s -> m (a, s)
}
type State s = StateT s Identity
runState :: State s a -> s -> (a, s)
evalState :: State s a -> s -> a
execState :: State s a -> s -> s
mapState :: ((a, s) -> (b, s)) -> State s a -> State s b
withState :: (s -> s) -> State s a -> State s a
evalStateT :: Monad m => StateT s m a -> s -> m a
execStateT :: Monad m => StateT s m a -> s -> m s
mapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
withStateT :: (s -> s) -> StateT s m a -> StateT s m a
liftCallCC' :: CallCC m (a, s) (b, s) -> CallCC (StateT s m) a b
gets :: Monad m => (s -> a) -> StateT s m a
modify' :: Monad m => (s -> s) -> StateT s m ()
modify :: Monad m => (s -> s) -> StateT s m ()
put :: Monad m => s -> StateT s m ()
get :: Monad m => StateT s m s
state :: Monad m => (s -> (a, s)) -> StateT s m a
stateS :: Monad m => MSF m (s, a) (s, b) -> MSF (StateT s m) a b
runStateS :: Monad m => MSF (StateT s m) a b -> MSF m (s, a) (s, b)
runStateS_ :: Monad m => MSF (StateT s m) a b -> s -> MSF m a (s, b)
runStateS__ :: Monad m => MSF (StateT s m) a b -> s -> MSF m a b
stateS' :: (Functor m, Monad m) => MSF m (s, a) (s, b) -> MSF (StateT s m) a b
runStateS' :: (Functor m, Monad m) => MSF (StateT s m) a b -> MSF m (s, a) (s, b)
runStateS'' :: (Functor m, Monad m) => MSF (StateT s m) a b -> MSF m (s, a) (s, b)
runStateS''' :: (Functor m, Monad m) => MSF (StateT s m) a b -> MSF m (s, a) (s, b)

Documentation

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.

Constructors

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

Instances

MonadSplit g m => MonadSplit g (StateT s m)
Instance details Defined in Control.Monad.Random.Class Methods getSplit :: StateT s m g #
MonadBase b m => MonadBase b (StateT s m)
Instance details Defined in Control.Monad.Base Methods liftBase :: b α -> StateT s m α #
MonadTrans (StateT s)
Instance details Defined in Control.Monad.Trans.State.Strict Methods lift :: Monad m => m a -> StateT s m a #
Monad m => Monad (StateT s m)
Instance details 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 # fail :: String -> StateT s m a #
Functor m => Functor (StateT s m)
Instance details 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 #
MonadFix m => MonadFix (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods mfix :: (a -> StateT s m a) -> StateT s m a #
MonadFail m => MonadFail (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods fail :: String -> StateT s m a #
(Functor m, Monad m) => Applicative (StateT s m)
Instance details 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 #
MonadPlus m => MonadPlus (StateT s m)
Instance details 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 #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods liftIO :: IO a -> StateT s m a #
MonadRandom m => MonadRandom (StateT s m)
Instance details 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] #
MonadInterleave m => MonadInterleave (StateT s m)
Instance details Defined in Control.Monad.Random.Class Methods interleave :: StateT s m a -> StateT s m a #
(Functor m, MonadPlus m) => Alternative (StateT s m)
Instance details 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] #
PrimMonad m => PrimMonad (StateT s m)
Instance details Defined in Control.Monad.Primitive Associated Types type PrimState (StateT s m) :: * # Methods primitive :: (State# (PrimState (StateT s m)) -> (#State# (PrimState (StateT s m)), a#)) -> StateT s m a #
type PrimState (StateT s m)
Instance details Defined in Control.Monad.Primitive type PrimState (StateT s m) = PrimState 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.

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

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

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

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

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

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

put s sets the state within the monad to s.

get :: Monad m => StateT s m s #

Fetch the current value of the state within the monad.

state #

Arguments

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

State MSF runningwrappingunwrapping

stateS :: 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 :: 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_ :: 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.

This should be always equal to:

runStateS_ msf s = feedback s $ runStateS msf >>> arr ((s,b) -> ((s,b), s))

although possibly more efficient.

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

This should be always equal to:

runStateS__ msf s = feedback s $ runStateS msf >>> arr ((s,b) -> (b, s))

although possibly more efficient.

Alternative implementation using `lifterS`

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

Alternative implementation of stateS using lifterS.

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

Alternative implementation of runStateS using lifterS.

Alternative implementation using `transS`

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

Alternative implementation of runStateS using transS.

Alternative implementation using `transG`

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

Alternative implementation of runStateS using transG.

Documentation

State MSF runningwrappingunwrapping

Alternative implementation using lifterS

Alternative implementation using transS

Alternative implementation using transG

Alternative implementation using `lifterS`

Alternative implementation using `transS`

Alternative implementation using `transG`