如何对参数化类型（类）进行分组？

Question

给定三个属于同一类的类（我试图通过类型参数来表达）：

abstract class Row[T <: Table[T, R, B], 
                   R <: Row[T, R, B], 
                   B <: RowBuffer[T, R, B]] extends Immutable {
  def id: Int
  def getTable: T
  def toRowBuffer: B

  def delete() {
    // does not compile: Found Row.this.type ... Row[T, R, B], required: R
    getTable.delete(this)
  }
}

---

abstract class RowBuffer[T <: Table[T, R, B], 
                         R <: Row[T, R, B], 
                         B <: RowBuffer[T, R, B]] extends Mutable {
  def id: Int
  def getTable: T
  def toRow: R

  def insert(): R = {
    // does not compile: Found RowBuffer.this.type ... RowBuffer[T, R, B], 
    // required: B
    getTable.insert(this)
  }
}

---

abstract class Table[T <: Table[T, R, B], 
                     R <: Row[T, R, B], 
                     B <: RowBuffer[T, R, B]] {
  def insert(b: B): R = {
    // insert ...
    b.toRow
  }

  def delete(r: R) {
    // delete ...
  }

如果有“跨类”调用，我还没有设法定义正确的类型。 所以我的问题是：

• 这个问题叫什么名字？
• 如何以类型安全的方式表达它？

Answer 1

我总是称这种构造为“表示”类型，但也许这不是正式名称（您可能听说过“F-bounded quantification”一词）。您的类型Row 和RowBuffer 分别采用递归类型R 和B，它描述了最终实现的类型（“表示”）。

为了确保你可以填写抽象类的方法，你需要声明最终实现将分别符合R和B。您可以使用自类型注释来做到这一点：

abstract class Row[T <: Table[T, R, B], 
                   R <: Row[T, R, B], 
                   B <: RowBuffer[T, R, B]] extends Immutable {
  _: R =>

  ...
}

abstract class RowBuffer[T <: Table[T, R, B], 
                         R <: Row[T, R, B], 
                         B <: RowBuffer[T, R, B]] extends Mutable {
  _: B =>

  ..
}

请注意，您可以使用任何标识符，例如this: R => 或 self: R =>。

有了这些，它就可以编译了，你不能创建一个不满足约束的非抽象子类。