Scala bu ve derleme olmayacaktır yazdım:

class TestDoubleDef{
  def foo(p:List[String]) = {}
  def foo(p:List[Int]) = {}
}

derleyici bildirir:

[error] double definition:
[error] method foo:(List[String])Unit and
[error] method foo:(List[Int])Unit at line 120
[error] have same type after erasure: (List)Unit

JVM jenerik için yerel destek var biliyorum bu hata anladığım kadarıyla.

List[String] List[Int] sarma ama ben tembelim :) yazabilirim

Şüpheli değilim ama, orada başka bir yolu List[String] ifade List[Int] daha aynı tip değil mi?

Teşekkürler.

Michael Krämer. implicits kullanma fikri hoşuma gitti, ama daha doğrudan uygulanabilir bence

case class IntList(list: List[Int])
case class StringList(list: List[String])

implicit def il(list: List[Int]) = IntList(list)
implicit def sl(list: List[String]) = StringList(list)

def foo(i: IntList) { println("Int: "   i.list)}
def foo(s: StringList) { println("String: "   s.list)}

Bu oldukça okunabilir ve anlaşılır olduğunu düşünüyorum.

[Güncelleme]

İş gibi görünüyor başka bir kolay yolu var:

def foo(p: List[String]) { println("Strings") }
def foo[X: ClassManifest](p: List[Int]) { println("Ints") }
def foo[X: ClassManifest, Y: ClassManifest](p: List[Double]) { println("Doubles") }

Her sürüm için bu ölçek yok yani ek bir tür parametresi gerekir, ama üç ya da dört sürümleri için sorun yok bence.

[Güncelleme 2]

Tam olarak iki yöntem için güzel bir hile buldum:

def foo(list: => List[Int]) = { println("Int-List "   list)}
def foo(list: List[String]) = { println("String-List "   list)}