Return with Labels

fun findFirstEven(numbers: List<Int>): Int? {
    numbers.forEach {
        if (it % 2 == 0) return it
    }
    return null
}

fun main() {
    println("First even: ${findFirstEven(listOf(1, 3, 4, 5))}")
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    numbers.forEach {
        if (it % 2 == 0) return@forEach
        println("Odd: $it")
    }
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    numbers.forEach myLoop@{
        if (it == 3) return@myLoop
        println("Value: $it")
    }
}

fun processAll(numbers: List<Int>) {
    for (n in numbers) {
        numbers.forEach {
            if (it == n) return@forEach
            println("Comparing $n with $it")
        }
    }
}

fun main() {
    processAll(listOf(1, 2))
}

1. Assuming a plain return inside a lambda passed to forEach exits only that lambda, when it actually returns from the enclosing function (a non-local return).
2. Forgetting to label the return when only the lambda itself should stop, resulting in the surrounding function exiting unexpectedly early.
3. Using implicit labels (named after the function, like forEach$0) instead of the clearer explicit label syntax when precision matters.

• A plain return inside a lambda passed to an inline function performs a non-local return, exiting the enclosing function entirely.
• Labeling a lambda with name@ { ... } and using return@name returns from just that lambda, not the whole function.
• Kotlin also provides an implicit label matching the name of the function the lambda is passed to, such as return@forEach.
• Choosing the right kind of return (local vs non-local) avoids surprising control-flow bugs in loops built from higher-order functions.