@@ -1,5 +1,4 @@
<!-- λ Λ ∀ ≡ α β γ ρ ω Ω ○ μ η δ ζ ξ ⋆ ★ • ∙ ● 𝟎 𝟏 𝟐 𝟘 𝟙 𝟚 𝟬 𝟭 𝟮 -->
-<!-- Loved this one: http://www.stephendiehl.com/posts/monads.html -->

The [[tradition in the functional programming
@@ -209,7 +208,7 @@ has to obey the following Map Laws:
k >=> mid == k
mid >=> k == k

-    If you studied algebra, you'll remember that a mon*oid* is a universe with some associative operation that has an identity. For example, the natural numbers form a monoid with multiplication as the operation and `1` as the identity, or with addition as the operation and `0` as the identity. Strings form a monoid with concatenation as the operation and the empty string as the identity. (This example shows that the operation need not be commutative.) Monads are a kind of generalization of this notion, and that's why they're named as they are. The key difference is that for monads, the values being operated on need not be of the same type. They *can* be, if they're all Kleisli arrows of a single type <code>P -> <u>P</u></code>. But they needn't be. Their types only need to "cohere" in certain ways.
+    If you studied algebra, you'll remember that a mon*oid* is a universe with some associative operation that has an identity. For example, the natural numbers form a monoid with multiplication as the operation and `1` as the identity, or with addition as the operation and `0` as the identity. Strings form a monoid with concatenation as the operation and the empty string as the identity. (This example shows that the operation need not be commutative.) Monads are a kind of generalization of this notion, and that's why they're named as they are. The key difference is that for monads, the values being operated on need not be of the same type. They *can* be, if they're all Kleisli arrows of a single type <code>P -> <u>P</u></code>. But they needn't be. Their types only need to "cohere" in the sense that the output type of the one arrow is a boxing of the input type of the next.

In the Haskell manuals, they express the Monad Laws using `>>=` instead of the composition operators `>=>` or `<=<`. This looks similar, but doesn't have the same symmetry:

@@ -383,7 +382,7 @@ That can be helpful, but it only enables us to have _zero or one_ elements in th
| [] -> []
| x' :: xs' -> List.append (k x') (catmap f xs')

-Now we can have as many elements in the result for a given `α` as `k` cares to return. Another way to write `catmap k xs` is as `List.concat (map k xs)`. And this is just the definition of `mbind` or `>>=` for the List Monad. The definition of `mcomp` or `<=<`, that we gave above, differs only in that it's the way to compose two functions `j` and `k`, that you'd want to `catmap`, rather than the way to `catmap` one of those functions over a value that's already a list.
+Now we can have as many elements in the result for a given `α` as `k` cares to return. Another way to write `catmap k xs` is as (Haskell) `concat (map k cs)` or (OCaml) `List.flatten (List.map k xs)`. And this is just the definition of `mbind` or `>>=` for the List Monad. The definition of `mcomp` or `<=<`, that we gave above, differs only in that it's the way to compose two functions `j` and `k`, that you'd want to `catmap`, rather than the way to `catmap` one of those functions over a value that's already a list.

This example is a good intuitive basis for thinking about the notions of `mbind` and `mcomp` more generally. Thus `mbind` for the option/Maybe type takes an option value, applies `k` to its element (if there is one), and returns the resulting option value. `mbind` for a tree with `α`-labeled leaves would apply `k` to each of the leaves, and return a tree containing arbitrarily large subtrees in place of all its former leaves, depending on what `k` returned.

@@ -392,12 +391,15 @@ This example is a good intuitive basis for thinking about the notions of `mbind`

Some a  >>=<sub>α option</sub>  (\a -> Some 0) ==> Some 0
None    >>=<sub>α option</sub>  (\a -> Some 0) ==> None
-
-    .                                                   _____
-   / \                                  .              /     \
-  .   3       >>=<sub>(α,unit) tree</sub>  (\a ->  / \  )  ==>   _/_      .
- / \                                  a   a         /   \    / \
-1   2                                              .     .  3   3
+      Some a  >>=<sub>α option</sub>  (\a -> None  ) ==> None
+
+                                                         .
+                                                        / \
+    .                                                  /   \
+   / \                                  .             .     \
+  .   3       >>=<sub>(α,unit) tree</sub>  (\a ->  / \  )  ==>   / \     .
+ / \                                  a   a         /   \   / \
+1   2                                              .     . 3   3
/ \   / \
1   1 2   2
</pre>
@@ -435,7 +437,9 @@ As we mentioned above, the notions of Monads have their origin in Category Theor
(http://en.wikipedia.org/wiki/Outline_of_category_theory)