index 46c575c..173160e 100644 (file)
@@ -1,6 +1,3 @@
-**Don't try to read this yet!!! Many substantial edits are still in process.
-
Caveats
-------
I really don't know much category theory. Just enough to put this
@@ -8,11 +5,16 @@ together. Also, this really is "put together." I haven't yet found an
authoritative source (that's accessible to a category theory beginner like
myself) that discusses the correspondence between the category-theoretic and
functional programming uses of these notions in enough detail to be sure that
-none of the pieces here is misguided. In particular, it wasn't completely
-obvious how to map the polymorphism on the programming theory side into the
-category theory. And I'm bothered by the fact that our `<=<` operation is only
-partly defined on our domain of natural transformations. But this does seem to
-me to be the reasonable way to put the pieces together. We very much welcome
+none of the pieces here is mistaken.
+In particular, it wasn't completely obvious how to map the polymorphism on the
+programming theory side into the category theory. The way I accomplished this
+may be more complex than it needs to be.
+Also I'm bothered by the fact that our `<=<` operation is only partly defined
+on our domain of natural transformations.
+There are three additional points below that I wonder whether may be too
+cavalier.
+But all considered, this does seem to
+me to be a reasonable way to put the pieces together. We very much welcome
feedback from anyone who understands these issues better, and will make
corrections.

@@ -24,8 +26,8 @@ A **monoid** is a structure <code>(S,&#8902;,z)</code> consisting of an associat

<pre>
for all s1, s2, s3 in S:
-       (i) s1&#8902;s2 etc are also in S
-       (ii) (s1&#8902;s2)&#8902;s3 = s1&#8902;(s2&#8902;s3)
+         (i) s1&#8902;s2 etc are also in S
+        (ii) (s1&#8902;s2)&#8902;s3 = s1&#8902;(s2&#8902;s3)
(iii) z&#8902;s1 = s1 = s1&#8902;z
</pre>

@@ -33,8 +35,8 @@ Some examples of monoids are:

*      finite strings of an alphabet `A`, with <code>&#8902;</code> being concatenation and `z` being the empty string
*      all functions <code>X&rarr;X</code> over a set `X`, with <code>&#8902;</code> being composition and `z` being the identity function over `X`
-*      the natural numbers with <code>&#8902;</code> being plus and `z` being `0` (in particular, this is a **commutative monoid**). If we use the integers, or the naturals mod n, instead of the naturals, then every element will have an inverse and so we have not merely a monoid but a **group**.)
-*      if we let <code>&#8902;</code> be multiplication and `z` be `1`, we get different monoids over the same sets as in the previous item.
+*      the natural numbers with <code>&#8902;</code> being plus and `z` being 0 (in particular, this is a **commutative monoid**). If we use the integers, or the naturals mod n, instead of the naturals, then every element will have an inverse and so we have not merely a monoid but a **group**.
+*      if we let <code>&#8902;</code> be multiplication and `z` be 1, we get different monoids over the same sets as in the previous item.

Categories
----------
@@ -45,32 +47,34 @@ When a morphism `f` in category <b>C</b> has source `C1` and target `C2`, we'll
To have a category, the elements and morphisms have to satisfy some constraints:

<pre>
-       (i) the class of morphisms has to be closed under composition:
-       where f:C1&rarr;C2 and g:C2&rarr;C3, g &#8728; f is also a
-       morphism of the category, which maps C1&rarr;C3.
-       (ii) composition of morphisms has to be associative
-       (iii) every element E of the category has to have an identity
-       morphism 1<sub>E</sub>, which is such that for every morphism
-       f:C1&rarr;C2: 1<sub>C2</sub> &#8728; f = f = f &#8728; 1<sub>C1</sub>
+         (i) the class of morphisms has to be closed under composition:
+             where f:C1&rarr;C2 and g:C2&rarr;C3, g &#8728; f is also a
+             morphism of the category, which maps C1&rarr;C3.
+
+        (ii) composition of morphisms has to be associative
+
+       (iii) every element X of the category has to have an identity
+             morphism 1<sub>X</sub>, which is such that for every morphism f:C1&rarr;C2:
+             1<sub>C2</sub> &#8728; f = f = f &#8728; 1<sub>C1</sub>
</pre>

-These parallel the constraints for monoids. Note that there can be multiple distinct morphisms between an element `E` and itself; they need not all be identity morphisms. Indeed from (iii) it follows that each element can have only a single identity morphism.
+These parallel the constraints for monoids. Note that there can be multiple distinct morphisms between an element `X` and itself; they need not all be identity morphisms. Indeed from (iii) it follows that each element can have only a single identity morphism.

-A good intuitive picture of a category is as a generalized directed graph, where the category elements are the graph's nodes, and there can be multiple directed edges between a given pair of nodes, and nodes can also have multiple directed edges to themselves. (Every node must have at least one such, which is that node's identity morphism.)
+A good intuitive picture of a category is as a generalized directed graph, where the category elements are the graph's nodes, and there can be multiple directed edges between a given pair of nodes, and nodes can also have multiple directed edges to themselves. Morphisms correspond to directed paths of length &ge; 0 in the graph.

Some examples of categories are:

-*      Categories whose elements are sets and whose morphisms are functions between those sets. Here the source and target of a function are its domain and range, so distinct functions sharing a domain and range (e.g., sin and cos) are distinct morphisms between the same source and target elements. The identity morphism for any element/set is just the identity function for that set.
+*      Categories whose elements are sets and whose morphisms are functions between those sets. Here the source and target of a function are its domain and range, so distinct functions sharing a domain and range (e.g., `sin` and `cos`) are distinct morphisms between the same source and target elements. The identity morphism for any element/set is just the identity function for that set.

-*      any monoid <code>(S,&#8902;,z)</code> generates a category with a single element `x`; this `x` need not have any relation to `S`. The members of `S` play the role of *morphisms* of this category, rather than its elements. All of these morphisms are understood to map `x` to itself. The result of composing the morphism consisting of `s1` with the morphism `s2` is the morphism `s3`, where <code>s3=s1&#8902;s2</code>. The identity morphism for the (single) category element `x` is the monoid's identity `z`.
+*      any monoid <code>(S,&#8902;,z)</code> generates a category with a single element `Q`; this `Q` need not have any relation to `S`. The members of `S` play the role of *morphisms* of this category, rather than its elements. All of these morphisms are understood to map `Q` to itself. The result of composing the morphism consisting of `s1` with the morphism `s2` is the morphism `s3`, where <code>s3=s1&#8902;s2</code>. The identity morphism for the (single) category element `Q` is the monoid's identity `z`.

-*      a **preorder** is a structure `(S, &le;)` consisting of a reflexive, transitive, binary relation on a set `S`. It need not be connected (that is, there may be members `x`,`y` of `S` such that neither `x&le;y` nor `y&le;x`). It need not be anti-symmetric (that is, there may be members `s1`,`s2` of `S` such that `s1&le;s2` and `s2&le;s1` but `s1` and `s2` are not identical). Some examples:
+*      a **preorder** is a structure <code>(S, &le;)</code> consisting of a reflexive, transitive, binary relation on a set `S`. It need not be connected (that is, there may be members `s1`,`s2` of `S` such that neither <code>s1 &le; s2</code> nor <code>s2 &le; s1</code>). It need not be anti-symmetric (that is, there may be members `s1`,`s2` of `S` such that <code>s1 &le; s2</code> and <code>s2 &le; s1</code> but `s1` and `s2` are not identical). Some examples:

*       sentences ordered by logical implication ("p and p" implies and is implied by "p", but these sentences are not identical; so this illustrates a pre-order without anti-symmetry)
*       sets ordered by size (this illustrates it too)

-       Any pre-order <code>(S,&le;)</code> generates a category whose elements are the members of `S` and which has only a single morphism between any two elements `s1` and `s2`, iff <code>s1&le;s2</code>.
+       Any pre-order <code>(S,&le;)</code> generates a category whose elements are the members of `S` and which has only a single morphism between any two elements `s1` and `s2`, iff <code>s1 &le; s2</code>.

Functors
@@ -78,10 +82,16 @@ Functors
A **functor** is a "homomorphism", that is, a structure-preserving mapping, between categories. In particular, a functor `F` from category <b>C</b> to category <b>D</b> must:

<pre>
-       (i) associate with every element C1 of <b>C</b> an element F(C1) of <b>D</b>
-       (ii) associate with every morphism f:C1&rarr;C2 of <b>C</b> a morphism F(f):F(C1)&rarr;F(C2) of <b>D</b>
-       (iii) "preserve identity", that is, for every element C1 of <b>C</b>: F of C1's identity morphism in <b>C</b> must be the identity morphism of F(C1) in <b>D</b>: F(1<sub>C1</sub>) = 1<sub>F(C1)</sub>.
-       (iv) "distribute over composition", that is for any morphisms f and g in <b>C</b>: F(g &#8728; f) = F(g) &#8728; F(f)
+         (i) associate with every element C1 of <b>C</b> an element F(C1) of <b>D</b>
+
+        (ii) associate with every morphism f:C1&rarr;C2 of <b>C</b> a morphism F(f):F(C1)&rarr;F(C2) of <b>D</b>
+
+       (iii) "preserve identity", that is, for every element C1 of <b>C</b>:
+             F of C1's identity morphism in <b>C</b> must be the identity morphism of F(C1) in <b>D</b>:
+             F(1<sub>C1</sub>) = 1<sub>F(C1)</sub>.
+
+        (iv) "distribute over composition", that is for any morphisms f and g in <b>C</b>:
+             F(g &#8728; f) = F(g) &#8728; F(f)
</pre>

A functor that maps a category to itself is called an **endofunctor**. The (endo)functor that maps every element and morphism of <b>C</b> to itself is denoted `1C`.
@@ -96,60 +106,77 @@ Natural Transformation
----------------------
So categories include elements and morphisms. Functors consist of mappings from the elements and morphisms of one category to those of another (or the same) category. **Natural transformations** are a third level of mappings, from one functor to another.

-Where `G` and `H` are functors from category <b>C</b> to category <b>D</b>, a natural transformation &eta; between `G` and `H` is a family of morphisms &eta;[C1]:G(C1)&rarr;H(C1)` in <b>D</b> for each element `C1` of <b>C</b>. That is, &eta;[C1]` has as source `C1`'s image under `G` in <b>D</b>, and as target `C1`'s image under `H` in <b>D</b>. The morphisms in this family must also satisfy the constraint:
+Where `G` and `H` are functors from category <b>C</b> to category <b>D</b>, a natural transformation &eta; between `G` and `H` is a family of morphisms <code>&eta;[C1]:G(C1)&rarr;H(C1)</code> in <b>D</b> for each element `C1` of <b>C</b>. That is, <code>&eta;[C1]</code> has as source `C1`'s image under `G` in <b>D</b>, and as target `C1`'s image under `H` in <b>D</b>. The morphisms in this family must also satisfy the constraint:

-       for every morphism f:C1&rarr;C2 in <b>C</b>: &eta;[C2] &#8728; G(f) = H(f) &#8728; &eta;[C1]
+<pre>
+       for every morphism f:C1&rarr;C2 in <b>C</b>:
+       &eta;[C2] &#8728; G(f) = H(f) &#8728; &eta;[C1]
+</pre>

-That is, the morphism via `G(f)` from `G(C1)` to `G(C2)`, and then via &eta;[C2]` to `H(C2)`, is identical to the morphism from `G(C1)` via &eta;[C1]` to `H(C1)`, and then via `H(f)` from `H(C1)` to `H(C2)`.
+That is, the morphism via `G(f)` from `G(C1)` to `G(C2)`, and then via <code>&eta;[C2]</code> to `H(C2)`, is identical to the morphism from `G(C1)` via <code>&eta;[C1]</code> to `H(C1)`, and then via `H(f)` from `H(C1)` to `H(C2)`.

How natural transformations compose:

Consider four categories <b>B</b>, <b>C</b>, <b>D</b>, and <b>E</b>. Let `F` be a functor from <b>B</b> to <b>C</b>; `G`, `H`, and `J` be functors from <b>C</b> to <b>D</b>; and `K` and `L` be functors from <b>D</b> to <b>E</b>. Let &eta; be a natural transformation from `G` to `H`; &phi; be a natural transformation from `H` to `J`; and &psi; be a natural transformation from `K` to `L`. Pictorally:

+<pre>
- <b>B</b> -+ +--- <b>C</b> --+ +---- <b>D</b> -----+ +-- <b>E</b> --
| |        | |            | |
-        F: -----&rarr; G: -----&rarr;     K: -----&rarr;
-                | |        | |  | &eta;     | |  | &psi;
+        F: ------> G: ------>     K: ------>
+                | |        | |  | &eta;       | |  | &psi;
| |        | |  v         | |  v
-                | |    H: -----&rarr;     L: -----&rarr;
-                | |        | |  | &phi;     | |
+                | |    H: ------>     L: ------>
+                | |        | |  | &phi;       | |
| |        | |  v         | |
-                | |    J: -----&rarr;         | |
+                | |    J: ------>         | |
-----+ +--------+ +------------+ +-------
+</pre>

-Then `(&eta; F)` is a natural transformation from the (composite) functor `GF` to the composite functor `HF`, such that where `b1` is an element of category <b>B</b>, `(&eta; F)[b1] = &eta;[F(b1)]`---that is, the morphism in <b>D</b> that &eta; assigns to the element `F(b1)` of <b>C</b>.
+Then <code>(&eta; F)</code> is a natural transformation from the (composite) functor `GF` to the composite functor `HF`, such that where `B1` is an element of category <b>B</b>, <code>(&eta; F)[B1] = &eta;[F(B1)]</code>---that is, the morphism in <b>D</b> that <code>&eta;</code> assigns to the element `F(B1)` of <b>C</b>.

-And `(K &eta;)` is a natural transformation from the (composite) functor `KG` to the (composite) functor `KH`, such that where `C1` is an element of category <b>C</b>, `(K &eta;)[C1] = K(&eta;[C1])`---that is, the morphism in <b>E</b> that `K` assigns to the morphism &eta;[C1]` of <b>D</b>.
+And <code>(K &eta;)</code> is a natural transformation from the (composite) functor `KG` to the (composite) functor `KH`, such that where `C1` is an element of category <b>C</b>, <code>(K &eta;)[C1] = K(&eta;[C1])</code>---that is, the morphism in <b>E</b> that `K` assigns to the morphism <code>&eta;[C1]</code> of <b>D</b>.

-`(&phi; -v- &eta;)` is a natural transformation from `G` to `J`; this is known as a "vertical composition". We will rely later on this, where `f:C1&rarr;C2`:
+<code>(&phi; -v- &eta;)</code> is a natural transformation from `G` to `J`; this is known as a "vertical composition". For any morphism <code>f:C1&rarr;C2</code> in <b>C</b>:

+<pre>
&phi;[C2] &#8728; H(f) &#8728; &eta;[C1] = &phi;[C2] &#8728; H(f) &#8728; &eta;[C1]
+</pre>

-by naturalness of &phi;, is:
+by naturalness of <code>&phi;</code>, is:

+<pre>
&phi;[C2] &#8728; H(f) &#8728; &eta;[C1] = J(f) &#8728; &phi;[C1] &#8728; &eta;[C1]
+</pre>

-by naturalness of &eta;, is:
+by naturalness of <code>&eta;</code>, is:

+<pre>
&phi;[C2] &#8728; &eta;[C2] &#8728; G(f) = J(f) &#8728; &phi;[C1] &#8728; &eta;[C1]
+</pre>

-Hence, we can define `(&phi; -v- &eta;)[x]` as: &phi;[x] &#8728; &eta;[x]` and rely on it to satisfy the constraints for a natural transformation from `G` to `J`:
+Hence, we can define <code>(&phi; -v- &eta;)[\_]</code> as: <code>&phi;[\_] &#8728; &eta;[\_]</code> and rely on it to satisfy the constraints for a natural transformation from `G` to `J`:

+<pre>
(&phi; -v- &eta;)[C2] &#8728; G(f) = J(f) &#8728; (&phi; -v- &eta;)[C1]
+</pre>

An observation we'll rely on later: given the definitions of vertical composition and of how natural transformations compose with functors, it follows that:

+<pre>
((&phi; -v- &eta;) F) = ((&phi; F) -v- (&eta; F))
+</pre>

I'll assert without proving that vertical composition is associative and has an identity, which we'll call "the identity transformation."

-`(&psi; -h- &eta;)` is natural transformation from the (composite) functor `KG` to the (composite) functor `LH`; this is known as a "horizontal composition." It's trickier to define, but we won't be using it here. For reference:
+<code>(&psi; -h- &eta;)</code> is natural transformation from the (composite) functor `KG` to the (composite) functor `LH`; this is known as a "horizontal composition." It's trickier to define, but we won't be using it here. For reference:

+<pre>
(&phi; -h- &eta;)[C1]  =  L(&eta;[C1]) &#8728; &psi;[G(C1)]
-                                          =  &psi;[H(C1)] &#8728; K(&eta;[C1])
+                                  =  &psi;[H(C1)] &#8728; K(&eta;[C1])
+</pre>

Horizontal composition is also associative, and has the same identity as vertical composition.

@@ -161,234 +188,423 @@ In earlier days, these were also called "triples."

A **monad** is a structure consisting of an (endo)functor `M` from some category <b>C</b> to itself, along with some natural transformations, which we'll specify in a moment.

-Let `T` be a set of natural transformations `p`, each being between some (variable) functor `P` and another functor which is the composite `MP'` of `M` and a (variable) functor `P'`. That is, for each element `C1` in <b>C</b>, `p` assigns `C1` a morphism from element `P(C1)` to element `MP'(C1)`, satisfying the constraints detailed in the previous section. For different members of `T`, the relevant functors may differ; that is, `p` is a transformation from functor `P` to `MP'`, `q` is a transformation from functor `Q` to `MQ'`, and none of `P`, `P'`, `Q`, `Q'` need be the same.
+Let `T` be a set of natural transformations <code>&phi;</code>, each being between some arbitrary endofunctor `F` on <b>C</b> and another functor which is the composite `MF'` of `M` and another arbitrary endofunctor `F'` on <b>C</b>. That is, for each element `C1` in <b>C</b>, <code>&phi;</code> assigns `C1` a morphism from element `F(C1)` to element `MF'(C1)`, satisfying the constraints detailed in the previous section. For different members of `T`, the relevant functors may differ; that is, <code>&phi;</code> is a transformation from functor `F` to `MF'`, <code>&gamma;</code> is a transformation from functor `G` to `MG'`, and none of `F`, `F'`, `G`, `G'` need be the same.

-One of the members of `T` will be designated the "unit" transformation for `M`, and it will be a transformation from the identity functor `1C` for <b>C</b> to `M(1C)`. So it will assign to `C1` a morphism from `C1` to `M(C1)`.
+One of the members of `T` will be designated the `unit` transformation for `M`, and it will be a transformation from the identity functor `1C` for <b>C</b> to `M(1C)`. So it will assign to `C1` a morphism from `C1` to `M(C1)`.

-We also need to designate for `M` a "join" transformation, which is a natural transformation from the (composite) functor `MM` to `M`.
+We also need to designate for `M` a `join` transformation, which is a natural transformation from the (composite) functor `MM` to `M`.

These two natural transformations have to satisfy some constraints ("the monad laws") which are most easily stated if we can introduce a defined notion.

-Let `p` and `q` be members of `T`, that is they are natural transformations from `P` to `MP'` and from `Q` to `MQ'`, respectively. Let them be such that `P' = Q`. Now `(M q)` will also be a natural transformation, formed by composing the functor `M` with the natural transformation `q`. Similarly, `(join Q')` will be a natural transformation, formed by composing the natural transformation `join` with the functor `Q'`; it will transform the functor `MMQ'` to the functor `MQ'`. Now take the vertical composition of the three natural transformations `(join Q')`, `(M q)`, and `p`, and abbreviate it as follows:
+Let <code>&phi;</code> and <code>&gamma;</code> be members of `T`, that is they are natural transformations from `F` to `MF'` and from `G` to `MG'`, respectively. Let them be such that `F' = G`. Now <code>(M &gamma;)</code> will also be a natural transformation, formed by composing the functor `M` with the natural transformation <code>&gamma;</code>. Similarly, `(join G')` will be a natural transformation, formed by composing the natural transformation `join` with the functor `G'`; it will transform the functor `MMG'` to the functor `MG'`. Now take the vertical composition of the three natural transformations `(join G')`, <code>(M &gamma;)</code>, and <code>&phi;</code>, and abbreviate it as follows. Since composition is associative I don't specify the order of composition on the rhs.

-       q <=< p  =def.  ((join Q') -v- (M q) -v- p)
-
-Since composition is associative I don't specify the order of composition on the rhs.
+<pre>
+       &gamma; <=< &phi;  =def.  ((join G') -v- (M &gamma;) -v- &phi;)
+</pre>

-In other words, `<=<` is a binary operator that takes us from two members `p` and `q` of `T` to a composite natural transformation. (In functional programming, at least, this is called the "Kleisli composition operator". Sometimes its written `p >=> q` where that's the same as `q <=< p`.)
+In other words, `<=<` is a binary operator that takes us from two members <code>&phi;</code> and <code>&gamma;</code> of `T` to a composite natural transformation. (In functional programming, at least, this is called the "Kleisli composition operator". Sometimes it's written <code>&phi; >=> &gamma;</code> where that's the same as <code>&gamma; &lt;=&lt; &phi;</code>.)

-`p` is a transformation from `P` to `MP'` which = `MQ`; `(M q)` is a transformation from `MQ` to `MMQ'`; and `(join Q')` is a transformation from `MMQ'` to `MQ'`. So the composite `q <=< p` will be a transformation from `P` to `MQ'`, and so also eligible to be a member of `T`.
+<code>&phi;</code> is a transformation from `F` to `MF'`, where the latter = `MG`; <code>(M &gamma;)</code> is a transformation from `MG` to `MMG'`; and `(join G')` is a transformation from `MMG'` to `MG'`. So the composite <code>&gamma; &lt;=&lt; &phi;</code> will be a transformation from `F` to `MG'`, and so also eligible to be a member of `T`.

Now we can specify the "monad laws" governing a monad as follows:

+<pre>
(T, <=<, unit) constitute a monoid
+</pre>

-That's it. (Well, perhaps we're cheating a bit, because `q <=< p` isn't fully defined on `T`, but only when `P` is a functor to `MP'` and `Q` is a functor from `P'`. But wherever `<=<` is defined, the monoid laws are satisfied:
+That's it. Well, there may be a wrinkle here. I don't know whether the definition of a monoid requires the operation to be defined for every pair in its set. In the present case, <code>&gamma; &lt;=&lt; &phi;</code> isn't fully defined on `T`, but only when <code>&phi;</code> is a transformation to some `MF'` and <code>&gamma;</code> is a transformation from `F'`. But wherever `<=<` is defined, the monoid laws must hold:

-       (i) q <=< p is also in T
-       (ii) (r <=< q) <=< p  =  r <=< (q <=< p)
-       (iii.1) unit <=< p  =  p                 (here p has to be a natural transformation to M(1C))
-       (iii.2)                p  =  p <=< unit  (here p has to be a natural transformation from 1C)
+<pre>
+           (i) &gamma; <=< &phi; is also in T
+
+          (ii) (&rho; <=< &gamma;) <=< &phi;  =  &rho; <=< (&gamma; <=< &phi;)

-If `p` is a natural transformation from `P` to `M(1C)` and `q` is `(p Q')`, that is, a natural transformation from `PQ` to `MQ`, then we can extend (iii.1) as follows:
+       (iii.1) unit <=< &phi;  =  &phi;
+               (here &phi; has to be a natural transformation to M(1C))

-       q = (p Q')
-         = ((unit <=< p) Q')
-         = ((join -v- (M unit) -v- p) Q')
-         = (join Q') -v- ((M unit) Q') -v- (p Q')
-         = (join Q') -v- (M (unit Q')) -v- q
-         ??
-         = (unit Q') <=< q
+       (iii.2)                &rho;  =  &rho; <=< unit
+               (here &rho; has to be a natural transformation from 1C)
+</pre>

-where as we said `q` is a natural transformation from some `PQ'` to `MQ'`.
+If <code>&phi;</code> is a natural transformation from `F` to `M(1C)` and <code>&gamma;</code> is <code>(&phi; G')</code>, that is, a natural transformation from `FG'` to `MG'`, then we can extend (iii.1) as follows:

-Similarly, if `p` is a natural transformation from `1C` to `MP'`, and `q` is `(p Q)`, that is, a natural transformation from `Q` to `MP'Q`, then we can extend (iii.2) as follows:
+<pre>
+       &gamma; = (&phi; G')
+         = ((unit <=< &phi;) G')
+         since unit is a natural transformation to M(1C), this is:
+         = (((join 1C) -v- (M unit) -v- &phi;) G')
+         = (((join 1C) G') -v- ((M unit) G') -v- (&phi; G'))
+         = ((join (1C G')) -v- (M (unit G')) -v- &gamma;)
+         = ((join G') -v- (M (unit G')) -v- &gamma;)
+         since (unit G') is a natural transformation to MG', this is:
+         = (unit G') <=< &gamma;
+</pre>

-       q = (p Q)
-         = ((p <=< unit) Q)
-         = (((join P') -v- (M p) -v- unit) Q)
-         = ((join P'Q) -v- ((M p) Q) -v- (unit Q))
-         = ((join P'Q) -v- (M (p Q)) -v- (unit Q))
-         ??
-         = q <=< (unit Q)
+where as we said <code>&gamma;</code> is a natural transformation from some `FG'` to `MG'`.

-where as we said `q` is a natural transformation from `Q` to some `MP'Q`.
+Similarly, if <code>&rho;</code> is a natural transformation from `1C` to `MR'`, and <code>&gamma;</code> is <code>(&rho; G)</code>, that is, a natural transformation from `G` to `MR'G`, then we can extend (iii.2) as follows:

+<pre>
+       &gamma; = (&rho; G)
+         = ((&rho; <=< unit) G)
+         = since &rho; is a natural transformation to MR', this is:
+         = (((join R') -v- (M &rho;) -v- unit) G)
+         = (((join R') G) -v- ((M &rho;) G) -v- (unit G))
+         = ((join (R'G)) -v- (M (&rho; G)) -v- (unit G))
+         since &gamma; = (&rho; G) is a natural transformation to MR'G, this is:
+         = &gamma; <=< (unit G)
+</pre>

+where as we said <code>&gamma;</code> is a natural transformation from `G` to some `MR'G`.

+Summarizing then, the monad laws can be expressed as:

-The standard category-theory presentation of the monad laws
------------------------------------------------------------
+<pre>
+       For all &rho;, &gamma;, &phi; in T for which &rho; <=< &gamma; and &gamma; <=< &phi; are defined:
+
+           (i) &gamma; <=< &phi; etc are also in T
+
+          (ii) (&rho; <=< &gamma;) <=< &phi;  =  &rho; <=< (&gamma; <=< &phi;)
+
+       (iii.1) (unit G') <=< &gamma;  =  &gamma;
+               whenever &gamma; is a natural transformation from some FG' to MG'
+
+       (iii.2)                     &gamma;  =  &gamma; <=< (unit G)
+               whenever &gamma; is a natural transformation from G to some MR'G
+</pre>
+
+
+
+Getting to the standard category-theory presentation of the monad laws
+----------------------------------------------------------------------
In category theory, the monad laws are usually stated in terms of `unit` and `join` instead of `unit` and `<=<`.

-(*
+<!--
P2. every element C1 of a category <b>C</b> has an identity morphism 1<sub>C1</sub> such that for every morphism f:C1&rarr;C2 in <b>C</b>: 1<sub>C2</sub> &#8728; f = f = f &#8728; 1<sub>C1</sub>.
P3. functors "preserve identity", that is for every element C1 in F's source category: F(1<sub>C1</sub>) = 1<sub>F(C1)</sub>.
-*)
+-->
+
+Let's remind ourselves of principles stated above:

-Let's remind ourselves of some principles:
-       * composition of morphisms, functors, and natural compositions is associative
-       * functors "distribute over composition", that is for any morphisms f and g in F's source category: F(g &#8728; f) = F(g) &#8728; F(f)
-       * if &eta; is a natural transformation from F to G, then for every f:C1&rarr;C2 in F and G's source category <b>C</b>: &eta;[C2] &#8728; F(f) = G(f) &#8728; &eta;[C1].
+*      composition of morphisms, functors, and natural compositions is associative

+*      functors "distribute over composition", that is for any morphisms `f` and `g` in `F`'s source category: <code>F(g &#8728; f) = F(g) &#8728; F(f)</code>
+
+*      if <code>&eta;</code> is a natural transformation from `G` to `H`, then for every <code>f:C1&rarr;C2</code> in `G` and `H`'s source category <b>C</b>: <code>&eta;[C2] &#8728; G(f) = H(f) &#8728; &eta;[C1]</code>.
+
+*      <code>(&eta; F)[X] = &eta;[F(X)]</code>
+
+*      <code>(K &eta;)[X] = K(&eta;[X])</code>
+
+*      <code>((&phi; -v- &eta;) F) = ((&phi; F) -v- (&eta; F))</code>

Let's use the definitions of naturalness, and of composition of natural transformations, to establish two lemmas.

-Recall that join is a natural transformation from the (composite) functor MM to M. So for elements C1 in <b>C</b>, join[C1] will be a morphism from MM(C1) to M(C1). And for any morphism f:a&rarr;b in <b>C</b>:
+Recall that `join` is a natural transformation from the (composite) functor `MM` to `M`. So for elements `C1` in <b>C</b>, `join[C1]` will be a morphism from `MM(C1)` to `M(C1)`. And for any morphism <code>f:C1&rarr;C2</code> in <b>C</b>:

-       (1) join[b] &#8728; MM(f)  =  M(f) &#8728; join[a]
+<pre>
+       (1) join[C2] &#8728; MM(f)  =  M(f) &#8728; join[C1]
+</pre>

-Next, consider the composite transformation ((join MQ') -v- (MM q)).
-       q is a transformation from Q to MQ', and assigns elements C1 in <b>C</b> a morphism q*: Q(C1) &rarr; MQ'(C1). (MM q) is a transformation that instead assigns C1 the morphism MM(q*).
-       (join MQ') is a transformation from MMMQ' to MMQ' that assigns C1 the morphism join[MQ'(C1)].
-       Composing them:
-       (2) ((join MQ') -v- (MM q)) assigns to C1 the morphism join[MQ'(C1)] &#8728; MM(q*).
+Next, let <code>&gamma;</code> be a transformation from `G` to `MG'`, and
+ consider the composite transformation <code>((join MG') -v- (MM &gamma;))</code>.

-Next, consider the composite transformation ((M q) -v- (join Q)).
-       (3) This assigns to C1 the morphism M(q*) &#8728; join[Q(C1)].
+*      <code>&gamma;</code> assigns elements `C1` in <b>C</b> a morphism <code>&gamma;\*:G(C1) &rarr; MG'(C1)</code>. <code>(MM &gamma;)</code> is a transformation that instead assigns `C1` the morphism <code>MM(&gamma;\*)</code>.

-So for every element C1 of <b>C</b>:
-       ((join MQ') -v- (MM q))[C1], by (2) is:
-       join[MQ'(C1)] &#8728; MM(q*), which by (1), with f=q*: Q(C1)&rarr;MQ'(C1) is:
-       M(q*) &#8728; join[Q(C1)], which by 3 is:
-       ((M q) -v- (join Q))[C1]
+*      `(join MG')` is a transformation from `MM(MG')` to `M(MG')` that assigns `C1` the morphism `join[MG'(C1)]`.

-So our (lemma 1) is: ((join MQ') -v- (MM q))  =  ((M q) -v- (join Q)), where q is a transformation from Q to MQ'.
+Composing them:
+
+<pre>
+       (2) ((join MG') -v- (MM &gamma;)) assigns to C1 the morphism join[MG'(C1)] &#8728; MM(&gamma;*).
+</pre>
+
+Next, consider the composite transformation <code>((M &gamma;) -v- (join G))</code>:
+
+<pre>
+       (3) ((M &gamma;) -v- (join G)) assigns to C1 the morphism M(&gamma;*) &#8728; join[G(C1)].
+</pre>
+
+So for every element `C1` of <b>C</b>:
+
+<pre>
+       ((join MG') -v- (MM &gamma;))[C1], by (2) is:
+       join[MG'(C1)] &#8728; MM(&gamma;*), which by (1), with f=&gamma;*:G(C1)&rarr;MG'(C1) is:
+       M(&gamma;*) &#8728; join[G(C1)], which by 3 is:
+       ((M &gamma;) -v- (join G))[C1]
+</pre>
+
+So our **(lemma 1)** is:
+
+<pre>
+       ((join MG') -v- (MM &gamma;))  =  ((M &gamma;) -v- (join G)),
+       where as we said &gamma; is a natural transformation from G to MG'.
+</pre>

-Next recall that unit is a natural transformation from 1C to M. So for elements C1 in <b>C</b>, unit[C1] will be a morphism from C1 to M(C1). And for any morphism f:a&rarr;b in <b>C</b>:
-       (4) unit[b] &#8728; f = M(f) &#8728; unit[a]
+Next recall that `unit` is a natural transformation from `1C` to `M`. So for elements `C1` in <b>C</b>, `unit[C1]` will be a morphism from `C1` to `M(C1)`. And for any morphism <code>f:C1&rarr;C2</code> in <b>C</b>:

-Next consider the composite transformation ((M q) -v- (unit Q)). (5) This assigns to C1 the morphism M(q*) &#8728; unit[Q(C1)].
+<pre>
+       (4) unit[C2] &#8728; f = M(f) &#8728; unit[C1]
+</pre>

-Next consider the composite transformation ((unit MQ') -v- q). (6) This assigns to C1 the morphism unit[MQ'(C1)] &#8728; q*.
+Next, consider the composite transformation <code>((M &gamma;) -v- (unit G))</code>:
+
+<pre>
+       (5) ((M &gamma;) -v- (unit G)) assigns to C1 the morphism M(&gamma;*) &#8728; unit[G(C1)].
+</pre>
+
+Next, consider the composite transformation <code>((unit MG') -v- &gamma;)</code>:
+
+<pre>
+       (6) ((unit MG') -v- &gamma;) assigns to C1 the morphism unit[MG'(C1)] &#8728; &gamma;*.
+</pre>

So for every element C1 of <b>C</b>:
-       ((M q) -v- (unit Q))[C1], by (5) =
-       M(q*) &#8728; unit[Q(C1)], which by (4), with f=q*: Q(C1)&rarr;MQ'(C1) is:
-       unit[MQ'(C1)] &#8728; q*, which by (6) =
-       ((unit MQ') -v- q)[C1]

-So our lemma (2) is: (((M q) -v- (unit Q))  =  ((unit MQ') -v- q)), where q is a transformation from Q to MQ'.
+<pre>
+       ((M &gamma;) -v- (unit G))[C1], by (5) =
+       M(&gamma;*) &#8728; unit[G(C1)], which by (4), with f=&gamma;*:G(C1)&rarr;MG'(C1) is:
+       unit[MG'(C1)] &#8728; &gamma;*, which by (6) =
+       ((unit MG') -v- &gamma;)[C1]
+</pre>

+So our **(lemma 2)** is:

-Finally, we substitute ((join Q') -v- (M q) -v- p) for q <=< p in the monad laws. For simplicity, I'll omit the "-v-".
+<pre>
+       (((M &gamma;) -v- (unit G))  =  ((unit MG') -v- &gamma;)),
+       where as we said &gamma; is a natural transformation from G to MG'.
+</pre>

-       for all p,q,r in T, where p is a transformation from P to MP', q is a transformation from Q to MQ', R is a transformation from R to MR', and P'=Q and Q'=R:

-       (i) q <=< p etc are also in T
-       ==>
-       (i') ((join Q') (M q) p) etc are also in T
+Finally, we substitute <code>((join G') -v- (M &gamma;) -v- &phi;)</code> for <code>&gamma; &lt;=&lt; &phi;</code> in the monad laws. For simplicity, I'll omit the "-v-".

+<pre>
+       For all &rho;, &gamma;, &phi; in T,
+       where &phi; is a transformation from F to MF',
+       &gamma; is a transformation from G to MG',
+       &rho; is a transformation from R to MR',
+       and F'=G and G'=R:

-       (ii) (r <=< q) <=< p  =  r <=< (q <=< p)
+            (i) &gamma; <=< &phi; etc are also in T
==>
-                (r <=< q) is a transformation from Q to MR', so:
-                       (r <=< q) <=< p becomes: (join R') (M (r <=< q)) p
-                                                       which is: (join R') (M ((join R') (M r) q)) p
-                       substituting in (ii), and helping ourselves to associativity on the rhs, we get:
+           (i') ((join G') (M &gamma;) &phi;) etc are also in T
+</pre>

-            ((join R') (M ((join R') (M r) q)) p) = ((join R') (M r) (join Q') (M q) p)
-                     ---------------------
-                       which by the distributivity of functors over composition, and helping ourselves to associativity on the lhs, yields:
-                    ------------------------
-            ((join R') (M join R') (MM r) (M q) p) = ((join R') (M r) (join Q') (M q) p)
-                                                             ---------------
-                       which by lemma 1, with r a transformation from Q' to MR', yields:
-                                                             -----------------
-            ((join R') (M join R') (MM r) (M q) p) = ((join R') (join MR') (MM r) (M q) p)
+<pre>
+           (ii) (&rho; <=< &gamma;) <=< &phi;  =  &rho; <=< (&gamma; <=< &phi;)
+       ==>
+                    (&rho; <=< &gamma;) is a transformation from G to MR', so
+                        (&rho; <=< &gamma;) <=< &phi; becomes: ((join R') (M (&rho; <=< &gamma;)) &phi;)
+                                                       which is: ((join R') (M ((join R') (M &rho;) &gamma;)) &phi;)

-                       which will be true for all r,q,p just in case:
+                        similarly, &rho; <=< (&gamma; <=< &phi;) is:
+                                                       ((join R') (M &rho;) ((join G') (M &gamma;) &phi;))

-             ((join R') (M join R')) = ((join R') (join MR')), for any R'.
+                        substituting these into (ii), and helping ourselves to associativity on the rhs, we get:
+                ((join R') (M ((join R') (M &rho;) &gamma;)) &phi;) = ((join R') (M &rho;) (join G') (M &gamma;) &phi;)
+
+                        which by the distributivity of functors over composition, and helping ourselves to associativity on the lhs, yields:
+                ((join R') (M join R') (MM &rho;) (M &gamma;) &phi;) = ((join R') (M &rho;) (join G') (M &gamma;) &phi;)
+
+                        which by lemma 1, with &rho; a transformation from G' to MR', yields:
+                ((join R') (M join R') (MM &rho;) (M &gamma;) &phi;) = ((join R') (join MR') (MM &rho;) (M &gamma;) &phi;)

-                       which will in turn be true just in case:
+                        [-- Are the next two steps too cavalier? --]

-       (ii') (join (M join)) = (join (join M))
+                        which will be true for all &rho;, &gamma;, &phi; only when:
+                ((join R') (M join R')) = ((join R') (join MR')), for any R'

+                        which will in turn be true when:
+       (ii') (join (M join)) = (join (join M))
+</pre>

-       (iii.1) (unit P') <=< p  =  p
+<pre>
+        (iii.1) (unit G') <=< &gamma;  =  &gamma;
+                when &gamma; is a natural transformation from some FG' to MG'
==>
-                       (unit P') is a transformation from P' to MP', so:
-                               (unit P') <=< p becomes: (join P') (M unit P') p
-                                                  which is: (join P') (M unit P') p
-                               substituting in (iii.1), we get:
-                       ((join P') (M unit P') p) = p
+                        (unit G') is a transformation from G' to MG', so:
+                        (unit G') <=< &gamma; becomes: ((join G') (M (unit G')) &gamma;)
+                                             which is: ((join G') ((M unit) G') &gamma;)

-                       which will be true for all p just in case:
+                        substituting in (iii.1), we get:
+                        ((join G') ((M unit) G') &gamma;) = &gamma;

-                ((join P') (M unit P')) = the identity transformation, for any P'
+                        which is:
+                        (((join (M unit)) G') &gamma;) = &gamma;

-                       which will in turn be true just in case:
+                        [-- Are the next two steps too cavalier? --]

-       (iii.1') (join (M unit) = the identity transformation
+                        which will be true for all &gamma; just in case:
+                        for any G', ((join (M unit)) G') = the identity transformation

+                        which will in turn be true just in case:
+       (iii.1') (join (M unit)) = the identity transformation
+</pre>

-       (iii.2) p  =  p <=< (unit P)
+<pre>
+        (iii.2) &gamma;  =  &gamma; <=< (unit G)
+                when &gamma; is a natural transformation from G to some MR'G
==>
-                       p is a transformation from P to MP', so:
-                               unit <=< p becomes: (join P') (M p) unit
-                               substituting in (iii.2), we get:
-                       p = ((join P') (M p) (unit P))
-                                                  --------------
-                               which by lemma (2), yields:
-                            ------------
-                       p = ((join P') ((unit MP') p)
+                        &gamma; <=< (unit G) becomes: ((join R'G) (M &gamma;) (unit G))
+
+                        substituting in (iii.2), we get:
+                        &gamma; = ((join R'G) (M &gamma;) (unit G))
+
+                        which by lemma 2, yields:
+                        &gamma; = (((join R'G) ((unit MR'G) &gamma;)

-                               which will be true for all p just in case:
+                        which is:
+                        &gamma; = (((join (unit M)) R'G) &gamma;)

-               ((join P') (unit MP')) = the identity transformation, for any P'
+                        [-- Are the next two steps too cavalier? --]

-                               which will in turn be true just in case:
+                         which will be true for all &gamma; just in case:
+                        for any R'G, ((join (unit M)) R'G) = the identity transformation

+                        which will in turn be true just in case:
(iii.2') (join (unit M)) = the identity transformation
+</pre>

Collecting the results, our monad laws turn out in this format to be:

-       when p a transformation from P to MP', q a transformation from P' to MQ', r a transformation from Q' to MR' all in T:
+<pre>
+       For all &rho;, &gamma;, &phi; in T,
+       where &phi; is a transformation from F to MF',
+       &gamma; is a transformation from G to MG',
+       &rho; is a transformation from R to MR',
+       and F'=G and G'=R:

-       (i') ((join Q') (M q) p) etc also in T
+           (i') ((join G') (M &gamma;) &phi;) etc also in T

-       (ii') (join (M join)) = (join (join M))
+          (ii') (join (M join)) = (join (join M))

(iii.1') (join (M unit)) = the identity transformation

-       (iii.2')(join (unit M)) = the identity transformation
-
+       (iii.2') (join (unit M)) = the identity transformation
+</pre>

-7. The functional programming presentation of the monad laws
-------------------------------------------------------------
-In functional programming, unit is usually called "return" and the monad laws are usually stated in terms of return and an operation called "bind" which is interdefinable with <=< or with join.

-Additionally, whereas in category-theory one works "monomorphically", in functional programming one usually works with "polymorphic" functions.
+Getting to the functional programming presentation of the monad laws
+--------------------------------------------------------------------
+In functional programming, `unit` is sometimes called `return` and the monad laws are usually stated in terms of `unit`/`return` and an operation called `bind` which is interdefinable with `<=<` or with `join`.

The base category <b>C</b> will have types as elements, and monadic functions as its morphisms. The source and target of a morphism will be the types of its argument and its result. (As always, there can be multiple distinct morphisms from the same source to the same target.)

-A monad M will consist of a mapping from types C1 to types M(C1), and a mapping from functions f:C1&rarr;C2 to functions M(f):M(C1)&rarr;M(C2). This is also known as "fmap f" or "liftM f" for M, and is called "function f lifted into the monad M." For example, where M is the list monad, M maps every type X into the type "list of Xs", and maps every function f:x&rarr;y into the function that maps [x1,x2...] to [y1,y2,...].
+A monad `M` will consist of a mapping from types `'t` to types `M('t)`, and a mapping from functions <code>f:C1&rarr;C2</code> to functions <code>M(f):M(C1)&rarr;M(C2)</code>. This is also known as <code>lift<sub>M</sub> f</code> for `M`, and is pronounced "function f lifted into the monad M." For example, where `M` is the list monad, `M` maps every type `'t` into the type `'t list`, and maps every function <code>f:x&rarr;y</code> into the function that maps `[x1,x2...]` to `[y1,y2,...]`.
+
+
+In functional programming, instead of working with natural transformations we work with "monadic values" and polymorphic functions "into the monad."
+
+A "monadic value" is any member of a type `M('t)`, for any type `'t`. For example, any `int list` is a monadic value for the list monad. We can think of these monadic values as the result of applying some function `phi`, whose type is `F('t)->M(F'('t))`. `'t` here is any collection of free type variables, and `F('t)` and `F'('t)` are types parameterized on `'t`. An example, with `M` being the list monad, `'t` being `('t1,'t2)`, `F('t1,'t2)` being `char * 't1 * 't2`, and `F'('t1,'t2)` being `int * 't1 * 't2`:
+
+<pre>
+       let phi = fun ((_:char, x y) -> [(1,x,y),(2,x,y)]
+</pre>
+

+Now where `gamma` is another function of type <code>F'('t) &rarr; M(G'('t))</code>, we define:
+
+<pre>
+       gamma =<< phi a  =def. ((join G') -v- (M gamma)) (phi a)
+                        = ((join G') -v- (M gamma) -v- phi) a
+                                        = (gamma <=< phi) a
+</pre>
+
+Hence:
+
+<pre>
+       gamma <=< phi = fun a -> (gamma =<< phi a)
+</pre>
+
+`gamma =<< phi a` is called the operation of "binding" the function gamma to the monadic value `phi a`, and is usually written as `phi a >>= gamma`.
+
+With these definitions, our monadic laws become:

-A natural transformation t assigns to each type C1 in <b>C</b> a morphism t[C1]: C1&rarr;M(C1) such that, for every f:C1&rarr;C2:
-       t[C2] &#8728; f = M(f) &#8728; t[C1]
+<pre>
+       Where phi is a polymorphic function of type F('t) -> M(F'('t))
+       gamma is a polymorphic function of type G('t) -> M(G'('t))
+       rho is a polymorphic function of type R('t) -> M(R'('t))
+       and F' = G and G' = R,
+       and a ranges over values of type F('t),
+       b ranges over values of type G('t),
+       and c ranges over values of type G'('t):
+
+             (i) &gamma; <=< &phi; is defined,
+                         and is a natural transformation from F to MG'
+       ==>
+               (i'') fun a -> gamma =<< phi a is defined,
+                         and is a function from type F('t) -> M(G'('t))
+</pre>
+
+<pre>
+            (ii) (&rho; <=< &gamma;) <=< &phi;  =  &rho; <=< (&gamma; <=< &phi;)
+       ==>
+                         (fun a -> (rho <=< gamma) =<< phi a)  =  (fun a -> rho =<< (gamma <=< phi) a)
+                         (fun a -> (fun b -> rho =<< gamma b) =<< phi a)  =  (fun a -> rho =<< (gamma =<< phi a))
+
+          (ii'') (fun b -> rho =<< gamma b) =<< phi a  =  rho =<< (gamma =<< phi a)
+</pre>
+
+<pre>
+         (iii.1) (unit G') <=< &gamma;  =  &gamma;
+                 when &gamma; is a natural transformation from some FG' to MG'
+       ==>
+                         (unit G') <=< gamma  =  gamma
+                         when gamma is a function of type F(G'('t)) -> M(G'('t))
+
+                         fun b -> (unit G') =<< gamma b  =  gamma
+
+                         (unit G') =<< gamma b  =  gamma b
+
+                         Let return be a polymorphic function mapping arguments of any
+                         type 't to M('t). In particular, it maps arguments c of type
+                         G'('t) to the monadic value (unit G') c, of type M(G'('t)).
+
+       (iii.1'') return =<< gamma b  =  gamma b
+</pre>
+
+<pre>
+         (iii.2) &gamma;  =  &gamma; <=< (unit G)
+                 when &gamma; is a natural transformation from G to some MR'G
+       ==>
+                         gamma  =  gamma <=< (unit G)
+                         when gamma is a function of type G('t) -> M(R'(G('t)))
+
+                         gamma  =  fun b -> gamma =<< (unit G) b
+
+                         As above, return will map arguments b of type G('t) to the
+                         monadic value (unit G) b, of type M(G('t)).
+
+                         gamma  =  fun b -> gamma =<< return b
+
+       (iii.2'') gamma b  =  gamma =<< return b
+</pre>

-The composite morphisms said here to be identical are morphisms from the type C1 to the type M(C2).
+Summarizing (ii''), (iii.1''), (iii.2''), these are the monadic laws as usually stated in the functional programming literature:

+*      `fun b -> rho =<< gamma b) =<< phi a  =  rho =<< (gamma =<< phi a)`

+       Usually written reversed, and with a monadic variable `u` standing in
+       for `phi a`:

-In functional programming, instead of working with natural transformations we work with "monadic values" and polymorphic functions "into the monad" in question.
+       `u >>= (fun b -> gamma b >>= rho)  =  (u >>= gamma) >>= rho`

-For an example of the latter, let p be a function that takes arguments of some (schematic, polymorphic) type C1 and yields results of some (schematic, polymorphic) type M(C2). An example with M being the list monad, and C2 being the tuple type schema int * C1:
+*      `return =<< gamma b  =  gamma b`

-       let p = fun c &rarr; [(1,c), (2,c)]
+       Usually written reversed, and with `u` standing in for `gamma b`:

-p is polymorphic: when you apply it to the int 0 you get a result of type "list of int * int": [(1,0), (2,0)]. When you apply it to the char 'e' you get a result of type "list of int * char": [(1,'e'), (2,'e')].
+       `u >>= return  =  u`

-However, to keep things simple, we'll work instead with functions whose type is settled. So instead of the polymorphic p, we'll work with (p : C1 &rarr; M(int * C1)). This only accepts arguments of type C1. For generality, I'll talk of functions with the type (p : C1 &rarr; M(C1')), where we assume that C1' is a function of C1.
+*      `gamma b  =  gamma =<< return b`

-A "monadic value" is any member of a type M(C1), for any type C1. For example, a list is a monadic value for the list monad. We can think of these monadic values as the result of applying some function (p : C1 &rarr; M(C1')) to an argument of type C1.
+       Usually written reversed:

+       `return b >>= gamma  =  gamma b`