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.

Practice

1. What does destructuring in Kotlin collection iteration allow you to do?
for ((key, value) in map) { ... }

easy

A. Only access the value in the loop

B. Only access the key in the loop

C. Access both key and value directly in the loop variables

D. Modify the map while iterating

Solution

1. Step 1: Understand destructuring syntax

   In Kotlin, for ((key, value) in map) extracts both key and value from each map entry.

2. Step 2: Recognize loop variable usage

   This lets you use key and value directly inside the loop without extra calls.

3. Final Answer:

   Access both key and value directly in the loop variables -> Option C

4. Quick Check:

   Destructuring = direct access to parts [OK]

Hint: Destructuring splits pairs into variables directly [OK]

Common Mistakes:

• Thinking only key or value is accessible
• Trying to modify map inside loop
• Not using parentheses for destructuring

2. Which of the following is the correct syntax for destructuring a map in Kotlin?
val map = mapOf("a" to 1, "b" to 2)

easy

A. for (key, value in map) { println(key + value) }

B. for ((key, value) in map) { println(key + value) }

C. for [key, value] in map { println(key + value) }

D. for {key, value} in map { println(key + value) }

Solution

1. Step 1: Recall Kotlin destructuring syntax

   Kotlin requires parentheses around variables when destructuring: for ((key, value) in map).

2. Step 2: Check each option

   Only for ((key, value) in map) { println(key + value) } uses parentheses correctly; others use commas without parentheses or wrong brackets.

3. Final Answer:

   for ((key, value) in map) { println(key + value) } -> Option B

4. Quick Check:

   Parentheses needed for destructuring [OK]

Hint: Use parentheses around variables in destructuring [OK]

Common Mistakes:

• Omitting parentheses in for loop
• Using square or curly brackets instead
• Confusing destructuring with tuple unpacking syntax

3. What is the output of this Kotlin code?

val map = mapOf("x" to 10, "y" to 20)
for ((k, v) in map) {
  println("$k$v")
}

medium

A. Syntax error

B. 10x\n20y

C. k v\nk v

D. x10\ny20

Solution

1. Step 1: Understand map entries and destructuring

   The map has entries "x" to 10 and "y" to 20. The loop destructures each entry into k and v.

2. Step 2: Print key and value concatenated

   Inside the loop, println("$k$v") prints key and value together without space, so outputs are "x10" and "y20" on separate lines.

3. Final Answer:

   x10\ny20 -> Option D

4. Quick Check:

   Print key + value per entry [OK]

Hint: Destructure map entries to print key and value [OK]

Common Mistakes:

• Swapping key and value in output
• Expecting spaces between key and value
• Confusing variable names

4. Identify the error in this Kotlin code snippet:

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

medium

A. Missing parentheses around key and value in for loop

B. mapOf cannot be iterated

C. Cannot add key and value directly

D. No error, code runs fine

Solution

1. Step 1: Check for destructuring syntax

   The for loop uses for (key, value in map) which lacks parentheses around key, value.

2. Step 2: Understand correct syntax

   Kotlin requires parentheses for destructuring pairs: for ((key, value) in map). Without them, it's a syntax error.

3. Final Answer:

   Missing parentheses around key and value in for loop -> Option A

4. Quick Check:

   Parentheses required for destructuring [OK]

Hint: Always use parentheses for destructuring in for loops [OK]

Common Mistakes:

• Omitting parentheses in destructuring
• Thinking mapOf is not iterable
• Confusing addition with string concatenation

5. Given a list of pairs representing database rows:

val rows = listOf(Pair("id", 1), Pair("name", "Alice"), Pair("age", 30))

Which Kotlin code correctly prints each key and value using destructuring?

hard

A. for ((key, value) in rows) { println("$key: $value") }

B. for (key, value in rows) { println("$key: $value") }

C. for (row in rows) { println(row.key + ": " + row.value) }

D. for ((k, v) in rows) { println(k + v) }

Solution

1. Step 1: Recognize list of pairs and destructuring

   The list contains pairs, so destructuring with (key, value) works to access each part.

2. Step 2: Check each option for correctness

   for ((key, value) in rows) { println("$key: $value") } uses correct destructuring syntax and prints key and value with colon and space. for (key, value in rows) { println("$key: $value") } misses parentheses, for (row in rows) { println(row.key + ": " + row.value) } tries to access properties that don't exist, for ((k, v) in rows) { println(k + v) } concatenates without separator.

3. Final Answer:

   for ((key, value) in rows) { println("$key: $value") } -> Option A

4. Quick Check:

   Use parentheses and print with separator [OK]

Hint: Use parentheses and print key: value format [OK]

Common Mistakes:

• Omitting parentheses in for loop
• Accessing pair elements as properties
• Concatenating without separator