Wie schreibe ich den Typ eines Iterators, der an eine Funktion übergeben wird?

Question

Ich versuche, einen Parser zu schreiben, der einen Iterator über einen Vektor an eine Funktion übergibt. Der Code ist ähnlich wie folgt aus:

fn foo(itr : ???) { 
    while let Some(c) = itr.next() { 
     if *c != 0 { 
      break; 
     } 
     println!("{}", *c); 
    } 
} 

fn main() { 
    let v = vec![0; 10]; 
    let itr = v.iter(); 
    while let Some(c) = itr.next() { 
     foo(itr); 
    } 
} 

Ich bin nicht sicher, wie die Art des Iterator über den Vektor zu schreiben. Ich habe versucht, den falschen Typ u32 zu setzen, um zu sehen, welcher Typ rustc erwartet: core::slice::Iter<'_, _>. Wenn ich versuche, core::slice rustc zu verwenden, klagt Use of undeclared type or module 'core::slice'

Answer 1

Es gibt viele Arten von Iteratoren hinzuzufügen; die meiste Zeit, was Sie wirklich wollen, ist eine Funktion, die in der Lage ist, eines von ihnen zu konsumieren. Um dies zu tun, ist die idiomatische Lösung, Generika zu verwenden.

fn foo<'a, T: Iterator<Item=&'a i32>>(mut itr: T) { 
    while let Some(c) = itr.next() { 
     if *c != 0 { 
      break; 
     } 
     println!("{}", *c); 
    } 
} 

fn main() { 
    let v = vec![0; 10]; 
    let mut itr = v.iter(); 
    while let Some(c) = itr.next() { 
     foo(itr); 
    } 
} 

Der obige Code kompiliert nicht obwohl, da es itr in foo bewegt, dann versucht es auf dem while let wieder zu verwenden. Um dies zu lösen, müssen wir den Iterator stattdessen durch Referenz übergeben.

fn foo<'a, T: Iterator<Item=&'a i32>>(itr: &mut T) { 
    while let Some(c) = itr.next() { 
     if *c != 0 { 
      break; 
     } 
     println!("{}", *c); 
    } 
} 

fn main() { 
    let v = vec![0; 10]; 
    let mut itr = v.iter(); 
    while let Some(c) = itr.next() { 
     foo(&mut itr); 
    } 
} 

Statt Generika, können wir auch ein Merkmal-Objekt verwenden:

fn foo<'a>(itr: &mut Iterator<Item=&'a i32>) { 
    while let Some(c) = itr.next() { 
     if *c != 0 { 
      break; 
     } 
     println!("{}", *c); 
    } 
} 

fn main() { 
    let v = vec![0; 10]; 
    let mut itr = v.iter(); 
    while let Some(c) = itr.next() { 
     foo(&mut itr); 
    } 
} 

Das Kapitel über trait objects vom Rust Buch den Unterschied zwischen diesen Lösungen erläutert.

Answer 2

wurde die Lösung

use std::slice::Iter; 

und der Typ war

fun foo<'a>(itr : &mut Iter<'a, i32>) {}