Scala在子类化的泛型函数中提供类型信息

Question

Here is my problem.

I have an abstract class that defines a method with type parameters as input and output. I want the subclasses to provide the type information when subclassing but I want to do it in a way that I don't parametrize the whole class.

Some pseudo code of what I'm aiming at.

abstract class A {
  def foo[T](t: T): T
}

class B() extends A {
  override foo[Int](t: Int): Int = t + 1
}

class C() extends A {
  override foo[Double](t: Double): Double = t + 1.0
}

How do I pass the type information on subclassing? I looked at similar problems. They address that with self types, type classes and abstract types.

Thanks

Answer 1

As you've said, an abstract type on A can solve that:

abstract class A {
  type T
  def foo(t: T): T
}

class B extends A {
  override type T = Int
  override def foo(t: Int): Int = t + 1
}

class C extends A {
  override type T = Double
  override def foo(t: Double): Double = t + 1.0
}

Answer 2

What about "parameterizing" on the abstract Class:

abstract class A[T] {
    def foo(t: T): T
}

class B extends A[Int] {
    override def foo(t: Int): Int = t + 1
}

class C extends A[Double] {
    override def foo(t: Double): Double = t + 1.0
}

Answer 3

Your A is specifically promising that it can be called with any T . So any type that extends it must fulfill that promise.

val a: A = ...
val x = a.foo("a") // calls foo[String]
val y = a.foo(1) // calls foo[Int]

is perfectly good code. But when it's executed, a can actually be a B , C , or anything that extends A . So "providing the type information when subclassing" doesn't really make sense: it would completely break the meaning of subtyping (or of type parameters).