Difference between revisions of "Monad"

From HaskellWiki
Jump to: navigation, search
(Added proper introduction, moved the content about Monad class to its own section, added a section about the do-notation.)
Line 1: Line 1:
 
{{Standard class|Monad|module=Control.Monad|module-doc=Control-Monad|package=base}}
 
{{Standard class|Monad|module=Control.Monad|module-doc=Control-Monad|package=base}}
The '''Monad''' class is defined like this:
 
  +
  +
'''Monads''' in Haskell are structures used to supplement pure computations with features like state, common environment or input-output. 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#Monad tutorials|monad tutorials]]).
  +
  +
== Common monads ==
  +
  +
Most common applications of monads include:
  +
* Representing failure using <hask>Maybe</hask> monad
  +
* Non-determinism using <hask>List</hask> monad
  +
* State using <hask>State</hask> monad
  +
* Read-only environment using <hask>Reader</hask> monad
  +
* Input-output using <hask>IO</hask> monad
  +
  +
== Monad class ==
 
All common monads are members of '''Monad''' class defined like this:
   
 
<haskell>
 
<haskell>
Line 10: Line 25:
 
</haskell>
 
</haskell>
   
All instances of Monad should obey:
+
In addition to implementing the class functions, all instances of Monad should obey following equations:
   
 
<haskell>
 
<haskell>
Line 27: Line 42:
   
 
However, the Functor class is not a superclass of the Monad class. See [[Functor hierarchy proposal]].
 
However, the Functor class is not a superclass of the Monad class. See [[Functor hierarchy proposal]].
  +
  +
== Simplified notation ==
  +
  +
In order to improve the look of code that uses monads Haskell provides a special [[syntactic sugar]] called <hask>do</hask>-notation. For example, following expression:
  +
<haskell>
  +
thing1 >>= (\x -> func1 x >>= (\y -> thing2 >>= (\_ -> func2 y (\z -> return z))))
  +
</haskell>
  +
which can be written more clearly by breaking it into several lines and omitting parentheses:
  +
<haskell>
  +
thing1 >>= \x ->
  +
func1 x >>= \y ->
  +
thing2 >>= \_ ->
  +
func2 y >>= \z ->
  +
return z
  +
</haskell>
  +
can be also written using the <hask>do</hask>-notation as follows:
  +
<haskell>
  +
do
  +
x <- thing1
  +
y <- func1 x
  +
thing2
  +
z <- func2 y
  +
return z
  +
</haskell>
  +
  +
When using the <hask>do</hask>-notation and a monad like <hask>State</hask> or <hask>IO</hask> 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 <hask>do</hask>-notation with regular notation.
   
 
== Monad tutorials ==
 
== Monad tutorials ==

Revision as of 21:00, 1 December 2007

Monad class (base)
import Control.Monad

Monads in Haskell are structures used to supplement pure computations with features like state, common environment or input-output. 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).

Common monads

Most common applications of monads include:

  • Representing failure using Maybe monad
  • Non-determinism using List monad
  • State using State monad
  • Read-only environment using Reader monad
  • Input-output using IO monad

Monad class

All common monads are members of Monad class defined like this:

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

Simplified notation

In order to improve the look of code that uses monads Haskell provides a special syntactic sugar called do-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 do-notation as follows:

do
  x <- thing1
  y <- func1 x
  thing2
  z <- func2 y
  return z

When using the do-notation and a monad like State or IO 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 do-notation with regular notation.

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.

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.

Monad research

A collection of research papers about monads.

Monads in other languages

Implementations of monads in other languages.

Unfinished:

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.

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.

Fun