From 718358bbaf75c965308de98e0bd527242e37855a Mon Sep 17 00:00:00 2001
From: jim
Date: Sat, 14 Feb 2015 12:43:34 0500
Subject: [PATCH] Move map2 question

exercises/assignment3.mdwn  7 ++++
1 file changed, 4 insertions(+), 3 deletions()
diff git a/exercises/assignment3.mdwn b/exercises/assignment3.mdwn
index a6d31730..f80fe71c 100644
 a/exercises/assignment3.mdwn
+++ b/exercises/assignment3.mdwn
@@ 18,9 +18,6 @@
8. Suppose you have two lists of integers, `left` and `right`. You want to determine whether those lists are equal, that is, whether they have all the same members in the same order. How would you implement such a list comparison? You can write it in Scheme or Kapulet using `letrec`, or if you want more of a challenge, in the Lambda Calculus using your preferred encoding for lists. If you write it in Scheme, don't rely on applying the builtin comparison operator `equal?` to the lists themselves. (Nor on the operator `eqv?`, which might not do what you expect.) You can however rely on the comparison operator `=` which accepts only number arguments. If you write it in the Lambda Calculus, you can use your implementation of `leq`, requested below, to write an equality operator for Churchencoded numbers. [[Here is a hintassignment3 hint3]], if you need it.
(Want a further challenge? Define `map2` in the Lambda Calculus, using our rightfold 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 the strategy discussed this week for defining `tail`. Purely extra credit.)


## Numbers
@@ 28,6 +25,10 @@
10. In last week's homework, you gave a Lambda Calculus definition of `succ` for Churchencoded numbers. Can you now define `pred`? Let `pred 0` result in whatever `err` is bound to. This is challenging. For some time theorists weren't sure it could be done. (Here is [some interesting commentary](http://okmij.org/ftp/Computation/lambdacalc.html#predecessor).) However, in this week's notes we examined one strategy for defining `tail` for our chosen encodings of lists, and given the similarities we explained between lists and numbers, perhaps that will give you some guidance in defining `pred` for numbers.
+ (Want a further challenge? Define `map2` in the Lambda Calculus, using our rightfold 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.)
+
+
+
11. Define `leq` for numbers (that is, ≤) in the Lambda Calculus. Here is the expected behavior,
where `one` abbreviates `succ zero`, and `two` abbreviates `succ (succ zero)`.

2.11.0