anchor.diff:  ;; (defgeneric compile-expression (form values successors))
   
   ;; ;;; factor the duplicated code
  -;; (defmethod compile-expression ((form constant-form) values successors)
  +;; (defmethod compile-expression ((form constant-ast) values successors)
   ;;   (if (null values)
   ;;       (warn "constant form compiled in a context where its value is not needed")
   ;;       (let ((succ successors))
  
positive.code: 
  ;;; Search an ast to see whether its original form is eq to the ast
  (defun search-ast (form ast)
    (cond ((eq form (original-form ast))
  	 ast)
  	((typep ast 'compound-form)
  	 (some (lambda (subform)
  		 (search-ast form subform))
  	       (subforms ast)))
  	(t nil)))
  
  ;;; Create a new ast from the form by either finding
  
negative.code: ;;;
  ;;; Internal representation of source code
  
  ;;; Terminology: We use `form' to mean raw Lisp expressions
  ;;; resulting from READing source code.  We use `ast'  for
  ;;; the abstract syntax tree resulting from converting such
  ;;; raw expressions to instances of our compiler objects. 
  
  ;;; The first step is to convert the raw Lisp form into an 
  ;;; abstract syntax tree, so that we can then use generic
  ;;; function dispatch for the following steps. 
  
  (defclass ast (compiler-object)
    ((%form :initarg :form :accessor form)))
  
  (defclass symbol-ast (ast) ())  
  
  (defclass constant-ast (ast) ())
  
  (defclass compound-ast (ast)
    ((%children :initarg :children :reader children)))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  