Advanced Iterators

🚂 The Iterator Express: Your Journey Through Rust’s Advanced Iterators

Imagine you’re on a magical train called the Iterator Express. Each car contains items, and you have special conductors (methods) who can transform, combine, and deliver these items in amazing ways!

🎯 What Are Advanced Iterators?

Think of iterators like a conveyor belt in a candy factory. Items move along, and workers (methods) can:

• Count them
• Transform them
• Package them together
• Create entirely new belts!

Simple Example:

let candies = vec![1, 2, 3];
let doubled: Vec<i32> = candies
    .iter()
    .map(|x| x * 2)
    .collect();
// Result: [2, 4, 6]

🍽️ Consuming Adaptors: The Hungry Helpers

What are they? Methods that “eat up” the entire iterator and give you one final result.

Think of a cookie monster eating every cookie on a plate and telling you how many he ate!

let cookies = vec![1, 2, 3, 4, 5];
let total = cookies.iter().sum::<i32>();
// Monster ate 5 cookies, total = 15

Common Consuming Adaptors:

let ages = vec![5, 8, 3, 12];
let oldest = ages.iter().max();
// oldest = Some(&12)

📦 The collect Method: The Magic Box

What is it? Transforms your iterator back into a collection!

Imagine a magic box that catches falling stars and arranges them however you want.

// Stars falling → Box catches them as Vec
let stars: Vec<i32> = (1..=5).collect();
// stars = [1, 2, 3, 4, 5]

// Same stars → Different box shape!
let star_set: HashSet<i32> = (1..=5).collect();

The Turbofish ::<>

Sometimes Rust needs help knowing what type to collect into:

let nums = vec!["1", "2", "3"];
let parsed: Vec<i32> = nums
    .iter()
    .map(|s| s.parse().unwrap())
    .collect();

🧮 The fold Method: The Super Calculator

What is it? Starts with a value and combines everything step by step.

Think of a snowball rolling downhill, getting bigger with each roll!

graph TD
    A["Start: 0"] --> B["+ 1 = 1"]
    B --> C["+ 2 = 3"]
    C --> D["+ 3 = 6"]
    D --> E["Final: 6"]

let numbers = vec![1, 2, 3];
let sum = numbers
    .iter()
    .fold(0, |snowball, &item| {
        snowball + item
    });
// sum = 6

Real Example: Building a Sentence

let words = vec!["I", "love", "Rust"];
let sentence = words
    .iter()
    .fold(String::new(), |mut acc, word| {
        if !acc.is_empty() {
            acc.push(' ');
        }
        acc.push_str(word);
        acc
    });
// sentence = "I love Rust"

🤝 zip and enumerate: The Pairing Partners

🔗 zip: The Zipper

Combines two iterators like a zipper on a jacket — left side meets right side!

let names = vec!["Alice", "Bob"];
let ages = vec![10, 12];

let paired: Vec<_> = names
    .iter()
    .zip(ages.iter())
    .collect();
// [("Alice", &10), ("Bob", &12)]

graph TD
    A["Alice"] --> C["#40;Alice, 10#41;"]
    B["10"] --> C
    D["Bob"] --> E["#40;Bob, 12#41;"]
    F["12"] --> E

🔢 enumerate: The Number Giver

Gives each item a ticket number as they board the train!

let fruits = vec!["apple", "banana"];

for (ticket, fruit) in fruits.iter().enumerate() {
    println!("#{}: {}", ticket, fruit);
}
// #0: apple
// #1: banana

🔧 Iterator Combinators: Chain Reactions!

What are they? Methods you chain together like LEGO blocks to build amazing things!

The Power Chain:

let result: Vec<i32> = (1..=10)
    .filter(|x| x % 2 == 0)  // Keep evens
    .map(|x| x * x)          // Square them
    .take(3)                 // Take first 3
    .collect();
// [4, 16, 36]

Common Combinators:

// Skip breakfast, take lunch and dinner
let meals = vec!["breakfast", "lunch", "dinner"];
let eating: Vec<_> = meals
    .iter()
    .skip(1)
    .collect();
// ["lunch", "dinner"]

🛠️ Creating Custom Iterators

What is it? Building your own magic conveyor belt!

Like creating your own toy factory that produces items on demand.

Step-by-Step Recipe:

struct Counter {
    count: u32,
    max: u32,
}

impl Counter {
    fn new(max: u32) -> Counter {
        Counter { count: 0, max }
    }
}

impl Iterator for Counter {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        if self.count < self.max {
            self.count += 1;
            Some(self.count)
        } else {
            None  // Factory closed!
        }
    }
}

// Using our custom iterator:
let counter = Counter::new(3);
for num in counter {
    println!("{}", num);
}
// 1, 2, 3

graph TD
    A["Create Counter"] --> B{count < max?}
    B -->|Yes| C["Return count + 1"]
    C --> B
    B -->|No| D["Return None"]
    D --> E["Stop"]

🎫 The IntoIterator Trait: The Ticket Booth

What is it? A trait that lets things become iterators!

Like a ticket booth that converts your group pass into individual tickets.

// Vec has IntoIterator, so this works:
for item in vec![1, 2, 3] {
    println!("{}", item);
}

// This is secretly:
for item in vec![1, 2, 3].into_iter() {
    println!("{}", item);
}

Your Own Type:

struct Basket {
    items: Vec<String>,
}

impl IntoIterator for Basket {
    type Item = String;
    type IntoIter = std::vec::IntoIter<String>;

    fn into_iter(self) -> Self::IntoIter {
        self.items.into_iter()
    }
}

🎭 iter vs iter_mut vs into_iter: The Three Modes

This is like visiting a museum, art class, or gift shop!

Visual Guide:

graph TD
    A["Your Collection"] --> B["iter"]
    A --> C["iter_mut"]
    A --> D["into_iter"]
    B --> E["&T - Borrow, just look"]
    C --> F["&mut T - Borrow, can change"]
    D --> G["T - Take ownership forever"]

Code Examples:

let toys = vec!["ball", "car", "doll"];

// iter() - Just looking
for toy in toys.iter() {
    println!("I see a {}", toy);
}
// toys still usable!

// iter_mut() - Can modify
let mut scores = vec![10, 20, 30];
for score in scores.iter_mut() {
    *score += 5;  // Add bonus points!
}
// scores = [15, 25, 35]

// into_iter() - Takes ownership
let gifts = vec!["book", "pen"];
for gift in gifts.into_iter() {
    println!("I now own: {}", gift);
}
// gifts is GONE, consumed!

Quick Decision Chart:

Need to read items only? → iter()
Need to change items? → iter_mut()
Done with the collection? → into_iter()

🎓 Summary: Your Iterator Toolkit

🚀 You’re Ready!

You now have all the tools to work with Rust’s powerful iterator system. Remember:

1. Chain combinators for clean, readable code
2. Choose the right iter method for your needs
3. Create custom iterators when you need special behavior

The Iterator Express has arrived at your destination. Happy coding! 🎉