anchor.diff:           (setf (find-generic-function function-name) gf)
            gf)))
   
  +(defun generic-function-single-dispatch-p (gf)
  +  "Returns true when the generic function only one non-t specialized argument."
  +  (when (eq (class-of gf) the-class-standard-gf)
  +    (let ((specializers (generic-function-relevant-arguments gf))
  +          (count 0)
  +          (offset 0))
  +      (dotimes (i (length specializers))
  +        (unless (zerop (aref specializers i))
  +          (setf offset i)
  +          (incf count)))
  +      (if (eql count 1)
  +          (values t offset)
  +          nil))))
  +
   ;;; finalize-generic-function
   
   ;;; N.B. Same basic idea as finalize-inheritance.  Takes care of recomputing
  
positive.code:     (setf (generic-function-lambda-list gf) lambda-list)
      (setf (generic-function-methods gf) ())
      (setf (generic-function-method-class gf) method-class)
      (setf (classes-to-emf-table gf) (make-hash-table :test #'equal))
      (finalize-generic-function gf)
      gf))
  
  
negative.code: ;;; function table.
  
  (defun finalize-generic-function (gf)
    ;; Examine all methods and compute the relevant argument bit-vector.
    (let* ((required-args (gf-required-arglist gf))
           (relevant-args (make-array (length required-args)
                                      ;:element-type 'bit
                                      :initial-element 0))
           (class-t (find-class 't)))
      (dolist (m (generic-function-methods gf))
        (do ((i 0 (1+ i))
             (spec (method-specializers m) (rest spec)))
            ((null spec))
          (unless (eql (first spec) class-t)
            (setf (aref relevant-args i) 1))))
      (setf (generic-function-relevant-arguments gf) relevant-args))
    (setf (generic-function-discriminating-function gf)
          (funcall (if (eq (class-of gf) the-class-standard-gf)
                       #'std-compute-discriminating-function
  