Why Iterating over collections in Rust? - Purpose & Use Cases

The Big Idea

What if your computer could handle all the boring, repetitive checking for you in just one simple step?

The Scenario

Imagine you have a list of your favorite songs written down on paper. To find the longest song, you have to look at each title one by one, write down its length, and compare it manually. This takes a lot of time and effort, especially if the list is very long.

The Problem

Doing this by hand is slow and easy to mess up. You might skip a song, misread a length, or forget which one was longest. If the list changes, you have to start all over again. This makes the task frustrating and error-prone.

The Solution

Using iteration in Rust lets the computer do this repetitive checking for you. You can tell it to look at each item in a collection one by one automatically. This saves time, avoids mistakes, and works even if the list grows or changes.

Before vs After

✗ Before

let mut i = 0;
while i < songs.len() {
    println!("{}", songs[i]);
    i += 1;
}

✓ After

for song in &songs {
    println!("{}", song);
}

What It Enables

It makes working with many items easy and reliable, letting you focus on what to do with each item instead of how to move through the list.

Real Life Example

Think of a grocery list app that shows each item one by one to check off. Iteration helps the app go through the list smoothly, no matter how many items you add or remove.

Key Takeaways

Manual checking of each item is slow and error-prone.

Iteration automates going through collections efficiently.

It works well even when collections change size or content.

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