scala - 继承和自递归类型推断

Question

(斯卡拉 2.11.8)

我有一个特征 GenTableLike 具有复杂的自递归类型签名，它定义了方法 ++ 用于连接兼容的表实现。我还有一个层次结构 GenTableLike >: KeyTable >: MapKeyTable。但是，++'ing 两个 MapKeyTable 无法推断自递归类型。

这里有一些简化的片段，其中问题仍然重现:

trait GenTableLike[RKT,
                   CKT,
                   +A,
                   +SelfType[+A2] <: GenTableLike[RKT, CKT, A2, SelfType, TransposedType],
                   +TransposedType[+A2] <: GenTableLike[CKT, RKT, A2, TransposedType, SelfType]] {
  def ++[B >: A,
         T2 <: GenTableLike[RKT, CKT, B, ST, TT],
         ST[+A2] <: GenTableLike[RKT, CKT, A2, ST, TT],
         TT[+A2] <: GenTableLike[CKT, RKT, A2, TT, ST]](that: T2): SelfType[B] = ???
}

trait KeyTable[RKT, CKT, +A]
  extends GenTableLike[RKT,
                       CKT,
                       A,
                       KeyTable.Curried[RKT, CKT]#Self,
                       KeyTable.Curried[CKT, RKT]#Self]

object KeyTable {
  /** Type helper for defining self-recursive type */
  type Curried[RKT, CKT] = {
    type Self[+A] = KeyTable[RKT, CKT, A]
  }
}

class MapKeyTable[RKT, CKT, +A]
  extends KeyTable[RKT, CKT, A]
  with GenTableLike[RKT,
                    CKT,
                    A,
                    MapKeyTable.Curried[RKT, CKT]#Self,
                    MapKeyTable.Curried[CKT, RKT]#Self]

object MapKeyTable {
  /** Type helper for defining self-recursive type */
  type Curried[RKT, CKT] = {
    type Self[+A] = MapKeyTable[RKT, CKT, A]
  }
}

val t1: MapKeyTable[Int, String, Int] = ???
val t2: MapKeyTable[Int, String, Any] = ???

// The following works
t1.++[Any, MapKeyTable[Int, String, Any], ({ type ST[+A2] = MapKeyTable[Int, String, A2] })#ST, ({ type TT[+A2] = MapKeyTable[String, Int, A2] })#TT](t2)
t1.++[Any, MapKeyTable[Int, String, Any], MapKeyTable.Curried[Int, String]#Self, MapKeyTable.Curried[String, Int]#Self](t2)
// Error: inferred type arguments [Int,MapKeyTable[Int,String,Any],Nothing,Nothing] do not conform to method ++'s type parameter bounds [B >: Int,T2 <: GenTableLike[Int,String,B,ST,TT],ST[+A2] <: GenTableLike[Int,String,A2,ST,TT],TT[+A2] <: GenTableLike[String,Int,A2,TT,ST]]
t1 ++ t2

我是不是做错了什么？

注意事项:

自类型和转置类型用于定义函数返回类型。我还有一个如下定义的 IndexedTable 实现，所以我无法重新处理自身类型以接受 3 个参数

trait IndexedTable[+A]
    extends GenTableLike[Int,
                         Int,
                         A,
                         IndexedTable,
                         IndexedTable]

class IndexedSeqTable[+A]
    extends IndexedTable[A]
    with GenTableLike[Int,
                      Int,
                      A,
                      IndexedSeqTable,
                      IndexedSeqTable]

Answer 1

如何将 SelfType 和 TransposeType 转换为抽象类型？这更简单，并且有效:

import scala.language.higherKinds

trait GenTableLike[RKT, CKT, +A] {
  type SelfType[+A2] <: GenTableLike[RKT, CKT, A2]
  type TransposedType[+A2] <: GenTableLike[CKT, RKT, A2]

  def ++[B >: A](that: GenTableLike[RKT, CKT, B]): SelfType[B]
}

trait KeyTable[RKT, CKT, +A]
  extends GenTableLike[RKT, CKT, A] {
  override type SelfType[+A2] <: KeyTable[RKT, CKT, A2]
  override type TransposedType[+A2] <: KeyTable[CKT, RKT, A2]
}

class MapKeyTable[RKT, CKT, +A]
  extends KeyTable[RKT, CKT, A] {
  override type SelfType[+A2] = MapKeyTable[RKT, CKT, A2]
  override type TransposedType[+A2] = MapKeyTable[CKT, RKT, A2]

  override def ++[B >: A](that: GenTableLike[RKT, CKT, B]): MapKeyTable[RKT, CKT, B] =
    new MapKeyTable[RKT, CKT, B]
}

val t1 = new MapKeyTable[Int, String, Int]
val t2 = new MapKeyTable[Int, String, Any]

// The following works
t1.++[Any](t2)
t1 ++ t2


trait IndexedTable[+A]
  extends GenTableLike[Int, Int, A] {
  override type SelfType[+A2] <: IndexedTable[A2]
  override type TransposedType[+A2] <: IndexedTable[A2]
}

class IndexedSeqTable[+A]
  extends IndexedTable[A] {
  override type SelfType[+A2] = IndexedSeqTable[A2]
  override type TransposedType[+A2] = IndexedSeqTable[A2]

  override def ++[B >: A](that: GenTableLike[Int, Int, B]): IndexedSeqTable[B] = new IndexedSeqTable[B]
}

2 月 15 日更新以回应 Alex 的评论:

递归类型 + 继承是棘手的，我总是尽可能避免它:-)。
如果 SelfType 和 TransposeType 仅用作函数返回类型，如何消除 SelfType 和 TransposeType 一起使用隐式构建器，如:

import scala.language.higherKinds

trait GenTableLike[RKT, CKT, +A] {

  def value: A

  def ++[B >: A](that: GenTableLike[RKT, CKT, B])(implicit builder: GenTableLike.Builder[this.type, B]): builder.Self = {
    builder.buildSelf(that.value)
  }

  def transpose(implicit builder: GenTableLike.Builder[this.type, A]) = builder.buildTranspose(value)

}

object GenTableLike {

  trait Builder[-This, -A] {
    type Self
    type Transpose

    def buildSelf(a: A): Self

    def buildTranspose(a: A): Transpose
  }

}

trait KeyTable[RKT, CKT, +A]
  extends GenTableLike[RKT, CKT, A] {
}

class MapKeyTable[RKT, CKT, +A](override val value: A)
  extends KeyTable[RKT, CKT, A] {
}

object MapKeyTable {

  implicit def builder[RKT, CKT, A] = new GenTableLike.Builder[MapKeyTable[RKT, CKT, A], A] {
    override type Self = MapKeyTable[RKT, CKT, A]
    override type Transpose = MapKeyTable[CKT, RKT, A]

    override def buildSelf(a: A): Self = new MapKeyTable[RKT, CKT, A](a)

    override def buildTranspose(a: A): Transpose = new MapKeyTable[CKT, RKT, A](a)
  }

}

class MapKeyTableEx[RKT, CKT, +A](override val value: A)
  extends MapKeyTable[RKT, CKT, A](value)

object MapKeyTableEx {
  implicit def builder[RKT, CKT, A] = new GenTableLike.Builder[MapKeyTableEx[RKT, CKT, A], A] {
    override type Self = MapKeyTableEx[RKT, CKT, A]
    override type Transpose = MapKeyTableEx[CKT, RKT, A]

    override def buildSelf(a: A): Self = new MapKeyTableEx[RKT, CKT, A](a)

    override def buildTranspose(a: A): Transpose = new MapKeyTableEx[CKT, RKT, A](a)
  }

}


val t1 = new MapKeyTable[Int, String, Int](1)
val t2 = new MapKeyTable[Int, String, Any]("b")
val t3 = new MapKeyTableEx[Int, String, Int](1)
val t4 = new MapKeyTableEx[Int, String, Any]("b")

// The following works
t1 ++ t2
t1 ++ t3
t2 ++ t3
t3 ++ t4

t1.transpose
t2.transpose
t3.transpose
t4.transpose