# Difference between revisions of "Monad"

Jump to: navigation, search

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

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.

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

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