66 And we're done. This gives us a bind function of the right type. We can then check whether, in combination with the unit function we chose, it satisfies the monad laws, and behaves in the way we intend. And it does.

225 In order for `u` to have the kind of argument it needs, the `fun a b -> ... f a ...` has to have type `'a -> 'b -> 'b`; so the `... f a ...` has to evaluate to a result of type `'b`. The easiest way to do this is to collapse (or "unify") the types `'b` and `'d`, with the result that `f a` will have type `('c -> 'b -> 'b) -> 'b -> 'b`. Let's postulate an argument `k` of type `('c -> 'b -> 'b)` and supply it to `f a`:

244 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.

250 Now let's think about what this does. It's a wrapper around `u`. In order to behave as the list `v` 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 `v` would.

253 Suppose we have a list' whose contents are `[1; 2; 4; 8]`---that is, our list' `u` will be `fun f z -> f 1 (f 2 (f 4 (f 8 z)))`. 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:

271 (or rather, their list' versions). Then it takes the accumulated result `b` of previous steps in the `k`,`z`-fold, and it folds `k` and `b` over the list generated by `f a`. The result of doing so is passed on to the next step of the `k`,`z`-fold as the new accumulated result `b`.

370 Consider the most eta-reduced versions of `l'_unit` and `l'_bind`. They're the same as the unit and bind for the Montague Continuation monad! In other words, the behavior of our v3-List monad and the behavior of the continuations monad are