1

Lets say we have a function def fun(x: X): X => Y and we pass this function as a parameter to another function using fun _ instead of just fun. I understand that fun _ is actually a function value, while fun refers to a function definition.

For example let:

val a = List(1,2,3,4)

def fun(x: Int) = {println(x); x + 1}

Then Running:

//This line works
a.map(fun _)

//This one also works, even though "fun" is not a function value
a.map(fun)

They have the same output:

1
2
3
4
resX: List[Int] = List(2, 3, 4, 5)

For the most part they seem to work the same, are there any examples in which the function value is not equivalent to the function definition?

Pokemon master
  • 11
  • 2
  • 1
    `fun` is a method, not a function. The distinction is important. –  Dec 25 '16 at 20:42
  • 3
    Possible duplicate of [What is the eta expansion in Scala?](http://stackoverflow.com/questions/39445018/what-is-the-eta-expansion-in-scala) – Haspemulator Dec 25 '16 at 21:16
  • Post an actual example showing "we pass this function as a parameter to another function using `fun _` instead of just `fun`" and "For the most part they seem to work the same". It'll be easier for us. http://stackoverflow.com/help/mcve – The_Tourist Dec 25 '16 at 21:32
  • 2
    "Function value" is a very misleading term. (1) `fun` is a method, it has no value and can't be passed as a parameter, (2) `fun _` or using `fun` in a functional context (including functional parameter) will perform η-expansion (another misleading term borrowed from λ-calculus, link above provided by @Haspemulator). – Victor Moroz Dec 25 '16 at 23:33

2 Answers2

4

In the signature of map, you can see that it's expecting a

"function" to apply to each element

But in your code, fun is a regular method in a class. So when you do:

a.map(fun _)

you are explicitly asking for eta-expansion. When you do:

a.map(fun)

you are implicitly asking for eta-expansion.

Because fun is a "method", and is being used in a place where a Function type is expected, it's automagically converted to that type. Basically to something like:

new Function1[Int, Int] {
    def apply(x: Int): Int = fun(x)
}

This transformation converting the name fun to a Function is called eta-expansion. See documentation for details.

Unfortunately, there are various ways of doing what you're doing - a.map(fun), a.map(fun _), a.map(fun(_)) and a.map(x => fun(x)). This is one of those frequent scenarios in Scala where you can explicitly do something yourself, or explicitly ask the compiler to do it for you, or just let the compiler do it implicitly. They can have different behaviors because of implicits and it can be a major source of confusion. Also, _ is heavily overloaded in the language, only adding to the confusion. So I use implicit behavior sparingly in general.

The_Tourist
  • 2,048
  • 17
  • 21
2

As others have pointed out in the comments, you need to use the fun _ syntax (which performs an eta expansion) when you need a value (methods have no value by themselves). Within the context of a map (or other functional contexts) an eta expansion is performed on the method implicitly. There are some cases where the eta expansion must be triggered manually.

As a concrete example of where an explicit eta expansion is needed, consider this valid snippet:

def f1(x: Int): Int = 2*x

def f2(x: Int): Int = 3*x

val fList1 = List(f1 _, f2 _)

fList1.map(_(2)) // List(4, 6)

as opposed to this invalid snippet.

val fList2 = List(f1, f2)
Community
  • 1
  • 1
evan.oman
  • 5,922
  • 22
  • 43