Scala 泛型 - 当使用类型约束时，为什么 scala 返回父类(super class)型而不是子类型的实例？

Question

我正在尝试将 y 转换为可以附加到 x 的内容，其中 x 是某种序列。

scala> def foo[U <: Seq[T], T](x: U, y: T): U = x :+ y
<console>:7: error: type mismatch;
 found   : Seq[T]
 required: U
       def foo[U <: Seq[T], T](x: U, y: T): U = x :+ y
                                                  ^

我有以下解决方案:

def foo[T]( x : Seq[T], y:T) = x :+ y
def foo[T]( x : Seq[T], y:T) : Seq[T] = x :+ y
def foo[U <: Seq[T], T](x: U, y: T): U = (x :+ y).asInstanceOf[U]

但我的疑问是为什么原来的那个不起作用。看起来如果我应用父类(super class)中定义的运算符(在本例中为 :+)，那么它会返回父类(super class)？即，如果 U 是 Vector，foo 返回 Seq，所以我收到错误 required "U”但找到了“Seq[T]”。

谁能告诉我为什么会出现这种行为？

Answer 1

遇到类型问题时，我通常采用“如果编译通过了，会发生什么”的逻辑来查找不合理的部分。

就您而言，假设原始版本没问题。

 def foo[U <: Seq[T], T](x: U, y: T): U = x :+ y

因为 Seq[T] 在 T 上是协变的，所以以下情况成立。

 for type A, T, if A <: T, List[A] <: Seq[T]

然后我们可以进行如下操作:

 class Parent 
 class Child extends Parent

 // List(new Child) :+ (new Parent) => List[Parent]
val result = foo(List(new Child), new Parent)

U 实际上是 foo 方法中的 List[Child]，但是当 List 使用与其元素类型不同的类型进行操作时，它会尝试找到共同的父级，在这种情况下结果是用 List[Parent] 键入的，但是所需的类型是List[Child]。显然，List[Parent] 不是 List[Child] 的子类型。

所以，问题是最终类型已提升，但所需类型是提升类型的子类型。如果你看一下Scala SeqLike的定义，可能会更清楚。

trait SeqLike[+A, +Repr] extends ... {
    def :+[B >: A, That](elem: B)(...): That = {
       ...
    }
}