anchor.diff:          (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)))
  
positive.code:              (&key          (entering-&key))
               (&rest         (process-&rest))
               (&optional     (entering-&optional))
               ((&whole &aux &allow-other-keys) (fail))
               (t             (process-required))))
           (process-required ()
             (unless args
               (done))
             (case (first args)
               (&key          (entering-&key))
               (&rest         (process-&rest))
               (&optional     (entering-&optional))
               ((&whole &allow-other-keys) (fail))
               (&aux          (entering-&aux))
               (t
  
negative.code:              (done))
             (case (first args)
               (&allow-other-keys       (funcall visitor '&allow-other-keys nil nil))
               ((&key &optional &whole &environment &body) (fail))
               (&aux                    (entering-&aux))
               (t
                (let ((arg (ensure-list (pop args))))
  