Type parameters, upper bounds and overriding - scala

Question

Here's a very simple example:
scala> class A(x: Int) {
| def withX(newX: Int): A = new A(newX)
| override def toString = x.toString
| }
defined class A
scala> class B(x: Int) extends A(x) {
| override def withX(newX: Int): B = new B(newX)
| }
defined class B
So we have two classes:
A, which defines a method withX returning the object of type A, and
B, which extends A and overrides its withX method to return the object of type B.
Now I'd like to create a container, which can process instances of both A and B. It should have a method, which can accept an instance of A (or B), run withX on it and return another instance of A (or B). To be more specific, the exact functionality I want to achieve (note the return types):
scala> val a = new A(0)
a: A = 0
scala> val b = new B(0)
b: B = 0
scala> val testA = new Test[A]
testA: Test[A] = Test#4bf59a3d
scala> val testB = new Test[B]
testB: Test[B] = Test#65e565d1
scala> testA.test(a)
res1: A = 1
scala> testB.test(b)
res2: B = 1
I suppose that this can be achieved via class with upper-bounded type parameter. I've tried to do it like this, but got an error:
scala> class Test[T <: A] {
| def test(t: T): T = t withX 1
| }
<console>:9: error: type mismatch;
found : A
required: T
def test(t: T): T = t withX 1
^
The only workaround I managed to find looks somewhat ugly. Besides that, the match clause will need to be rewritten if we add some new class C extends B:
scala> class Test[T <: A] {
| def test(t: T): T = (t match {
| case b: B => b withX 1
| case a: A => a withX 1
| }).asInstanceOf[T]
| }
Can this functionality be achieved in more elegant way? I feel like I'm missing something about type parameters, type bounds and all scala type system in general.

Answer 1

While it's possible to override a method with a more specific return type, it's rarely a good idea. Consider the following:
class C(x: Int) extends A(x) {
override def withX(newX: Int): B = new B(x)
}
This is completely legal, but breaks your assumption that the return type of withX is the same subtype of A as the (statically known) type of the instance you're calling it on.
You can make that assumption safely (i.e. with support from the type system) by using F-bounded polymorphism:
trait Base[T <: Base[T]] {
def withX(newX: Int): T
}
class A(x: Int) extends Base[A] {
def withX(newX: Int) = new A(newX)
override def toString = x.toString
}
class B(x: Int) extends Base[B] {
def withX(newX: Int) = new B(newX)
override def toString = x.toString
}
class Test[T <: Base[T]] {
def test(t: T): T = t withX 1
}
This requires some changes to your type hierarchy, but it's a pretty standard way to encode the idea that the return type of a method is the same as the instance it's called on.

Answer 2

Somewhat along the lines of Travis' answer, if you want to encode the fact that a type supports a specific operation (withX in this case), you can consider using a type class.
class A(x: Int) {
override def toString = x.toString
}
class B(x: Int) extends A(x)
trait HasWithX[T] {
def withX(x: Int): T
}
implicit val AHasWithX = new HasWithX[A] {
def withX(x: Int) = new A(x)
}
implicit val BHasWithX = new HasWithX[B] {
def withX(x: Int) = new B(x)
}
class Test[T] {
def test(t: T)(implicit ev: HasWithX[T]): T = ev withX 1
}
Example:
scala> val a = new A(0)
a: A = 0
scala> val b = new B(0)
b: B = 0
scala> val testA = new Test[A]
testA: Test[A] = Test#4bf59a3d
scala> val testB = new Test[B]
testB: Test[B] = Test#65e565d1
scala> testA.test(a)
res1: A = 1
scala> testB.test(b)
res2: B = 1