anchor.diff:                        (nthcdr 3 -form-) -environment-)))
   
   (def unwalker function-definition-form (form name arguments body declares)
  -  `(defun ,name ,(unwalk-lambda-list arguments) 
  +  `(defun ,name ,(unwalk-ordinary-lambda-list arguments)
        ,@(unwalk-declarations declares)
        ,@(recurse-on-body body)))
   
  
positive.code: 
  (def layered-function walk-lambda-like (ast-node args body env)
    (:method (ast-node args body env)
      (setf (values (arguments-of ast-node) env) (walk-lambda-list args ast-node env))
      (walk-implict-progn ast-node body env :declare t)
      ast-node))
  
  (defun walk-lambda-list (lambda-list parent env &key allow-specializers macro-p)
    (declare (ignore macro-p))
    (let ((result (list)))
      (flet ((extend-env (argument)
               (unless (typep argument 'allow-other-keys-function-argument-form)
                 (augment-walkenv! env :variable (name-of argument) argument))))
        (parse-lambda-list lambda-list
                           (lambda (kind name argument)
                             (declare (ignore name))
                             (let ((parsed
                                    (case kind
                                      ((nil)
                                       (if allow-specializers
                                           (walk-specialized-argument-form argument parent env)
                                           (make-form-object 'required-function-argument-form  parent
                                                             :name argument)))
                                      (&optional
                                       (walk-optional-argument argument parent env))
                                      (&allow-other-keys
                                       (make-form-object 'allow-other-keys-function-argument-form parent))
                                      (&rest (make-form-object 'rest-function-argument-form parent :name argument))
                                      (&key
                                       (walk-keyword-argument argument parent env)))))
                               (when parsed
                                 (push parsed result)
                                 (extend-env parsed)))))
        (values (nreverse result) env))))
  
  (def (class* e) function-argument-form (walked-form)
    ((name)))
  
negative.code:   ((arguments)))
  
  (def unwalker lambda-function-form (arguments body declares)
    `#'(lambda ,(unwalk-ordinary-lambda-list arguments)
         ,@(unwalk-declarations declares)
         ,@(recurse-on-body body)))
  
  