LESSON 128 OF 414 · WHILE LOOPS & FOR LOOPS

Infinite Loops in Scala: Replacing a While Loop with a For Range

Remember the infinite while loop? Well, there is also such a thing called the infinite for loop.

Here is an example:

var i = 0
while (i < 10) {
    println(i)
    i -= 1
    i += 1 // undoes the i -= 1 above
}

This is what happens during this loop:

0. Creates and initializes a variable i = 0

1. First iteration:
	a. Is i < 10 true? <=> Is 0 < 10 true? Yes.
	b. Run the code inside {}:
        1) println(i) => Output: 0
	      2) i -= 1 => i becomes -1
  c. i += 1 => i becomes 0 again

2. Second iteration:
	a. Is i < 10 true? <=> Is 0 < 10 true? Yes.
	b. Run the code inside {}:
        1) println(i) => Output: 0
	      2) i -= 1 => i becomes -1
  c. i += 1 => i becomes 0 again

3. Third iteration:
	a. Is i < 10 true? <=> Is 0 < 10 true? Yes.
	b. Run the code inside {}:
        1) println(i) => Output: 0
	      2) i -= 1 => i becomes -1
  c. i += 1 => i becomes 0 again

...

This program will never terminate as i will always have value 0 and thus the condition i < 10 will always be satisfied.

The program would basically print 0 forever never exiting the loop.

Assignment
Follow the Coding Tutorial and let's practice with infinite for loops!

Hint
Look at the examples above if you get stuck.

STEP 1 OF 1

Guided

Ctrl + Enter to check

Infinite For Loops in Scala, explained

The problem with the starting code

The goal is to print the odd numbers from 15 down to 1, which are 15, 13, 11 and so on, and then stop. The code you start with is a while loop:

var number = 15
while (number != 0) {
    println(number)
    number += 1
}

It prints 15, 16, 17, and keeps growing. It has two mistakes, and both come from the loop being managed by hand.

What goes wrong

The counter moves the wrong way. The numbers should get smaller, but number += 1 makes them bigger. Each pass takes the counter further from the end of the sequence, and it also prints every number instead of every second one.
The condition waits for an exact value. The loop stops only when number equals 0. Even if the update were number -= 2, the counter would go 15, 13, ..., 3, 1, -1 and jump over 0, so the condition would stay true forever. This is the same trap as in the infinite while loop lesson.

With the code as written, an Int doesn't stop growing at its maximum. It wraps around to a large negative number, and the counter reaches 0 only after 4,294,967,281 passes. For practical purposes the program never ends.

The fix: let a range do the counting

A for loop over a range removes both mistakes. The range lists exactly the values to visit, the loop variable takes them one at a time, and the loop ends by itself after the last one. There is no condition to get wrong and no update to forget.

Choose the start and end. The sequence starts at 15 and ends at 1, and 1 must be printed. Use to, which includes its end value.
Choose the step. The numbers go down by 2, so the step is -2. The negative step makes the range count down.
Write the loop. Together these give 15 to 1 by -2, and for (number <- ...) binds each value to number.
Print inside the body. println(number) is the only statement needed.

for (number <- 15 to 1 by -2) {
    println(number)
}

The output is 15, 13, 11, 9, 7, 5, 3 and 1, each on its own line. After 1 the range has no more values, so the loop ends.

Why this loop cannot run forever

A range has a fixed, finite list of values, worked out from its start, end and step. Because the loop visits each value once, the number of passes can't be larger than the size of the range. The loop variable is also a fresh value on each pass that you can't reassign, so the body can't accidentally move it in the wrong direction. The only way to get an endless loop in this style would be to loop over something that is itself endless, which a range with a nonzero step is not.

Common mistakes

Using the wrong sign for the step. 15 to 1 by 2 is empty, so the loop prints nothing.
Writing until instead of to. 15 until 1 by -2 still ends on 1 here, because the step skips 0, but only by luck of the numbers. Use to when the last value should be included, so that the intent is clear.
Using a step of -1. That prints every number from 15 to 1, evens included.
Keeping the var and the manual update inside a for loop. The range already does that job, and a hand-written update only adds a second counter to track.

Key takeaways

An exact-value condition such as != 0 is fragile when the counter can step over the value.
A for loop over a range ends by itself after the last value.
start to end by step, with a negative step, counts down and includes the end if the step lands on it.

Keep going with ScalaAbout 340 step-by-step lessons, from your first line of code to coding interviews. Free to start.

Start learning free