创建部分应用的函数时键入推断

Question

When I do:

def x(i: Int, i2: Int, i3: Int) = i

x(_: Int, _: Int, 3)

Why do I have to specify that the first two arguments are "Int"?

Is there a way to make the compiler infer types, so that I can type:

  x(_, _, 3)

Answer 1

Short answer:

You always have to be explicit about the parameter types of anonymous functions, unless a function type is expected. "Partial application" is just a syntactical sugar for creating an anonymous function.

Long answer:

First, note that you don't always have to supply type arguments when partially applying x . Consider this example:

def x(i: Int, i1: Int, i2: Int) = i

def g(f: (Int, Int) => Int) = f(1, 2)

// types are inferred!
g(x(_, _, 3)) // evaluates to 1

// again, types are inferred
val f: (Int, Int) => Int = x(_, _, 3)

So clearly it helps to be in a context where a (Int, Int) => Int is expected.

Second, note that you're defining an anonymous function. You could write it more explicitly like this:

(a, b) => x(a, b, 3) 

Written this way, it should be more clear that the defining context (ie, as a lone expression) sets up no expectation for the type of the anonymous function. In the application of g , on the other hand, g 's parameter type implies an expectation for a specific function type.

The compiler could, in principle, infer the types of a and b from the type of x , but it does not, as specified in §6.23 of the Scala Language Specification (bold-emphasis added):

The anonymous function ( x ₁ : T ₁ , ..., x _n : T _n ) => e maps parameters x _i of types T _i to a result given by expression e . [...]

If the expected type of the anonymous function is of the form scala.FunctionN[ S ₁ ,..., S _n , R ], the expected type of e is R and the type T _i of any of the parameters x _i can be omitted, in which case T _i = S _i is assumed. If the expected type of the anonymous function is some other type, all formal parameter types must be explicitly given , and the expected type of e is undefined.