Iterating over collections in Rust - Step-by-Step Execution

Concept Flow - Iterating over collections

Start

↓

Get collection

↓

Create iterator

↓

Check next item

↓

Process item

↓

Repeat check next item

This flow shows how Rust creates an iterator from a collection, checks for the next item, processes it if present, and repeats until no items remain.

Execution Sample

Rust

let numbers = vec![1, 2, 3];
for num in &numbers {
    println!("{}", num);
}

This code loops over each number in the vector and prints it.

Execution Table

Step	Iterator State	Current Item	Action	Output
1	Start at beginning	1	Print item	1
2	Move to next	2	Print item	2
3	Move to next	3	Print item	3
4	Move to next	None	Stop iteration	End

💡 Iterator has no more items, loop ends.

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
num	undefined	1	2	3	undefined

Key Moments - 3 Insights

Why does the loop stop after printing 3?

Because the iterator reaches the end of the collection and returns None, as shown in step 4 of the execution_table.

Is the original collection changed during iteration?

No, the collection is only borrowed (&numbers), so it remains unchanged throughout the loop.

What does '&numbers' mean in the for loop?

It means the loop borrows the vector by reference, so it does not take ownership or modify it.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'num' at step 2?

A 1

B 2

C 3

D None

💡 Hint

Check the 'Current Item' column at step 2 in the execution_table.

At which step does the loop stop iterating?

A Step 4

B Step 3

C Step 2

D Step 1

💡 Hint

Look for the step where 'Current Item' is None in the execution_table.

If we changed 'for num in &numbers' to 'for num in numbers', what would happen?

A The loop would not compile

B The vector would be borrowed and remain usable

C The vector would be moved and no longer usable after the loop

D The loop would print nothing

💡 Hint

Borrowing vs moving ownership is shown in key_moments about '&numbers'.

Concept Snapshot

Rust iterates collections by creating an iterator.
Use 'for item in &collection' to borrow and loop.
Each loop step gets the next item until none left.
Original collection stays unchanged when borrowed.
Loop stops when iterator returns None.

Full Transcript

This visual execution shows how Rust loops over a collection using an iterator. The vector 'numbers' contains three items: 1, 2, and 3. The for loop borrows the vector by reference using '&numbers'. At each step, the iterator provides the next item. Step 1 gets 1 and prints it. Step 2 gets 2 and prints it. Step 3 gets 3 and prints it. Step 4 finds no more items (None) and stops the loop. The variable 'num' changes from undefined to 1, then 2, then 3, then back to undefined after the loop ends. The original vector remains unchanged because it was only borrowed. This example helps beginners see how iteration works step-by-step in Rust.

Practice

1. What does the following Rust code do?

let numbers = [1, 2, 3];
for num in numbers {
    println!("{}", num);
}

easy

A. Causes a compile error because arrays can't be iterated

B. Prints each number in the array on a new line

C. Prints the whole array as one line

D. Prints the length of the array

Solution

1. Step 1: Understand the for loop over an array

   The for loop visits each element in the array named 'numbers'.

2. Step 2: Action inside the loop

   Each element is printed on its own line using println! macro.

3. Final Answer:

   Prints each number in the array on a new line -> Option B

4. Quick Check:

   for loop over array prints elements one by one [OK]

Hint: For loops visit each item in order [OK]

Common Mistakes:

• Thinking arrays can't be iterated
• Expecting the whole array printed at once
• Confusing print! with println!

2. Which of these is the correct syntax to iterate over a vector named v in Rust?

easy

A. for i in v { println!("{}", i); }

B. for i to v { println!("{}", i); }

C. foreach i in v { println!("{}", i); }

D. loop i in v { println!("{}", i); }

Solution

1. Step 1: Recall Rust for loop syntax

   Rust uses 'for variable in collection' to iterate over items.

2. Step 2: Check each option

   for i in v { println!("{}", i); } matches correct syntax; others use invalid keywords.

3. Final Answer:

   for i in v { println!("{}", i); } -> Option A

4. Quick Check:

   Rust uses 'for ... in ...' loops [OK]

Hint: Remember: for variable in collection [OK]

Common Mistakes:

• Using 'to' instead of 'in'
• Using 'foreach' which is not Rust syntax
• Using 'loop' incorrectly

3. What is the output of this Rust code?

let v = vec![10, 20, 30];
let mut sum = 0;
for &num in &v {
    sum += num;
}
println!("{}", sum);

medium

A. 60

B. 303020

C. Error due to borrowing

D. 0

Solution

1. Step 1: Understand iteration with references

   The loop uses '&num in &v' to borrow each element by reference and dereference it with '&num'.

2. Step 2: Calculate sum of elements

   sum starts at 0, then adds 10, 20, and 30, resulting in 60.

3. Final Answer:

   60 -> Option A

4. Quick Check:

   Sum of 10+20+30 = 60 [OK]

Hint: Sum elements by iterating with references [OK]

Common Mistakes:

• Confusing references and values
• Expecting concatenation instead of sum
• Thinking borrowing causes error here

4. Identify the error in this Rust code snippet:

let arr = [1, 2, 3];
for num in arr {
    num += 1;
    println!("{}", num);
}

medium

A. Loop variable 'num' must be a reference

B. Syntax error: missing semicolon after println!

C. Array cannot be iterated directly

D. Cannot modify 'num' because it is an immutable copy

Solution

1. Step 1: Check mutability of loop variable

   In Rust, loop variables are immutable by default; 'num' is a copy of array element.

2. Step 2: Understand why 'num += 1' fails

   Trying to change 'num' causes error because it is not declared mutable.

3. Final Answer:

   Cannot modify 'num' because it is an immutable copy -> Option D

4. Quick Check:

   Loop variables are immutable unless declared mutable [OK]

Hint: Loop vars are immutable unless 'mut' used [OK]

Common Mistakes:

• Thinking semicolon missing causes error
• Believing arrays can't be iterated
• Assuming loop vars are references by default

5. You have a vector of strings: let words = vec!["apple", "banana", "cherry"];. How do you create a new vector containing the lengths of each word using iteration?

hard

A. let lengths = words.map(|w| w.len());

B. let lengths = for w in words { w.len() };

C. let lengths: Vec<usize> = words.iter().map(|w| w.len()).collect();

D. let lengths = words.iter().for_each(|w| w.len());

Solution

1. Step 1: Use iterator and map to transform elements

   words.iter() creates an iterator over references to strings; map applies a function to each element.

2. Step 2: Collect results into a new vector

   collect() gathers the mapped lengths into a Vec<usize>.

3. Final Answer:

   let lengths: Vec<usize> = words.iter().map(|w| w.len()).collect(); -> Option C

4. Quick Check:

   Use iter().map(...).collect() to transform collections [OK]

Hint: Use iter().map(...).collect() to build new collections [OK]

Common Mistakes:

• Trying to use for loop as expression
• Using map directly on vector without iter()
• Using for_each which returns () not a collection