Portability | portable |
---|---|

Stability | provisional |

Maintainer | libraries@haskell.org |

Safe Haskell | Safe |

# Documentation

The `Functor`

class is used for types that can be mapped over.
Instances of `Functor`

should satisfy the following laws:

fmap id == id fmap (f . g) == fmap f . fmap g

The instances of `Functor`

for lists, `Maybe`

and `IO`

satisfy these laws.

Functor [] | |

Functor IO | |

Functor Maybe | |

Functor ReadP | |

Functor ReadPrec | |

Functor STM | |

Functor Handler | |

Functor ZipList | |

Functor ((->) r) | |

Functor (Either a) | |

Functor ((,) a) | |

Functor (ST s) | |

Arrow a => Functor (ArrowMonad a) | |

Functor (ST s) | |

Monad m => Functor (WrappedMonad m) | |

Functor (Const m) | |

Arrow a => Functor (WrappedArrow a b) |

The `Monad`

class defines the basic operations over a *monad*,
a concept from a branch of mathematics known as *category theory*.
From the perspective of a Haskell programmer, however, it is best to
think of a monad as an *abstract datatype* of actions.
Haskell's `do`

expressions provide a convenient syntax for writing
monadic expressions.

Minimal complete definition: `>>=`

and `return`

.

Instances of `Monad`

should satisfy the following laws:

return a >>= k == k a m >>= return == m m >>= (\x -> k x >>= h) == (m >>= k) >>= h

Instances of both `Monad`

and `Functor`

should additionally satisfy the law:

fmap f xs == xs >>= return . f

The instances of `Monad`

for lists, `Maybe`

and `IO`

defined in the Prelude satisfy these laws.

(>>=) :: forall a b. m a -> (a -> m b) -> m bSource

Sequentially compose two actions, passing any value produced by the first as an argument to the second.

(>>) :: forall a b. m a -> m b -> m bSource

Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.

Inject a value into the monadic type.

Fail with a message. This operation is not part of the
mathematical definition of a monad, but is invoked on pattern-match
failure in a `do`

expression.