In an earlier post I already showed how to work around ambiguous method overloads resulting from type erasure. In a nut shell the following code wont compile since both overloaded methods foo erase to the same type.
Scala:
def foo(ints: List[Int]) {}
def foo(strings: List[String]) {}
Java:
void foo(List<Integer> ints) {}
void foo(List<String> strings) {}
It turns out that there is a simple though somewhat hacky way to work around this limitations: in order to make the ambiguity go away, we need to change the signature of foo in such a way that 1) the erasure of the foo methods are different and 2) the call site is not affected.
Here is a solution for Java:
void foo(List<Integer> ints, Integer... ignore) {}
void foo(List<String> strings, String... ignore) {}
We can now call foo passing either a list of ints or a list of strings without ambiguity:
foo(new ArrayList<Integer>()); foo(new ArrayList<String>());
This doesn’t directly port over to Scala (why?). However, there is a similar hack for Scala. I leave this as a puzzle for a couple of days before I post my solution.
