by-name function calls in scala

byname.scala

object ByName {
  /**
   * So-called 'by name' function parameters are basically automatically wrapped in thunks
   *
   * how 'by name' function are desugared:
   *
   * def f(x: => Int): Int  = { x; x }
   * f( { println("once"); 1 } )
   *
   * desugars to
   *
   * def f(x: Unit => Int): Int = { x(); x() }
   * f( () => { prlntln("once"); 1 } )
   */
  def main(args: Array[String]): Unit = {
    basicUseCase()
    nested()
  }

  def basicUseCase(): Unit = {
    var oneToTen = (1 to 10).iterator

    def useItByValue(x: Int): Unit = {
      println(s"x: $x, x again: $x")
    }
    oneToTen = (1 to 10).iterator
    useItByValue(oneToTen.next()) // "x: 1, x again: 1"
    // next() is called once, and the return value is passed in

    def useItByName(x: => Int): Unit = {
      println(s"x: $x, x again: $x")
    }
    oneToTen = (1 to 10).iterator
    useItByName(oneToTen.next()) // "x: 1, x again: 2"
    // next() is called twice. it's called each time the variable x is evaluated

    def useItByName2(x: => Int): Unit = {
      val y = x
      println(s"x: $y, x again: $y")
    }
    oneToTen = (1 to 10).iterator
    useItByName2(oneToTen.next()) // "x: 1, x again: 1"
    // next() is called once, when x is evaluated on assignment to y
  }

  def nested(): Unit = {
    def inner(y: => Int): Int = y
    def outer(x: => Int): Int = inner(x)

    val oneToTen = (1 to 10).iterator
    println(outer(oneToTen.next())) // 1
    // the by-name parameter only gets evaluated once, the return value of inner()

    // desugared and evaluated like so
    //
    // outer(oneToTen.next())
    // desugars to
    // outer(x = () => { oneToTen.next() })
    // evaluates to
    // inner(x())
    // desugars to
    // inner(y = () => { x() })
    // evaluates to
    // y()
    // evaluates to
    // x()
    // evaluates to
    // oneToTen.next()
    // evaluates to
    // 1
    //
    // keep in mind the desugaring happens at compile-time, and the evaluation happens at runtime
  }
}