anchor.diff:  
   ;;; defmethod
   
  +(defun defmethod-1 (gf-name &rest args)
  +  (when (not (fboundp gf-name))
  +    (warn "Implicit defintion of generic function ~S." gf-name))
  +  (apply #'ensure-method
  +         (ensure-generic-function gf-name)
  +         args))
  +
   (defmacro defmethod (&rest args)
     (multiple-value-bind (function-name qualifiers
                           lambda-list specializers function)
           (parse-defmethod args)
  -    `(ensure-method (find-generic-function ',function-name)
  +    `(defmethod-1 ',function-name
          :lambda-list ',lambda-list
          :qualifiers ',qualifiers
          :specializers ,(canonicalize-specializers specializers)
  
positive.code:                      #'compute-discriminating-function)
                   gf))
    (set-funcallable-instance-function gf (generic-function-discriminating-function gf))
    (setf (fdefinition (generic-function-name gf)) gf)
    (values))
  
  ;;; make-instance-standard-generic-function creates and initializes an
  
negative.code: ;;; programs without this feature of full CLOS.
  
  (defun add-method (gf method)
    ;; If the GF has no methods and an empty lambda-list, then it may have
    ;; been implicitly created via defmethod. Fill in the lambda-list.
    (when (and (endp (generic-function-methods gf))
               (endp (generic-function-lambda-list gf)))
      (setf (generic-function-lambda-list gf) (method-lambda-list method)))
    (let ((old-method
             (find-method gf (method-qualifiers method)
                             (method-specializers method) nil)))
  