Unexpected Future.map() execution order - scala

Question

I have a following Scala program:
object FutureMapTest extends App {
println("start")
val f: Future[Long] = Future {
Thread.sleep(2000)
val x = 1
println(s"started with ${x}")
x
}
f.map { i =>
println(s"mapped to ${i*2}")
}
f.map {
val nothing = "nothing"
println(s"mapped to ${nothing}")
_ * 2
}
Thread.sleep(3000)
println("end")
}
What I'd expect it to print on the console is
start
started with 1
followed by (in any order):
mapped to 2
mapped to nothing
followed by
end
What it actually prints is:
start
mapped to nothing
started with 1
mapped to 2
end
So, it seems like the second "map" block gets executed immediately, without waiting for the original future to complete. How is that possible?
You can even remove Thread.sleep() from the original future block, the result would still be the same.

Answer 1

There are a couple sources of confusion here.
This:
f.map {
val nothing = "nothing"
println(s"mapped to ${nothing}")
_ * 2
}
Expands to:
f.map {
val nothing = "nothing"
println(s"mapped to ${nothing}")
i => i * 2
}
What does this mean? Future#map expects a function argument of a A => B for some Future[A]. The expression:
val nothing = "nothing"
println(s"mapped to ${nothing}")
i => i * 2
..Evaluates to Long => Long, but the val assignment and println are evaluated first because they are part of the expression that returns the function. i => i * 2 isn't executed until f completes. This is similar to (Scala puzzler 001):
scala> List(1, 2, 3) map {
| val a = 1 // this only happens once, not three times
| i => a + i + 1
| }
res0: List[Int] = List(3, 4, 5)
Changing it to this will exhibit the behavior you expect (now that val assignment and println are part of the function body):
f.map { i =>
val nothing = "nothing"
println(s"mapped to ${nothing}")
i * 2
}
Here's another way to look at it:
f.map {
println("evaluated immediately")
i => { println("evaluated after f"); i * 2 }
}