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

我有一组重载函数：

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编译器会与不同的重载混淆。

---

正确的方法是什么？

编辑：您的实现的问题是，在编译时，它不知道应该使用哪个版本的

C.dump

，因为它只知道存在某种类型的

T

，但它不可能知道在实际使用该方法时它将持有什么类型

---

您可以使用特殊多态性解决此问题：

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)
}

当您调用

C.dump

时，编译器将尝试查找

转储程序[A]

的实例。如果找不到，则不会编译：

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))

scala>C.dump（A（“foo”））
字符串：A（foo）
scala>C.dump（A（1.2））
双人：A（1.2）
scala>C.dump（A（1））
：17:错误：找不到参数转储程序的隐式值：转储程序[A[Int]]
C.1（A（1））

基于@drexin-answer，通过使用特殊多态性，我只是稍微改变一下，使用问题的签名，让它更清楚一点

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