Lazy, Zero-Cost Sequence Processing

In Rust, iterators are lazy, meaning they do nothing until you call a consumer method (like collect, next, or fold) that actively pulls items through the pipeline.

Core Trait Definition

At the heart of the iterator system is the Iterator trait from the standard library:

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

How Iterators Are Created

1. .iter(): Yields shared references (&T).
2. .iter_mut(): Yields mutable references (&mut T).
3. .into_iter(): Consumes the collection, yielding owned values (T).

let items = vec![10, 20, 30];

// Shared reference iterator
for val in items.iter() {
    println!("Ref: {}", val); // val is &i32
}

// Owned value iterator (items is consumed here)
for val in items.into_iter() {
    println!("Val: {}", val); // val is i32
}

Key Functional Adapters (Lazy)

Adapters take an iterator and return a new iterator. They do not perform calculations until a consumer is called:

• .map(f): Transforms each element.
• .filter(p): Retains only elements matching a predicate.
• .take(n): Yields only the first n elements.
• .enumerate(): Yields pairs of (index, element).

Key Consumers (Active)

Consumers actively poll the iterator until it's finished:

• .collect(): Materializes the iterator into a collection (like Vec or HashMap).
• .fold(init, f): Accumulates values into a single result (analogous to reduce).
• .find(p): Searches for the first element matching a predicate.

let sum: i32 = vec![1, 2, 3, 4, 5]
    .into_iter()
    .filter(|&x| x % 2 == 0) // Keep even numbers
    .map(|x| x * x)         // Square them
    .sum();                 // Consume and add: 4 + 16 = 20

Performance Metrics

• Storage Size: Structs wrapping pointer state, size is compile-time deterministic.
• Zero-Cost Abstraction: Rust compiles functional iterator pipelines into loops that are equivalent to (or faster than) hand-written assembly loops. LLVM actively unrolls, optimizes, and eliminates index checks.