Kotlin Academy · Lesson

Lazy Operations

Avoid intermediate lists.

Lazy Operations is a free Kotlin Academy lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Kotlin Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Lazy Operations

The power of sequences comes from lazy operations. Intermediate operations build a pipeline without running it, and only a terminal operation pulls elements through. This avoids intermediate lists.

No Intermediate Lists

With collections, each map and filter allocates a new list. With sequences, elements stream through all steps without creating those temporary lists.

fun main() {
    val result = (1..6).asSequence()
        .map { it * it }
        .filter { it % 2 == 0 }
        .toList()
    println(result)
}

Observing Laziness

Without a terminal operation, none of the lambdas run. The pipeline is just a recipe until it is consumed.

fun main() {
    val pipeline = (1..3).asSequence()
        .map { println("map $it"); it }
    println("Built pipeline, nothing ran")
    pipeline.toList()
}

take Limits Work

take(n) is a lazy intermediate operation. Combined with an infinite generator, it stops after producing n elements.

fun main() {
    val firstThree = generateSequence(1) { it + 1 }
        .map { it * 10 }
        .take(3)
        .toList()
    println(firstThree)
}

first Short-Circuits

Terminal operations like first stop as soon as they have what they need, skipping the rest of the elements entirely.

fun main() {
    val result = (1..1000).asSequence()
        .map { println("processing $it"); it }
        .first { it > 3 }
    println("Found $result")
}

Per-Element Streaming

In a sequence, element 1 goes through map then filter, then element 2, and so on. This ordering is what enables short-circuiting and avoids buffering all results.

fun main() {
    listOf(1, 2, 3, 4).asSequence()
        .filter { println("filter $it"); it % 2 == 0 }
        .map { println("map $it"); it * 10 }
        .toList()
}

takeWhile and dropWhile

takeWhile yields elements until the predicate fails; dropWhile skips leading elements while the predicate holds. Both are lazy.

fun main() {
    val nums = generateSequence(1) { it + 1 }
    println(nums.takeWhile { it < 5 }.toList())
}

Avoiding Wasted Computation

Because nothing runs until consumed and consumption can stop early, expensive transforms are only applied to the elements that actually reach a terminal operation.

fun main() {
    val result = (1..100).asSequence()
        .map { it * 2 }
        .filter { it > 10 }
        .take(2)
        .toList()
    println(result)
}

Reusing Sequences

Most sequences can be iterated multiple times, re-running the pipeline each time. But sequences from one-shot sources (like an iterator) can be consumed only once. Be mindful of the source.

fun main() {
    val seq = sequenceOf(1, 2, 3).map { it * 2 }
    println(seq.toList())
    println(seq.sum())
}

Stateful vs Stateless Operations

Most operations are stateless (process one element at a time). Some, like sorted or distinct, are stateful and must buffer or scan all elements, reducing the laziness benefit.

fun main() {
    val result = sequenceOf(3, 1, 2, 1).distinct().sorted().toList()
    println(result)
}

The Laziness Payoff

Lazy operations save memory by skipping intermediate lists and save time by short-circuiting. The bigger the data and the more selective the terminal operation, the larger the benefit.

Quick Check

When do the lambdas in a sequence chain actually execute?

Recap

Lazy operations build a pipeline that runs only when a terminal operation consumes it, avoiding intermediate lists and enabling short-circuiting with first, take, and takeWhile. Watch out for stateful operations like sorted. Next you will decide when sequences beat collections.

Frequently asked questions

Is the “Lazy Operations” lesson free?

Yes — the full text of “Lazy Operations” is free to read here on the web, and the Kotlin Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Kotlin Academy course, upgrade to CoddyKit PRO.

What will I learn in “Lazy Operations”?

Avoid intermediate lists. You practise Kotlin Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Kotlin Academy?

No prior experience is required. Kotlin Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Lazy Operations” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Kotlin Academy lesson?

Yes. Every Kotlin Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Kotlin Academy