Future mapping transparently split in two functions when using anonymous parameters

Question

I am stuck with something I observed with Scala futures and I cannot figure out what happens here. I am mapping a future to another result, nothing fancy here: ``` import scala.concurrent.{Await, Future} import scala.concurrent.ExecutionContext.Implicits.global import scala.concurrent.duration._ object Example extends App { val f = Future { Thread.sleep(1000) println("Future: " + Thread.currentThread + " (" + System.currentTimeMillis + ")") "future" } val g = f map { x => println("Map future: " + Thread.currentThread + " (" + System.currentTimeMillis + ")") "mapped " + x } println(Await.result(g, 5 seconds)) } ``` Since the function I map the future to is depending on the result of `f`, I expect the function to be only triggered after the computation of `f` is complete. This is also what I can observe with the above code. However, when I change the function for `g` to carry anonymous parameters, this behavior changes: ``` val g = f map { println("Map future: " + Thread.currentThread +…

Accepted Answer

It may surprize you, but println is executed during lambda construction time:

```
List(1,2,3).map { 
    println("Hi!")
    "Processing " + _ 
}

// Hi! 
// res4: List[String] = List(Processing 1, Processing 2, Processing 3)
```

As you can see `Hi!` is outputed only once.

That is because your code is semantically identical to:

```
def constructLambda() = {
  // do something, e.g. println
  // now return actual lambda
}
val lambda = constructLambda()
xs map (lambda) // now trigger previously *lazy* piece of code
// or even this, like in your snippet
xs map lambda
```

Future mapping transparently split in two functions when using anonymous parameters

Solution

Problem