anchor.diff:                     (t
                       (values forms decls)))))
                (parse-lambda-vars (llist)
  -               ;; NB: Return value for PARSE-DECL-TYPES LVARS (unused param)
  -               ;;     and PARSE-FTYPE LVARS
  +               ;; NB: Return value for PARSE-FTYPE LVARS
                  (let (vars context)
                    (dolist (expr llist vars)
                      (cond
  
positive.code:                            (setq type (cdr (nth type-n type-map))))
                           (pushl type param-spec)
                         ))))
                   (values `(ftype (function ,param-spec ,vdecl) ,name)))
                 )
               (parse-meta (name llist forms)
  
negative.code:                           (cons (pushl (cons (cadr vexpr) context) vars)))))
                       ))))
  
               (parse-decl-types (decls env)
                 ;; TBD: Return value for PARSE-FTYPE DECLS
                 (let (typed ;; ftyped cldecl classed other ;; unused lambda parser parameters
                       vdecl
                       )
                   ;; NB: This does not need to provide a full, compiler-
                   ;; integrated defun (lambda) declarations parser. It
                   ;; must parse the declarations, to some extent, in
                   ;; order to determine which declarations denote types
                   ;; for bindings established per the defun lambda list.
                   ;;
                   ;; Subsequent functions may use this function's return
                   ;; value, for estalblishing type declarations for
                   ;; function parameters, such that would be visible from
                   ;; any calling lexical environment.
                   ;;
                   ;; Note that some ambiguity is possible, in the normal
                   ;; declarations syntax. This parser is a best effort for
                   ;; addressing such ambiguities as may pertain to typing of
                   ;; lambda list parameters.
                   (dolist (expr decls)
                     ;; sort each element of DECLS per declaration kind
                     (let ((kind (car expr)))
                       (cond
                         ((eq kind 'type)
                          (let ((type (cadr expr)))
                            ;; record the type for each explicitly typed
                            ;; variable
                            (dolist (var (cddr expr))
                              (pushl (cons var type) typed))))
                         ((eq kind 'values)
                          ;; Assumption: This EXPR denotes a CMUCL lambda
                          ;; VALUES declaration. This declaration may also
                          ;; be evaluated in SBCL.
  
                          ;; NB This does not warn about multiple VALUES
                          ;; declarations - would implicitly use the last
                          ;; VALUES decl.
  
                          ;; FIXME prune this VALUES EXPR from the set of
                          ;; output declarations, when not either of CMUCL
                          ;; or SBCL - thus avoiding some style warnings,
                          ;; in implementations assumed not to implement
                          ;; the VALUES declaration, per se.
  
                          ;; Note that this DEFUN* proposes to utilize
                          ;; the CMUCL (or SBCL) lambda VALUES declaration
                          ;; in producing a top-level FTYPE declaration -
                          ;; thus, supporting such a convention of strong
                          ;; typing, insofar as in FTYPE declarations,
                          ;; for all implementations.
                          ;;
                          ;; Implementation-specific optimizations would
                          ;; be beyond the scope of this comment
                          (setq vdecl expr))
                         ((eq kind 'ftype)
                          ;; NB a manner of a subset of TYPE decls
                          ;; Not per se used here (No-Op)
                          #+NIL (pushl expr ftyped)
                          )
                         ((find kind +declare-notype+ :test #'eq)
                          ;; No-Op
                          #+NIL
                          (pushl expr cldecl))
                         ((find-class kind nil env)
                          #+NIL (pushl expr classed)
                          #-NIL
                          (dolist (var (cdr expr))
                            (pushl (cons var kind) typed)
                            ))
                         (t ;; No-Op
                          #+NIL
                          (pushl expr other)))))
                   ;; NB: OTHER may contain non-class type-name and
                   ;; implementation-specific declarations
                   ;;
                   ;; FIXME: This, in its present revision, will not
                   ;; recognize any shorthand type declarations that do
                   ;; not represent class names.
                   ;;
                   ;; This revision of DEFUN* will not provide implementation-
                   ;; specific code.
                   ;;
                   ;; Assumption: Any declarations in OTHER will not provide
                   ;; type information about the LAMBDA list
  
                   ;; ...
                   (values typed vdecl)))
               (parse-ftype (name lvars type-map &optional (vdecl nil vdecl-p))
                 (declare (type list type-map))
                 ;; NB vis a vis VALUES in DECLARE w/ CMUCL and SBCL,
                 ;; and CL:FTYPE declarations
                 ;;
                 ;; Parse any VALUES decls from the original DECLARE set.
                 ;; Subsequently, use that value (when non-nil) in a
                 ;; top-level FTYPE declaration - using a default type T
                 ;; for the VALUES type and for any LAMBDA parameters
                 ;; that have not been expressly typed in the DECLARE form.
                 ;;
                 ;; When adapted for LABELS* the FTYPE declaration must be
                 ;; handled for a declaration within the calling lexical
  