Scala : Method overloading and type inference - scala

Question

I cannot understand why Scala is not able to infer an overloaded method's arguments :
object A {
implicit object SequenceMarker
implicit object IntMarker
def b(f: Int => Seq[Int])(implicit ev: SequenceMarker.type) = 0
def b(f: Int => Int)(implicit ev: IntMarker.type) = 0
def c() = { b(i => i + 1) } // this doesn't compile
}
When I try to compile this, I get the following error :
error: missing parameter type
def c() = { b(i => i + 1) }
I've made some investigation using javap and scala -print and figure out that the previous code cannot be compiled without specifying what i is :
object A {
...
def c() = { b((i: Int) => i + 1) }
}
Why is that so ? Is there any other way to overload a method while not specifying its argument's type during the call ?
Thank you in advance.
UPDATE
I've noticed using scala -print :
#SerialVersionUID(value = 0) final <synthetic> class anonfun$c$1 extends scala.runtime.AbstractFunction1$mcII$sp with Serializable {
final def apply(i: Int): Int = anonfun$c$1.this.apply$mcII$sp(i);
<specialized> def apply$mcII$sp(i: Int): Int = i.+(1);
final <bridge> <artifact> def apply(v1: Object): Object = scala.Int.box(anonfun$c$1.this.apply(scala.Int.unbox(v1)));
def <init>(): <$anon: Function1> = {
anonfun$c$1.super.<init>();
()
}
}
that the argument seems to be casted in some way:
scala.Int.box(anonfun$c$1.this.apply(scala.Int.unbox(v1)))
This line changes depending on the argument's type :
scala.Int.box(anonfun$c$1.this.apply(scala.Int.unbox(v1)));
...
scala.Int.box(anonfun$c$1.this.apply(v1.$asInstanceOf[String]()))
which would explain why the type is required. Here is the whole log :
package <empty> {
object A extends Object {
def b(f: Function1, ev: A$SequenceMarker.type): Int = 0;
def b(f: Function1, ev: A$IntMarker.type): Int = 0;
def c(): Int = A.this.b({
(new <$anon: Function1>(): Function1)
}, A$IntMarker);
def <init>(): A.type = {
A.super.<init>();
()
}
};
object A$SequenceMarker extends Object {
def <init>(): A$SequenceMarker.type = {
A$SequenceMarker.super.<init>();
()
}
};
object A$IntMarker extends Object {
def <init>(): A$IntMarker.type = {
A$IntMarker.super.<init>();
()
}
};
#SerialVersionUID(value = 0) final <synthetic> class anonfun$c$1 extends scala.runtime.AbstractFunction1$mcII$sp with Serializable {
final def apply(i: Int): Int = anonfun$c$1.this.apply$mcII$sp(i);
<specialized> def apply$mcII$sp(i: Int): Int = i.+(1);
final <bridge> <artifact> def apply(v1: Object): Object = scala.Int.box(anonfun$c$1.this.apply(scala.Int.unbox(v1)));
def <init>(): <$anon: Function1> = {
anonfun$c$1.super.<init>();
()
}
}
}
Therefore, what I want to achieve cannot be done in the way previously described. Any other idea ?
UPDATE 2
I've also tried :
def c() = { b(_ + 1) }
but I get another error
error: missing parameter type for expanded function ((x$1) => x$1.$plus(1))
def c() = { b(_ + 1) }
When I comment the first b(f: Int => Seq[Int]), it compiles well.

Answer 1

It's because for purposes of overload resolution, arguments are typed without an expected type, so there is no information about what function is expected.
http://www.scala-lang.org/files/archive/spec/2.11/06-expressions.html#overloading-resolution
The compiler doesn't care that the set of possible overloads includes only methods that take an Int.