anchor.diff:    ;; Objects," for processing the LAMBDA form and any declarations
     ;; parsed from the provided FORMS.
   
  -  (labels ((parse-meta (name llist forms)
  -             (let ((lparms (parse-lambda-call-params llist
  -                                                     (list 'defun* name)))
  -                   type-map values-type)
  -               (multiple-value-bind (forms docs)
  -                   (parse-named-forms-docs forms)
  -                 (declare (ignore docs)) ;; as if.
  -                 (labels ((build-type-map (decl-rest)
  -                            (multiple-value-bind (map vdecl)
  -                                (parse-declared-types decl-rest env)
  -                              (setq type-map
  -                                    (nconc type-map map))
  -                              (when vdecl
  -                                (setq values-type vdecl)))))
  -
  -                   (walk-forms-declarations forms #'build-type-map)
  -
  -                   (multiple-value-bind (ftype)
  -                       (unparse-named-ftype name lparms type-map values-type)
  -                     (values ftype forms)))))))
  -
  -    (multiple-value-bind (ftype)
  -        (parse-meta name lambda forms)
  +    (let ((ftype
  +           (unparse-ftype-named-declaration name lambda forms
  +                                            (quote defun*)
  +                                            env)))
         `(progn
            (declaim ,ftype)
            (defun ,name ,lambda ,@forms)
  -         ))))
  +         )))
   
   
   #+NIL
  
positive.code:         ;; effective FTYPE declaration form.
          vars context)
      (declare (type package kwdpkg))
      (dolist (expr llist vars)
        (etypecase expr
          (symbol
           (cond
  
negative.code:       (t
         (values forms nil)))))
  
  
  (defun parse-lambda-call-params (lambda-list &optional eval-context)
    ;; NB: This function's return value is used together with
    ;; the return value from PARSE-DECLARED-TYPES, for computing
    ;; an FTYPE declaration in UNPARSE-FTYPE-FUNCTION-DECLARATION-1
    ;;
    ;; This function, as such, provides a value for the
    ;; LPARMS parameter to UNPARSE-FTYPE-FUNCTION-DECLARATION-1
    ;;
    ;; Usage - Within UNPARSE-FTYPE-FUNCTION-DECLARATION-1, 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-CALL-PARAMS. For any parameter not
    ;; given an explicit type in any declaration forms,
    ;; UNPARSE-FTYPE-FUNCTION-DECLARATION-1 will provide a resonable default type -
    ;; similarly, for the VALUES element in the resulting
    ;; FTYPE declaration.
    ;;
  