anchor.diff:                 (t
                   (npushl type param-spec))))
              )))) ;; DOLIST
  -    ;; Provide a default value for VALUES-DECL
  -    (unless values-decl
  -      (setq values-decl *default-ftype-values*))
       ;; return from the unparser
  -
  -    ;; FIXME: This is the only location where NAME is used here.
  -    ;;
  -    ;; Move this much into UNPARSE-FTYPE-NAMED-FORMS
  -    (values `(ftype (function ,param-spec ,values-decl) ,name))))
  -
  +    (values `(function ,param-spec ,values-decl))))
   ;; --
   
  -#+TBD
  -(defun unparse-ftype-named-forms (name forms
  -                                  &optional
  -                                    (eval-context
  -                                     (load-time-value
  -                                      (make-symbol "unknown context") t)))
  -  (
  -  ))
  -
  +
  +(defun unparse-ftype-function-declaration (lambda-list forms
  +                                           &optional eval-context
  +                                             environment)
  +  ;; return an unadorned FUNCTION type declaration in a syntax as may
  +  ;; be used for an FTYPE declaration, per LAMBDA-LIST and any
  +  ;; declarations directly in FORMS
  +  (let ((lparms (parse-lambda-call-params lambda-list eval-context))
  +        type-map values-type)
  +    (labels ((build-type-map (decl-rest)
  +               (multiple-value-bind (map vdecl)
  +                   (parse-declared-types decl-rest environment)
  +                 (setq type-map
  +                       (nconc type-map map))
  +                 (when vdecl
  +                   (setq values-type vdecl)))))
  +      (walk-forms-declarations forms #'build-type-map)
  +      (values
  +       (unparse-ftype-function-declaration-1
  +        lparms type-map (or values-type *default-ftype-values*))
  +       ))))
  +
  +
  +
  +
  +(defun unparse-ftype-named-declaration (name lambda-list forms
  +                                        &optional eval-context
  +                                          environment)
  +  ;; NB: Generalized onto the LAMBDA case
  +  ;;
  +  ;; See also/TBD: LABELS*
  +  (multiple-value-bind (forms docs)
  +        (parse-named-forms-docs forms)
  +      (declare (ignore docs)) ;; as though!
  +      (multiple-value-bind (ftype-functype)
  +          (unparse-ftype-function-declaration lambda-list forms
  +                                              (eval-context-add-suffix
  +                                               name eval-context)
  +                                              environment)
  +        (values `(ftype ,ftype-functype ,name)))))
   
   ;; --
   
  
positive.code:       (t
         (values forms nil)))))
  
  (defun parse-lambda-call-params (llist &optional error-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-NAMED-FTYPE
    ;;
    ;; This function, as such, provides a value for the
    ;; LPARMS parameter to UNPARSE-NAMED-FTYPE
    ;;
    ;; Usage - Within UNPARSE-NAMED-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-CALL-PARAMS. For any parameter not
    ;; given an explicit type in any declaration forms,
    ;; UNPARSE-NAMED-FTYPE will provide a resonable default type -
    ;; similarly, for the VALUES element in the resulting
    ;; FTYPE declaration.
    ;;
  
negative.code:     ;;       corresponding :REPORT function, generally illustrative of
      ;;       such application.
      :initform nil
      :type eval-context-name
      :initarg :context
      :reader macroexpansion-condition-context)))
  
  
  (declaim (ftype (function (eval-context-name eval-context-name)
                            (values list &optional))
                   eval-context-add-suffix))
  
  (defun eval-context-add-suffix (suffix whence)
    ;; utility for forms that may dispatch to generally signal a
    ;; MACROEXPANSION-CONDITION - add SUFFIX to WHENCE, in a manner
    ;; dependent on the syntax of each value
  
    ;; NB Could style-warning when (NULL SUFFIX)
  
    (etypecase whence
      (cons
       (etypecase suffix
         (symbol
          (append whence (list suffix)))
         (cons
          (append whence suffix))
         (null
          (values whence))))
      (null
       (etypecase suffix
         (symbol
          (list suffix))
         (cons
          (values suffix))
         (null
          (values nil))))
      (symbol
       (etypecase suffix
         (symbol
          (list whence suffix))
         (cons
          (append (list whence) suffix))
         (null
          (list whence))))))
  
  
  (define-condition lambda-parser-condition (macroexpansion-condition)
  