Kotlin sequenceOf

In this guide, you will learn everything about the Kotlin sequenceOf function with examples.

What is sequenceOf()? 

sequenceOf() is a function in Kotlin's standard library used to create a sequence. Sequences in Kotlin represent a lazily evaluated collection. In simpler terms, elements are computed on-demand, which can be advantageous in terms of performance, especially when dealing with large datasets or expensive computations. 

Basic Syntax:

val sequence: Sequence<Type> = sequenceOf(element1, element2, ...)

Examples with Outputs

Creating a Basic Sequence

val simpleSeq = sequenceOf(1, 2, 3)
println(simpleSeq.toList())  // Output: [1, 2, 3]

Laziness in Action 

Unlike lists that evaluate immediately, sequences are evaluated lazily:

val sequence = sequenceOf(1, 2, 3, 4, 5)
    .map { it * it }
    .filter { it > 10 }

println(sequence.first())  // Output: 16

Here, even though the sequence has five elements, the transformations (map and filter) only get executed until the first element satisfying the condition is found. 

Generating Infinite Sequences 

Thanks to lazy evaluation, we can create theoretically infinite sequences:

val infiniteSeq = generateSequence(1) { it + 1 }
println(infiniteSeq.take(5).toList())  // Output: [1, 2, 3, 4, 5]

Flattening Sequences

val nestedSeq = sequenceOf(sequenceOf(1, 2, 3), sequenceOf(4, 5, 6))
val flatSeq = nestedSeq.flatten()
println(flatSeq.toList())  // Output: [1, 2, 3, 4, 5, 6]

Chaining Operations 

Sequences can be chained with various operations:

val numSeq = sequenceOf(1, 2, 3, 4, 5)
val result = numSeq.map { it * 2 }.filter { it > 5 }.take(2)
println(result.toList())  // Output: [6, 8]

When to Use Sequences

Performance Concerns: When intermediate operations on large collections can produce a significant overhead, sequences can help by evaluating elements only when necessary. 

Infinite Data: Sequences can represent theoretically infinite datasets because of their lazy nature.

Stream-like Operations: When dealing with stream-like data, sequences can provide a familiar and efficient programming model. 


Kotlin's sequenceOf() and the entire concept of sequences bring forth the power of lazy evaluation to everyday coding. They can be immensely powerful when wielded correctly, offering both performance improvements and concise code. Like any tool, understanding when and how to use them is crucial, and with the provided examples, you’re well-equipped to make the most of sequences in Kotlin.

Related Kotlin Posts