Authors Top

If you have a few years of experience with the Kotlin language and server-side development, and you’re interested in sharing that experience with the community, have a look at our Contribution Guidelines.

1. Intro

It’s not possible to use the break and continue keywords to jump out of functional loops in Kotlin – at least, not in the traditional way.

For example, we can’t stop the execution of a forEach functional loop by simply writing the break statement.

However, there are techniques we can use to mimic that behavior. Let’s look at some of them.

2. Using Labels

As we know, we can use labels to qualify return statements. We can use this to simulate the traditional ‘continue’ and ‘break’ behavior in functional loops.

2.1. Simulating continue

Let’s look at an example:

val list = listOf(3, 4, 3, 4, 3)
var sum = 0
list.forEach [email protected]{ number ->
    if (number % 2 == 0) { // skip all even numbers
        [email protected]
    }
    sum += number
}
assertTrue { sum == 9 }

Here, we label the forEach loop as ‘loop’. Later, the execution jumps to this label to simulate the ‘continue’ behavior.

We need our functional loop to skip the execution of a particular iteration. To do that, we use the ‘loop’ label with the [email protected] statement.

2.2. Simulating break

Similarly, we can also simulate ‘break’ using labels and return statements:

run [email protected]{
    list.forEach [email protected]{ number ->
        if (number % 2 == 0) { // 'break' at the first even number
            [email protected]
        }
        sum += number
    }
}
assertTrue { sum == 3 }

Unlike the previous example, we need some extra boilerplate to simulate ‘break’. We need to surround the loop within another scope. This is needed so we can return to the outer scope later.

We assign distinct labels to the outer and inner scopes. This is followed by returning to the outer scope from the loop in the inner scope. This is how we simulate the ‘break’ behavior.

To clarify, we create the outer scope because returning to the (inner) loop label, we only skip the current iteration. We don’t stop the execution of the loop itself.

We could also use a return statement with no label. In that case, we’d end up returning the function itself. This may lead to skipping other statements in the function after our loop, hence the need for an extra outer scope.

Notably, we can also use other scope functions here instead of run.

3. Using filter and takeWhile

Another way to imitate the ‘continue’ and ‘break’ behavior is by chaining them with functions like filter and takeWhile.

3.1. Simulating continue With filter

Using continue in a regular for loop, we can skip iterating over the elements we don’t want to process. We can do this with functional loops by using filter:

val list = listOf(3, 4, 3, 4, 
var sum = 0
list.filter { it % 2 != 0 } // skip all even numbers
    .forEach { number ->
        sum += number
    }
assertTrue { sum == 9 }

Here, we filter the elements we want to skip beforehand by using a filter operation. We then iterate over the filtered list. This effectively achieves the same result as using continue in a regular for loop.

3.2. Simulating break With takeWhile

Likewise, we can mimic the break behavior in a functional loop by calling takeWhile before it:

list.takeWhile { it % 2 != 0 } // 'break' at the first even number
    .forEach { number ->
        sum += number
    }
assertTrue { sum == 3 }

As we know, takeWhile filters the list, removing all elements after reaching the first element that doesn’t satisfy the given predicate. By iterating over the resultant list, we achieve the same results as break.

4. Conclusion

Functional loops in Kotlin don’t support break and continue jumps. However, we can use some techniques to imitate this.

It appears that labeled return statements are more efficient. This is due to the overhead of function chaining, which may lead to the creation of intermediate collections.

On the other hand, using filter and takeWhile seems to require the least boilerplate.

As always, the code samples are available over on GitHub.

Authors Bottom

If you have a few years of experience with the Kotlin language and server-side development, and you’re interested in sharing that experience with the community, have a look at our Contribution Guidelines.

Comments are closed on this article!