Scala中具有参数化类型的类层次结构的隐式转换？

我有以下类层次结构：

class A[T](val value: T)
class B[T](value: T) extends A[T](value)

我希望为层次结构定义隐式转换和排序，以便能够通过以下方式比较实例：

new A(1) < new A(2)
new B(2) > new A(1)

newa（1）新A（1）

等等

排序应依赖于值字段排序。 新的B（2）>A（1），因为新的B（2）.值>新的A（1）.值

---

求求你，救命

你不知道在

B（1）

和

A（1）

之间应该发生什么。假设他们是平等的

object A {
  implicit def orderingOfA[T : Ordering] : Ordering[A[T]] = Ordering.by(_.value)
}

子类型

B

基本上是不相关的，排序是

A

，is也必须排序

B

的实例，因为它们是

A

的实例。即使你决定成为一个

B

改变了比较（也许它打破了联系），这将迫使你写一个定制订单，但仍然在同一个地方，使用相同的签名

---

当然，只有在

T

（因此

[T:ordering]

）上有ordering时，才定义排序。最好在companion

object A

中定义它，这将使它始终可用，无需导入

你不知道在

B（1）

和

A（1）

之间应该发生什么。假设他们是平等的

object A {
  implicit def orderingOfA[T : Ordering] : Ordering[A[T]] = Ordering.by(_.value)
}

scala> class A[T](val value: T)
defined class A

scala> class B[T](value: T) extends A(value)
defined class B                                                          

scala> implicit def xord[T : Ordering] = Ordering.by((_: A[T]).value)
xord: [T](implicit evidence$1: Ordering[T])scala.math.Ordering[A[T]]

scala> import Ordering.Implicits._
import Ordering.Implicits._

scala> new A(1) < new A(2)
res2: Boolean = true

scala> new B(1) < new A(2)
res3: Boolean = true

scala> new B(2) < new A(1)
res4: Boolean = false

子类型

B

基本上是不相关的，排序是

A

，is也必须排序

B

的实例，因为它们是

A

的实例。即使你决定成为一个

B

改变了比较（也许它打破了联系），这将迫使你写一个定制订单，但仍然在同一个地方，使用相同的签名

当然，只有在

T

（因此

[T:ordering]

）上有ordering时，才定义排序。最好在companion

object A

中定义它，这将使它始终可用，无需导入

scala>A类[T]（val值：T）
scala> class A[T](val value: T)
defined class A

scala> class B[T](value: T) extends A(value)
defined class B                                                          

scala> implicit def xord[T : Ordering] = Ordering.by((_: A[T]).value)
xord: [T](implicit evidence$1: Ordering[T])scala.math.Ordering[A[T]]

scala> import Ordering.Implicits._
import Ordering.Implicits._

scala> new A(1) < new A(2)
res2: Boolean = true

scala> new B(1) < new A(2)
res3: Boolean = true

scala> new B(2) < new A(1)
res4: Boolean = false

定义的A类
scala>class B[T]（值：T）扩展了A（值）
定义的B类
scala>implicit def xorder[T:Ordering]=Ordering.by（（u:A[T]）.value）
xord:[T]（隐式证据$1:Ordering[T]）scala.math.Ordering[A[T]]
scala>import Ordering.Implicits_
导入Ordering.Implicits_
scala>新A（1）<新A（2）
res2:Boolean=true
scala>新B（1）<新A（2）
res3:Boolean=true
scala>新B（2）<新A（1）
res4:Boolean=false

scala>A类[T]（val值：T）
定义的A类
scala>class B[T]（值：T）扩展了A（值）
定义的B类
scala>implicit def xorder[T:Ordering]=Ordering.by（（u:A[T]）.value）
xord:[T]（隐式证据$1:Ordering[T]）scala.math.Ordering[A[T]]
scala>import Ordering.Implicits_
导入Ordering.Implicits_
scala>新A（1）<新A（2）
res2:Boolean=true
scala>新B（1）<新A（2）
res3:Boolean=true
scala>新B（2）<新A（1）
res4:Boolean=false

谢谢！它起作用了。下面的答案也是可以接受的。但你是第一个：）谢谢！它起作用了。下面的答案也是可以接受的。但你是第一个：）