**Packages**- mtl
- base
- package
- transformers

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.

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.

Monads that also support choice and failure.

Provides a monad-transformer version of the Control.Exception.catch function. For this, it defines the MonadCatchIO class, a subset of MonadIO. It defines proper instances for most monad transformers in the mtl library.
Version 0.3.0.5

Provides functions to throw and catch exceptions. Unlike the functions from Control.Exception, which work in IO, these work in any stack of monad transformers (from the transformers package) with IO as the base monad. You can extend this functionality to other monads, by creating an instance of the MonadCatchIO class. Warning: this package is deprecated. Use the exceptions package instead, if possible.
Version 0.3.1.0

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 .

A fast-paced 2-D scrolling vector graphics clone of the arcade game Gradius; it is dedicated to the 20th anniversary of Gradius series.
Version 0.99

"Prompting" monad that allows splitting the description of a computation from the implementation of the effects used in that computation. http://www.haskell.org/pipermail/haskell-cafe/2008-January/038301.html
Version 1.0.0.3

Support for computations which consume random values.
Version 0.1.12

Support for lazy computations which consume random values.
Version 0.1

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 .

This package provides automated lifting of operations via functional dependencies for the transformers-abort package.
Version 0.4

Monadically map objects to unique ints.
Version 0.0.2

This package has been removed.
Version 0.2.0

The library provides functions for encoding and decoding complex data structures with unique integer numbers. The codec structure can be explicitly defined which distinguishes this package from a monad-atom library.
Version 0.2.0