anchor.diff:                              (classp b))
                          (string< (class-name a)
                                   (class-name b)))
  -                      ((and (eql-specializer-p a)
  -                            (not (eql-specializer-p b)))
  +                      ((and (typep a 'clim-mop:eql-specializer)
  +                            (not (typep b 'clim-mop:eql-specializer)))
                          nil)
  -                      ((and (not (eql-specializer-p a))
  -                            (eql-specializer-p b))
  +                      ((and (not (typep a 'clim-mop:eql-specializer))
  +                            (typep b 'clim-mop:eql-specializer))
                          t)
  -                      ((and (eql-specializer-p a)
  -                            (eql-specializer-p b))
  +                      ((and (typep a 'clim-mop:eql-specializer)
  +                            (typep b 'clim-mop:eql-specializer))
                          (string<
  -                        (princ-to-string (eql-specializer-object a))
  -                        (princ-to-string (eql-specializer-object b))))
  +                        (princ-to-string (clim-mop:eql-specializer-object a))
  +                        (princ-to-string (clim-mop:eql-specializer-object b))))
                         (t (warn "Received specializer of unknown type")
                            nil) ))))
             (compute-gf-specializers gf)))
  
positive.code:          collect (remove-duplicates (mapcar (lambda (specs) (nth index specs))
                                              specializers)))))
  
  (defun classp (x)
    (or (typep x 'cl:class)
        #+CMU (typep x 'pcl::class)))
  
  (defun eql-specializer-p (x)
    #+SBCL (typep x 'sb-mop:eql-specializer)
    #+CMU  (typep x 'pcl:eql-specializer))
  
  (defun eql-specializer-object (x)
    #+SBCL (sb-mop:eql-specializer-object x)
    #+CMU  (pcl::eql-specializer-object x))
  
  (defun compute-applicable-methods-from-specializers (gf specializers)
    (clim-mop:compute-applicable-methods gf
       (mapcar (lambda (spec)
                 (cond ((eql-specializer-p spec)
                        (eql-specializer-object spec))
                       ((classp spec)
                        (clim-mop:class-prototype spec))
                       (t (error "Can't compute effective methods, specializer ~A is not understood." spec))))
  
negative.code:   "Pretty print the name of a method specializer"
    (cond ((classp spec)
           (princ-to-string (class-name spec)))
          ((typep spec 'clim-mop:eql-specializer)
           (format nil "(EQL '~A)" (clim-mop:eql-specializer-object spec)))
          (t (princ-to-string spec))))
  
  (defun maybe-find-gf (name)
  