The code for this section is in Scheme.

Exercise 2.77

When represented in Scheme notation, the expression in figure 2.24 is:

(cons 'complex (cons 'rectangular (cons 3 4)))
(complex rectangular 3 . 4)

When Louis tries to evaluate (magnitude z), what is actually called is: (apply-generic 'magnitude z). apply-generic looks in the table of operations trying to find the operation magnitude for z.

Here’s apply-generic again:

(define (apply-generic op . args)
  (let ((type-tags (map type-tag args)))
    (let ((proc (get op type-tags)))
      (if proc
          (apply proc (map contents args))
            "No method for these types -- APPLY-GENERIC" 
            (list op type-tags))))))

It examines the tag of z and finds that it’s (complex) (the type-tag function just takes the car as the type tag). However, no magnitude operation is registered for this type, hence the error. The operations Alyssa proposes:

(put 'real-part '(complex) real-part)
(put 'imag-part '(complex) imag-part)
(put 'magnitude '(complex) magnitude)
(put 'angle '(complex) angle)

Place magnitude and other selectors for type (complex) into the table – which makes it work as expected.

apply-generic is invoked twice in the process – first dispatching to the magnitude of (complex) (which is what calls apply-generic the second time) and second to the magnitude of (rectangular).

Exercise 2.78

(define (attach-tag type-tag contents)
  (if (number? contents)
    (cons type-tag contents)))

(define (type-tag datum)
  (cond ((number? datum) 'scheme-number)
        ((pair? datum) (car datum))
          (error "Bad tagged datum -- TYPE-TAG" datum))))

(define (contents datum)
  (cond ((number? datum) datum)
        ((pair? datum) (cdr datum))
          (error "Bad tagged datum -- TYPE-TAG" datum))))

This code demonstrates one of the sad facts of life in programming – you often have to break your abstraction barriers for the sake of efficiency. All languages do it, and Lisp / Scheme is no different. It’s a pity that having built such a pretty, orthogonal arithmetic package, we now have to brutally slice into the generic functions that make it possible and add special cases for special values.

Now we can write simpler code for working with numbers:

(print (add 5 19))

Exercise 2.79

(define (equ? x y) (apply-generic 'equ? x y))

;; Add into install-scheme-number-package
  (put 'equ? '(scheme-number scheme-number)
    (lambda (x y) (= x y)))

;; Add into install-rational-package
  (define (equal-rat? x y)
      (= (numer x) (numer y))
      (= (denom x) (denom y))))

  (put 'equ? '(rational rational)
    (lambda (x y) (equal-rat? x y)))

;; Add into install-complex-package
  (define (equal-complex? z1 z2)
      (= (real-part z1) (real-part z2))
      (= (imag-part z1) (imag-part z2))))

  (put 'equ? '(complex complex)
      (lambda (z1 z2) (equal-complex? z1 z2)))

Note that the results of the functions placed into the table for equ? are not tagged. This is because the result of the equality operator is boolean.

Exercise 2.80

(define (=zero? x) (apply-generic '=zero? x))

;; Add into install-scheme-number-package
  (put '=zero? '(scheme-number)
    (lambda (x) (= x 0)))

;; Add into install-rational-package
  (put '=zero? '(rational)
    (lambda (x) (= (numer x) 0)))

;; Add into install-complex-package
  (put '=zero? '(complex)
    (lambda (z) 
      (and  (= (real-part z) 0)
            (= (imag-part z) 0))))