anchor.diff:         (discriminating-function)  ; :accessor generic-function-
                                     ;    -discriminating-function
          (classes-to-emf-table      ; :accessor classes-to-emf-table
  -          :initform (make-hash-table :test #'equal)))))
  +          :initform (make-hash-table :test #'equal))
  +       (relevant-arguments))))    ; :accessor generic-function-relevant-arguments
   
   (defvar the-class-standard-gf) ;standard-generic-function's class metaobject
   
  
positive.code: ;;; compute-discriminating-function
  
  (defun std-compute-discriminating-function (gf)
    #'(lambda (&rest args)
        (let* ((classes (mapcar #'class-of
                                (required-portion gf args)))
               (emfun (gethash classes (classes-to-emf-table gf) nil)))
          (if emfun
              (funcall emfun args)
              (slow-method-lookup gf args classes)))))
  
  (defun slow-method-lookup (gf args classes)
    (let* ((applicable-methods
             (compute-applicable-methods-using-classes gf classes))
           (emfun
             (funcall
               (if (eq (class-of gf) the-class-standard-gf)
  
negative.code:          (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
  