Question

我有这组重载函数：

case class A[T](t: T)

object C {
   def dump(a: A[String], s: String) = ....
   def dump(a: A[Int], s: Int) = ....
   def dump(a: A[Double], s: Double) = ....
}

并拥有这种通用方法：

class B {
   def dump[T](a: A[T], t: T) = C.dump(a, t)
}

它无法编译，因为Scala编译器与不同的重载混淆。这样做的正确方法是什么？

Answer 1

编辑：你的实现的问题是，在编译时它不知道它应该使用哪个版本的C.dump，因为它只知道有一些类型T，但它可以当实际使用该方法时，它可能知道它将保持什么类型。

您可以使用ad-hoc多态解决此问题：

trait Dumper[A] {
  def dump(a: A): Unit
}

case class A[T](t: T)

object A {
  implicit object AStringDumper extends Dumper[A[String]] {
    def dump(a: A[String]) = println(s"String: $a")
  }

  implicit object ADoubleDumper extends Dumper[A[Double]] {
    def dump(a: A[Double]) = println(s"Double: $a")
  }
}

object C {
  def dump[A](a: A)(implicit dumper: Dumper[A]) = dumper.dump(a)
}

当您致电Dumper[A]时，编译器会尝试查找C.dump的实例。如果找不到，则无法编译：

scala> C.dump(A("foo"))
String: A(foo)

scala> C.dump(A(1.2))
Double: A(1.2)

scala> C.dump(A(1))
<console>:17: error: could not find implicit value for parameter dumper: Dumper[A[Int]]
              C.dump(A(1))

Answer 2

基于@drexin使用ad-hoc多态性回答，我只是略微改变使用问题的签名使其更清晰一点。

def dump[T](a: A[T], t: T) = C.dump(a, t)

case class A[T](t: T)
trait Dumper[T] {
  def dump(a: A[T], t: T): Unit
}
class B {
  def dump[T](a: A[T], t: T)(implicit dumper: Dumper[T]) = dumper.dump(a, t)
}
implicit val IntDummper = new Dumper[Int] {
  override def dump(a: A[Int], t: Int): Unit = {
    println("int dummper processing it")
  }
}

implicit val StringDummper = new Dumper[String] {
  override def dump(a: A[String], t: String): Unit = {
    println("string dummper processing it")
  }
}

val result = new B

result.dump(A("3"), "3") //string dummper processing it
result.dump(A(3), 3) //int dummper processing it

如何从泛型类型调用重载方法

2 个答案: