How does the cats-effect IO monad really work?

Question

I'm new to functional programming and Scala, and I was checking out the Cats Effect framework and trying to understand what the IO monad does. So far what I've understood is that writing code in the IO block is just a description of what needs to be done and nothing happens until you explicitly run using the unsafe methods provided, and also a way to make code that performs side-effects referentially transparent by actually not running it.

I tried executing the snippet below just to try to understand what it means:

object Playground extends App {
  var out = 10
  var state = "paused"

  def changeState(newState: String): IO[Unit] = {
    state = newState
    IO(println("Updated state."))
  }

  def x(string: String): IO[Unit] = {
    out += 1
    IO(println(string))
  }

  val tuple1 = (x("one"), x("two"))

  for {
    _ <- x("1")
    _ <- changeState("playing")
  } yield ()

  println(out)
  println(state)
}

And the output was:

13
paused

I don't understand why the assignment state = newState does not run, but the increment and assign expression out += 1 run. Am I missing something obvious on how this is supposed to work? I could really use some help. I understand that I can get this to run using the unsafe methods.

Just as a side note, if you are going for pure functional programming `var` has no place in your code. The whole point of `IO Monad` is to contain side effects. If you want to maintain a mutable state like this, `cats` provide you a number of options such as `Ref` — sinanspd, Dec 10 '20 at 06:20
@sinanspd Yep, gotcha! I was just trying to understand what it means by IO not running side effects, but only when wrapped within. — ssmallya, Dec 10 '20 at 06:29
This is the funtion you are calling when doing IO(...): https://github.com/typelevel/cats-effect/blob/d2c1eed51c504681bdf53a2d39b51f9023e5714d/core/shared/src/main/scala/cats/effect/IO.scala#L1141 It takes a value as by-name-parameter. You have to know what that is and how it works to understand how IO works. — Saskia, Dec 10 '20 at 09:57

score 4 · Accepted Answer · answered Dec 10 '20 at 05:38

In your particular example, I think what is going on is that regular imperative Scala coded is unaffected by the IO monad--it runs when it normally would under the rules of Scala.

When you run:

for {
  _ <- x("1")
  _ <- changeState("playing")
} yield ()

this immediately calls x. That has nothing to do with the IO monad; it's just how for comprehensions are defined. The first step is to evaluate the first statement so you can call flatMap on it.

As you observe, you never "run" the monadic result, so the argument to flatMap, the monadic continuation, is never invoked, resulting in no call to changeState. This is specific to the IO monad, as, e.g., the List monad's flatMap would have immediately invoked the function (unless it were an empty list).

How does the cats-effect IO monad really work?

1 Answers1