ST +Control.Monad +mtl

module Control.Monad.RWS.Strict
mtl Control.Monad.RWS.Strict
Strict RWS monad. Inspired by the paper Functional Programming with Overloading and Higher-Order Polymorphism, Mark P Jones (http://web.cecs.pdx.edu/~mpj/) Advanced School of Functional Programming, 1995.
module Control.Monad.State
mtl Control.Monad.State
State monads. This module is inspired by the paper Functional Programming with Overloading and Higher-Order Polymorphism, Mark P Jones (http://web.cecs.pdx.edu/~mpj/) Advanced School of Functional Programming, 1995.
module Control.Monad.State.Strict
mtl Control.Monad.State.Strict
Strict state monads. This module is inspired by the paper Functional Programming with Overloading and Higher-Order Polymorphism, Mark P Jones (http://web.cecs.pdx.edu/~mpj/) Advanced School of Functional Programming, 1995.
module Control.Monad.Writer.Strict
mtl Control.Monad.Writer.Strict
Strict writer monads. Inspired by the paper Functional Programming with Overloading and Higher-Order Polymorphism, Mark P Jones (http://web.cecs.pdx.edu/~mpj/pubs/springschool.html) Advanced School of Functional Programming, 1995.
type State s = StateT s Identity
mtl Control.Monad.State.Lazy, mtl Control.Monad.State.Strict
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.
state :: MonadState s m => (s -> (a, s)) -> m a
mtl Control.Monad.State.Class, mtl Control.Monad.State.Lazy, mtl Control.Monad.State.Strict
StateT :: (s -> m (a, s)) -> StateT s a
mtl Control.Monad.State.Lazy, mtl Control.Monad.State.Strict
strMsg :: Error a => String -> a
mtl Control.Monad.Error.Class, mtl Control.Monad.Error
module Control.Monad.List
mtl Control.Monad.List
The List monad.
evalRWST :: Monad m => RWST r w s m a -> r -> s -> m (a, w)
mtl Control.Monad.RWS.Lazy, mtl Control.Monad.RWS.Strict
Evaluate a computation with the given initial state and environment, returning the final value and output, discarding the final state.
evalState :: State s a -> s -> a
mtl Control.Monad.State.Lazy, mtl Control.Monad.State.Strict
Evaluate a state computation with the given initial state and return the final value, discarding the final state. *  m s = fst (runState m >  
evalStateT :: Monad m => StateT s m a -> s -> m a
mtl Control.Monad.State.Lazy, mtl Control.Monad.State.Strict
Evaluate a state computation with the given initial state and return the final value, discarding the final state. *  m s = liftM fst > (runStateT m  
execRWST :: Monad m => RWST r w s m a -> r -> s -> m (s, w)
mtl Control.Monad.RWS.Lazy, mtl Control.Monad.RWS.Strict
Evaluate a computation with the given initial state and environment, returning the final state and output, discarding the final value.
execState :: State s a -> s -> s
mtl Control.Monad.State.Lazy, mtl Control.Monad.State.Strict
Evaluate a state computation with the given initial state and return the final state, discarding the final value. *  m s = snd (runState m >  
execStateT :: Monad m => StateT s m a -> s -> m s
mtl Control.Monad.State.Lazy, mtl Control.Monad.State.Strict
Evaluate a state computation with the given initial state and return the final state, discarding the final value. *  m s = liftM snd > (runStateT m  
listen :: MonadWriter w m => m a -> m (a, w)
mtl Control.Monad.Writer.Class, mtl Control.Monad.Writer.Lazy, mtl Control.Monad.Writer.Strict
listens :: MonadWriter w m => (w -> b) -> m a -> m (a, b)
mtl Control.Monad.Writer.Class, mtl Control.Monad.Writer.Lazy, mtl Control.Monad.Writer.Strict
listens f m is an action that executes the action m and adds the result of applying f to the output to the value of the computation. *  f m = liftM (id *** f) (listen >  
ListT :: m [a] -> ListT a
mtl Control.Monad.List
mapListT :: (m [a] -> n [b]) -> ListT m a -> ListT n b
mtl Control.Monad.List
Map between ListT computations. *  (mapListT f m) = f (runListT >  
mapRWST :: (m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b
mtl Control.Monad.RWS.Lazy, mtl Control.Monad.RWS.Strict
Map the inner computation using the given function. *  (mapRWST f m) r s = f (runRWST m > r  

Show more results