Rust中如何传递以迭代器为参数的函数？

你的代码存在两个核心问题：迭代器的Item类型不匹配，以及泛型函数作为参数时的约束错误，导致编译器无法推断类型。

问题1：迭代器Item类型不匹配 #

v.iter()返回的迭代器，其Item是&String（字符串引用），但process函数要求的是Item为String（拥有所有权的字符串）的迭代器，类型不兼容。你可以选择两种方式处理：

• 消费原Vec，用v.into_iter()获取String类型的迭代器；
• 修改process，让它接受引用类型的迭代器。

问题2：泛型函数的参数约束错误 #

process是一个泛型函数，可以接受任意满足Iterator<Item = String>的迭代器类型，但原run函数的约束F: Fn(I)固定了一个具体的I类型，无法适配process的泛型特性。需要调整约束，让F能接受所有符合条件的迭代器类型。

方案1：让process接受IntoIterator（推荐） #

使用IntoIterator可以让函数同时接受迭代器和可迭代对象（比如Vec），更符合Rust的惯用写法：

fn process<I>(lines: I)
where
    I: IntoIterator<Item = String>,
{
    for line in lines {
        println!("{}", line.to_uppercase());
    }
}

fn run<F>(processor: F)
where
    F: FnOnce(impl IntoIterator<Item = String>),
{
    let v = vec![
        String::from("aaa"),
        String::from("BBB"),
        String::from("cCcC"),
    ];
    processor(v.into_iter()); // 消费Vec，得到String类型的迭代器
}

fn main() {
    run(process);
}

方案2：保留process的Iterator约束，使用高阶泛型 #

如果要坚持让process直接接受Iterator，可以用高阶泛型约束，让F能适配任意符合条件的迭代器类型：

fn process<I>(lines: I)
where
    I: Iterator<Item = String>,
{
    for line in lines {
        println!("{}", line.to_uppercase());
    }
}

fn run<F>(processor: F)
where
    F: for<I> Fn(I) where I: Iterator<Item = String>,
{
    let v = vec![
        String::from("aaa"),
        String::from("BBB"),
        String::from("cCcC"),
    ];
    processor(v.into_iter());
}

fn main() {
    run(process);
}

方案3：让process接受引用迭代器 #

如果不想消费原Vec，可以修改process接受&String的迭代器：

fn process<I>(lines: I)
where
    I: Iterator<Item = &String>,
{
    for line in lines {
        println!("{}", line.to_uppercase());
    }
}

fn run<F>(processor: F)
where
    F: for<I> Fn(I) where I: Iterator<Item = &String>,
{
    let v = vec![
        String::from("aaa"),
        String::from("BBB"),
        String::from("cCcC"),
    ];
    processor(v.iter()); // 使用iter()获取引用迭代器
}

fn main() {
    run(process);
}

内容的提问来源于stack exchange，提问作者nightuser