Monads in Haskell are structures used to supplement pure computations with features like state, common environment or I/O. Even though Haskell is a purely-functional language, side effects can be conveniently simulated using monads.
Because they are very useful in practice but rather mind-twisting for the beginners, numerous tutorials that deal exclusively with monads were created (see monad tutorials).
1 Common monads
Most common applications of monads include:
- Representing failure using monadMaybe
- Nondeterminism through backtracking using monadList
- State using monadState
- Read-only environment using monadReader
- I/O using monadIO
2 Monad classMonads can be viewed as a standard programming interface to various data or control structures, which is captured by the
class Monad m where (>>=) :: m a -> (a -> m b) -> m b (>>) :: m a -> m b -> m b return :: a -> m a fail :: String -> m a
In addition to implementing the class functions, all instances of Monad should obey the following equations:
return a >>= k = k a m >>= return = m m >>= (\x -> k x >>= h) = (m >>= k) >>= h
See this intuitive explanation of why they should obey the Monad laws.
Any Monad can be made a Functor by defining
fmap ab ma = ma >>= (return . ab)
However, the Functor class is not a superclass of the Monad class. See Functor hierarchy proposal.
3 Special notationIn order to improve the look of code that uses monads Haskell provides a special syntactic sugar called
thing1 >>= (\x -> func1 x >>= (\y -> thing2 >>= (\_ -> func2 y (\z -> return z))))
which can be written more clearly by breaking it into several lines and omitting parentheses:
thing1 >>= \x -> func1 x >>= \y -> thing2 >>= \_ -> func2 y >>= \z -> return z
do x <- thing1 y <- func1 x thing2 z <- func2 y return z
4 Commutative monads
Commutative monads are monads for which the order of actions makes no difference (they commute), that is when following code:
do a <- f x b <- g y m a b
is the same as:
do b <- g y a <- f x m a b
Examples of commutative include:
5 Monad tutorials
Monads are known for being deeply confusing to lots of people, so there are plenty of tutorials specifically related to monads. Each takes a different approach to Monads, and hopefully everyone will find something useful.
See Monad tutorials.
6 Monad reference guides
An explanation of the basic Monad functions, with examples, can be found in the reference guide A tour of the Haskell Monad functions, by Henk-Jan van Tuyl.
7 Monad research
A collection of research papers about monads.
8 Monads in other languages
Implementations of monads in other languages.
- C++, doc
- CML.event ?
- Clean State monad
- Java (tar.gz)
- LINQ, more, C#, VB
- Perl6 ?
- The Unix Shell
- More monads by Oleg
- CLL: a concurrent language based on a first-order intuitionistic linear logic where all right synchronous connectives are restricted to a monad.
And possibly there exist:
- Standard ML (via modules?)
Please add them if you know of other implementations.
9 Interesting monads
A list of monads for various evaluation strategies and games:
- Identity monad
- Optional results
- Random values
- Read only state
- Writable state
- Unique supply
- Undoable state
- Function application
- Atomic memory transactions
- Non-deterministic evaluation
- List monad
- Concurrent threads
- Region allocation
- LogicT: backtracking monad transformer with fair operations and pruning
- Pi calculus as a monad
- Halfs, uses a read-only and write-only monad for filesystem work.
- House's H monad for safe hardware access
- Commutable monads for parallel programming
There are many more interesting instance of the monad abstraction out there. Please add them as you come across each species.
- If you are tired of monads, you can easily get rid of them.