+ fun k -> u (fun a b -> f a k b)
+
+That is a function of the right type for our bind, but to check whether it works, we have to verify it (with the unit we chose) against the monad laws, and reason whether it will have the right behavior.
+
+Here's a way to persuade yourself that it will have the right behavior. First, it will be handy to eta-expand our `fun k -> u (fun a b -> f a k b)` to:
+
+ fun k z -> u (fun a b -> f a k b) z
+
+Now let's think about what this does. It's a wrapper around `u`. In order to behave as the list which is the result of mapping `f` over each element of `u`, and then joining (`concat`ing) the results, this wrapper would have to accept arguments `k` and `z` and fold them in just the same way that the list which is the result of mapping `f` and then joining the results would fold them. Will it?
+
+Suppose we have a list' whose contents are `[1; 2; 4; 8]`---that is, our list' will be `fun f z -> f 1 (f 2 (f 4 (f 8 z)))`. We call that list' `u`. Suppose we also have a function `f` that for each `int` we give it, gives back a list of the divisors of that `int` that are greater than 1. Intuitively, then, binding `u` to `f` should give us:
+
+ concat (map f u) =
+ concat [[]; [2]; [2; 4]; [2; 4; 8]] =
+ [2; 2; 4; 2; 4; 8]
+
+Or rather, it should give us a list' version of that, which takes a function `k` and value `z` as arguments, and returns the right fold of `k` and `z` over those elements. What does our formula
+
+ fun k z -> u (fun a b -> f a k b) z
+
+do? Well, for each element `a` in `u`, it applies `f` to that `a`, getting one of the lists:
+
+ []
+ [2]
+ [2; 4]
+ [2; 4; 8]