Scala: Is there a way for a parent class to access methods defined only by children?
case-class, scala, self-type
Solution
You can't do what you want because `copy` needs to know about all the possible parameters. So even if case classes inherited from `Copyable`, it wouldn't be the `copy` you needed. Also, if you're going to keep the types straight, you'll be thwarted by Scala's lack of a "`MyType`". So you can't just extend a base class. However, you could add an abstract method and type annotation:
abstract class BaseClass[C <: BaseClass[_]](a: String, b: Int) {
def setB(b0: Int): C
def doubleB(b0: Int) = setB(b0*2)
}
case class HasC(a: String, b: Int, c: Boolean) extends BaseClass[HasC](a,b) {
def setB(b0: Int) = this.copy(b = b0)
def doesStuffWithC(c0: Boolean) = doubleB(if (c0) b else -b).copy(c = c0)
}
And then you can:
scala> HasC("fish",1,false).doesStuffWithC(true)
res47: HasC = HasC(fish,2,true)
This extra work will be worth it if you have a lot of shared functionality that depends on the ability to copy just `b` (either many methods, or a small number of complicated methods)--that is, this solves the DRY issue. If instead you want to abstract over `HasC` and other derived classes, you can either use `BaseClass[_]` or add yet another level that defines `setB(b0: Int): BaseBase` or simply forget the type parameterization and use `BaseClass` as the return type (but recognize that `HasC` cannot use `BaseClass` methods and still retain its type identity).
Problem
I have two case classes that inherit from an abstract base class. I want to define some methods on the abstract base class that use the copy methods on the inheriting case classes (and so return an instance of the child class.) Is there a way to do this using self types? Example code: ``` abstract class BaseClass(a: String, b: Int) { this: case class => //not legal, but I'm looking for something similar def doubleB(newB: Int) = this.copy(b = b * 2) //doesn't work because BaseClass has no copy } case class HasC(a: String, b: Int, c: Boolean) extends BaseClass(a, b) { def doesStuffWithC(newC: Boolean) = { ... } } case class HasD(a: String, b: Int, D: Double) extends BaseClass(a, b) { def doesStuffWithD(newD: Double) = { ... } } ``` I've figured out how to get the result I want thanks to this question: How to use Scala's this typing, abstract types, etc. to implement a Self type? but it involves adding a makeCopy method to BaseClass and overriding it with a call to copy in each of the child case classes, and the syntax (especially for the Self type) is fairly confusing. Is there a way to do this with Scala's built in self typing?