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: 
  (defun specializer-pretty-name (spec)
    "Pretty print the name of a method specializer"
    (cond ((classp spec)
           (princ-to-string (class-name spec)))
          ((eql-specializer-p spec)
           (format nil "(EQL '~A)" (eql-specializer-object spec)))
          (t (princ-to-string spec))))
  
  (defun maybe-find-gf (name)
  