scala - 在scala中，如何指示编译器实现两个抽象类型的等价？

Question

我有一个简单的案例来测试scala的类型推断能力:

    trait Super1[S] {

      final type Out = this.type
      final val out: Out = this
    }

    trait Super2[S] extends Super1[S] {

      final type SS = S
    }

    case class A[S](k: S) extends Super2[S] {}

    val a = A("abc")

    implicitly[a.type =:= a.out.type]
    // success

    implicitly[a.Out =:= a.out.Out]
    // success

    implicitly[a.SS =:= a.out.SS]
    implicitly[a.SS <:< a.out.SS]
    implicitly[a.out.SS <:< a.SS]
    // oops

最后 4 行的错误如下所示:

[Error] /home/peng/git-spike/scalaspike/common/src/test/scala/com/tribbloids/spike/scala_spike/AbstractType/InferInheritance.scala:28: Cannot prove that a.SS =:= Super2.this.SS.
[Error] /home/peng/git-spike/scalaspike/common/src/test/scala/com/tribbloids/spike/scala_spike/AbstractType/InferInheritance.scala:29: Cannot prove that a.SS <:< Super2.this.SS.
[Error] /home/peng/git-spike/scalaspike/common/src/test/scala/com/tribbloids/spike/scala_spike/AbstractType/InferInheritance.scala:30: Cannot prove that Super2.this.SS <:< a.SS.
three errors found

显然 Scala 编译器在这些情况下搞砸了:如果我移动:

      final type Out = this.type
      final val out: Out = this

下 Super2它将成功编译。我的问题是:为什么现状推理算法在这种情况下不起作用？以及如何重写我的代码来规避编译器的这个问题？

Answer 1

如 a.SS =:= a.out.SS那么我们应该能够使用一个来代替另一个。是这样吗？

不。

val x: a.SS = "hello"
val y: a.out.SS = "hello"

编译这个我得到:

ScalaFiddle.scala:29: error: type mismatch;
 found   : lang.this.String("hello")
 required: Super2.this.SS
    (which expands to)  S
  val y: a.out.SS = "hello"

看起来 Scala 明白 a.SS真的是 String ，这并不奇怪。

但是很明显 a.out.SS不是 String而是... S .

奇怪的是，即使它显然是错误的，这仍然有效:

val b = A(1)
implicitly[a.out.SS =:= b.out.SS]

如果你只是定义 out类型为 this.type那么你的代码有效。

我能想到的最好的方法是在定义 out 的类型时, Scala 无法关联由 S 表示的实际类型与 out所以类型 SS通过 out 查看只有泛型类型 S .

型号 Out似乎理解 S 所代表的实际类型，所以这有效:

implicitly[a.SS =:= a.Out#SS]
implicitly[a.SS <:< a.Out#SS]
implicitly[a.Out#SS <:< a.SS]

这正确地无法编译:

val b = A(1)
implicitly[a.Out#SS =:= b.Out#SS]