Scala:我怎样才能让我的不可变类更容易子类化？

Question

我最近创建了一个不可变类，它支持 +、- 等操作，当它被更改时，它会返回该类的新实例。

我想创建该类的子类以添加一些状态和功能，但现在我遇到了一个问题，即所有原始类的方法都返回其自身而不是子类的实例。

根据我目前对 Scala 的有限知识，我可以提出以下建议:

class Foo(val bar:Int) { 
  def copy(newBar:Int) = new Foo(newBar)
  def + (other:Foo):This = copy(this.bar + other.bar) 
}
class Subclass(barbar:Int) extends Foo(barbar) { 
  override def copy(newBar:Int) = new Subclass(newBar)
  override def + (other:Subclass) = super.+(other).asInstanceOf[Subclass]
}

这里的问题很明显——所有返回新实例的父类(super class)操作都必须在子类中使用强制转换重新定义。

起初“this.type”看起来很有希望，但“this.type”只包含“this”而不包括任何其他相同类型的对象。

是否有使不可变类易于子类化的标准模式？就像是:

class Foo(val bar:Int) { 
  def copy(newBar:Int):SameType = new Foo(newBar)
  def + (other:Foo) = copy(this.bar + other.bar) 
}
class Subclass(barbar:Int) extends Foo(barbar) { 
  override def copy(newBar:Int):SameType = new Subclass(newBar)
  override def + (other:Subclass) = super.+(other).asInstanceOf[Subclass]
}

这种特殊方法将要求编译器要求所有子类实现一个 copy() 方法，该方法返回与该子类相同的类型，这对我来说非常好。但是，我认为目前 Scala 中不存在这样的东西。

想到的一些解决方法是:

使用委托(delegate) - 但当然我仍然会重新实现所有方法作为委托(delegate)调用

使用隐式类型添加操作而不是子类化

使用可变数据结构。这可能是最简单和最快的解决方案，但我会失去使用不可变数据结构的好处(我仍然希望了解更多)。

我相信这已经讨论过很多次了，我很抱歉再次询问。我用谷歌搜索了一个重复的问题，但没有成功，所以我的搜索词一定是构建得很差。

提前致谢，

多布斯

Answer 1

您可以使用实现特征，就像集合类所做的那样，由具体类型参数化。例如，类似:

trait FooLike[+A] {
  protected def bar: Int

  protected def copy(newBar: Int): A
  def +(other: Foo): A = copy(bar + other.bar)
}

class Foo(val bar: Int) extends FooLike[Foo] {
  protected def copy(newBar: Int): Foo = new Foo(newBar)
}

class Subclass(barbar: Int) extends Foo(barbar) with FooLike[Subclass] {
  protected def copy(newBar: Int): Subclass = new Subclass(newBar)
}