scala - 尽管参数类型不同，但双重定义错误

Question

我收到以下两种方法的双重定义错误:

def apply[T](state: T, onRender: T => Graphic,
             onMouseEvent: (MouseEvent, T) => T): GraphicPanel = 
  apply(state, onRender, onMouseEvent = Some(onMouseEvent))

和

def apply[T](state: T, onRender: T => Graphic,
             onKeyEvent: (KeyEvent, T) => T): GraphicPanel = 
  apply(state, onRender, onKeyEvent = Some(onKeyEvent))

它们都是更通用的 apply 方法的方法重载，带有签名:

def apply[T](state: T, onRender: T => Graphic,
             onTickEvent: Option[T => T] = None, fps: Int = 30,
             onMouseEvent: Option[(MouseEvent, T) => T] = None,
             onMouseMotionEvent: Option[(MouseEvent, T) => T] = None,
             onMouseInputEvent: Option[(MouseEvent, T) => T] = None,
             onKeyEvent: Option[(KeyEvent, T) => T] = None)

我会假设即使类 KeyEvent 和 MouseEvent 有一个共同的父类(super class) (InputEvent)，编译器仍然应该能够来区分它们。但是，它正在抛出错误:

double definition: method apply:[T](state: T, onRender: T => edu.depauw.scales.graphics.Graphic, someOnKeyEvent: (java.awt.event.KeyEvent, T) => T)edu.depauw.scales.graphics.GraphicPanel and method apply:[T](state: T, onRender: T => edu.depauw.scales.graphics.Graphic, onMouseEvent: (java.awt.event.MouseEvent, T) => T)edu.depauw.scales.graphics.GraphicPanel at line 115 have same type after erasure: (state: Object, onRender: Function1, someOnKeyEvent: Function2) edu.depauw.scales.graphics.GraphicPanel

有人知道发生了什么吗？诚然，我不知道短语“删除后”是什么意思，所以解释一下它的工作原理可能会有所帮助。

Answer 1

这是一个显示相同问题的更简单示例:

object Example {
  def foo[T](f: Int => T) = ???
  def foo[T](f: String => T) = ???
}

在将 => 符号脱糖后，这相当于以下内容:

object Example {
  def foo[T](f: Function[Int, T]) = ???
  def foo[T](f: Function[String, T]) = ???
}

问题在于 Java 虚拟机 doesn't know about generics (在 Scala 或 Java 中)，所以它认为这两种方法如下:

object Example {
  def foo[T](f: Function) = ???
  def foo[T](f: Function) = ???
}

这显然是个问题。

这是 many reasons 之一避免Scala中的方法重载。如果这不是一个选项，您可以使用以下技巧:

object Example {
  implicit object `Int => T disambiguator`
  implicit object `String => T disambiguator`

  def foo[T](f: Int => T)(implicit d: `Int => T disambiguator`.type) = ???
  def foo[T](f: String => T)(implicit d: `String => T disambiguator`.type) = ???
}

在用法上看起来相同，但显然非常可怕。