(define true (lambda (t) (lambda (f) t)))
(define false (lambda (t) (lambda (f) f)))
- [8] Define a "neg" operator that negates "true" and "false".
+* Define a "neg" operator that negates "true" and "false".
+
Expected behavior:
- (((neg true) 10) 20)
+ (((neg true) 10) 20)
evaluates to 20, and
- (((neg false) 10) 20)
+ (((neg false) 10) 20)
evaluates to 10.
- [9] Define an "and" operator.
+* Define an "and" operator.
+
+* Define an "xor" operator.
- [10] Define an "xor" operator. (If you haven't seen this term before, here's a truth table:
+(If you haven't seen this term before, here's a truth table:
- true xor true = false
- true xor false = true
- false xor true = true
- false xor false = false
+ true xor true = false
+ true xor false = true
+ false xor true = true
+ false xor false = false
)
- 11. Inspired by our definition of boolean values, propose a data structure
-capable of representing one of the two values "black" or "white". If we have
+* Inspired by our definition of boolean values, propose a data structure
+capable of representing one of the two values "black" or "white".
+If we have
one of those values, call it a black-or-white-value, we should be able to
write:
a definition for each of "black" and "white". (Do it in both lambda calculus
and also in Racket.)
-12. Now propose a data structure capable of representing one of the three values
+* Now propose a data structure capable of representing one of the three values
"red" "green" or "blue," based on the same model. (Do it in both lambda
calculus and also in Racket.)
Here are some defintions in Racket:
(define make-pair (lambda (fst) (lambda (snd) (lambda (f) ((f fst) snd)))))
- (define get-first (lamda (fst) (lambda (snd) fst)))
- (define get-second (lamda (fst) (lambda (snd) snd)))
+ (define get-first (lambda (fst) (lambda (snd) fst)))
+ (define get-second (lambda (fst) (lambda (snd) snd)))
Now we can write: