Question

以下无法使用Scala 2.11.4进行编译：

trait Test {
  type A
  type F = Function1[A, String]
}

trait Util[T <: Test] {
  def compute1( f: T#A => String, a: T#A ): String = f(a)
  def compute2( f: T#F, a: T#A ): String = f(a)
  //                                         ^
}

调用的参数（^）存在编译错误：

type mismatch; 
found : a.type (with underlying type T#A) required: _3317.A

我原本期望compute1和compute2中的两个f参数具有相同的类型;显然不是。

发生了什么事？

@Eugene和@ Zim-Zam回答说，这里的问题是由于Scala的路径依赖类型。基于他们的建议，我想出了几个选择：

trait Test {
  type A
  type Fa = Function1[A, String]       // original question
  type Fb = Function1[Test#A, String]  // Zim-Zam's suggestion
}

trait TestOps[T <: Test] {
  type G = Function1[T#A, String]
}

trait Util[T <: Test] {
  def compute1( f: T#A => String, a: T#A ): String = f(a)
  // def compute2a( f: T#Fa, a: T#A ): String = f(a)
  // type mismatch; found : a.type (with underlying type T#A) required: _1536.A
  def compute2b( f: T#Fb, a: T#A ): String = f(a)
}

trait Util1 {  
  def compute3a(t: Test)( f: t.Fa, a: t.A ): String = f(a)
  def compute3b(t: Test)( f: t.Fb, a: t.A ): String = f(a)
}

trait Util2[T <: Test] { tops: TestOps[T] =>
  // def compute4a( f: T#Fa, a: T#A ): String = f(a)
  // type mismatch; found : a.type (with underlying type T#A) required: _1642.A
  def compute4b( f: T#Fb, a: T#A ): String = f(a)
  def compute5( f: tops.G, a: T#A ): String = f(a)
}

Util将原始操作与@ Zim-Zam的建议进行比较

Util1在指定Function1参数类型方面有所不同：A vs Test#A

Util2提出了将Function1类型定义为另一个特征的建议：TestOps

注释掉未进行类型检查的变体，我们留下：

compute1 compute2b compute3a compute3b compute4b compute5

哪种特性更适合专业化？

为了梳理出差异，我做了一个简单的改进：

class U 

class TestU extends Test {
  override type A = U  
}

class UOps extends TestOps[TestU]

结果如下：

trait UtilU extends Util[TestU] {
  def get1( f: TestU#A => String, a: TestU#A) = compute1(f, a)
  // def get2b( f: TestU#A => String, a: TestU#A) = compute2b(f, a)
  // type mismatch; found : A.U ⇒ String required: A.Test#A ⇒ String
}

trait UtilU1 extends Util1 {
  val u = new TestU()
  def get3a( f: u.A => String, a: u.A) = compute3a(u)(f, a)
  // def get3b( f: u.A => String, a: u.A) = compute3b(u)(f, a)
  // type mismatch; 
  // found : UtilU1.this.u.A ⇒ String (which expands to) A.U ⇒ String 
  // required: UtilU1.this.u.Fb (which expands to) A.Test#A ⇒ String
}

class UtilU2 extends Util2[TestU] with TestOps[TestU] {
  // def get4b( f: TestU#A => String, a: TestU#A) = compute4b(f, a)
  // type mismatch; found : A.U ⇒ String required: A.Test#A ⇒ String
  def get5( f: TestU#A => String, a: TestU#A) = compute5(f, a)
}

所以，我们只剩下3个合理的变化：

compute1（没有Function1类型别名） compute3a compute5

对于别名Function1类型，我们只剩下两种选择：compute3a和compute5

描述它们之间差异的正确方法是什么？

Answer 1

这是因为在scala中实现路径依赖类型的方式

val test1 = new Test {}
val test2 = new Test {}
// test1.A is different type from test2.A

在你的例子中，你基本上是说f和a可以从不同的Test实例传递，在这种情况下，在第一个参数中用于F类的A将与第二个参数不同。

但如果你将它限制在T的某个实例，它将编译

def compute2(t: T)( f: t.F, a: t.A ): String = f(a)

<强> UPD 但是对于compute1

来说仍然应该如此

Answer 2

@Eugene关于这是由路径依赖类型引起的 - 你可以用

修复它

trait Test {
  type A
  type F = Function1[Test#A, String]
}

现在F可以将A作为参数

应用Scala Function1时因类型不匹配而感到困惑

2 个答案: