anchor.diff:  ;;;; * Entry point
   
   (defgeneric lisp1 (form)
  -  (:documentation "Translate FORM from Lisp-1 to Lisp-2"))
  +  (:documentation "Translate FORM from Lisp-1 to Lisp-2.
  +
  +Define methods on this generic function with DEFLISP1-WALKER."))
   
   (defmethod lisp1 (form)
  +  "If FORM isn't a FORM object, we'll convert it to one, apply
  +the transformation and convert it back."
     (unwalk-form (lisp1 (walk-form form))))
   
   (defmacro with-lisp1 (form)
  +  "Execute FORM as if it were run in a Lisp-1."
     (lisp1 form))
   
   (defmacro deflisp1-walker (class (&rest slots) &body body)
  +  "Define a Lisp-1 to Lisp-2 walker.
  +
  +It takes the class of a CL form object, and its slots as
  +arguments.  It also captures the variable FORM for convenience."
     `(defmethod lisp1 ((form ,class))
        (with-slots ,slots form
          ,@body)))
   
   ;;;; * Special Variables
   
  -(defvar *bound-vars* nil)
  +(defvar *bound-vars* nil
  +  "When walking code, this variable contains a list of
  +variables (represented by symbols) which have been bound.")
   
   ;;;; * Definers
   
   (defmacro defun1 (name (&rest args) &body body)
  +  "Define a function with BODY written in Lisp-1 style.
  +
  +This is just like DEFUN."
     (let1 *bound-vars*
         (append *bound-vars* (extract-argument-names args :allow-specializers nil))
       `(defun ,name ,args
          ,(lisp1 `(block ,name ,@body)))))
   
   (defmacro defmethod1 (name (&rest args) &body body)
  +  "Define a function with BODY written in Lisp-1 style.
  +
  +This is just like DEFMETHOD."
     (let1 *bound-vars*
         (append *bound-vars* (extract-argument-names args :allow-specializers t))
       `(defmethod ,name ,args
  
positive.code: ;;;; * Walkers
  
  (deflisp1-walker form ()
    form)
  
  (deflisp1-walker if-form (consequent then else)
    (new 'if-form
         :consequent (lisp1 consequent)
         :then       (lisp1 then)
         :else       (lisp1 else)))
  
  (deflisp1-walker lambda-function-form (arguments body)
    (let1 *bound-vars*
        (append (mapcar #'name arguments) *bound-vars*)
      (new 'lambda-function-form
  
negative.code: 
  (deflisp1-walker multiple-value-call-form (func arguments)
    (new 'multiple-value-call-form
         :func      (lisp1  func)
         :arguments (lisp1s arguments)))
  
  (deflisp1-walker multiple-value-prog1-form (first-form other-forms)
    (new 'multiple-value-prog1-form
         :first-form  (lisp1  first-form)
         :other-forms (lisp1s other-forms)))
  
  (deflisp1-walker symbol-macrolet-form (binds body)
  