## Implementation

``````trait Monad[M[_]] extends Applicative[M] {

def flatMap[A, B](ma: M[A])(f: A => M[B]): M[B]

def join[A](mma: M[M[A]]): M[A] =
flatMap(mma)(ma => ma)

def ap[A, B](f: M[A => B])(ma: M[A]): M[B] =
flatMap(f)({ g => flatMap(ma)({ a => pure(g(a)) }) })
}``````

## Extension methods

``````object Monad {

import Functor._

def flatMap[B](f: A => M[B]): M[B] =

def >>=[B](f: A => M[B]): M[B] =
flatMap(f)
}
}``````

## Background

In category theory, a monad builds on a certain morphism between categories. In functional programming, this allows a function of type `A => F[B]` to be lifted to a function of type `F[A] => F[B]` for some type constructor `F`.

``````.--------------.         .-------------------.
|  Category _  |         |   Category F[_]   |
|--------------|         |-------------------|
| A  ~~~~~~~~~~~ pure ~~~~~> F[A]            |
| B  ~~~~~~~~~~~ pure ~~~~~> F[B]            |
| A  ======================> F[B]            |
|           |  |         |                   |
|           '~~~ flatMap ~~> F[A] => F[B]    |
'--------------'         '-------------------'``````

This diagram can be read as:

1. The category `_` contains objects of type `A` and `B`, and a morphism from `A` to `F[B]`, which is in the category `F[_]`
2. The category `F[_]` contains objects of type `F[A]` and `F[B]`, and a morphism from `F[A]` to `F[B]`
3. A monad for `F[_]` converts the `A` object into the `F[A]` object via `pure`
4. A monad for `F[_]` converts the `A => F[B]` morphism into the `F[A] => F[B]` morphism via `flatMap`

This is useful when you have a value of type `F[A]` and you want to apply a function of type `A => F[B]` to it, resulting in a value of type `F[B]`.