Difference between revisions of "Monad"
MichalPalka (talk | contribs) (Added proper introduction, moved the content about Monad class to its own section, added a section about the do-notation.) |
MichalPalka (talk | contribs) m (Small remark to the do-notation) |
||
Line 66: | Line 66: | ||
return z |
return z |
||
</haskell> |
</haskell> |
||
+ | Code written using the <hask>do</hask>-notation is transformed to expressions that use <hask>Monad</hask> class functions by the compiler. |
||
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. |
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. |
Revision as of 22:38, 1 December 2007
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).
Contents
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
Code written using the do
-notation is transformed to expressions that use Monad
class functions by the compiler.
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.
- Monads as containers, Monads as computation
- All About Monads
- Simple monad examples
- Of monads and space suits
- You could have invented monads
- Meet Bob The Monadic Lover, or the slightly more serious The Monadic Way
- Computational monads part 1 and part 2.
- Three kind of monads : sequencing, side effects or containers
- More tutorials on monads
- Even more tutorials on monads..
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.
- C
- C++, doc
- CML.event ?
- Clean State monad
- JavaScript
- Java (tar.gz)
- Joy
- LINQ, more, C#, VB
- Lisp
- Miranda
- OCaml:
- Perl
- Perl6 ?
- Prolog
- Python
- Python
- here
- Twisted's Deferred monad
- Ruby:
- Scala:
- Scheme:
- Tcl
- 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.
Unfinished:
- Slate
- Parsing, Maybe and Error in Tcl
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:
- Identity monad
- Optional results
- Random values
- Read only state
- Writable state
- Unique supply
- ST
- State
- Undoable state
- Function application
- Error
- Atomic memory transactions
- Continuations
- IO
- Non-deterministic evaluation
- List monad
- Concurrent threads
- Backtracking
- 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
There are many more interesting instance of the monad abstraction out there. Please add them as you come across each species.
Fun
- If you are tired of monads, you can easily get rid of them.