Monad +Control -package

class Monad m
base Prelude, base Control.Monad, base Control.Monad.Instances
The Monad class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's do expressions provide a convenient syntax for writing monadic expressions. Minimal complete definition: >>= and return. Instances of Monad should satisfy the following laws: > return a >>= k == k a > m >>= return == m > m >>= (\x -> k x >>= h) == (m >>= k) >>= h Instances of both Monad and Functor should additionally satisfy the law: > fmap f xs == xs >>= return . f The instances of Monad for lists, Data.Maybe.Maybe and System.IO.IO defined in the Prelude satisfy these laws.
module Control.Monad
base Control.Monad
The Functor, Monad and MonadPlus classes, with some useful operations on monads.
class Monad m => MonadFix m
base Control.Monad.Fix
Monads having fixed points with a 'knot-tying' semantics. Instances of MonadFix should satisfy the following laws: * purity mfix (return . h) = return (fix h) * left shrinking (or tightening) mfix (\x -> a >>= \y -> f x y) = a >>= \y -> mfix (\x -> f x y) * sliding mfix (Control.Monad.liftM h . f) = Control.Monad.liftM h (mfix (f . h)), for strict h. * nesting mfix (\x -> mfix (\y -> f x y)) = mfix (\x -> f x x) This class is used in the translation of the recursive do notation supported by GHC and Hugs.
class Monad m => MonadPlus m
base Control.Monad
Monads that also support choice and failure.
class Monad m => MonadCont m
mtl Control.Monad.Cont.Class, mtl Control.Monad.Cont
class Monad m => MonadError e m | m -> e
mtl Control.Monad.Error.Class, mtl Control.Monad.Error
The strategy of combining computations that can throw exceptions by bypassing bound functions from the point an exception is thrown to the point that it is handled. Is parameterized over the type of error information and the monad type constructor. It is common to use Either String as the monad type constructor for an error monad in which error descriptions take the form of strings. In that case and many other common cases the resulting monad is already defined as an instance of the MonadError class. You can also define your own error type and/or use a monad type constructor other than Either String or Either IOError. In these cases you will have to explicitly define instances of the Error and/or MonadError classes.
class Monad m => MonadIO m
transformers Control.Monad.IO.Class
Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class. Instances should satisfy the following laws, which state that liftIO is a transformer of monads: *  . return = *  (m >>= f) = liftIO m >>= > (liftIO .  
class Monad m => MonadReader r m | m -> r
mtl Control.Monad.Reader.Class, mtl Control.Monad.Reader
See examples in Control.Monad.Reader. Note, the partially applied function type (->) r is a simple reader monad. See the instance declaration below.
class (Monoid w, MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s m | m -> r, m -> w, m -> s
mtl Control.Monad.RWS.Class
class Monad m => MonadState s m | m -> s
mtl Control.Monad.State.Class, mtl Control.Monad.State.Lazy, mtl Control.Monad.State.Strict
Minimal definition is either both of get and put or just state
class MonadTrans t
transformers Control.Monad.Trans.Class
The class of monad transformers. Instances should satisfy the following laws, which state that lift is a transformer of monads: *  . return = *  (m >>= f) = lift m >>= > (lift .  
class (Monoid w, Monad m) => MonadWriter w m | m -> w
mtl Control.Monad.Writer.Class, mtl Control.Monad.Writer.Lazy, mtl Control.Monad.Writer.Strict
ArrowMonad :: (a () b) -> ArrowMonad a b
base Control.Arrow
newtype ArrowApply a => ArrowMonad a b
base Control.Arrow
The ArrowApply class is equivalent to Monad: any monad gives rise to a Kleisli arrow, and any instance of ArrowApply defines a monad.
unwrapMonad :: WrappedMonad m a -> m a
base Control.Applicative
WrapMonad :: m a -> WrappedMonad m a
base Control.Applicative
newtype WrappedMonad m a
base Control.Applicative