Copyright	(c) Edward Kmett & Sjoerd Visscher 2011
License	BSD3
Maintainer	ekmett@gmail.com
Stability	experimental
Safe Haskell	None
Language	Haskell98

Control.Monad.Representable.State

Description

A generalized State monad, parameterized by a Representable functor. The representation of that functor serves as the state.

Synopsis

type State g = StateT g Identity
runState :: Representable g => State g a -> Rep g -> (a, Rep g)
evalState :: Representable g => State g a -> Rep g -> a
execState :: Representable g => State g a -> Rep g -> Rep g
mapState :: Functor g => ((a, Rep g) -> (b, Rep g)) -> State g a -> State g b
newtype StateT g m a = StateT {
- getStateT :: g (m (a, Rep g))
}
stateT :: Representable g => (Rep g -> m (a, Rep g)) -> StateT g m a
runStateT :: Representable g => StateT g m a -> Rep g -> m (a, Rep g)
evalStateT :: (Representable g, Monad m) => StateT g m a -> Rep g -> m a
execStateT :: (Representable g, Monad m) => StateT g m a -> Rep g -> m (Rep g)
mapStateT :: Functor g => (m (a, Rep g) -> n (b, Rep g)) -> StateT g m a -> StateT g n b
liftCallCC :: Representable g => ((((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g)) -> ((a -> StateT g m b) -> StateT g m a) -> StateT g m a
liftCallCC' :: Representable g => ((((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g)) -> ((a -> StateT g m b) -> StateT g m a) -> StateT g m a
class Monad m => MonadState s m | m -> s where
- get :: m s
- put :: s -> m ()
- state :: (s -> (a, s)) -> m a

Documentation

type State g = StateT g Identity Source

A memoized state monad parameterized by a representable functor g, where the representatation of g, Rep g is 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 Source

Arguments

:: Representable g

=> State g a

state-passing computation to execute

-> Rep g

initial state

-> (a, Rep g)

return value and final state

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

evalState Source

Arguments

:: Representable g

=> State g a

state-passing computation to execute

-> Rep g

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 Source

Arguments

:: Representable g

=> State g a

state-passing computation to execute

-> Rep g

initial value

-> Rep g

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 :: Functor g => ((a, Rep g) -> (b, Rep g)) -> State g a -> State g b Source

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

runState  (mapState  f m) = f . runState  m

newtype StateT g m a Source

A state transformer monad parameterized by:

g - A representable functor used to memoize results for a state Rep g
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

getStateT :: g (m (a, Rep g))

Instances

(Functor f, Representable g, MonadFree f m) => MonadFree f (StateT g m)

(Representable g, MonadReader e m) => MonadReader e (StateT g m)

(Representable g, Monad m, (~) * (Rep g) s) => MonadState s (StateT g m)

(Representable g, MonadWriter w m) => MonadWriter w (StateT g m)

Representable f => MonadTrans (StateT f)

Representable f => BindTrans (StateT f)

(Representable g, Monad m) => Monad (StateT g m)

(Functor g, Functor m) => Functor (StateT g m)

(Representable g, Functor m, Monad m) => Applicative (StateT g m)

(Representable g, MonadCont m) => MonadCont (StateT g m)

(Representable g, Bind m) => Apply (StateT g m)

(Representable g, Bind m) => Bind (StateT g m)

stateT :: Representable g => (Rep g -> m (a, Rep g)) -> StateT g m a Source

runStateT :: Representable g => StateT g m a -> Rep g -> m (a, Rep g) Source

evalStateT :: (Representable g, Monad m) => StateT g m a -> Rep g -> m a Source

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 :: (Representable g, Monad m) => StateT g m a -> Rep g -> m (Rep g) Source

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 :: Functor g => (m (a, Rep g) -> n (b, Rep g)) -> StateT g m a -> StateT g n b Source

liftCallCC :: Representable g => ((((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g)) -> ((a -> StateT g m b) -> StateT g m a) -> StateT g m a Source

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

liftCallCC' :: Representable g => ((((a, Rep g) -> m (b, Rep g)) -> m (a, Rep g)) -> m (a, Rep g)) -> ((a -> StateT g m b) -> StateT g m a) -> StateT g m a Source

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 laws of a monad transformer.

class Monad m => MonadState s m | m -> s where

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

Minimal complete definition

Nothing

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.

Instances