Question

运行以下代码时出现了一些奇怪的结果：

object Example {

  implicit object StringOrdering extends Ordering[String] {
    def compare(o1: String, o2: String) = {
      o1.length - o2.length
    }
  }
  object StringOrdering1 extends Ordering[String] {
    def compare(o1: String, o2: String) = {
      o2.length - o1.length
    }
  }


  import collection.mutable
  import collection.immutable.TreeSet

  val x = TreeSet(1, 5, 8, 12)
  val y = mutable.Set.empty ++= x // mutable.Set[Int]
  val y1 = mutable.Set.empty[Int] ++= x // mutable.Set[Int]
  val z = TreeSet.empty ++ y // Set[Any]
  val z1 = TreeSet.empty[Int] ++ y // TreeSet[Int]
}

为什么可变和不可变集合中的类型推断表现得如此不同？ z部分最令人费解，为什么我们至少得不到TreeSet[Any]？

Answer 1

问题可以简化为：

scala> TreeSet.empty[Int] ++ TreeSet.empty[BigInt]
res15: scala.collection.immutable.Set[Any] = Set()

您对TreeSet.empty的使用并未揭示其实际类型。实际上，它甚至没有按原样编译。我假设您在未显示的范围内有Ordering[A]隐式A != Int。

关于问题：

为什么我们至少得不到TreeSet [Any]

简单的答案是，如果没有TreeSet[Any]，您就无法拥有Ordering[Any]。如果我尝试将TreeSet[Int]与TreeSet[BigInt]合并，则最常见的类型为Any。 TreeSet是一种SortedSet，但我们如何对Any进行排序？默认情况下，我们不能，因为对一组Any进行排序没有任何意义。

如果我真的想要，我可以设法Ordering[Any]，我最终会得到TreeSet[Any]：

implicit val ordAny = new Ordering[Any] {
    def compare(x: Any, y: Any): Int = Ordering.Int.compare(x.hashCode, y.hashCode)
}

scala> TreeSet.empty[Int] ++ TreeSet.empty[BigInt]
res8: scala.collection.immutable.TreeSet[Any] = TreeSet()

但这没有任何意义。

技术答案是，为了连接两个TreeSet，TreeSet[A]和TreeSet[B]，我们需要隐式CanBuildFrom[TreeSet[A], B, TreeSet[B]]。

SortedSetFactory生成一些 CanBuildFrom，但请注意它们如何需要隐式Ordering[A]。由于找不到Ordering[Any]，编译器会查找更通用的内容，并找到Set[Any]。这是有道理的，因为如果我们将元素放入一个我们不知道如何排序的有序集中，那么我们就不再有一个有序集。剩下的只是简单的Set。

为什么可变和不可变集合中的类型推断表现得如此不同？

1 个答案: