anchor.diff:                                   :keywords-list (coherent-lambda-list-keywords-list raw-keywords-list)
                                    :mapper (lambda (parent)
                                              (make-instance 'standard-effective-lambda-list-keyword
  +                                                          :name (defsys:name parent)
                                                             :parent parent)))))
             (when (and recurse-p
                        (not (typep recurse '(or null fcll:lambda-list-kind))))
  
positive.code:                                                         mapped-lambda-list-keywords-list)
    ())
  
  (defclass effective-lambda-list-keyword (fcll:lambda-list-keyword)
    ())
  
  (defclass standard-effective-lambda-list-keyword (fcll:standard-lambda-list-keyword
                                                    effective-lambda-list-keyword)
    ()
    (:metaclass standard-inheritable-slots-class))
  
  (defun %make-list-processor-maker (recurse args)
  
negative.code:              (format stream "The following lambda list keywords conflict:~%~S"
                       (lambda-list-keywords condition)))))
  
  (defun %make-keyword-processor-maker (lambda-list-keyword backtrackp)
    (let ((inner
           (let ((parser (parser lambda-list-keyword)))
             (if backtrackp
                 (lambda (tail)
                   (let ((new-tail (funcall parser tail)))
                     (values new-tail (not (eq new-tail tail)))))
                 parser))))
      ;; TODO: Optimize according to lambda list keyword order.
      (let* ((conflicts-with (conflicts-with lambda-list-keyword))
             (inner (if conflicts-with
                        ;; TODO: Don't parse introducer twice.
                        (let ((introducer (introducer lambda-list-keyword)))
                          (%make-introducer-parser
                           introducer
                           (lambda (tail)
                             (let ((conflicts (remove-if-not (lambda (lambda-list-keyword)
                                                               (member lambda-list-keyword
                                                                       conflicts-with
                                                                       :test #'eq))
                                                             *sections*
                                                             :key #'fcll:lambda-list-keyword)))
                               (if conflicts
                                   (%malformed-lambda-list 'fcll:lambda-list-keywords-conflict
                                                           :lambda-list-keywords conflicts)
                                   (funcall inner (cons introducer tail)))))))
                        inner)))
        (lambda ()
          inner))))
  
  ;;; ↑ WORST. CODE. EVER! ↓
  
  (defun %make-parser (keywords-list parse-recursable-variable)
    (labels ((recurse (spec &optional backtrackp)
               (etypecase spec
                 (cons (destructuring-bind (operator &rest args) spec
                         (check-type args cons)
                         (ecase operator
                           (list (%make-list-processor-maker #'recurse args))
                           (or (%make-or-processor-maker #'recurse args)))))
                 (fcll:lambda-list-keyword
                  (%make-keyword-processor-maker spec backtrackp)))))
      (let ((parser-maker (recurse (tree (keyword-order keywords-list)))))
        (lambda (tail)
          (let ((*sections* nil)
                (*%malformed-lambda-list*
                 (lambda (error-type &rest args)
                   (apply #'error error-type
                          :root-lambda-list *root-lambda-list*
                          :specification tail
                          args))))
            (multiple-value-bind (new-tail donep)
                (let* ((parser (funcall parser-maker))
                       (*parse-recursable-variable* parse-recursable-variable))
                  (funcall parser tail))
              (let ((sections (nreverse *sections*)))
                (if new-tail
                    (%malformed-lambda-list 'simple-malformed-lambda-list-error
                                            :tail new-tail
                                            :format-control "Could not completely parse lambda list.~@
                                                             donep: ~S~%sections: ~S"
                                            :format-arguments (list donep sections))
                    sections))))))))
  
  (defmethod shared-initialize :around ((kind fcll:standard-lambda-list-kind) slot-names
                                        &rest initargs &key
  