anchor.diff:      (loop for index from 0 below (length (first specializers))
            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))))
  +             specializers)))
   
   ;; FIXME: Support EQL specializers.
   ;; This is hard to do ideally, and I'm not really trying.
  
positive.code: ;;;   * Portable MOP provided by CLIM-MOP package
  
  ;;; TODO:
  ;;;   * EQL specializers (not portable according to AMOP)
  ;;;   * Nicer, more clever display of methods than simply listing them in a row.
  ;;;     To do this right really involes some nonportable fun and a codewalker.
  ;;;     You could probably write something that just understood the standard
  
negative.code:                     (cond
                        ((eql a (find-class t)) t)
                        ((eql b (find-class t)) nil)
                        ((and (classp a)
                              (classp b))
                         (string< (class-name a)
                                  (class-name b)))
                        ((and (eql-specializer-p a)
                              (not (eql-specializer-p b)))
                         nil)
                        ((and (not (eql-specializer-p a))
                              (eql-specializer-p b))
                         t)
                        ((and (eql-specializer-p a)
                              (eql-specializer-p b))
                         (string<
                          (princ-to-string (eql-specializer-object a))
                          (princ-to-string (eql-specializer-object b))))
                        (t (warn "Received specializer of unknown type")
                           nil) ))))
            (compute-gf-specializers gf)))
  
  (defun simple-generic-function-lambda-list (gf)
  