Scala double definition (2 methods have the same type erasure)

Question

I wrote this in scala and it won't compile:

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

the compiler notify:

[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 

I know JVM has no native support for generics so I understand this error.

I could write wrappers for List[String] and List[Int] but I'm lazy :)

I'm doubtful but, is there another way expressing List[String] is not the same type than List[Int]?

Thanks.

Answer 1

I like Michael Krämer's idea to use implicits, but I think it can be applied more directly:

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

I think this is quite readable and straightforward.

[Update]

There is another easy way which seems to work:

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

For every version you need an additional type parameter, so this doesn't scale, but I think for three or four versions it's fine.

[Update 2]

For exactly two methods I found another nice trick:

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

Answer 2

Instead of inventing dummy implicit values, you can use the DummyImplicit defined in Predef which seems to be made exactly for that:

class TestMultipleDef {   def foo(p:List[String]) = ()   def foo(p:List[Int])(implicit d: DummyImplicit) = ()   def foo(p:List[java.util.Date])(implicit d1: DummyImplicit, d2: DummyImplicit) = () }