Exercise 2.73.  Section 2.3.2  described a program that performs 
symbolic differentiation:

(define (deriv exp var)
  (cond ((number? exp) 0)
        ((variable? exp) (if (same-variable? exp var) 1 0))
        ((sum? exp)
         (make-sum (deriv (addend exp) var)
                   (deriv (augend exp) var)))
        ((product? exp)
         (make-sum
           (make-product (multiplier exp)
                         (deriv (multiplicand exp) var))
           (make-product (deriv (multiplier exp) var)
                         (multiplicand exp))))
        <more rules can be added here>
        (else (error "unknown expression type -- DERIV" exp))))

We can regard this program as performing a dispatch on the type of the 
expression to be differentiated. In this situation the ``type tag'' of 
the datum is the algebraic operator symbol (such as +) and the operation 
being performed is deriv. We can transform this program into 
data-directed style by rewriting the basic derivative procedure as

(define (deriv exp var)
   (cond ((number? exp) 0)
         ((variable? exp) (if (same-variable? exp var) 1 0))
         (else ((get 'deriv (operator exp)) (operands exp)
                                            var))))
(define (operator exp) (car exp))
(define (operands exp) (cdr exp))

a.  Explain what was done above. Why can't we assimilate the predicates 
number? and same-variable? into the data-directed dispatch?

————————————————————————————————————————————————————————————————————————

The operator and operands procedures will fail on them, as they are not 
lists.



b.  Write the procedures for derivatives of sums and products, and the 
auxiliary code required to install them in the table used by the program 
above.

————————————————————————————————————————————————————————————————————————

(define (install-foo)
  (define (deriv-sum sum var)
    (make-sum (deriv (addend sum) var) -- see note
              (deriv (augend sum) var)))
  (define (deriv-prod prod var)
    (make-sum
      (make-product (multiplier prod)
                    (deriv (multiplicand prod) var))
      (make-product (deriv (multiplier prod) var)
                    (multiplicand prod))))
  (put 'deriv '(+) deriv-sum)
  (put 'deriv '(*) deriv-prod))

The selectors addend, etc would also need to be changed since they 
expect the operator to still be on the front of the list.



c.  Choose any additional differentiation rule that you like, such as 
the one for exponents (exercise 2.56), and install it in this 
data-directed system.

————————————————————————————————————————————————————————————————————————

(define (deriv-exp exp var)
  (let ((n (exponent exp))
        (u (base exp)))
    (make-product (make-product n (make-exponentiation u (- n 1)))
                  (deriv u var))))

(put 'deriv '(**) deriv-exp)



d.  In this simple algebraic manipulator the type of an expression is 
the algebraic operator that binds it together. Suppose, however, we 
indexed the procedures in the opposite way, so that the dispatch line in 
deriv looked like

((get (operator exp) 'deriv) (operands exp) var)

What corresponding changes to the derivative system are required?

————————————————————————————————————————————————————————————————————————

Um, the corresponding arguments to put would need to be flipped as well?

I guess I don't understand the point of this question.