使用 Ordered 特性扩展泛型类型会使 sbt 编译器出现 'diverging implicit expansion for type' 错误

Question

我有一个实现 Scala 有序特征的特征：

package stackQuestions

trait ValueTrait[TYPE] extends Ordered[ValueTrait[TYPE]]{
  def value: Double
}

和一个子类：

package stackQuestions

class Value[A](list: List[A], function: (A, A) => Double) extends ValueTrait[A] {
  private val _value: Double = list.zip(list.tail).map(pair => function(pair._1, pair._2)).sum

  override def value: Double = _value

  override def compare(that: ValueTrait[A]): Int = {
    (this.value - that.value).signum
  }
}

基本上，当使用提供的函数创建 Value 对象时，会计算该值。我想要实现的是根据值对 Value 对象的集合进行排序。这应该由 Ordered 特征来保证。我为此编写了一些简单的测试：

package stackQuestions

import org.scalatest.FunSpec

class ValueTest extends FunSpec {
  def evaluationFunction(arg1: Int, arg2: Int): Double = {
    if (arg1 == 1 && arg2 == 2) return 1.0
    if (arg1 == 2 && arg2 == 1) return 10.0
    0.0
  }

  val lesserValue = new Value(List(1, 2), evaluationFunction) // value will be: 1.0
  val biggerValue = new Value(List(2, 1), evaluationFunction) // value will be: 10.0

  describe("When to Value objects are compared") {
    it("should compare by calculated value") {
      assert(lesserValue < biggerValue)
    }
  }
  describe("When to Value objects are stored in collection") {
    it("should be able to get max value, min value, and get sorted") {
      val collection = List(biggerValue, lesserValue)

      assertResult(expected = lesserValue)(actual = collection.min)
      assertResult(expected = biggerValue)(actual = collection.max)

      assertResult(expected = List(lesserValue, biggerValue))(actual = collection.sorted)
    }
  }
}

但是，当 sbt test -Xlog-implicits 我收到错误消息时：

[info] Compiling 1 Scala source to /project/target/scala-2.11/test-classes ...
[error] /project/src/test/scala/stackQuestions/ValueTest.scala:24:64: diverging implicit expansion for type Ordering[stackQuestions.Value[Int]]
[error] starting with method $conforms in object Predef
[error]       assertResult(expected = lesserValue)(actual = collection.min)
[error]                                                                ^
[error] /project/src/test/scala/stackQuestions/ValueTest.scala:25:64: diverging implicit expansion for type Ordering[stackQuestions.Value[Int]]
[error] starting with method $conforms in object Predef
[error]       assertResult(expected = biggerValue)(actual = collection.max)
[error]                                                                ^
[error] /project/src/test/scala/stackQuestions/ValueTest.scala:27:83: diverging implicit expansion for type scala.math.Ordering[stackQuestions.Value[Int]]
[error] starting with method $conforms in object Predef
[error]       assertResult(expected = List(lesserValue, biggerValue))(actual = collection.sorted)
[error]                                                                                   ^
[error] three errors found
[error] (Test / compileIncremental) Compilation failed
[error] Total time: 1 s, completed 2018-09-01 08:36:18

我已经挖掘了类似的问题并在阅读之后：

What's a “diverging implicit expansion” scalac message mean?、
Why am I getting a “ diverging implicit expansion” error when trying to sort instances of an ordered class?,
、
scala - Confusing “diverging implicit expansion” error when using “sortBy”,

我了解到编译器对如何选择合适的函数进行比较感到困惑。我知道我可以使用 sortBy(obj => obj.fitness) 来规避这个问题，但是有什么方法可以使用更简洁的 sorted 方法吗？

Answer 1

Scala 将 Ordering[T] 特征用于 sorted、min 和 max 类型集合的方法 T。它可以为扩展 Ordered[T] 的 T 自动生成 Ordering[T] 的实例。

因为 Java 兼容性 Ordering[T] extends java.util.Comparator[T]，它在 T 中是不变的，所以 Ordering[T] 在 [=18= 中必须是不变的】还有。看到这个问题：SI-7179.

这意味着 Scala 无法为实现 Ordered 的类的子类的 T 生成 Ordering[T] 的实例。

在您的代码中有 val collection = List(biggerValue, lesserValue)，其类型为 List[Value[Int]]。 Value 没有自己的 Ordered 或 Ordering，因此 Scala 无法对 collection.

进行排序

要修复，您可以指定 collection 类型为 List[ValueTrait[Int]]:

val collection = List[ValueTrait[Int]](biggerValue, lesserValue)

或者为Value[T]定义一个明确的Ordering:

object Value {
  implicit def ord[T]: Ordering[Value[T]] = 
    Ordering.by(t => t: ValueTrait[T])
}

如果符合您的其他要求，您也可以考虑在此问题中使用不同的设计：

在您的代码中，ValueTrait[TYPE] 的所有实例都具有类型 Double 的值，子类和 TYPE 的区别在运行时似乎并不重要。所以你可以只定义一个 case class Value(value: Double) 并使用不同的工厂方法来根据不同类型的参数创建 Value。

case class Value(value: Double) extends Ordered[Value] {
  override def compare(that: Value): Int = this.value compareTo that.value
}

object Value {
  def fromList[A](list: List[A], function: (A, A) => Double): Value =
    Value((list, list.tail).zipped.map(function).sum)
}

以及用法：

scala> val lesserValue = Value.fromList(List(1, 2), evaluationFunction)
lesserValue: Value = Value(1.0)

scala> val biggerValue = Value.fromList(List(2, 1), evaluationFunction)
biggerValue: Value = Value(10.0)

scala> val collection = List(biggerValue, lesserValue)
collection: List[Value] = List(Value(10.0), Value(1.0))

scala> (collection.min, collection.max, collection.sorted)
res1: (Value, Value, List[Value]) = (Value(1.0),Value(10.0),List(Value(1.0), Value(10.0)))

使用 Ordered 特性扩展泛型类型会使 sbt 编译器出现 'diverging implicit expansion for type' 错误

Extending generic type with Ordered trait makes sbt compiler issue 'diverging implicit expansion for type' error

scala

implicit

scala-generics