Destructuring in collection iteration in Kotlin - Step-by-Step Execution

Concept Flow - Destructuring in collection iteration

Start with collection

↓

Begin iteration over collection

↓

Destructure each element into parts

↓

Use destructured parts in loop body

↓

Repeat for next element

↓

End when all elements processed

This flow shows how Kotlin loops over a collection, breaking each element into parts using destructuring, then using those parts inside the loop.

Execution Sample

Kotlin

val map = mapOf("a" to 1, "b" to 2)
for ((key, value) in map) {
  println("$key -> $value")
}

This code loops over a map, destructuring each entry into key and value, then prints them.

Execution Table

Step	Element	Destructured key	Destructured value	Action	Output
1	("a", 1)	"a"	1	Print key and value	a -> 1
2	("b", 2)	"b"	2	Print key and value	b -> 2
3	No more elements	-	-	End loop	-

💡 All elements processed, loop ends

Variable Tracker

Variable	Start	After 1	After 2	Final
key	-	"a"	"b"	-
value	-	1	2	-

Key Moments - 2 Insights

Why do we write (key, value) in the for loop instead of a single variable?

Because the map entries are pairs, destructuring lets us split each pair into key and value directly, as shown in execution_table rows 1 and 2.

What happens if the collection elements are not pairs?

Destructuring expects the element to have components to split; if not, it causes an error. Here, map entries have two parts, so destructuring works.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'key' at step 2?

A "b"

B "a"

C 1

D 2

💡 Hint

Check the 'Destructured key' column at step 2 in the execution_table.

At which step does the loop end according to the execution table?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look for the row where 'No more elements' is noted in the 'Element' column.

If the map had three entries, how many rows would the execution table have before the loop ends?

A 3

B 4

C 5

D 6

💡 Hint

Each entry adds one step plus one final step for loop end, see current table with 2 entries and 3 rows.

Concept Snapshot

Kotlin lets you destructure elements in a for loop.
Use syntax: for ((part1, part2) in collection) { ... }
Works when elements have multiple components (like pairs).
Inside loop, use parts directly.
Loop ends after all elements processed.

Full Transcript

This visual execution shows how Kotlin uses destructuring in collection iteration. We start with a collection, here a map of pairs. The loop goes through each element. Each element is destructured into key and value parts. These parts are used inside the loop body, for example to print them. The execution table shows each step: the element, the destructured key and value, the action, and the output. Variables key and value change each iteration to the current pair's parts. The loop ends when no elements remain. Common confusions include why destructuring is used and what happens if elements are not pairs. The quiz tests understanding of variable values at steps, loop termination, and how the table changes with more elements.