anchor.diff:      (append '(type ftype) +declare-notype+))
   
   (defconstant* +defun-lambda-param-kwd+
  +    ;; NB: This provides a more specialized set of symbols than
  +    ;; CL:LAMBDA-LIST-KEYWORDS
     '(&optional &rest &key &allow-other-keys))
   
   (defconstant* +defun-lambda-kwd+
  
positive.code:   (- m n o))
  
  
  (macroexpand (quote
  (defun* find-frob (token where &key (start 0) from-end
                           &allow-other-keys
                           &rest fluff)
    "Find NIL"
    (declare (string token where)
             (type (mod #.array-dimension-limit) start)
    ))
  ))
  
  )
  
  
negative.code:                    (t
                      (values forms decls)))))
               (parse-lambda-vars (llist)
                 ;; NB: This function's return value is used for PARSE-FTYPE LVARS
                 ;;
                 ;; Usage - Within PARSE-FTYPE, this function's return
                 ;; value is processed within an iterative form, such that
                 ;; will compute a type for each lambda parameter parsed
                 ;; out by PARSE-LAMBDA-VARS.
                 ;;
                 ;; For &key arguments, these two functions will utilize a
                 ;; specific, list-based data structure:
                 ;;   (CONTEXT . (VAR . KEYNAME))
                 ;; juxtaposed to the data structure used for other lambda
                 ;; list parameters:
                 ;;   (CONTEXT . VAR)
                 (let ((kwdpkg (find-package '#:keyword))
                       vars context)
                   (declare (type package kwdpkg)
                            (dynamic-extent kwdpkg))
                   (dolist (expr llist vars)
                     (etypecase expr
                       (symbol
                        (cond
                          ((find expr +defun-lambda-kwd+ :test #'eq)
                           (setq context expr))
                          ;; NB: All symbol type expressions not denoted
                          ;; in +DEFUN-LAMBDA-KWD+ will be parsed subsq.
                          ((eq context (quote &key))
                           (let ((key (intern (symbol-name expr)
                                              kwdpkg)))
                             (pushl (cons context (cons expr key))
                                    vars)))
                          (t (pushl (cons context expr) vars))))
                       (cons
                        ;; assumptions: EXPR is a CONS - thus denoting an
                        ;; &optional or &key parameter. These specifiers
                        ;; will include further information than a
                        ;; parameter name.
                        (let ((vexpr (car expr)))
                          (case context
                            (&optional
                             (pushl (cons context vexpr) vars))
                            (&key
                             (etypecase vexpr
                               (symbol
                                (let ((key (intern (symbol-name vexpr)
                                                   kwdpkg)))
                                  (pushl (cons context (cons vexpr key))
                                         vars)))
                               (cons
                                ;; Specialized &key forms
                                (let ((key (car vexpr))
                                      (var (cadr vexpr)))
                                  (pushl (cons context (cons var key))
                                         vars)))))
                            (&aux) ;; no-op
                            ;; FIXME: This style warning introduces NAME
                            ;; and LAMBDA from the calling lexical
                            ;; environment. As such, it introduces a
                            ;; concern with regards to porting this lambda
                            ;; list parser for both LABELS* and DEFUN*
                            ;;
                            ;; Note also, BOA lambda list forms in
                            ;; constructor specifications for DEFSTRUCT
                            (t (simple-style-warning
                                "~<Ignoring lambda list expression ~S ~S~>~
  ~< in DEFUN* ~S ~S~>" context vexpr name lambda)))
                          ))))))
  
               (parse-decl-types (decls env)
                 ;; TBD: Return value for PARSE-FTYPE DECLS
                 (let (typed
                       ;;; unused lambda parser parameters
                       ;; ftyped cldecl classed other
                       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
  