anchor.diff:  
   (deflisp1-walker lambda-function-form (arguments body)
     ;; For any function-form (ie lambda), we just transform the body.
  -  ;; We also must add the parameters to the list of bound variables.
  -  (let1 *bound-vars*
  -      (append (mapcar #'name arguments) *bound-vars*)
  +  ;; We also must add the parameters to the variable namespace, and
  +  ;; remove the parameters from the function namespace.
  +  (with-vars-bound (mapcar #'name arguments)
       (new 'lambda-function-form
   	 :arguments arguments
   	 :body      (lisp1s body))))
   
  -(deflisp1-walker free-variable-reference (name)
  +(deflisp1-walker variable-reference (name)
     ;; If a free variable is bound in the toplevel, *and* not bound by
  -  ;; an enclosing lambda, then we'll return that function.  We take
  -  ;; advantage of the fact that the `name' slot is shared.
  -  (if (and (fboundp name) (not (member name *bound-vars*)))
  +  ;; an enclosing lambda, then we'll return that function.  Also, if
  +  ;; the variable has been bound by an enclosing function binding form
  +  ;; then we'll return that function.  We take advantage of the fact
  +  ;; that the `name' slot is shared.
  +  (if (or (and (fboundp name) (not (member name *vars-bound*)))
  +	  (member name *funs-bound*))
         (change-class form 'free-function-object-form)
         form))
   
  
positive.code: 			(lisp1s arguments))))
  
  (deflisp1-walker function-binding-form (binds body)
    (new (class-name-of form)
         :binds (lisp1b binds)
         :body  (lisp1s body)))
  
  (deflisp1-walker variable-binding-form (binds body)
    (new (class-name-of form)
         :binds (lisp1b binds)
         :body  (lisp1s body)))
  
  (deflisp1-walker setq-form (var value)
    (new 'setq-form
  
negative.code:   "Define a function with BODY written in Lisp-1 style.
  
  This is just like DEFUN."
    (with-vars-bound (extract-argument-names args :allow-specializers nil)
      `(defun ,name ,args
         ,(lisp1 `(block ,name ,@body)))))
  
  (defmacro defmethod1 (name (&rest args) &body body)
    "Define a method with BODY written in Lisp-1 style.
  
  This is just like DEFMETHOD."
    (with-vars-bound (extract-argument-names args :allow-specializers t)
      `(defmethod ,name ,args
         ,(lisp1 `(block ,name ,@body)))))
  
  