Snippet

Optimierung benutzerdefinierter Iteratoren durch Überschreiben von Fold

Während die standardmäßige externe Iteration next() verwendet, führt die interne Iteration über die fold-Methode oft zu einer besseren Leistung. Durch das Überschreiben von fold bei einem benutzerdefinierten Iterator umgehen wir die wiederholten Zustandsprüfungen und den Setup-Overhead von next(), wodurch der Compiler das Entrollen von Schleifen und die Registerallokation optimieren kann.

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
    }
}

Erklärung

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

Überschreibt die Standard-fold-Methode, um eine benutzerdefinierte interne Iteration zu implementieren.

while self.current < self.end {

Iteriert mithilfe einer schnellen, lokalen while-Schleife, anstatt die Kontrolle an einen next()-Aufrufer zurückzugeben.

accum = f(accum, self.current);

Leitet den Akkumulator direkt durch das Closure und minimiert so Zustandsübergänge.

Vorheriges Snippet Nächstes Snippet

Mehr Rust-Übungen für Experten →

Optimierung benutzerdefinierter Iteratoren durch Überschreiben von Fold

Verwandt