Scala不变的泛型类型参数被方法参数类型忽略，具体取决于参数是文字表达式还是变量

Question

概括

如果我将文字表达式作为参数传递给函数，那不应该与首先评估相同的文字表达式，然后将变量绑定(bind)到从该评估返回的值，然后将变量名作为相同的参数传递到相同的功能？如果该文字表达式为函数的参数返回了错误的类型，那么跳过将值分配给一个中间变量的步骤，该变量的类型 Scala 从表达式的返回值中推断出来，不应该在之前将不兼容的类型传递给函数它引发了类型不匹配错误，应该吗？然而，这不是以下示例所显示的吗？

例子

这里我尝试获取 Array[Super] 类型的函数参数接受 Array[Sub] 的值.在 Scala repl 中声明以下内容。注意函数的单个参数的类型:

class Super
class Sub extends Super
def wantsSuperArray(a: Array[Super]) { println(a.size) }

然后构造 Sub的实例

scala> val s = new Sub
s: Sub = Sub@2c9fa2fb

创建 Array[Sub] :

scala> val subArray = Array(s)
subArray: Array[Sub] = Array(Sub@2c9fa2fb)

以下将表明通用 Array is invariant in its element type ，以及 Array[Sub]不是 Array[Super]即使是 Sub是 Super :

scala> wantsSuperArray(subArray)
<console>:13: error: type mismatch;
 found   : Array[Sub]
 required: Array[Super]
Note: Sub <: Super, but class Array is invariant in type T.
You may wish to investigate a wildcard type such as `_ <: Super`. (SLS 3.2.10)
              wantsSuperArray(subArray)
                              ^

到目前为止没有任何惊喜。

令人惊讶的观察

我们刚刚看到 wantsSuperArray()不会将 Array[Sub] 作为参数类型.那么为什么下面不会产生与上面相同的类型不匹配错误消息呢？

scala> wantsSuperArray(Array(new Sub))
1

同样，为什么会引发这个没有错误？

scala> wantsSuperArray(Array(s))
1

考虑到编译器对这三个变体的处理与 repl 一致，即拒绝编译并为第一个提供相同的类型不匹配错误，并编译第二个和第三个。

附加细节

如果我们明确参数化 Array如下然后错误信息再次出现:

scala> wantsSuperArray(Array[Sub](new Sub))
<console>:11: error: type mismatch;
 found   : Array[Sub]
 required: Array[Super]
Note: Sub <: Super, but class Array is invariant in type T.
You may wish to investigate a wildcard type such as `_ <: Super`. (SLS 3.2.10)
              wantsSuperArray(Array[Sub](new Sub))
                                        ^

因此，显然当不涉及中间变量时，Scala 可以看到 wantsSuperArray 的类型。想要并且正在做某种转换，可能从 Array[Sub] 转换至 Array[Super] .尽管如此，这似乎是一个陷阱，因为我仍然认为是否使用中间变量的选择不应该在程序的操作中造成这样的差异，而且这种特殊情况似乎是在执行强制转换而不是引发错误基于泛型 Array 的不变性，程序员会期望类型参数。

问题

如果我相信在调用 wantsSuperArray()如上所述，传递一个文字表达式应该与传递一个变量的名称相同，该变量包含评估同一表达式所产生的值，如上所示，那么我误解了什么？

我怎样才能更好地理解我在这里观察和提示的内容？

我可以在 Scala 文档中的什么地方阅读我在这里观察到的现象，以便能够理解它并且再也不会对它感到惊讶？

Answer 1

这是因为 Scala 基于 wantsSuperArray 的预期类型执行类型推断。范围。
所以即使 Array(new Sub)单独使用将被推断为 Array[Sub] 类型的表达式，编译器会看到您处于类型为 Array[Super] 的值的上下文中。是预期的，因此在调用 Array.apply 时(这是通用的)它尝试使用 Super作为类型参数(而不是 Sub )，它正确类型( Array.apply 采用类型为 T 的参数的可变参数列表，此处为 T = Super 并且您传递 Sub 的实例，这是一个子Super 的类型，即声音)。

这是 scala 规范的相关摘录，第 6.1 章:表达式类型，第 6.6 章:函数应用程序和第 6.26.4 章:局部类型推断(强调我的):

The typing of expressions is often relative to some expected type (1) (which might be undefined). When we write “expression e is expected to conform to type T ”, we mean: the expected type of e is T , and the type of expression e must conform to T .

...

An application f (e1, ..., em) applies the function f to the argument expressions e1, ..., em. If f has a method type (p1:T1, ..., pn:Tn)U, the type of each argument expression ei is typed with the corresponding parameter type Ti as expected type (2). Let Si be type type of argument ei (i in 1, ..., m). If f is a polymorphic method, local type inference is used to determine type arguments for f (3) .

...

If f is a polymorphic method it is applicable if local type inference can determine type arguments so that the instantiated method is applicable (4)*.

...

Local type inference infers type arguments to be passed to expressions of polymorphic type. Say e is of type [a1 >: L1 <: U1, ..., an >: Ln <: Un]T and no explicit type parameters are given ... If the expression e appears as a value without being applied to value arguments, the type arguments are inferred by solving a constraint system which relates the expression’s type T with the expected type pt (5)

第 (3) 和 (4) 点解释了表达式 Array(new Sub) 中的含义。 , 类型推断来自 new Sub至 Array.apply产生类型 Array[Sub] .这是您显然没有问题的“简单”案例。如果你只接受这条规则， Array(new Sub)应键入 Array[Sub] .事实上，当它被单独输入时会发生这种情况(例如 val subArray = Array(new Sub) ， subArray 确实具有类型 Array[Sub] )。

但是点 (1)、(2) 和 (5) 一起也说在 wantsSuperArray(Array(new Sub)) ，参数的预期类型为 wantsSuperArray (即 Array[Super] )传递给表达式 Array(new Sub) (因为它是多态类型的表达式，其中类型参数没有明确给出)。因此表达式 Array(new Sub)计算为表达式 Array[Super](new Sub) .换句话说，它的类型为 Array[Super] .