Question

我有一个斯卡拉预检问题，我无法通过。可能有人可以提供帮助。

右边的表达式是否符合声明的类型，为什么？

（a）val x2: A => C => D = (a: A) => (b: D) => new C

（b）val x3: (D => B) => A = (db: D => A) => new B

（c）var $tables = $('.resultsTable');//cache table elements to avoid repeated dom searches $tables.not(':first').hide(); $('#someButton').click(function(){ var $currTable = $tables.filter(':visible').hide(), nextIndex = $tables.index($currTable) +1; if(nextIndex === $tables.length){ nextIndex = 0; } $tables.eq(nextIndex).show(); });

类层次结构：

A级

B类延伸A

C班

D类扩展C

Answer 1

你不需要我们。只需将代码粘贴到REPL中即可。

scala> class A
defined class A

scala> class B extends A
defined class B

scala> class C
defined class C

scala> class D extends C
defined class D

scala> val x1: B => D = (b: A) => new D
x1: B => D = <function1>

scala> val x2: A => C => D = (a: A) => (b: D) => new C
<console>:10: error: type mismatch;
 found   : C
 required: D
       val x2: A => C => D = (a: A) => (b: D) => new C
                                                 ^

scala> val x3: (D => B) => A = (db: D => A) => new B
x3: (D => B) => A = <function1>

Answer 2

我猜他们之间没有正确的表达。

Answer 3

Mb有一个答案，需要更多信息。

当我们写T => F时 - 它表示函数类型，trait Function1[-P, +R] { def apply(p: P): R }的糖
当我们写(t: T) => new F时，它意味着一个lambda函数，其类型为T => F或（别名，糖）Function1[T, F]，您可以注意到{{1}是一个应用程序参数。
我们在类型上有关系，其中一个是子类型，所以你需要在这个任务中解释函数子类型。

让我们考虑为什么代码由@ChrisMartin提供，编译。

所以功能，是一个特质：

这意味着函数通过参数和协变（trait Function1[-P, +R] { def apply(p: P): R }）按结果反变（+）。

允许-，让F: P → R, p ∈ P => F(p) ∈ R。然后，F' : P' → R' : P' ⊃ P, R' ⊂ R'。

这意味着p ∈ P => p ∈ P' => F'(p) ∈ R'=> F'(p) ∈ R函数是其域上F'函数的特例。换句话说，超级类型F到子类型P的某些函数是从R到P的函数的子类型。

在您的示例中：

R是一个更通用的功能，然后是B => D（A => D是A的超级类型（检查：B）
implicitly[(A => D) <:< (B => D)]是一个更具体的功能，然后A => C => D（检查：A => D => C）
implicitly[(A => C => D) <:< (A => D => C)]是一个更通用的功能，然后(D => B) => A（检查：(D => A) => B）

在Scala中键入定义

3 个答案: