scala：使用 F-Bound 参数引用特征答案

【问题标题】：scala: Referencing Trait with F-Bound Parametersscala：使用 F-Bound 参数引用特征
【发布时间】：2015-04-20 14:22:04
【问题描述】：

我正在设计一个 F-Bound 数据类型，并且有一个工作伴侣对象。我想从特征本身引用这个伴生对象，但我无法正确获取类型。

trait A[AA <: A[AA]] {
  self =>
  val data: String
}
case class A1(data : String) extends A[A1]

trait B[BB <: B[BB, AA], AA <: A[AA]] {
  self: BB =>
  val content: AA
  def companion: BComp[BB, AA]  // What is the correct type?
  def companion2: BComp2[BB, AA] // What is the correct type?
}
trait BComp[BB[X <: BB[X, AA], Y <: AA[Y]], AA[Y <: AA[Y]]]

trait BComp2[BB[X <: AA[X]], AA[X <: AA[X]]]

case class BInst[AA <: A[AA]](content: AA) extends B[BInst[AA], AA] {
  def companion = BInst
  def companion2 = BInst2
}

object BInst extends BComp[B, A]
object BInst2 extends BComp2[BInst, A]

companion 或 companion2 的有效解决方案就足够了，尽管关于如何构造这些类型签名的一般提示会很有用。

编辑

我想使用伴随对象来存储 canBuildFrom 样式的隐式以及构建器，但是由于内容类型 A 有一个上限，所有生成函数都需要知道这个边界，因此参数化伴生对象的特征。这个设计的灵感来自GenericCompanion.scala，当然，添加类型边界让一切变得更加困难：P

【问题讨论】：

+ 一个简洁完整的不可编译最小工作示例；）
好的，抱歉 - 如果您注释掉 companion 和 companion2 两个定义，它将编译。
不，我说的是真的。没有讽刺。这个问题是好。但在这种情况下，我们不是运行代码，而是使用类型系统计算运行时行为的静态编译时间近似。因此，代码完全符合它应该的样子：它在类型检查阶段失败，而不是在运行时失败。
我很确定我对 CBF 和 Builders 和 Companion 对象有所了解：stackoverflow.com/questions/23432339/… 但是，我无法将所有 A 和 BB 映射到 cbf 和构建器。受 GenericCompanion 启发的说法太含糊了，恕我直言，所以我不明白你想要达到什么目的。
另一条评论：约定是像CC 这样的标识符代表某种集合。特别是，它总是CC[_]，而不仅仅是CC。我在你的代码中看不到它。

标签： scala parametric-polymorphism

【解决方案1】：

任何明确定义companion 类型的障碍在于BComp 由两个参数化 类型参数化——而第一个与B 兼容，第二个与@987654324 兼容@ 是不可能构造的。所以很简单，我们需要将此类型添加到B的参数化中：

trait B[BB <: B[BB, AA, X],
        AA[T <: AA[T]] <: A[T], 
        X <: AA[X]]  {
    self: BB =>
    val content: X
    def companion: BComp[B, AA]
}

现在我们的伴生对象有一个兼容的类型AA（只需要一个小的扩展）：

trait BComp[BHere[BB <: BHere[BB, AAA, Z],
                  AAA[Y <: AAA[Y]],
                  Z <: AAA[Z]],
            AA[Y <: AA[Y]]]

是不是很漂亮？

case class BInst[X <: A[X]](content: X) extends B[BInst[X], A, X] {
    def companion: BComp[B, A] = BInst5
  }
object BInst extends BComp[B, A]

companion2

对于companion2，我们只需要改变B的参数化的第一部分，使得trait B和伴随的trait变成：

trait B[BB[TS <: AA[TS]] <: B[BB, AA, TS],
        AA[T <: AA[T]] <: A[T], 
        X <: AA[X]] {
    self: BB[X] =>
    val content: X
    def companion2: BComp[BB, AA]
  }

trait BComp[BHere[TS <: AA[TS]],
            AA[Y <: AA[Y]]]

这稍微更易于管理。案例类和案例对象是：

case class BInst[X <: A[X]](content: X) extends B[BInst, A, X] {
  def companion2: BComp[BInst, A] = BInst5
}
object BInst extends BComp[BInst, A]

如果这对任何人有用，请重新考虑。我已经改变了我自己的设计方法，我建议你也这样做。想出解决这些类型的方法现在只是一项纯粹的学术活动！

【讨论】：