lists-monad tweaks

[lambda.git] / list_monad_as_continuation_monad.mdwn

diff --git a/list_monad_as_continuation_monad.mdwn b/list_monad_as_continuation_monad.mdwn
index 0edec25..7a57ea7 100644 (file)
--- a/list_monad_as_continuation_monad.mdwn
+++ b/list_monad_as_continuation_monad.mdwn
@@ -88,7 +88,7 @@ need to posit a store `s` that we can apply `u` to.  Once we do so,
 however, we won't have an `'a`; we'll have a pair whose first element
 is an `'a`.  So we have to unpack the pair:
 
-       ... let (a, s') = u s in ... (f a) ...
+       ... let (a, s') = u s in ... f a ...
 
 Abstracting over the `s` and adjusting the types gives the result:
 
@@ -222,7 +222,7 @@ fold that function over its type `'a` members, and that's where we can get at th
 
        ... u (fun (a : 'a) (b : 'b) -> ... f a ... ) ...
 
-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)`:
+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`:
 
        ... u (fun (a : 'a) (b : 'b) -> ... f a k ... ) ...
 
@@ -276,7 +276,7 @@ So if, for example, we let `k` be `+` and `z` be `0`, then the computation would
        right-fold + and 2+4+2+4+8+0 over [2] = 2+(2+4+(2+4+8+(0))) ==>
        right-fold + and 2+2+4+2+4+8+0 over [] = 2+(2+4+(2+4+8+(0)))
 
-which indeed is the result of right-folding + and 0 over `[2; 2; 4; 2; 4; 8]`. If you trace through how this works, you should be able to persuade yourself that our formula:
+which indeed is the result of right-folding `+` and `0` over `[2; 2; 4; 2; 4; 8]`. If you trace through how this works, you should be able to persuade yourself that our formula:
 
        fun k z -> u (fun a b -> f a k b) z