Ietrator Fundmaentals

Iterators traverse collections sequentially, abstracting element access patterns. In Rust, they enable functional programming techniques while maintaining performance through compiler optimziations.

Iterator Implementation

Implement the Iterator trait to create custom iterators:

pub trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}

Example implementation for a custom collection:

struct LibraryItem {
    title: String,
    creator: String,
    description: String
}

impl LibraryItem {
    fn iterator(&self) -> LibraryIterator {
        LibraryIterator {
            position: 0,
            elements: vec![
                self.title.clone(),
                self.creator.clone(),
                self.description.clone()
            ]
        }
    }
}

struct LibraryIterator {
    position: usize,
    elements: Vec<String>
}

impl Iterator for LibraryIterator {
    type Item = String;
    
    fn next(&mut self) -> Option<String> {
        if self.position < self.elements.len() {
            let result = self.elements[self.position].clone();
            self.position += 1;
            Some(result)
        } else {
            None
        }
    }
}

Iterator Variants

Standard collections provide multiple iterator types:

let values = vec![10, 20, 30];
values.iter();      // Immutable reference
values.into_iter(); // Ownership transfer
values.iter_mut();  // Mutable reference

Adapter Patterns

Rust provides two iterator composition patterns:

// Iterator adapter (lazy evaluation)
let mapped = values.iter().map(|x| x * 2);

// Consumer adapter (eager evaluation)
let total: i32 = values.iter().sum();

Performance Characteristics

Rust's compiler optimizes iterators to match loop performance through:

• Zero-cost abstractions
• Loop unrolling optimizations
• Inline code generation

Demonstration of unrolling optimization:

// Original loop
fn calculate_sum() {
    let numbers = [5, 10, 15];
    let mut result = 0;
    for n in &numbers {
        result += n;
    }
}

// Equivalent unrolled version
fn unrolled_sum() {
    let numbers = [5, 10, 15];
    let result = numbers[0] + numbers[1] + numbers[2];
}

Key Concepts

• Implement Iterator trait for custom collections
• Leverage built-in adapter patterns
• Combine with closures for functional programming
• Utilize zero-cost abstraction guarantees