| ||||||||||||||||||||||||||||||||||||

| ||||||||||||||||||||||||||||||||||||

| ||||||||||||||||||||||||||||||||||||

Description | ||||||||||||||||||||||||||||||||||||

State monads. This module is inspired by the paper
See below for examples. | ||||||||||||||||||||||||||||||||||||

Synopsis | ||||||||||||||||||||||||||||||||||||

| ||||||||||||||||||||||||||||||||||||

MonadState class | ||||||||||||||||||||||||||||||||||||

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

| ||||||||||||||||||||||||||||||||||||

modify :: MonadState s m => (s -> s) -> m () | ||||||||||||||||||||||||||||||||||||

Monadic state transformer. Maps an old state to a new state inside a state monad. The old state is thrown away. Main> :t modify ((+1) :: Int -> Int) modify (...) :: (MonadState Int a) => a () This says that | ||||||||||||||||||||||||||||||||||||

gets :: MonadState s m => (s -> a) -> m a | ||||||||||||||||||||||||||||||||||||

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

The State Monad | ||||||||||||||||||||||||||||||||||||

newtype State s a | ||||||||||||||||||||||||||||||||||||

| ||||||||||||||||||||||||||||||||||||

evalState | ||||||||||||||||||||||||||||||||||||

| ||||||||||||||||||||||||||||||||||||

execState | ||||||||||||||||||||||||||||||||||||

| ||||||||||||||||||||||||||||||||||||

mapState :: ((a, s) -> (b, s)) -> State s a -> State s b | ||||||||||||||||||||||||||||||||||||

Map a stateful computation from one (return value, state) pair to another. For instance, to convert numberTree from a function that returns a tree to a function that returns the sum of the numbered tree (see the Examples section for numberTree and sumTree) you may write: sumNumberedTree :: (Eq a) => Tree a -> State (Table a) Int sumNumberedTree = mapState (\ (t, tab) -> (sumTree t, tab)) . numberTree | ||||||||||||||||||||||||||||||||||||

withState :: (s -> s) -> State s a -> State s a | ||||||||||||||||||||||||||||||||||||

Apply this function to this state and return the resulting state. | ||||||||||||||||||||||||||||||||||||

The StateT Monad | ||||||||||||||||||||||||||||||||||||

newtype StateT s m a | ||||||||||||||||||||||||||||||||||||

| ||||||||||||||||||||||||||||||||||||

evalStateT :: Monad m => StateT s m a -> s -> m a | ||||||||||||||||||||||||||||||||||||

Similar to evalState
| ||||||||||||||||||||||||||||||||||||

execStateT :: Monad m => StateT s m a -> s -> m s | ||||||||||||||||||||||||||||||||||||

Similar to execState
| ||||||||||||||||||||||||||||||||||||

mapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b | ||||||||||||||||||||||||||||||||||||

Similar to mapState
| ||||||||||||||||||||||||||||||||||||

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

Similar to withState
| ||||||||||||||||||||||||||||||||||||

module Control.Monad | ||||||||||||||||||||||||||||||||||||

module Control.Monad.Fix | ||||||||||||||||||||||||||||||||||||

module Control.Monad.Trans | ||||||||||||||||||||||||||||||||||||

Examples | ||||||||||||||||||||||||||||||||||||

A function to increment a counter. Taken from the paper
tick :: State Int Int tick = do n <- get put (n+1) return n Add one to the given number using the state monad: plusOne :: Int -> Int plusOne n = execState tick n A contrived addition example. Works only with positive numbers: plus :: Int -> Int -> Int plus n x = execState (sequence $ replicate n tick) x An example from data Tree a = Nil | Node a (Tree a) (Tree a) deriving (Show, Eq) type Table a = [a] numberTree :: Eq a => Tree a -> State (Table a) (Tree Int) numberTree Nil = return Nil numberTree (Node x t1 t2) = do num <- numberNode x nt1 <- numberTree t1 nt2 <- numberTree t2 return (Node num nt1 nt2) where numberNode :: Eq a => a -> State (Table a) Int numberNode x = do table <- get (newTable, newPos) <- return (nNode x table) put newTable return newPos nNode:: (Eq a) => a -> Table a -> (Table a, Int) nNode x table = case (findIndexInList (== x) table) of Nothing -> (table ++ [x], length table) Just i -> (table, i) findIndexInList :: (a -> Bool) -> [a] -> Maybe Int findIndexInList = findIndexInListHelp 0 findIndexInListHelp _ _ [] = Nothing findIndexInListHelp count f (h:t) = if (f h) then Just count else findIndexInListHelp (count+1) f t numTree applies numberTree with an initial state: numTree :: (Eq a) => Tree a -> Tree Int numTree t = evalState (numberTree t) [] testTree = Node "Zero" (Node "One" (Node "Two" Nil Nil) (Node "One" (Node "Zero" Nil Nil) Nil)) Nil numTree testTree => Node 0 (Node 1 (Node 2 Nil Nil) (Node 1 (Node 0 Nil Nil) Nil)) Nil sumTree is a little helper function that does not use the State monad: sumTree :: (Num a) => Tree a -> a sumTree Nil = 0 sumTree (Node e t1 t2) = e + (sumTree t1) + (sumTree t2) | ||||||||||||||||||||||||||||||||||||

Produced by Haddock version 0.7 |