anchor.diff:    (- m n o))
   
   
  +
   (macroexpand (quote
  -(defun* find-frob (token where &key (start 0) from-end
  -                         &allow-other-keys
  -                         &rest fluff)
  +(defun* find-frob (digit where &rest kwlist
  +                         &key ((:start %start) 0) from-end
  +                         &allow-other-keys &aux (c (digit-char digit)))
     "Find NIL"
  -  (declare (string token where)
  -           (type (mod #.array-dimension-limit) start)
  -  ))
  +  (declare (type (mod 10) digit) (string where)
  +           (ignore kwlist)
  +           (type (mod #.array-dimension-limit) %start))
  +  (let ((n
  +         (position c where :test #'char= :start %start
  +                   :from-end from-end)))
  +    (declare (type base-char c))
  +    (cond
  +      (n (values c n))
  +      (t (values nil nil )))))
   ))
   
  +
  +
  +;; (find-frob 1 "54321012345")
  +;; (find-frob 1 "54321012345" :from-end t)
  +
   )
   
  
positive.code:                (let (param-spec context)
                   ;; Re-map LVARS x TYPE-MAP into a lambda-like PARAM-SPEC
                   (dolist (bkt lvars)
                     (destructuring-bind (var . ctxt) bkt
                       (unless (eq ctxt '&aux) ;; TBD: &AUX in FTYPE
                         (unless (eq ctxt context)
                           (setq context ctxt)
                           (pushl ctxt param-spec))
                         (let ((type-n (position var type-map
                                                 :key #'car
                                                 :test #'eq))
                               (type t))
                           (when type-n
                             (setq type (cdr (nth type-n type-map))))
                           (case ctxt
                             (&key
                              ;; FIXME not yet suitable for all &KEY forms
                              (pushl (list (intern (symbol-name var)
                                                   :keyword)
                                           type) param-spec))
                             (t
                              (pushl type param-spec)))
                         ))))
                   ;; Provide a default value for VDECL
                   (unless vdecl
                     (setq vdecl *default-ftype-values*))
                   (values `(ftype (function ,param-spec ,vdecl) ,name)))
                 )
               (parse-meta (name llist forms)
                 (let ((lvars (parse-lambda-vars llist)))
                   (multiple-value-bind (forms docs)
  
negative.code:     (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+
  