Monad
From HaskellWiki
(tweak lead) 
(One more redirect solved) 

(20 intermediate revisions by 6 users not shown)  
Line 1:  Line 1:  
{{Standard classMonadmodule=Control.Monadmoduledoc=ControlMonadpackage=base}} 
{{Standard classMonadmodule=Control.Monadmoduledoc=ControlMonadpackage=base}} 

−  '''''Monads''''' in Haskell can be thought of as ''composable'' computation descriptions. The essence of monad is thus ''separation'' of ''composition timeline'' from the composed computation's ''execution timeline'', as well as the ability of ''computation'' to implicitly carry extra data, as pertaining to the computation itself, in addition to its ''one'' (hence the name) output, that it will produce when run (or queried, or called upon). This lends monads to supplementing ''pure'' calculations with features like I/O, common environment or state, and to ''preprocessing'' of computations (simplification, optimization etc.). 
+  '''''Monads''''' in Haskell can be thought of as ''composable'' computation descriptions. The essence of monad is thus ''separation'' of ''composition timeline'' from the composed computation's ''execution timeline'', as well as the ability of ''computation'' to implicitly carry extra data, as pertaining to the computation itself, in addition to its ''one'' (hence the name) output, that it '''''will produce''''' when run (or queried, or called upon). This lends monads to supplementing ''pure'' calculations with features like I/O, common environment or state, and to ''preprocessing'' of computations (simplification, optimization etc.). 
−  Each monad, or computation type, provides means, subject to '''''Monad Laws''''', to '''''(a)''''' ''create'' a description of computation action that ''will produce'' (a.k.a. "return") a given Haskell value, '''''(b)''''' ''run'' a computation action description, getting its output back into Haskell, and '''''(c)''''' ''combine'' (a.k.a. "bind") an action description with a ''reaction'' to it – a regular Haskell function of one argument (that will receive actionproduced output) returning another action description (using or dependent on that output, if need be) – thus creating a combined action description that will feed the original action's output into the reaction while automatically taking care of the particulars of the computation process itself. A monad might also define additional primitives to provide access and/or enable manipulation of data it implicitly carries, specific to its nature: 
+  Each monad, or computation type, provides means, subject to '''''Monad Laws''''', to '''''(a)''''' ''create'' a description of computation action that will produce (a.k.a. "return") a given Haskell value, '''''(b)''''' somehow ''run'' a computation action description (possibly getting its output back into Haskell should the monad choose to allow it, if computations described by the monad are pure, or causing the prescribed side effects if it's not), and '''''(c)''''' ''combine'' (a.k.a. "bind") a computation action description with a ''reaction'' to it – a regular Haskell function of one argument (that will receive computationproduced value) returning another action description (using or dependent on that value, if need be) – thus creating a combined computation action description that will feed the original action's output through the reaction while automatically taking care of the particulars of the computational process itself. A monad might also define additional primitives to provide access to and/or enable manipulation of data it implicitly carries, specific to its nature. 
[[Image:Monads interdependencies 2.pngcenter]] 
[[Image:Monads interdependencies 2.pngcenter]] 

Line 14:  Line 14:  
Most common applications of monads include: 
Most common applications of monads include: 

* Representing failure using <hask>Maybe</hask> monad 
* Representing failure using <hask>Maybe</hask> monad 

−  * Nondeterminism through backtracking using <hask>List</hask> monad 
+  * Nondeterminism using <hask>List</hask> monad to represent carrying multiple values 
* State using <hask>State</hask> monad 
* State using <hask>State</hask> monad 

* Readonly environment using <hask>Reader</hask> monad 
* Readonly environment using <hask>Reader</hask> monad 

Line 85:  Line 85:  
<haskell> 
<haskell> 

do 
do 

−  a < f x 
+  a < actA 
−  b < g y 
+  b < actB 
m a b 
m a b 

</haskell> 
</haskell> 

Line 92:  Line 92:  
<haskell> 
<haskell> 

do 
do 

−  b < g y 
+  b < actB 
−  a < f x 
+  a < actA 
m a b 
m a b 

</haskell> 
</haskell> 

Line 105:  Line 105:  
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 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 [[Tutorials#Using_monadsMonad tutorials]]. 
+  See the [[Monad tutorials timeline]] for a comprehensive list of monad tutorials. 
== Monad reference guides == 
== Monad reference guides == 

Line 119:  Line 119:  
Implementations of monads in other languages. 
Implementations of monads in other languages. 

−  * [http://programming.reddit.com/goto?id=1761q C] 
+  * [http://www.reddit.com/r/programming/comments/1761q/monads_in_c_pt_ii/ C] 
−  * [http://wwwstatic.cc.gatech.edu/~yannis/fc++/FC++.1.5/monad.h C++], [http://wwwstatic.cc.gatech.edu/~yannis/fc++/New1.5/lambda.html#monad doc] 

* [http://cml.cs.uchicago.edu/pages/cml.html CML.event] ? 
* [http://cml.cs.uchicago.edu/pages/cml.html CML.event] ? 

* [http://www.st.cs.ru.nl/papers/2010/CleanStdEnvAPI.pdf Clean] State monad 
* [http://www.st.cs.ru.nl/papers/2010/CleanStdEnvAPI.pdf Clean] State monad 

−  * [http://clojure.googlegroups.com/web/monads.clj Clojure] 

* [http://cratylus.freewebspace.com/monadsinjavascript.htm JavaScript] 
* [http://cratylus.freewebspace.com/monadsinjavascript.htm JavaScript] 

* [http://www.ccs.neu.edu/home/dherman/browse/code/monads/JavaMonads/ Java] 
* [http://www.ccs.neu.edu/home/dherman/browse/code/monads/JavaMonads/ Java] 

* [http://permalink.gmane.org/gmane.comp.lang.concatenative/1506 Joy] 
* [http://permalink.gmane.org/gmane.comp.lang.concatenative/1506 Joy] 

−  * [http://research.microsoft.com/~emeijer/Papers/XLinq%20XML%20Programming%20Refactored%20(The%20Return%20Of%20The%20Monoids).htm LINQ], [http://www.idealliance.org/xmlusa/05/call/xmlpapers/63.1015/.63.html#S4. more, C#, VB] (inaccessible) 
+  * [http://research.microsoft.com/enus/um/people/emeijer/Papers/XLinq%20XML%20Programming%20Refactored%20(The%20Return%20Of%20The%20Monoids).htm LINQ] 
−  * [http://sleepingsquirrel.org/monads/monads.lisp Lisp] 
+  * [http://commonlisp.net/project/clmonadmacros/monadmacros.htm Lisp] 
* [http://lambdatheultimate.org/node/1136#comment12448 Miranda] 
* [http://lambdatheultimate.org/node/1136#comment12448 Miranda] 

* OCaml: 
* OCaml: 

** [http://www.cas.mcmaster.ca/~carette/pa_monad/ OCaml] 
** [http://www.cas.mcmaster.ca/~carette/pa_monad/ OCaml] 

** [https://mailman.rice.edu/pipermail/metaocamlusersl/2005March/000057.html more] 
** [https://mailman.rice.edu/pipermail/metaocamlusersl/2005March/000057.html more] 

−  ** [http://www.pps.jussieu.fr/~beffara/darcs/pivm/camlvm/monad.mli also] 

** [http://www.cas.mcmaster.ca/~carette/metamonads/ MetaOcaml] 
** [http://www.cas.mcmaster.ca/~carette/metamonads/ MetaOcaml] 

−  ** [http://enfranchisedmind.com/blog/posts/amonadtutorialforocaml/ A Monad Tutorial for Ocaml] 
+  ** [http://blog.enfranchisedmind.com/2007/08/amonadtutorialforocaml/ A Monad Tutorial for Ocaml] 
−  * [http://sleepingsquirrel.org/monads/monads.html Perl] 
+  * [http://www.reddit.com/r/programming/comments/p66e/are_monads_actually_used_in_anything_except Perl6 ?] 
−  * [http://programming.reddit.com/info/p66e/comments Perl6 ?] 

* [http://logic.csci.unt.edu/tarau/research/PapersHTML/monadic.html Prolog] 
* [http://logic.csci.unt.edu/tarau/research/PapersHTML/monadic.html Prolog] 

* Python 
* Python 

−  ** [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/439361 Python] 
+  ** [http://code.activestate.com/recipes/439361/ Python] 
−  ** [http://www.etsimo.uniovi.es/python/pycon/papers/deferex/ here] 
+  ** Twisted's [http://www.reddit.com/r/programming/comments/p66e/are_monads_actually_used_in_anything_except/cp8eh Deferred monad] 
−  ** Twisted's [http://programming.reddit.com/info/p66e/comments/cp8eh Deferred monad] 

* Ruby: 
* Ruby: 

** [http://moonbase.rydia.net/mental/writings/programming/monadsinruby/00introduction.html Ruby] 
** [http://moonbase.rydia.net/mental/writings/programming/monadsinruby/00introduction.html Ruby] 

−  ** [http://metameta.blogspot.com/2006/12/monadsinrubypart1identity.htmland other implementation] 
+  ** [http://metameta.blogspot.com/2006/12/monadsinrubypart1identity.html and other implementation] 
−  * Scala: 

−  ** [http://scala.epfl.ch/examples/files/simpleInterpreter.html Scala] 

−  ** [http://scala.epfl.ch/examples/files/callccInterpreter.html A continuation monad] 

* Scheme: 
* Scheme: 

** [http://okmij.org/ftp/Scheme/monadinScheme.html Scheme] 
** [http://okmij.org/ftp/Scheme/monadinScheme.html Scheme] 

Line 153:  Line 151:  
Unfinished: 
Unfinished: 

−  * [http://slate.tunes.org/repos/main/src/unfinished/monad.slate Slate] 

* [http://wiki.tcl.tk/14295 Parsing], [http://wiki.tcl.tk/13844 Maybe and Error] in Tcl 
* [http://wiki.tcl.tk/14295 Parsing], [http://wiki.tcl.tk/13844 Maybe and Error] in Tcl 

Line 162:  Line 159:  
Please add them if you know of other implementations. 
Please add them if you know of other implementations. 

−  [http://lambdatheultimate.org/node/1136 Collection of links to monad implementations in various languages.] on [http://lambdatheultimate/ Lambda The Ultimate]. 
+  [http://lambdatheultimate.org/node/1136 Collection of links to monad implementations in various languages.] on [http://lambdatheultimate.org/ Lambda The Ultimate]. 
==Interesting monads== 
==Interesting monads== 

Line 168:  Line 165:  
A list of monads for various evaluation strategies and games: 
A list of monads for various evaluation strategies and games: 

−  * [http://hackage.haskell.org/packages/archive/mtl/1.1.0.2/doc/html/ControlMonadIdentity.html Identity monad] 
+  * [http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/ControlMonadIdentity.html Identity monad]  the trivial monad. 
−  * [http://haskell.org/ghc/docs/latest/html/libraries/base/DataMaybe.html Optional results] 
+  * [http://www.haskell.org/ghc/docs/latest/html/libraries/base/DataMaybe.html Optional results from computations]  error checking without null. 
−  * [http://haskell.org/haskellwiki/New_monads/MonadRandom Random values] 
+  * [http://hackage.haskell.org/packages/archive/monadmersennerandom/latest/doc/html/ControlMonadMersenneRandom.html Random values]  run code in an environment with access to a stream of random numbers. 
−  * [http://haskell.org/ghc/docs/latest/html/libraries/mtl/ControlMonadReader.html Read only state] 
+  * [http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/ControlMonadReader.html Read only variables]  guarantee readonly access to values. 
−  * [http://haskell.org/ghc/docs/latest/html/libraries/mtl/ControlMonadWriter.html Writable state] 
+  * [http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/ControlMonadWriterLazy.html Writable state]  i.e. log to a state buffer 
−  * [http://haskell.org/haskellwiki/New_monads/MonadSupply Unique supply] 
+  * [http://www.haskell.org/haskellwiki/New_monads/MonadSupply A supply of unique values]  useful for e.g. guids or unique variable names 
−  * [http://haskell.org/ghc/docs/latest/html/libraries/base/ControlMonadST.html ST  memoryonly effects] 
+  * [http://www.haskell.org/ghc/docs/latest/html/libraries/base/ControlMonadST.html ST  memoryonly, locallyencapsulated mutable variables]. Safely embed mutable state inside pure functions. 
−  * [http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/ControlMonadState.html Global state] 
+  * [http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/ControlMonadStateLazy.html Global state]  a scoped, mutable state. 
−  * [http://haskell.org/haskellwiki/New_monads/MonadUndo Undoable state effects] 
+  * [http://hackage.haskell.org/packages/archive/Hedi/latest/doc/html/Undo.html Undoable state effects]  roll back state changes 
−  * [http://haskell.org/ghc/docs/latest/html/libraries/base/ControlMonadInstances.html Function application] 
+  * [http://www.haskell.org/ghc/docs/latest/html/libraries/base/ControlMonadInstances.html#t:Monad Function application]  chains of function application. 
−  * [http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/ControlMonadError.html Functions which may error] 
+  * [http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/ControlMonadError.html Functions which may error]  track location and causes of errors. 
−  * [http://haskell.org/ghc/docs/latest/html/libraries/stm/ControlMonadSTM.html Atomic memory transactions] 
+  * [http://hackage.haskell.org/packages/archive/stm/latest/doc/html/ControlMonadSTM.html Atomic memory transactions]  software transactional memory 
−  * [http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/ControlMonadCont.html Continuations] 
+  * [http://hackage.haskell.org/packages/archive/mtl/latest/doc/html/ControlMonadCont.html Continuations]  computations which can be interrupted and resumed. 
−  * [http://haskell.org/ghc/docs/latest/html/libraries/base/SystemIO.html#t%3AIO IO  unrestricted side effects] 
+  * [http://www.haskell.org/ghc/docs/latest/html/libraries/base/SystemIO.html#t%3AIO IO]  unrestricted side effects on the world 
−  * [http://www.haskell.org/haskellwiki/Sudoku Nondeterministic evaluation] 
+  * [http://hackage.haskell.org/packages/archive/levelmonad/0.4.1/doc/html/ControlMonadLevels.html Search monad]  bfs and dfs search environments. 
−  * [http://haskell.org/ghc/docs/latest/html/libraries/mtl/ControlMonadList.html List monad: computations with multiple choices] 
+  * [http://hackage.haskell.org/packages/archive/streammonad/latest/doc/html/ControlMonadStream.html nondeterminism]  interleave computations with suspension. 
−  * [http://www.math.chalmers.se/~koen/pubs/entryjfp99monad.html Concurrent threads] 
+  * [http://hackage.haskell.org/packages/archive/stepwise/latest/doc/html/ControlMonadStepwise.html stepwise computation]  encode nondeterministic choices as stepwise deterministic ones 
* [http://logic.csci.unt.edu/tarau/research/PapersHTML/monadic.html Backtracking computations] 
* [http://logic.csci.unt.edu/tarau/research/PapersHTML/monadic.html Backtracking computations] 

* [http://www.cs.cornell.edu/people/fluet/research/rgnmonad/index.html Region allocation effects] 
* [http://www.cs.cornell.edu/people/fluet/research/rgnmonad/index.html Region allocation effects] 

−  * [http://okmij.org/ftp/Computation/monads.html#LogicT LogicT: backtracking monad transformer with fair operations and pruning] 
+  * [http://hackage.haskell.org/packages/archive/logict/0.5.0.2/doc/html/ControlMonadLogic.html LogicT]  backtracking monad transformer with fair operations and pruning 
−  * [http://tsukimi.agusa.i.is.nagoyau.ac.jp/~sydney/PiMonad/ Pi calculus as a monad] 
+  * [http://hackage.haskell.org/packages/archive/monadtask/latest/doc/html/ControlMonadTask.html concurrent events and threads]  refactor event and callback heavy programs into straightline code via coroutines 
−  * [http://www.haskell.org/halfs/ Halfs], uses a readonly and writeonly monad for filesystem work. 
+  * [http://hackage.haskell.org/package/QIO QIO]  The Quantum computing monad 
−  * House's H monad for safe hardware access 
+  * [http://hackage.haskell.org/packages/archive/fullsessions/latest/doc/html/ControlConcurrentFullSession.html Pi calculus]  a monad for Picalculus style concurrent programming 
* [http://wwwfp.dcs.stand.ac.uk/~kh/papers/pasco94/subsubsectionstar3_3_2_3.html Commutable monads for parallel programming] 
* [http://wwwfp.dcs.stand.ac.uk/~kh/papers/pasco94/subsubsectionstar3_3_2_3.html Commutable monads for parallel programming] 

−  * [http://hackage.haskell.org/package/QIO The Quantum computing monad] 

* [http://hackage.haskell.org/package/streammonad Simple, Fair and Terminating Backtracking Monad] 
* [http://hackage.haskell.org/package/streammonad Simple, Fair and Terminating Backtracking Monad] 

* [http://hackage.haskell.org/package/controlmonadexception Typed exceptions with call traces as a monad] 
* [http://hackage.haskell.org/package/controlmonadexception Typed exceptions with call traces as a monad] 

Line 202:  Line 198:  
* [http://hackage.haskell.org/package/monadiccp A constraint programming monad] 
* [http://hackage.haskell.org/package/monadiccp A constraint programming monad] 

* [http://hackage.haskell.org/package/ProbabilityMonads A probability distribution monad] 
* [http://hackage.haskell.org/package/ProbabilityMonads A probability distribution monad] 

−  +  * [http://hackage.haskell.org/package/setmonad Sets]  Set computations 

+  * [http://hackage.haskell.org/package/httpmonad/ HTTP]  http connections as a monadic environment 

+  * [http://hackage.haskell.org/package/monadmemo Memoization]  add memoization to code 

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

Line 216:  Line 212:  
* [[Monads as computation]] 
* [[Monads as computation]] 

* [[Monad/ST]] 
* [[Monad/ST]] 

+  * [http://www.haskellforall.com/2012/06/youcouldhaveinventedfreemonads.html Why free monads matter] (blog article) 

[[Category:Monad*]] 
[[Category:Monad*]] 
Revision as of 09:28, 24 December 2012
import Control.Monad 
Monads in Haskell can be thought of as composable computation descriptions. The essence of monad is thus separation of composition timeline from the composed computation's execution timeline, as well as the ability of computation to implicitly carry extra data, as pertaining to the computation itself, in addition to its one (hence the name) output, that it will produce when run (or queried, or called upon). This lends monads to supplementing pure calculations with features like I/O, common environment or state, and to preprocessing of computations (simplification, optimization etc.).
Each monad, or computation type, provides means, subject to Monad Laws, to (a) create a description of computation action that will produce (a.k.a. "return") a given Haskell value, (b) somehow run a computation action description (possibly getting its output back into Haskell should the monad choose to allow it, if computations described by the monad are pure, or causing the prescribed side effects if it's not), and (c) combine (a.k.a. "bind") a computation action description with a reaction to it – a regular Haskell function of one argument (that will receive computationproduced value) returning another action description (using or dependent on that value, if need be) – thus creating a combined computation action description that will feed the original action's output through the reaction while automatically taking care of the particulars of the computational process itself. A monad might also define additional primitives to provide access to and/or enable manipulation of data it implicitly carries, specific to its nature.
Thus in Haskell, though it is a purelyfunctional language, side effects that will be performed by a computation can be dealt with and combined purely at the monad's composition time. Monads thus resemble programs in a particular DSL. While programs may describe impure effects and actions outside Haskell, they can still be combined and processed ("assembled") purely, inside Haskell, creating a pure Haskell value  a computation action description that describes an impure calculation. That is how Monads in Haskell separate between the pure and the impure.
The computation doesn't have to be impure and can be pure itself as well. Then monads serve to provide the benefits of separation of concerns, and automatic creation of a computational "pipeline". Because they are very useful in practice but rather mindtwisting for the beginners, numerous tutorials that deal exclusively with monads were created (see monad tutorials).
Contents 
1 Common monads
Most common applications of monads include:
 Representing failure using monadMaybe
 Nondeterminism using monad to represent carrying multiple valuesList
 State using monadState
 Readonly environment using monadReader
 I/O using monadIO
2 Monad class
Monads can be viewed as a standard programming interface to various data or control structures, which is captured by theclass 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, or Monad Laws:
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. It basically says that monad's reactions should be associative under Kleisli composition, defined as (f >=> g) x = f x >>= g
, with return
its left and right identity element.
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 calledthing1 >>= (\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 < actA b < actB m a b
is the same as:
do b < actB a < actA m a b
Examples of commutative include:
 monadReader
 monadMaybe
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 the Monad tutorials timeline for a comprehensive list of 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 HenkJan van Tuyl.
7 Monad research
A collection of research papers about monads.
8 Monads in other languages
Implementations of monads in other languages.
 C
 CML.event ?
 Clean State monad
 JavaScript
 Java
 Joy
 LINQ
 Lisp
 Miranda
 OCaml:
 Perl6 ?
 Prolog
 Python
 Python
 Twisted's Deferred monad
 Ruby:
 Scheme:
 Tcl
 The Unix Shell
 More monads by Oleg
 CLL: a concurrent language based on a firstorder intuitionistic linear logic where all right synchronous connectives are restricted to a monad.
Unfinished:
 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.
9 Interesting monads
A list of monads for various evaluation strategies and games:
 Identity monad  the trivial monad.
 Optional results from computations  error checking without null.
 Random values  run code in an environment with access to a stream of random numbers.
 Read only variables  guarantee readonly access to values.
 Writable state  i.e. log to a state buffer
 A supply of unique values  useful for e.g. guids or unique variable names
 ST  memoryonly, locallyencapsulated mutable variables. Safely embed mutable state inside pure functions.
 Global state  a scoped, mutable state.
 Undoable state effects  roll back state changes
 Function application  chains of function application.
 Functions which may error  track location and causes of errors.
 Atomic memory transactions  software transactional memory
 Continuations  computations which can be interrupted and resumed.
 IO  unrestricted side effects on the world
 Search monad  bfs and dfs search environments.
 nondeterminism  interleave computations with suspension.
 stepwise computation  encode nondeterministic choices as stepwise deterministic ones
 Backtracking computations
 Region allocation effects
 LogicT  backtracking monad transformer with fair operations and pruning
 concurrent events and threads  refactor event and callback heavy programs into straightline code via coroutines
 QIO  The Quantum computing monad
 Pi calculus  a monad for Picalculus style concurrent programming
 Commutable monads for parallel programming
 Simple, Fair and Terminating Backtracking Monad
 Typed exceptions with call traces as a monad
 Breadth first list monad
 Continuationbased queues as monads
 Typed network protocol monad
 NonDeterminism Monad for LevelWise Search
 Transactional state monad
 A constraint programming monad
 A probability distribution monad
 Sets  Set computations
 HTTP  http connections as a monadic environment
 Memoization  add memoization to code
There are many more interesting instance of the monad abstraction out there. Please add them as you come across each species.
10 Fun
 If you are tired of monads, you can easily get rid of them.