Dynamically changing functions scala

Question

I'm learning scala and I have come across the following code.

def whileLoop(cond: => Boolean)(body: => Unit): Unit =
    if (cond) {
      body
      whileLoop(cond)(body)
    }
  var i = 10
  whileLoop (i > 0) {
    println(i)
    i -= 1
  }

The output is the numbers 10 to 1.

So both cond and body are "call by name" parameters. Which means they are evaluated when used in the function. If I understand that correctly. What I don't understand is how the body

println(i)
i -= 1

changes for each level of recursion that is applied the body is changing as the variable i is changing. But how does that exactly work? Each time the same function body is passed, to me this function stays the same but running the program shows me otherwise. I know that the function is evaluated each time but I don't understand how the i variable inside changes each time so can someone explain me how that works?

Kulu Limpa · Accepted Answer · 2015-05-29 08:42:40Z

1

In this example, the body

println(i)
i -= 1

is a closure that operates on the variable i which is in the scope of the body's definition. Hence i is not a local variable of the body, meaning that the operation -= modifies the only existing value i, not a local copy that gets discarded after the method invocation.

The same is true for the condition: It is a closure that captures the same variable i, hence after each execution of the body, the condition will see the now updated value of i.

Let us rewrite the example slightly without altering the meaning: Firstly, we can rewrite the whileLoop to take functions as arguments instead of call-by-name parameters:

def whileLoop(cond: () => Boolean)(body: () => Unit): Unit =
  if (cond()) {
    body()
    whileLoop(cond)(body)
  }

This rewritten whileLoop is semantically identical since a call-by-name argument is passed as an expression instead of the expression's evaluation. Disclaimer: I do not know if there are technical differences, e.g., regarding performance.

Secondly, we can make the expressions that are passed for cond and body functions that take no argument:

val condDef = () => i > 0

val bodyDef = () => {
  println(i)
  i -= 1
}

Since both of them reference the variable i that is neither part of their parameters nor defined inside their body, we must put i in their scope.

def main(args: Array[String]) {
  var i = 10

  val condDef = () => i > 0

  val bodyDef = () => {
    println(i)
    i -= 1
  }

  whileLoop (condDef) {
    bodyDef
  }
}

So i is accessible from both, condDef and bodyDef and is accessed and modified when they are evaluated.

edited May 29, 2015 at 8:42

answered May 28, 2015 at 21:54

Kulu Limpa

3,5411 gold badge24 silver badges31 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Juru Over a year ago

So the external value i which seems to be out of scope of body and condition is still referenced inside the body? How is that technically accomplished?

Kulu Limpa Over a year ago

@Juru i is in the surrounding environment of both, the body and the condition. I updated the answer trying to make the functions more explicit. Regarding the technical implementation of closures I recommend reading on Wikipedia and this question on SO

Carlos Vilchez · Accepted Answer · 2015-05-28 21:54:17Z

When you declare a parameter with a type => Type you are declaring that parameter as an anonymous function (a function that only returns that Type without any input). So when the function is called the first time, each parameter is evaluated for that particular value of i each time. As body changes the i value with each iteration, the program will reevaluate i each time body changes it.

I know it sounds complex, but bear with me. Lets see what happens when you remove the =>.

If you remove the => you are not declaring anonymous functions to be reevaluated. You are defining parameters that won't be able to be rewritten. And as the condition can't be reevaluated each time, you will have an infinite bucle.

I hope this explanation gives some help.

Karl · Accepted Answer · 2015-05-28 21:54:29Z

1

i -= 1 takes the variable i and reassigns it to its value decremented by 1. Your body is referencing the same i variable, which is being modified everytime body is called. Ignoring all the recursion and your whileLoop essentially it is doing this:

var i = 10
println(i) // prints 10
i -= 1
println(i) // prints 9
i -= 1
...
i -= 1
println(i) // prints 1
i -= 1
println(i) // prints 0

answered May 28, 2015 at 21:54

Karl

1,2309 silver badges16 bronze badges

Collectives™ on Stack Overflow

Dynamically changing functions scala

3 Answers 3

2 Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related