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

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]

简单的答案是，如果没有Ordering[Any]，就不能拥有TreeSet[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()

但这并没有任何意义。

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

有一些 CanBuildFroms 由SortedSetFactory 生成，但请注意它们如何需要隐式Ordering[A]。因为找不到Ordering[Any]，所以编译器会寻找更通用的东西，然后找到Set[Any]。这是有道理的，因为如果我们将元素放入一个我们不知道如何排序的有序集合中，那么我们就不再有一个有序集合。剩下的只是一个普通的Set。