Loops 如何编写传递给函数的迭代器的类型？

我试图编写一个解析器，将迭代器通过向量传递给函数。代码与此类似：

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

---

我不知道如何在向量上编写迭代器的类型。我试图输入错误的类型

u32

，以查看

rustc

期望的类型：

core:：slice:：Iter解决方案是添加

use std::slice::Iter;

类型是

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

fun foo）{
解决方案是添加

use std::slice::Iter;

类型是

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

fun foo）{
迭代器有多种类型；大多数时候，您真正想要的是一个能够使用其中任何一个的函数。为此，惯用的解决方案是使用泛型

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

除了泛型，我们还可以使用trait对象：

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

fn-foo）{
而让一些（c）=itr.next（）{
如果*c！=0{
打破
}
println！（{}，*c）；
}
}
fn main（）{
设v=vec！[0；10]；
设mut-itr=v.iter（）；
而让一些（c）=itr.next（）{
foo（和mut-itr）；
}
}

Rust book中关于的章节解释了这些解决方案之间的区别。
迭代器有多种类型；大多数时候，您真正想要的是一个能够使用其中任何一个的函数。为此，惯用的解决方案是使用泛型

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

除了泛型，我们还可以使用trait对象：

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

fn-foo）{
而让一些（c）=itr.next（）{
如果*c！=0{
打破
}
println！（{}，*c）；
}
}
fn main（）{
设v=vec！[0；10]；
设mut-itr=v.iter（）；
而让一些（c）=itr.next（）{
foo（和mut-itr）；
}
}

Rust book中关于的章节解释了这些解决方案之间的差异。
请注意，这只允许您的函数与切片上的
iter（）
方法返回的迭代器一起使用，而不是与
iter（）.map（| x |…）
一起使用，因为它有另一种类型。正如@FrancisGagné所建议的，您需要在这里使用泛型。请注意，这只允许您的函数与切片上的
iter（）
方法返回的迭代器一起使用，而不能与
iter（）.map（| x |…）
一起使用，因为它有另一种类型。正如@FrancisGagné所建议的，您需要在这里使用泛型。太棒了！仅供参考，如果你有递归下降解析器中的相互递归函数，如果你使用泛型，rust将不会被编译，但是如果你使用trait对象，它将工作。太棒了！仅供参考，如果您有递归下降解析器中的相互递归函数，则如果使用泛型，则不会编译rust，但如果使用trait对象，则它会工作。