anchor.diff:  
   ;; -----
   
  +#|
  +
  +Ed. NB: The following was defined originally in an effort to provide a
  +complete semantic model for lambda list expressions. It had provided, in
  +version one, a preliminary support for the subset of labmda list syntax
  +as supported in standard generic functions.
  +
  +The API is still in revision. Though it may lastly resemble not much
  +more than a specially typed list-like API, but perhaps it may serve to
  +be of some use in application support.
  +
  +|#
  +
   (eval-when (:compile-toplevel :execute)
     (defmacro lform (val)
  -    `(load-time-value ,val :constant t))
  -  )
  -
  -(defstruct (param
  +    `(load-time-value ,val t)))
  +
  +
  +(defstruct (lambda-element
                (:constructor))
     (name
      (lform (make-symbol "Unbound Name"))
      :type symbol
  -   :read-only t)
  -  #+NEXT_CHANGE
  +   :read-only t))
  +
  +
  +(defstruct (lambda-keyword
  +             (:include lambda-element)
  +             (:constructor
  +              make-lambda-keyword (name))))
  +
  +(defstruct (param
  +             (:include lambda-element)
  +             (:constructor))
     (next
      nil ;; indicating, in effect, "End of lambda list"
      :type (or param null)
  -   ;; NB: Not defined as read-only, due to how PARAM subclases are
  -   ;; initialized within COMPUTE-LAMBDA-SIGNATURE
  +   ;; NB: Theoretically, COMPUTE-LAMBDA-SIGNATURE could be updated to
  +   ;; allow for this slot to be defined as not read-only. It's been
  +   ;; defined as being not read-only, due to how PARAM subclases
  +   ;; will be initialized sequentially, within
  +   ;; COMPUTE-LAMBDA-SIGNATURE.
  +   ;l
  +   ;; As to why this slot is not defined as read-only, remarks in
  +   ;; the source form of COMPUTE-LAMBDA-SIGNATURE may serve to detail
  +   ;; that decision.
      ;;
  -   ;; If any application modifies the value of this slot once it's
  -   ;; bound, the behaviors will be unspecified for any procedure
  -   ;; unparsing a lambda list from any containing LAMBDA-SIGNATURE.
  +   ;; If any application destructively modifies the value of this slot,
  +   ;; in any procedure external to COMPUTE-LAMBDA-SIGNATURE, the
  +   ;; behaviors will be unspecified for any later procedures operating
  +   ;; as to unparse a lambda list from any LAMBDA-SIGNATURE containing
  +   ;; such a modified PARAM.
  +   ;;
  +   ;; NB: Together with the FIRST-PARAM slot of LABMDA-SIGNATURE, these
  +   ;; data structures provide an interface not entirely unlike Lisp LIST
  +   ;; objects, insofar as for LIST CAR and CDR accessors. Somewhat
  +   ;; unlike CDR, however, the PARAM-NEXT accessor returns a PARAM
  +   ;; object, as whenever it does not return NIL.
  +   ;;
  +   ;; One might consider that this may be fairly trivial, for any data
  +   ;; sturctures that may be defined initially as being singularly
  +   ;; linked.
      :read-only nil)
     )
  +
  +;; FIXME: Although this API might be expanded beyond any point of
  +;; obvious utility, there may be support provided for storage of the
  +;; actual lambda list keywords symbols within the effective sequence of
  +;; PARAM-NEXT values. Otherwise, it may be impossible to maintain an
  +;; accurate, parsed representation of such as:
  +;; - &KEY without any subsequent keyword parameters
  +;; - &OPTIONAL without any subsequent optional parameters
  +;;
  +;; Furthermore, such an addition should serve to simplify the unparsing.
  +;;
  +;; Albeit, this API then would provide  something very much like lambda
  +;; lists in a list format, albeit with some additional semantic
  +;; properties stored for any later application.
   
   
   (defstruct (initialized-param
  
positive.code: 
  
  (declaim (ftype (function
                   (list #+TBD &optional #+TBD function)
                   (values lambda-signature &optional))
                  compute-lambda-signature))
  
  (defun compute-lambda-signature (lambda-list
                                   #+TBD &optional #+TBD other-handler)
    ;;
    ;; NB: OTHER-HANDLER - if provided, a function accepting TBD arguments,
    ;; at the least:
    ;;
    ;; - a lambda-list keyword symbol, or a symbol or list type PARAM
    ;;   expression -- namely, as not "otherwise handled", below.
  
negative.code: 
                 (dolist (c (class-precedence-list cls))
                   (let ((known known))
                     (while (progn
                              #+DEBUG (warn "ITERATE ~D ~D ~D" specializer-offset depth (length known))
                              known)
                       ;; (warn "ITERATE w/ KNOWN ~S" known)
                       (let ((n (position c (the cons known)
                                          :key #'(lambda (row)
  