MyClass 和 MyClass.this.type 之间有什么区别以及如何将其转换为另一个？

Question

我有类似这样的情况：

trait Abst{
  type T
  def met1(p: T) = p.toString
  def met2(p: T, f: Double=>this.type){
    val v = f(1.0)
    v.met1(p)
  }
}
class MyClass(x: Double) extends Abst{
  case class Param(a:Int)
  type T = Param
  val s = met2(Param(1), (d: Double) => new MyClass(d))
}

在我运行它之前它不会显示错误，然后它会说：

类型不匹配；找到：MyClass，必填： MyClass.this.type

我也尝试了泛型类型的解决方案，但后来我遇到了 this.T 与 v.T 不同的冲突

所以如果可能的话，我只需要克服上面的错误信息？

---

更新

因此，this.type 是该单个实例的 singleton type。我在评论中建议使用

val s = met2(Param(1), (d: Double) => (new MyClass(d)).asInstanceOf[this.type])

所以如果有人对此发表评论，我知道它有多丑陋，只是对它有多不安全感兴趣？

你们也都提议将 Param 的定义移到课堂之外，我绝对同意。所以它的定义会在伴生对象MyClass中

Answer 1

this.type 是 singleton type，它被一个单一的值所占据，即this。因此，接受f: X => this.type 类型的函数作为参数肯定是没有意义的，因为f 的每次调用都可以被this 替换（加上f 执行的副作用）。

这是一种强制您的代码以最少更改进行编译的方法：

trait Abst { self =>
  type T
  def met1(p: T) = p.toString
  def met2(p: T, f: Double => Abst { type T = self.T }){
    val v = f(1.0)
    v.met1(p)
  }
}

case class Param(a:Int)
class MyClass(x: Double) extends Abst {
  type T = Param
  val s = met2(Param(1), (d: Double) => new MyClass(d))
}

但老实说：不要这样做。而且也不要做任何 F 有界的东西，它可能最终会变得一团糟，特别是如果你不熟悉这种模式。相反，重构你的代码，这样你就没有任何自引用螺旋。

---

更新

关于为什么告诉编译器 (new MyClass(d)) 的类型为 this.type 而其他 this: MyClass 是一个非常糟糕的主意：

abstract class A {
  type T
  val x: T
  val f: T => Unit
  def blowup(a: A): Unit = a.asInstanceOf[this.type].f(x)
}

object A {
  def apply[X](point: X, function: X => Unit): A = new A {
    type T = X
    val x = point
    val f = function
  }
}

val a = A("hello", (s: String) => println(s.size))
val b = A(42, (n: Int) => println(n + 58))

b.blowup(a)

尽管a 和b 都属于A 类型，但是这会导致ClassCastException。

Answer 2

如果您不介意让 trait 将 T 作为通用参数，这是一个相当简单直接的等效解决方案：

trait Abst[T]{
  def met1(p: T) = p.toString
  def met2(p: T, f: Double=>Abst[T]){
    val v = f(1.0)
    v.met1(p)
  }
}

case class Param(a:Int)
class MyClass(x: Double) extends Abst[Param]{
  val s = met2(Param(1), (d: Double) => new MyClass(d))
}

我说它是等价的，因为让met2 使用超类型而不是子类型不会丢失任何信息。在特征中引用子类型的经典用例是例如有一个您想要返回 MyClass 而不是 Abst 的方法，即使它是在 Abst 中定义的，但这不是您所处的情况。唯一使用子类型引用的地方是 f 的定义，由于函数类型在其输出参数上是协变的，因此您可以毫无问题地将任何 f: Double => MyClass 传递给 f: Double => Abst[T]。

如果您确实想引用子类型，请参阅 Markus 的回答...如果您确实想避免将 T 用作通用参数，那么事情又会变得更加复杂，因为现在您有潜在的冲突在Abst 的T 与met2 定义中子类型的T 之间。

Answer 3

要克服此错误消息，您必须使用 F-bounded polymorphism。

您的代码将如下所示：

trait Abst[F <: Abst[F, T], T]{ self: F =>

  def met1(p: T): String = p.toString

  def met2(p: T, f: Double => F): String = {
    val v = f(1.0)
    v.met1(p)
  }
}

case class Param(a:Int)

class MyClass(x: Double) extends Abst[MyClass, Param] {
  val s = met2(Param(1), (d: Double) => new MyClass(d))
}

解释：

在 trait 或类定义中使用 self: F => 会限制 this 的值。因此，如果 this 不是 F 类型，您的代码将无法编译。

我们使用F:F <: Abst[F, T]的循环类型约束。虽然违反直觉，但编译器并不介意。

在实现中，MyClass，然后我们用Abst[MyClass, Param] 扩展MyClass，这反过来又满足F <: Abst[F, T]。

现在您可以在Abst 中使用F 作为函数的返回类型，并让MyClass 在实现中返回MyClass。

---

你可能认为这个解决方案很丑，如果你这样做，那么你是对的。

始终建议使用 临时多态性的类型类，而不是使用 F 有界多态性。

您将在我之前提供的链接中找到有关它的更多信息。

真的，阅读它。它将永远改变你对泛型编程的看法。

我希望这会有所帮助。