Sequence operators (map, filter) in Kotlin - Step-by-Step Execution

Concept Flow - Sequence operators (map, filter)

Start with a Sequence

↓

Apply map operator

↓

Transform each element

↓

Apply filter operator

↓

Keep elements matching condition

↓

Resulting Sequence

↓

Convert to List or use

↓

End

Start with a sequence, transform elements with map, then keep only those matching a condition with filter, producing a new sequence.

Execution Sample

Kotlin

val numbers = sequenceOf(1, 2, 3, 4, 5)
val result = numbers.map { it * 2 }.filter { it > 5 }.toList()
println(result)

This code doubles each number, then keeps only those greater than 5, and prints the final list.

Execution Table

Step	Element	After map (it * 2)	Filter condition (it > 5)	Kept in result?
1	1	2	2 > 5 = false	No
2	2	4	4 > 5 = false	No
3	3	6	6 > 5 = true	Yes
4	4	8	8 > 5 = true	Yes
5	5	10	10 > 5 = true	Yes
End	-	-	-	No more elements

💡 All elements processed; sequence ends.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	Final
numbers	[1,2,3,4,5]	[1,2,3,4,5]	[1,2,3,4,5]	[1,2,3,4,5]	[1,2,3,4,5]	[1,2,3,4,5]	[1,2,3,4,5]
mapped	empty	[2]	[2,4]	[2,4,6]	[2,4,6,8]	[2,4,6,8,10]	[2,4,6,8,10]
filtered	empty	empty	empty	[6]	[6,8]	[6,8,10]	[6,8,10]

Key Moments - 3 Insights

Why does the filter keep only some elements after map?

Because filter checks the mapped values against the condition (it > 5). Only elements with mapped values greater than 5 are kept, as shown in execution_table rows 3-5.

Does map change the original sequence?

No, map creates a new sequence with transformed elements without changing the original, as variable_tracker shows 'numbers' stays the same.

When does the sequence stop processing elements?

After all elements are processed, as indicated by the 'End' row in execution_table and the final states in variable_tracker.

Visual Quiz - 3 Questions

Look at the execution_table, what is the mapped value of element 4?

A 8

B 6

C 4

D 10

💡 Hint

Check the 'After map (it * 2)' column for Step 4 in execution_table.

At which step does the filter condition become true for the first time?

A Step 2

B Step 3

C Step 1

D Step 5

💡 Hint

Look at the 'Filter condition (it > 5)' column in execution_table to find when it first says true.

If the filter condition changed to it > 8, which elements would be kept?

A [6, 8, 10]

B [8, 10]

C [10]

D [2, 4, 6]

💡 Hint

Refer to the mapped values in variable_tracker and apply the new condition it > 8.

Concept Snapshot

Sequence operators map and filter in Kotlin:
- map transforms each element.
- filter keeps elements matching a condition.
- Both return new sequences.
- Use toList() to get a list.
- Processing is lazy until terminal operation.

Full Transcript

This example shows how Kotlin sequences use map and filter operators. We start with a sequence of numbers 1 to 5. The map operator doubles each number, creating a new sequence of doubled values. Then filter keeps only those doubled values greater than 5. The execution table traces each element through these steps, showing which elements pass the filter. The variable tracker shows how the original sequence stays unchanged, while mapped and filtered sequences build up. Key moments clarify common confusions about sequence immutability and lazy processing. The visual quiz tests understanding of mapped values, filter conditions, and how changing conditions affects results. The concept snapshot summarizes the key points about map and filter on sequences in Kotlin.