为什么 var 在 Scala 中编译 val 时会导致类型差异错误？

Question

scala> case class Data[+T](val value:T=null)
defined class Data

scala> val foo=Data[ArrayBuffer[Data[Any]]]()
foo: Data[scala.collection.mutable.ArrayBuffer[Data[Any]]] = Data(null)

scala> foo.value+=Data[String]()
java.lang.NullPointerException
  ... 33 elided

我想要一个 Data class 实例化为 Data[String]、Data[ArrayBuffer[Data[Any]]] 或 Data[Map[String,Data[Any]]] .在上面的示例中，我尝试将其实例化为 Data[ArrayBuffer[Data[Any]]] 并将 Data[String] 添加到其数组缓冲区。当然我得到一个空指针异常，因为值是空的。但是这个例子的重点是它至少可以编译和运行。

现在，在 Data 构造函数中，我想根据初始值的类型将值实例化为 Data[String]、ArrayBuffer[Data[Any]] 或 Map[String,Data[Any]] getClass 方法返回的空值。但是为此我需要 value 是一个 var，这样我就可以在检查它的 null 值的类型后修改它。

但是我得到这个错误：

scala> case class Data[+T](var value:T=null)
<console>:11: error: covariant type T occurs in contravariant position in type T of value value_=
       case class Data[+T](var value:T=null)

Answer 1

http://like-a-boss.net/2012/09/17/variance-in-scala.html#variance_and_type_safety

Variance and type safety

When defining a generic class with a var field we can get compile time errors:

scala> class Invariant[T](var t: T)
defined class Invariant

scala> class Covariant[+T](var t: T)
<console>:7: error: covariant type T occurs in contravariant position in type T of value t_=
      class Covariant[+T](var t: T)
            ^

scala> class Contravariant[-T](var t: T)
<console>:7: error: contravariant type T occurs in covariant position in type => T of method t
      class Contravariant[-T](var t: T)

Let’s break it down a little. Why doesn’t the compiler allow getters in the Covariant class?

scala> abstract trait Covariant[+T] {
    |   def take(t: T): Unit
    | }
<console>:8: error: covariant type T occurs in contravariant position in type T of value t
        def take(t: T): Unit
                  ^

scala> abstract trait Contravariant[-T] {
    |   def take(t: T): Unit
    | }
defined trait Contravariant

Why? Let’s think about usages of covariance let’s say that we have a class:

class Printer[+T] {
    |    def print(t: T): Unit = ???
    | }
<console>:8: error: covariant type T occurs in contravariant position in type T of value t
          def print(t: T): Unit = ???

If the print method can print Dogs does it make sense (in general) that it should also print Animals? Maybe sometimes but in the general sense if we want to generalize the Printer class we should use contravariance. The compiler is smart enough to check this type of usage for us.

Let’s think about the second use case: returning a generic parameter:

scala> class Create[-T] {
    |   def create: T = ???
    | }
<console>:8: error: contravariant type T occurs in covariant position in type => T of method create
        def create: T = ???

And again - does it make sense that Create should generalize by contravariance? If Create returns instances of the Animal class should we be able to use it in every place that expects Create[Dog]? The scala compiler is smart enough that it explodes in our face if we try it.

Answer 2

让你的 Data 在 T 中保持不变。只需删除 +: Data[T] - 这应该可以编译。更好的是，重新考虑您的设计以摆脱空值和可变变量 - 它们都有异味。

编辑：在阅读了您的评论后，我更好地理解了您的意图。例如考虑这样的事情作为选项之一。

sealed trait Node 
case class ListNode(list: Seq[Node]) extends Node
case class MapNode(map: Map[String, Node]) extends Node
case class LeafNode(data: String) extends Node

现在您可以用类似的东西解析您的文档（这是 "pseudocode"，将其调整为您正在使用的任何 xml-parsing 库）：

def parseNode(tag: XMLTag): Node = tag.tagType match {
   case LIST => 
      val subNodes = tag.getNestedTags.map(parseNode)
      ListNode(subNodes)
   case MAP => 
      val subNodes = tag.getNestedTags.map { tag => 
        tag.name -> parseNode(tag) 
      }
      MapNode(subNodes.toMap)
   case _ =>  
      LeafNode(tag.text)
}

Answer 3

我可以这样做：

package data

case class Data[+T](val value:T)
{
    println(value.getClass)
}

这样我就必须从构造函数中显式初始化值。没什么问题，只是我觉得它有点太冗长了。

import data.Data

import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.Map

object Run extends App
{

    val a=Data[ArrayBuffer[Data[Any]]](ArrayBuffer[Data[Any]]())

    a.value+=Data[String]("bar")

    println(a.value)

    val m=Data[Map[String,Data[Any]]](Map[String,Data[Any]]())

    m.value+=("foo"->Data[String]("bar"))

    println(m.value)

}

这会打印：

class scala.collection.mutable.ArrayBuffer
class java.lang.String
ArrayBuffer(Data(bar))
class scala.collection.mutable.HashMap
class java.lang.String
Map(foo -> Data(bar))

该程序只能使用具有 +T 类型参数的 Data 进行编译，否则会出现错误：

type mismatch;
[error]  found   : data.Data[String]
[error]  required: data.Data[Any]
[error] Note: String <: Any, but class Data is invariant in type T.
[error] You may wish to define T as +T instead. (SLS 4.5)
[error]         a.value+=Data[String]("bar")

为什么 var 在 Scala 中编译 val 时会导致类型差异错误？

Why does var cause a type variance error where val compiles in Scala?

types

scala

variance