X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=exercises%2Fassignment3_answers.mdwn;h=08375b6986cb512ab7bfb0998019a6ee9b5fa4e2;hp=781649ce504096c76f81ad7a6745eb535c26256b;hb=c55a7320fe75884e8fda7f7785b68194ac9554b5;hpb=422bf1f49096fad4e372d80b7bab3432e4165d60

diff --git a/exercises/assignment3_answers.mdwn b/exercises/assignment3_answers.mdwn
index 781649ce..08375b69 100644
--- a/exercises/assignment3_answers.mdwn
+++ b/exercises/assignment3_answers.mdwn
@@ -119,17 +119,18 @@
 
     > Here is another solution, due to Martin Bunder and F. Urbanek:
 
-    >     let pred = \n. \s z. n (\u v. v (u s)) (K z) I in
+    >     let box = \a. \v. v a in
+    >     let pred = \n. \s z. n (\b. box (b s)) (K z) I in
     >     ...
 
-    > That can be hard to wrap your head around. If you trace it through, you'll see that:
+    > That can be hard to wrap your head around. If you trace this expression through, you'll see that:
 
-    > * when `n == 0`, it reduces to `\s z. (\v. z) I`, or `\s z. z`
-    > * when `n == 1`, it reduces to `\s z. (\v. v z) I`, or `\s z. z`
-    > * when `n == 2`, it reduces to `\s z. (\v. v (s z)) I`, or `\s z. s z`
-    > * when `n == 3`, it reduces to `\s z. (\v. v (s (s z))) I`, or `\s z. s (s z)`
+    > * when `n == 0`, it reduces to `\s z. (K z) I`, or `\s z. z`
+    > * when `n == 1`, it reduces to `\s z. (box z) I`, or `\s z. z`
+    > * when `n == 2`, it reduces to `\s z. (box (s z)) I`, or `\s z. s z`
+    > * when `n == 3`, it reduces to `\s z. (box (s (s z))) I`, or `\s z. s (s z)`
 
-    > The technique used here is akin to that used in [[the hint for last week's `reverse`|assignment2_answers#cps-reverse]].
+    > `box a` is `\v. v a`; this stands to `pair a b` as one stands to two. Since boxes (like pairs) are really just functions, the technique used in this definition of `pred` is akin to that used in [[the hint for last week's `reverse`|assignment2_answers#cps-reverse]].
 
     (Want a further challenge? Define `map2` in the Lambda Calculus, using our right-fold encoding for lists, where `map2 g [a, b, c] [d, e, f]` should evaluate to `[g a d, g b e, g c f]`. Doing this will require drawing on a number of different tools we've developed, including that same strategy for defining `tail`. Purely extra credit.)
 
@@ -167,7 +168,7 @@ where `one` abbreviates `succ zero`, and `two` abbreviates `succ (succ zero)`.
     >      let leq? = \l r. zero? (sub l r) in
     >      ...
 
-    > Here is another solution. Jim crafted this particular implementation, but like a great deal of the CS knowledge he's gained over the past eight years, Oleg Kiselyov pointed the way.
+    > Here is another solution. Jim crafted this particular implementation, but like a great deal of the CS knowledge he's gained over the past eight years, Oleg Kiselyov pointed the way. <!-- see "lambda-calc-opposites.txt" at http://okmij.org/ftp/Computation/lambda-calc.html#neg -->
 
     >     let leq? = (\base build consume. \l r. r consume (l build base) fst)
     >             ; where base is