Differences in computation order IO.println()

[AlekseyBulaev]

Hi all,

Here is my 1st code snippet:

val tickingClock1: IO[Unit] = for {
    _ <- IO.println("IO println = " + System.currentTimeMillis())
    _ <- IO.sleep(1.second)
    _ <- tickingClock1
  } yield ()

It produces this result:

IO println = 1717008861143
IO println = 1717008861143
IO println = 1717008861143

When I change the order of the IO.sleep(1.second) and put it after the IO.println(...) it changes the behavior:

val tickingClock2: IO[Unit] = for {
    _ <- IO.sleep(1.second)
    _ <- IO.println("IO println = " + System.currentTimeMillis())
    _ <- tickingClock2
  } yield ()

It produces the next result:

IO println = 1717009205508
IO println = 1717009206533
IO println = 1717009207540

Why in the first snippet I get the same time every second instead of increment every second like in the second snippet ?

[mpilquist]

Take a look at the signature of IO.println:

def println[A](a: A)(implicit S: Show[A] = Show.fromToString[A]): IO[Unit] = ???

Note that a is not a by-name parameter so IO.println(anExpression) can be rewritten to the following without any change in evaluation order:

val tmp = anExpression
IO.println(tmp)

If the signature of println was def println[A](a: => A)(implicit S: Show[A] = Show.fromToString[A]): IO[Unit] instead, then we wouldn't be able to perform this val-extraction refactoring with changing the evaluation order, as the entire expression would be passed to println instead of first being evaluated.

Using this val-extraction rewrite in the definition tickingClock1 gives us:

val tickingClock1: IO[Unit] = 
  val tmp = "IO println = " + System.currentTimeMillis()
  for {
    _ <- IO.println(tmp)
    _ <- IO.sleep(1.second)
    _ <- tickingClock1
  } yield ()

Because tmp is created just once at the start of the definition of tickingClock1, and tickingClock1 is itself defined as a val, the result is you only see one evaluation of currentTimeMillis().

Contrast with tickingClock2 rewrite:

val tickingClock2: IO[Unit] = for {
    _ <- IO.sleep(1.second)
    tmp = "IO println = " + System.currentTimeMillis()
    _ <- IO.println(tmp)
    _ <- tickingClock2
  } yield ()

It's a bit harder to see why the extraction of tmp doesn't show the same behavior here as it did previously. Let's rewrite the for-comp in to flatMap+map:

val tickingClock2: IO[Unit] =
  IO.sleep(1.second).flatMap { _ =>
    val tmp = "IO println = " + System.currentTimeMillis()
    IO.println(tmp).flatMap { _ =>
      tickingClock2.map { _ =>
        ()
      }
    }
  }

Without the for-comprehension sugar, you can see the tmp val is created inside the lambda function passed to the first flatMap -- and hence, is created uniquely each time that initial IO.sleep is evaluated.