Imported From: https://issues.scala-lang.org/browse/SI-7641?orig=1
Reporter: Leif Warner (pdxleif)

Leif Warner (pdxleif) said:
This works fine in Haskell (and Idris), btw.

Leif Warner (pdxleif) said:
Additional example:
https://gist.github.com/edrex-janrain/5946323

@retronym said:
Standalone:

object Test {
  trait TC[_]
  implicit val tcInt: TC[Int] = ???
  def bar[T](t:T)(implicit x: TC[T]): Int = 0
  def foo[B](f: Int => B) {}
  foo (x => bar(x)) // okay
  foo (bar) // fails
}

@retronym said:
Leaving away the explicit type of the anonymous function's parameter x triggers it to be inferred as Int:

6.23 Anonymous functions

If the expected type of the anonymous function is of the form scala.Functionn[S1,...,Sn, R], the expected type of e is R and the type Ti of any of the parameters xi can be omitted, in which case Ti = Si is assumed.

Eta expansion drives the type of the parameter from the MethodType being expanded:

Second, one creates a fresh name yi for every argument type Ti of the method (i = 1, ..., n). The result of eta-conversion is then:

{
   val x1 = e1; ... val xm = em;
  (y1:T1,...,yn:Tn) => e′(y1,...,yn) 
}

In the example about, that gives:

(t: T) => bar(t)

where T is an abstract type corresponding to the method type parameter.

I'm not sure yet whether we can make the two behave uniformly. I'll leave this ticket open in the hope that someone finds a way.

For future reference, the interesting stuff is in instantiateToMethodType, instantiateToMethodType, and etaExansion.

Even though the expected type is Int => Int, we

Leif Warner (pdxleif) said:
Did your last comment get cut off?

Other cases:

Some(Some("yes")).map(_.orNull) // works

def orNull[A](o:Option[A])(implicit ev: <:<[Null,A]): A = o getOrElse null
Some(Some("yes")).map(orNull) // doesn't

@retronym said:
WIP https://github.com/retronym/scala/tree/ticket/7641

@adriaanm you might want to look at this in your work on eta-expansion