ANNOUNCEMENTS

In part 2, III.1, you need to consider only the cases where the condition is #t and #f.
In part 2, II.1 and 2, make sure you can handle the case where the number of inputs is not 2. In the rest of the problem set (II.3 and V.1), you are allowed to handle only the binary cases. For your amusement, you can work on the more general cases, which are not difficult, but this is not required.
In constant folding, make sure that you don't do constant folding for expressions that don't return a value. An example would be :
```
(let ((x (/ 1 0))) x)
```
A good compiler would give a warning here, but you don't need to worry about that.
In ps6 part2, in constant folding booleans, you don't need to handle the cases for and and or.
In ps6 part1, section III, problem 5, regarding the "case" expression, you can further assume that the values v1,..., vn are integers. This is to make your life easier. However, if you are keen on using quotes, here is the part you need to add to the compiler. This is NOT required. Do it just for fun, if you want to.
```
;;; Do not recursively compile the sub-expressions of a quote
;;; expression.
(defmethod (ts:reduce-combination (operator = 'quote) exps)
  (if (= (length exps) 1)
    (cons 'quote exps)
    (ts:reducer-error (cons 'quote exps)
                       "malformed quote-expression")))
```
You will still need to add (quote e) to the interpreter.
The second part of the problem set regarding optimization is now due by 12/14/99.
There is a typo in question 1 for extending the interpreter. You need to solve the question for equal?, not equals?.
For question 1 for extending the interpreter, you HAVE TO extend the code you are given. That is the whole point of all of the questions in the problem set.
Assume that define's are always in the global expression, as was emphasized in the lecture throughout the semester.
In the compiler section, in problem 3, you don't need to do the part on (define ...), (let* ...) and (let...) . You have already done it in problem 1 and 2 and the compiler handles multiple bodies in let.
and and or are in the compiler part.