1. Review Section 2.2 on list primitives and S-expression literals
    and say what is the value of each of the expressions below.
    If a run-time error would occur, please say so.

    ````
    (car '(a b 1 2))  
    (cdr '(a b 1 2))  
    (= 'a 'b)         
    ````

    To write your answers, use S-expression literals. For example:
    ````
    '(a b c)
    #t
    17
    'b
    ````

 2. Review the first few pages of Section 2.3, through the end of
    Section 2.3.2.  Which of the following expressions evaluate to
    `#t` for every *list* `xs`?

    ````
    (=      (reverse (reverse xs)) xs)
    (equal? (reverse (reverse xs)) xs)
    ````

    (a) Only the first
    (b) Only the second
    (c) Both the first and the second
    (d) None

 3. Read Section 2.3.2, then please explain in your own words the
    difference between `simple-reverse` and `reverse`.

 4. Review the first part of Section 2.4, up to 2.4.4, and
    discover a new algebraic law that applies to some combination
    of `append` and `length`. Write your law in the style of section
    2.4.4.  Like the other list laws in that section, your law must
    mention a variable `xs`, which must be allowed to be any arbitrary
    list.

 5. Imagine you are tasked with translating the following C function
    into $\mu$Scheme:

    ````
    bool parity(int m) {
      int half_m = m / 2;
      int other_half = m - half_m;
      return half_m == other_half;
    }      
    ````

    Review Section 2.5, and answer each of these questions
    with "yes" or "no."

      (a) Is it sensible to bind `half_m` and `other_half` in the same
          `let` expression?
      (b) Is it sensible to bind `half_m` and `other_half` in the same
          `let*` expression?