泛型 – 初学者：我怎么说“任何超类泛型A”

到目前为止我的工作是

def sort[A <: Ordered[A]](xs: Array[A])

允许排序在所有类型的反复排序上运行,如RichBoolean.

但是我还想允许它们扩展的类型A Ordered [B]其中B是A的超类(例如,任何扩展Ordered [Any]的东西).

我该怎么说呢？

我真正得到了工作,感谢agilesteel’s answer：

case class X( i : Int ) extends Ordered[X] {
  def compare( x : X ) = x.i - i
}

class Y( i : Int,j : Int ) extends X(i)

case class Z( i : Int ) extends Ordered[Any] {
  def compare( a : Any ) : Int = {
    if (! a.isInstanceOf[Z] ) 
      sys.error("whoops") 

    val z = a.asInstanceOf[Z]
    z.i - i
  }
}

object QuickSort {
  def main( args : Array[String] ) {
    val xs = Array( 3,1,2,4 ) map X
    sort( xs );
    val ys = Array( 3,4 ) map { i => new Y(i,-i) }
    sort[X,Y]( ys );
    val zs = Array( 3,4 ) map Z
    sort[Any,Z]( zs );
  }
  def sort[B >: A,A <: Ordered[B]](xs: Array[A]) {
    def swap(i: Int,j: Int) {
      val t = xs(i); xs(i) = xs(j); xs(j) = t;
    }
    def sort1(l: Int,r: Int) {
      val pivot = xs((l + r) / 2)
        var i = 1; var j = r
      while (i <= j) {
        while (xs(i) < pivot) i += 1
        while (xs(j) > pivot) j -= 1
        if (i <= j) {
          swap(i,j)
          i += 1
          j += 1
        }
      }
      if (l < j) sort1(l,j)
      if (j < r) sort1(i,r)
    }
    sort1(0,xs.length - 1)
  }
}

我被试图使用RichLong和RichBoolean作为测试类型而被误导,因为它们并未实际反射性地排序(它们扩展了Ordered [Long]和Ordered [Boolean]).