双向关联中的泛型

Question

假设我有两个类 A 和 B，其中 B 是 A 的子类型。显然，这只是更丰富的类型层次结构的一部分，但我认为这不相关。假设 A 是层次结构的根。有一个集合类 C，它跟踪 A 的列表。但是，我想让 C 变得通用，这样就可以创建一个只保留 B 而不接受 A 的实例。

class A(val c: C[A]) {
    c.addEntry(this)
}
class B(c: C[A]) extends A(c)
class C[T <: A]{
    val entries = new ArrayBuffer[T]()
    def addEntry(e: T) { entries += e }
}
object Generic {
    def main(args : Array[String]) {
        val c = new C[B]()
        new B(c)
    }
}

上面的代码显然在 new B(c) 行上给出了错误“类型不匹配：找到 C[B]，需要 C[A]”。

我不知道如何解决这个问题。不可能使 C 在 T 中协变（如 C[+T <: A]），因为 ArrayBuffer 在 T 中是非变体类型。不可能使 B 的构造函数需要 a C[B] 因为 C 不能协变。

我是不是找错树了？我是一个十足的 Scala 新手，所以任何想法和技巧可能都会有帮助。谢谢你！

编辑： 基本上，我想要的是编译器接受两者

val c = new C[B]()
new B(c)

，

val c = new C[A]()
new B(c)

但会拒绝

val c = new C[B]()
new A(c)

它可能可以将 C 中 ArrayBuffer 的类型放宽为 A 而不是 T，因此在 addEntry 方法中也是如此，如果这有帮助的话。

Answer 1

如果你想跟踪 A 的实例，则必须将 C[A] 的实例传递给 B 的构造函数，因为每个 B 也是 A：

def main(args : Array[String]) {
    val c = new C[A]()
    new B(c)
}

但是，如果你想跟踪 B，那么你可以'不要将其委托给 A，因为 A 对 B 一无所知。

总的来说，我感觉你的问题有点不适。

Answer 2

假设这是可能的。然后您就可以执行以下操作：

class A(val c: C[A]) {
    c.addEntry(this)
}
class B(c: C[A]) extends A(c)
class C[+T <: A]{
    val entries: ArrayBuffer[T] @uncheckedVariance = new ArrayBuffer[T]()
    def addEntry(e: T @uncheckedVariance) { entries += e }
}
object Generic {
    def main(args : Array[String]) {
        // Everything's fine so far...
        val c = new C[B]()
        c.addEntry(new B(c))
        // but, suddenly...
        val ca: C[A] = c
        ca.addEntry(new A(ca))
        // a problem appears!
        c.entries forall {
            case thing: B => true // ok
            case otherThing => false // not ok -- c now contains an A!
        }
    }
}

尝试运行此代码将导致类转换异常。

编辑

您添加了此要求：

val c = new C[B]()
新B(c)

和

val c = new C[A]()
新B(c)

但会拒绝

val c = new C[B]()
新A(c)

但是，如果 B 使用 C[B] 初始化，并且考虑到 B 扩展 A ，那么B将使用C[B]初始化A，从而违反了最后一个要求。

Answer 3

不可能在 T 中使 C 协变（例如 C[+T <: A]），因为 ArrayBuffer 在 T 中是非变体类型

不仅因为这个。 addEntry 的类型足以禁止它：

val a: A = ...
val b: B = ...

val cb: C[B] = ...

cb.addEntry(b) // works
cb.addEntry(a) // doesn't and shouldn't

Answer 4

Hacky，但似乎有效：

class A(val c: C[A]) {
  c.addEntry(this.asInstanceOf[c.X])
}

class B(c: C[B]) extends A(c)

class C[+T <: A] {
    type X <: T
    val entries = new ArrayBuffer[X]()
    def addEntry(e: X) { entries += e }
}

object Generic {
    def main(args : Array[String]) {
        val c = new C(){ type T = B }
        new B(c)
    }
}

当然我也对适当的解决方案感兴趣......