anchor.diff:               (&key          (entering-&key))
                (&rest         (process-&rest))
                (&optional     (entering-&optional))
  +             (&body         (process-&body))
  +             (&environment  (process-&environment))
                ((&whole &aux &allow-other-keys) (fail))
                (t             (process-required))))
  -         (process-required ()
  -           (unless args
  -             (done))
  +         (process-&body ()
  +           (assert (eq (first args) '&body))
  +           (pop args)
  +           (unless macro
  +             (fail))
  +           (let ((body (pop args)))
  +             (unless (null args)
  +               (fail))
  +             (unless body
  +               (fail))
  +             (funcall visitor '&body body body)))
  +         (process-&environment ()
  +           (assert (eq (first args) '&environment))
  +           (pop args)
  +           (unless macro
  +             (fail))
  +           (let ((env (pop args)))
  +             (unless env
  +               (fail))
  +             (funcall visitor '&environment env env))
              (case (first args)
                (&key          (entering-&key))
                (&rest         (process-&rest))
                (&optional     (entering-&optional))
  +             (&body         (process-&body))
  +             (&aux          (process-&aux))
  +             ((&whole &environment &allow-other-keys) (fail))
  +             (t             (process-required))))
  +         (process-required ()
  +           (unless args
  +             (done))
  +           (case (first args)
  +             (&key          (entering-&key))
  +             (&rest         (process-&rest))
  +             (&optional     (entering-&optional))
  +             (&body         (process-&body))
  +             (&environment  (process-&environment))
                ((&whole &allow-other-keys) (fail))
                (&aux          (entering-&aux))
                (t
  
positive.code:              (done))
             (case (first args)
               (&allow-other-keys       (funcall visitor '&allow-other-keys nil nil))
               ((&key &optional &whole) (fail))
               (&aux                    (entering-&aux))
               (t
                (let ((arg (ensure-list (pop args))))
  
negative.code:         (case (first args)
            (&whole (process-&whole))
            (t      (process-required)))))))
  
  (defun lambda-list-to-variable-name-list (args &key macro include-specials)
    (let ((result (list))
          (rest-variable-name nil)
          (whole-variable-name nil)
          (env-variable-name nil))
      (parse-lambda-list args
                         (lambda (kind name entry)
                           (declare (ignore entry))
                           (case kind
                             (&allow-other-keys )
                             (&environment      (setf env-variable-name name)
                                                (when include-specials
                                                  (push name result)))
                             (&whole            (setf whole-variable-name name)
                                                (when include-specials
                                                  (push name result)))
                             ((&rest &body)     (setf rest-variable-name name)
                                                (when include-specials
                                                  (push name result)))
                             (t                 (push name result))))
                         :macro macro)
      (values (nreverse result)
              rest-variable-name
              whole-variable-name
              env-variable-name)))
  