如果泛型类型已经固定，如何使用隐式参数重写泛型方法？

Question

我尝试

def sum[B >: A](implicit num: Numeric[B]): B = ...

在类型 A 已固定为 Int 的子类中重写此方法。

我已经尝试过，

override def sum: Int = ...

但这当然不会覆盖，导致基于运行时动态类型的不同方法解析。

更进一步，

def sum[B >: Int](implicit num: Numeric[B]): Int

does override，而

def sum[B >: Int](implicit num: Numeric[Int]): Int

does not，以及

def sum(implicit num: Numeric[Int]): Int

为什么会这样？至少有可能摆脱多余的绑定B吗？

我不确定哪些类型和隐式可以省略，哪些必须保留，以便该方法仍然可以覆盖。

Answer 1

第一个问题是重写的方法需要相同数量和类型的类型参数，即使它们没有被使用。例如，

class C1 {
  def f[B] = println("hello")
}

class C2 extends C1 {
  override def f = println("world") // Error: f overrides nothing (needs parameter B)
}

除此之外，还存在健全性问题，因为 Numeric[A] 在 A 中是不变的。这意味着只要 B 和 C 存在，Numeric[B] 和 Numeric[C] 之间就没有子类型关系。不同的。

想象 Numeric 是具有适当方差的特征，它仍然不起作用；显然，重写方法的签名需要完全相同：

class D1 {
  def g(x: Int) {}
}

class D2 extends D1 {
  override def g(x: Any) {} // Error: g overrides nothing (different parameter type)
}

我不确定为什么不能扩展重写方法的类型。 编辑：也许原因是与重载的兼容性，如

class D1 {
  def g(x: Any) {}
  def g(x: Int) {} // This is legal, even though the definitions seem to overlap
}

---

总结所示，当您重写时，必须保留方法的签名，包括类型参数。就您而言，这是您能做的最好的事情：

override def sum[B >: Int](implicit num: Numeric[B]): B = ...

Answer 2

好的，尝试解释为什么规则必须强制您保留带有隐式参数和方差的签名。

首先，隐式参数仍然是一个参数，它可以显式传递，并且除非它具有单例类型（这不是很有用），否则它的多个不同实例是可能的。

假设我创建

case class ZModulo(val p: Int) extends Numeric[Int] {
  def plus(a: Int, b: Int) = (a+b) % p
  // others along the same line
}

It 看起来像一个正确的Numeric。 Numeric 文档没有说明应该遵循哪些定律，但 ZModulo 并非没有道理。

现在，

class Summable[A] {
  def sum[B >: A](implicit num: Numeric[A]): B =...
}

如果我有 val ints : Summable[Int]，我当然可以调用 ints.Sum(ZModulo(3))。因此，如果您的类是 Summable[Int] 的子类，它必须允许我这样做。因此您无法删除 Numeric 参数。

其次，假设我带有一个Numeric[Any]。不知道如何对数字合理地做到这一点，但规范和编译器无法知道这一点。无论如何，他们也必须接受不合理的实施。因此，让

object MixThemAll : Numeric[A] {...}

Summable 中的签名允许 ints.sum(MixThemAll)。所以你的子类也必须允许这样做。

因此，让您删除子类中的隐式参数或方差是不合理的。