Rust for C-Programmers

13.4 Advanced Iterator Concepts

Rust offers additional iterator features such as double-ended iteration, fused iteration, and various optimizations.

13.4.1 Double-Ended Iterators

A DoubleEndedIterator can advance from both the front (next()) and the back (next_back()). Many standard iterators (like those over Vec) support this:

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

    assert_eq!(iter.next(), Some(&1));
    assert_eq!(iter.next_back(), Some(&5));
    assert_eq!(iter.next(), Some(&2));
    assert_eq!(iter.next_back(), Some(&4));
    assert_eq!(iter.next(), Some(&3));
    assert_eq!(iter.next_back(), None);
}

To implement this yourself, provide a next_back() method in addition to next() and implement the DoubleEndedIterator trait.

13.4.2 Fused Iterators

A FusedIterator is one that promises once next() returns None, it will always return None. Most standard library iterators are naturally fused.

13.4.3 Iterator Fusion and Short-Circuiting

Rust can optimize chained iterators by fusing them or short-circuiting them once the final result is determined.

13.4.4 Exact Size and size_hint()

Some iterators know exactly how many items remain. If an iterator implements the ExactSizeIterator trait, it must always report an accurate count of remaining items. For less exact cases, the size_hint() method on Iterator provides a lower and upper bound on the remaining length:

fn main() {
    let numbers = vec![10, 20, 30];
    let mut iter = numbers.iter();
    println!("{:?}", iter.size_hint()); // (3, Some(3))

    // Advance one step
    iter.next();
    println!("{:?}", iter.size_hint()); // (2, Some(2))
}

This feature helps optimize certain operations, but it’s optional unless your iterator truly knows its size in advance.