Personal tools


From HaskellWiki

Revision as of 02:37, 31 July 2008 by HowardBGolden (Talk | contribs)

Jump to: navigation, search
Monad class (base)
import Control.Monad

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
  • Nondeterminism through backtracking using
  • State using
  • Read-only environment using
  • I/O using

2 Monad class

Monads can be viewed as a standard programming interface to various data or control structures, which is captured by the
class. All common monads are members of it:
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 notation

In order to improve the look of code that uses monads Haskell provides a special syntactic sugar called
-notation. For example, following expression:
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
can be also written using the
-notation as follows:
  x <- thing1
  y <- func1 x
  z <- func2 y
  return z
Code written using the
-notation is transformed by the compiler to ordinary expressions that use
class functions. When using the
-notation and a monad like
programs look very much like programs written in an imperative language as each line contains a statement that can change the simulated global state of the program and optionally binds a (local) variable that can be used by the statements later in the code block. It is possible to intermix the
-notation with regular notation. More on the
-notation can be found in a section of Monads as computation and in other tutorials.

4 Commutative monads

Commutative monads are monads for which the order of actions makes no difference (they commute), that is when following code:

  a <- f x
  b <- g y
  m a b

is the same as:

  b <- g y
  a <- f x
  m a b

Examples of commutative include:

  • Reader
  • Maybe

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.


And possibly there exist:

  • Standard ML (via modules?)

Please add them if you know of other implementations.

Collection of links to monad implementations in various languages. on Lambda The Ultimate.

9 Interesting monads

A list of monads for various evaluation strategies and games:

There are many more interesting instance of the monad abstraction out there. Please add them as you come across each species.

10 Fun