为什么该示例无法编译，即（同、对、内）方差如何工作？

Question

继这个问题之后，有人可以在 Scala 中解释以下内容：

class Slot[+T] (var some: T) { 
   //  DOES NOT COMPILE 
   //  "COVARIANT parameter in CONTRAVARIANT position"

}

我理解类型声明中 +T 和 T 之间的区别（如果我使用 T）。 但是，如何真正编写一个在其类型参数中协变的类，而不需要创建未参数化的东西呢？ 如何确保只能使用 T 实例创建以下内容？

class Slot[+T] (var some: Object){    
  def get() = { some.asInstanceOf[T] }
}

编辑 - 现在将其归结为以下内容：

abstract class _Slot[+T, V <: T] (var some: V) {
    def getT() = { some }
}

这一切都很好，但我现在有两个类型参数，我只想要一个。 我将重新问这个问题：

如何编写一个不可变 Slot 类，其类型协变？< /strong>

编辑 2：呃！ 我使用了 var 而不是 val。 以下是我想要的：

class Slot[+T] (val some: T) { 
}

Answer 1

一般来说，协变类型参数是允许随着类的子类型化而向下变化的类型参数（或者，随着子类型化而变化，因此有“co-”前缀）。 更具体地说：

trait List[+A]

List[Int] 是 List[AnyVal] 的子类型，因为 Int 是 AnyVal 的子类型。 这意味着当需要 List[AnyVal] 类型的值时，您可以提供 List[Int] 的实例。 对于泛型来说，这确实是一种非常直观的工作方式，但事实证明，当在存在可变数据的情况下使用时，它是不健全的（破坏了类型系统）。 这就是为什么泛型在 Java 中是不变的。 使用 Java 数组（错误地协变）的不健全性的简单示例：

Object[] arr = new Integer[1];
arr[0] = "Hello, there!";

我们刚刚将 String 类型的值分配给 Integer[] 类型的数组。 出于显而易见的原因，这是个坏消息。 Java 的类型系统实际上在编译时允许这样做。 JVM 将在运行时“有效地”抛出 ArrayStoreException。 Scala 的类型系统可以防止此问题，因为 Array 类上的类型参数是不变的（声明是 [A] 而不是 [+A]） 。

请注意，还有另一种类型的方差，称为逆变。 这非常重要，因为它解释了为什么协方差会导致一些问题。 逆变实际上与协变相反：参数随着子类型的变化向上。 它不太常见，部分原因是它非常违反直觉，尽管它确实有一个非常重要的应用：函数。

trait Function1[-P, +R] {
  def apply(p: P): R
}

请注意 P 类型参数上的“-”差异注释。 该声明作为一个整体意味着 Function1 在 P 中是逆变的，在 R 中是协变的。 因此，我们可以推导出以下公理：

T1' <: T1
T2 <: T2'
---------------------------------------- S-Fun
Function1[T1, T2] <: Function1[T1', T2']

注意，T1' 必须是 T1 的子类型（或相同类型），而 T2 则相反 和T2'。 在英语中，这可以读作如下：

如果 A 的参数类型是 A 参数类型的超类型，则函数 A 是另一个函数 B 的子类型>B 而 A 的返回类型是 B 返回类型的子类型。

这条规则的原因留给读者作为练习（提示：考虑不同的情况，因为函数是子类型的，就像上面的数组示例一样）。

凭借您新发现的协变和逆变知识，您应该能够明白为什么以下示例无法编译：

trait List[+A] {
  def cons(hd: A): List[A]
}

问题是 A 是协变的，而 cons > 函数期望其类型参数不变。 因此，A 改变了错误的方向。 有趣的是，我们可以通过在 A 中使 List 逆变来解决这个问题，但是返回类型 List[A] 将无效，因为cons 函数期望其返回类型为协变。

这里我们唯一的两个选择是 a) 使 A 不变，失去协方差的良好、直观的子类型属性，或者 b) 将本地类型参数添加到 cons 中将 A 定义为下限的方法：

def cons[B >: A](v: B): List[B]

现在有效。 您可以想象 A 向下变化，但 B 能够相对于 A 向上变化，因为 A是它的下界。 通过这个方法声明，我们可以让 A 协变并且一切正常。

请注意，只有当我们返回专门针对不太特定的类型 B 的 List 实例时，此技巧才有效。 如果您尝试使 List 可变，事情就会崩溃，因为您最终尝试将 B 类型的值分配给 A 类型的变量，这是编译器不允许的。 每当你具有可变性时，你就需要有某种类型的增变器，这需要某种类型的方法参数，这（与访问器一起）意味着不变性。 协变适用于不可变数据，因为唯一可能的操作是访问器，它可以被赋予协变返回类型。

Answer 2

@Daniel已经解释得很好了。 但简而言之，如果允许：

  class Slot[+T](var some: T) {
    def get: T = some   
  }

  val slot: Slot[Dog] = new Slot[Dog](new Dog)   
  val slot2: Slot[Animal] = slot  //because of co-variance 
  slot2.some = new Animal   //legal as some is a var
  slot.get ??

slot.get 将在运行时抛出错误，因为它未能成功地将 Animal 转换为 Dog< /代码>（呃！）。

一般来说，可变性与协变和逆变不太相配。 这就是所有 Java 集合都是不变的原因。

Answer 3

请参阅 Scala 示例，第57+对此进行了全面讨论。

如果我正确理解你的评论，你需要重新阅读从第 56 页底部开始的段落（基本上，我认为你所要求的在没有运行时检查的情况下不是类型安全的，scala 不这样做，所以你运气不好）。 翻译他们的示例以使用您的构造：

val x = new Slot[String]("test") // Make a slot
val y: Slot[Any] = x             // Ok, 'cause String is a subtype of Any
y.set(new Rational(1, 2))        // Works, but now x.get() will blow up 

如果您觉得我不理解您的问题（一种明显的可能性），请尝试在问题描述中添加更多解释/上下文，我会再试一次。

回应您的编辑：不可变插槽是一种完全不同的情况...*微笑*我希望上面的示例有所帮助。

Answer 4

您需要对参数应用下限。 我很难记住语法，但我认为它看起来像这样：

class Slot[+T, V <: T](var some: V) {
  //blah
}

Scala-by-example 有点难以理解，一些具体的例子会有所帮助。