Scala类型推断隐式解析匿名函数

Question

While trying to grasp Scala implicits, I ran into this type inference problem:

object Demo extends App {

  def demo(f: (Int, Int) => Int) = ???

  demo((a: Int) => 42)
  demo((a) => 42) // <-- any tricks to make this compile?

  implicit def f1Tof2(f: Int => Int): (Int, Int) => Int =
    (a: Int, b: Int) => f.apply(a)

}

What's the reason behind the compiler's inability to infer the type correctly? Any tricks to make it work?

Answer 1

This isn't possible. When you call demo((a, b) => a + b) (for example), the compiler is already expecting an (Int, Int) => Int , so it will infer (a, b) => a + b as (Int, Int) => Int , since it has the correct shape.

However, when you call demo(a => 42) , the compiler sees a Function1[?, Int] as the argument, with no indication as to what the parameter type is. Since demo expects a Function2 , the only way this can compile is if the compiler can find an implicit conversion from the passed argument type to (Int, Int) => Int . But it can't, because it doesn't know the type it's converting from . It cannot just assume it will a Int => Int .

There are only two ways to make this work.

1.) Explicitly declare the parameter type of the anonymous function, like you have done already. This is the only way the implicit conversion can be applied.

demo((a: Int) => 42)

2.) Provide an overload for demo that accepts a Int => Int .

def demo(f: (Int, Int) => Int): Int = f(1, 2)
def demo(f: Int => Int): Int = demo((a, b) => f(a))

scala> demo(a => 42)
res3: Int = 42