Imported From: https://issues.scala-lang.org/browse/SI-3293?orig=1
Reporter: @pchiusano

@pchiusano said:
Screwed up the formatting, here is the example, properly formatted:

scala> def foo[A,B,C](f: A => B, g: B => C): A => C = error("todo")
foo: [A,B,C](f: (A) => B,g: (B) => C)(A) => C

scala> foo((a: Int) => a.toDouble, _ + 2.0)
<console>:6: error: missing parameter type for expanded function ((x$$1) => x$$1.$$plus(2.0))
       foo((a: Int) => a.toDouble, _ + 2.0)
                                   ^

scala> foo((a: Int) => a.toDouble, b => b + 2.0)
<console>:6: error: missing parameter type
       foo((a: Int) => a.toDouble, b => b + 2.0)
                                   ^

@dubochet said:
Finding the type of foo requires knowing the types of the parameters (because of static dispatch). This is why knowledge about the type of a method cannot be used, in the general case, to infer the type of its parameters.

In theory, it would be possible to do better inference by creating a complex set of type constraints encompassing simultaneously the knowledge about the parameters and the method. However, this is extremely complex to implement. Because of this complexity, the Scala type inference system will continue to make the above simplification, for the time being.

@pchiusano said:
Thanks for this response. However, you state: "Finding the type of foo requires knowing the types of the parameters (because of static dispatch)." Isn't that only true if the foo name is overloaded? If there is only one 'foo' method in scope of the correct arity the type of foo can be easily determined. In my experience, it's pretty rare to overload a method and have multiple versions with the same arity and it would be a huge win to improve the type inference in these cases.

If there is something fundamental that I'm missing, please let me know. :)

@retronym said:
The typical solution is to curry the function, as per Traversable#foldLeft

scala> def foo[A,B,C](f: A => B)(g: B => C): A => C = null
foo: [A,B,C](f: (A) => B)(g: (B) => C)(A) => C

scala> foo((a: Int) => a.toDouble)(_ + 2.0)
res2: (Int) => Double = null

@dubochet said:
No, there is nothing fundamental you are missing. As I said before, the type inference system has enough information to infer all types (I think), but doesn't do it because the required logic is considered too complex.

If you want to discuss the limitations of the Scala inference mechanism, I would recommend you use the mailing list, where you will get more feedback from a wider audience.