Closures and Iterators

# CHAPTER 21

Closures and Iterators #

1. Chapter Introduction #

2. Learning Objectives #

• Define and execute Closures.

• Understand how Closures capture environmental variables.

• Use the Iterator trait to process collections.

• Chain Iterator adapters like map() and filter().

• Consume Iterators using collect().

3. What are Closures? #

Syntax: Instead of fn and (), closures use pipes | | for parameters.

fn main() {
    // A simple closure assigned to a variable
    let add_one = |x: i32| -> i32 { x + 1 };
    
    // The compiler can usually infer types, making it much shorter!
    let add_two = |x| x + 2;

    println!("5 + 1 = {}", add_one(5));
    println!("5 + 2 = {}", add_two(5));
}

4. Capturing the Environment #

fn main() {
    let multiplier = 3;

    // This closure captures the 'multiplier' variable from the main scope!
    let multiply = |x| x * multiplier;

    println!("4 * 3 = {}", multiply(4)); // Outputs 12
}

5. Iterators #

let v1 = vec![1, 2, 3];

// Creates an iterator, but does NO work yet.
let v1_iter = v1.iter(); 

// The 'for' loop consumes the iterator
for val in v1_iter {
    println!("Got: {}", val);
}

6. Iterator Adapters: map and filter #

Using map() to transform data:

fn main() {
    let numbers = vec![1, 2, 3];

    // map() takes a closure and applies it to every item.
    // Iterators are lazy, so we MUST call .collect() at the end to execute the chain 
    // and gather the results into a new Vector!
    let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();

    println!("Doubled: {:?}", doubled); // [2, 4, 6]
}

Using filter() to remove data:

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];

    // filter() keeps items where the closure returns 'true'
    // Notice the double reference &&x. .iter() produces &x, and filter borrows it again.
    let evens: Vec<i32> = numbers.into_iter().filter(|x| x % 2 == 0).collect();

    println!("Evens: {:?}", evens); // [2, 4, 6]
}

7. The Power of Chaining #

let numbers = vec![1, 2, 3, 4, 5];

let processed: Vec<i32> = numbers.into_iter()
    .filter(|x| x > &2)    // Keep 3, 4, 5
    .map(|x| x * 10)       // Multiply by 10
    .collect();            // Execute and gather into [30, 40, 50]

*Because of "Zero-Cost Abstractions", this compiles down to code that runs exactly as fast as a manually written, highly optimized for loop!*

8. Common Mistakes #

• Forgetting .collect(): Because Iterators are lazy, writing numbers.iter().map(|x| x * 2); does literally nothing. The compiler will warn you that the Iterator is unused. You must consume it with .collect(), .sum(), or a loop.

• Type inference on .collect(): You must usually declare the type you are collecting into (e.g., let v: Vec<i32> = ...), because .collect() can build Vectors, HashMaps, Strings, and more.

9. Best Practices #

• Use into_iter() when you want ownership: v.iter() yields immutable references (&T). v.into_iter() takes ownership of the vector and yields the actual values (T), which is often easier for map/filter operations where you build a brand new collection.

10. Exercises #

1. 1. Create a Vec of names: ["Alice", "Bob", "Charlie"].

1. 2. Use .into_iter(), .filter(), and .collect() to create a new Vec containing only names longer than 3 letters.

11. MCQs with Answers #

Q9. Is chaining Iterator methods slower than writing a manual for loop in Rust? a) Yes, much slower b) No, due to Zero-Cost Abstractions, the compiler optimizes it to be just as fast as a manual loop Answer: b) No, they compile to identical machine code.

Q10. Can Closures be passed as arguments into functions? a) Yes b) No Answer: a) Yes.

12. Interview Questions #

• Q: Explain what a Closure is and how it differs from a standard function in Rust.

• Q: Why are Iterators in Rust considered "Lazy", and what is the benefit of this design?

13. Summary #

14. Next Chapter Recommendation #