Kotlin Academy · Lesson

Lazy Operations

Avoid intermediate lists.

Lesson 3 of 413 steps

Lazy Operations is a free Kotlin Academy lesson on CoddyKit. This is lesson 3 of 4. Any 3 lessons of this learning path are free to read in full — after that, CoddyKit PRO unlocks every lesson, plus hands-on practice with a built-in code editor and a 24/7 AI tutor. It is part of the Kotlin Academy learning path, and your progress syncs across the web and the CoddyKit app. The Kotlin Academy course includes 4 lessons in total.

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?

Answer it in the interactive lesson

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.

Free to start

Learn Kotlin with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses: 51
Lessons: 203

Start learning free View the full course

Frequently Asked Questions

Is the “Lazy Operations” lesson free?

Yes — any 3 lessons of the Kotlin Academy learning path, including “Lazy Operations”, are free to read in full here on the web. After that, CoddyKit PRO unlocks every lesson, plus interactive practice with a built-in code editor and a 24/7 AI tutor. The Kotlin Academy course includes 4 lessons in total.

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, so you can start here or from the beginning and move at your own pace. This is lesson 3 of 4.

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