`λx`

as `\x`.
1. `(\x \y. y x) z`
2. `(\x (x x)) z`
3. `(\x (\x x)) z`
4. `(\x (\z x)) z`
5. `(\x (x (\y y))) (\z (z z))`
6. `(\x (x x)) (\x (x x))`
7. `(\x (x x x)) (\x (x x x))`
Booleans
--------
Recall our definitions of true and false.
> **true** is defined to be `\t \f. t`
> **false** is defined to be `\t \f. f`
In Racket, these can be defined like this:
(define true (lambda (t) (lambda (f) t)))
(define false (lambda (t) (lambda (f) f)))
- Define a `neg` operator that negates `true` and `false`. Expected behavior: (((neg true) 10) 20) evaluates to 20, and (((neg false) 10) 20) evaluates to 10.
- Define an `and` operator.
- Define an `xor` operator. 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
- 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: the-value if-black if-white (where `if-black` and `if-white` are anything), and get back one of `if-black` or `if-white`, depending on which of the black-or-white values we started with. Give a definition for each of `black` and `white`. (Do it in both lambda calculus and also in Racket.)
- 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.)

- Define a `swap` function that reverses the elements of a pair. Expected behavior: (define p ((make-pair 10) 20)) ((p swap) get-first) ; evaluates to 20 ((p swap) get-second) ; evaluates to 10 Write out the definition of `swap` in Racket.
- Define a `dup` function that duplicates its argument to form a pair whose elements are the same. Expected behavior: ((dup 10) get-first) ; evaluates to 10 ((dup 10) get-second) ; evaluates to 10
- Define a `sixteen` function that makes sixteen copies of its argument (and stores them in a data structure of your choice).
- Inspired by our definition of ordered pairs, propose a data structure capable of representing ordered triples. That is, (((make-triple M) N) P) should return an object that behaves in a reasonable way to serve as a triple. In addition to defining the `make-triple` function, you have to show how to extract elements of your triple. Write a `get-first-of-triple` function, that does for triples what `get-first` does for pairs. Also write `get-second-of-triple` and `get-third-of-triple` functions.
- Write a function `second-plus-third` that when given to your triple, returns the result of adding the second and third members of the triple. You can help yourself to the following definition: (define add (lambda (x) (lambda (y) (+ x y))))