compute-applicable-methods-using-classes

(defmethod compute-applicable-methods-using-classes ((f typeclass-generic-function) classes)
  (labels ((eql-specializer-applicablep (specializer class)
         (eq class (class-of (eql-specializer-object specializer))))
       (eql-specializerp (obj)
         (subclassp (class-of obj) (find-class 'eql-specializer)))
       (more-specific-specializerp (spec1 spec2)
         (cond ((eql-specializerp spec1) (not (eql-specializerp spec2)))
           ((typeclassp spec1) (and (classp spec2) (subclassp spec1 spec2)))
           ((classp spec1) (or (and (classp spec2) (subclassp spec1 spec2))
                       (typeclassp spec2)))))
       (more-specific-methodp (m1 m2)
         (some (lambda (s1 s2)
             (more-specific-specializerp s1 s2))
           (method-specializers m1)
           (method-specializers m2))))
    (let ((methods (generic-function-methods f)))
      ;if there is a eql specializer which does not satisfies the classes of the arguments
      ;in one of the methods' specializers...
      (if (and (some (lambda (m)
               (some #'eql-specializerp (method-specializers m)))
             methods)
           (some (lambda (specializers)
               (every (lambda (s)
                (eql-specializer-applicablep (car s) (cdr s)))
                  (remove-if-not (lambda (x)
                           (eql-specializerp (car x)))
                         (mapcar #'cons specializers classes))))
             (mapcar #'method-specializers methods)))
      (values '() nil);then applicable-methods cannot be found by the argument's classes
      (if (some (lambda (specs)
              (some (lambda (spec)
                  (and (classp spec)
                   (typeclassp spec)))
                specs))
            (mapcar #'method-specializers methods))
          (values (sort (remove-if-not (lambda (m)
                         (let ((specs (method-specializers m)))
;each specializer must agree with the corresponding argument's class
                    (every (lambda (spec c)
;'implement-typeclassp' is simply a lookup for the typeclass 'spec' in the slot 'typeclasses' of the class 'c'
                         (cond ((typeclassp spec) (implement-typeclassp c spec)))
                               ((eql-specializerp spec) (eql-specializer-applicablep spec c))
                               ((classp spec) (subclassp c spec))))
                           specs classes)))
                       methods) #'more-specific-methodp)
              t)
          (call-next-method))))));if there is no typeclass in the method's specializer, calls the default algorithm