Monad +Control +base

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