Snippet

Optimizing Custom Iterators by Overriding Internal Fold

While standard external iteration uses next(), internal iteration via the fold method often yields superior performance. By overriding fold on a custom iterator, we bypass the repeated state checks and setup overhead required by next(), allowing the compiler to optimize loop unrolling and register allocation.

snippet.rs

rust

struct StepByTwo {
    current: usize,
    end: usize,
}
 
impl Iterator for StepByTwo {
    type Item = usize;
 
    fn next(&mut self) -> Option<Self::Item> {
        if self.current < self.end {
            let val = self.current;
            self.current += 2;
            Some(val)
        } else {
            None
        }
    }
 
    fn fold<B, F>(mut self, init: B, mut f: F) -> B
    where
        F: FnMut(B, Self::Item) -> B,
    {
        let mut accum = init;
        while self.current < self.end {
            accum = f(accum, self.current);
            self.current += 2;
        }
        accum
    }
}

Breakdown

fn fold<B, F>(mut self, init: B, mut f: F) -> B

Overrides the default fold method to implement customized internal iteration.

while self.current < self.end {

Iterates using a fast, local while-loop instead of yielding control back to a next() caller.

accum = f(accum, self.current);

Directly threads the accumulator through the closure, minimizing state transitions.

Previous snippet Next snippet

More Expert Rust exercises →

Optimizing Custom Iterators by Overriding Internal Fold

Related