Rust 作为函数参数的InIterator不'；不接受适配器结构

我想要一个函数，它接受

&IntoIterator

，这样我就可以将

&Vec

和迭代器的适配器结构（比如

Map

，

Filter

和任何其他，我相信它们都实现了

IntoIterator

）

所以我有一个函数，比如

pub fn f<'a, T>(it_src: &'a T) -> u32
where &'a T: IntoIterator<Item = u32> {
    let it = it_src.into_iter();
    let result: u32;
    // more more usage
    result
}

pub fn f u32
where&'at:into迭代器{
让it=it_src.into_iter（）；
let结果：u32；
//更多使用
结果
}

这就是我试图使用它的方式（相同的签名，但不同的名称）

pub fn f_with_feature（）u32
where&'at:into迭代器{
让调整后的_值=it_src.into_iter（）
.map（|e | adjust（e））；
f（调整后的_值（&U）
}

我得到的是一个错误

 error[E0308]: mismatched types
  --> src\main.rs:14:7
   |
14 |     f(&adjusted_values)
   |       ^^^^^^^^^^^^^^^^ expected type parameter, found struct `std::iter::Map`
   |
   = note: expected type `&T`
              found type `&std::iter::Map<<&T as std::iter::IntoIterator>::IntoIter, [closure@src\main.rs:13:14: 13:27]>`

错误[E0308]：类型不匹配
-->src\main.rs:14:7
|
14 | f（和调整后的| U值）
|^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
|
=注意：应为类型“%T”`
找到类型“%std:：iter:：Map”`

为什么地图与t不匹配

---

此外，我还提出了一个想法，通过静态分派传递迭代器的适配器不是一个好主意，因为用于生成映射的每个闭包都将创建一个新的函数专门化。尽管我已经看到静态分派方法在大多数情况下在Rust中是惯用的。如何处理这种情况？

我认为您希望在

T

上设置特征边界（而不是

和'a T

）。所以我想你真的想要以下几点：

pub fn f<'a, T>(it_src: &'a T) -> u32
where T: IntoIterator<Item = u32> {
    let it = it_src.into_iter();
    let result: u32 = 1;
    // more more usage
    result
}

pub fn f_with_feature<'a, T>(it_src: &'a T) -> u32
where T: IntoIterator<Item = u32> {
    let adjusted_values = it_src.into_iter()
        .map(|e| adjust(e));
    f(&adjusted_values)
}

但是，上述要求您将值移动到

f

resp<代码>带功能的f_

根据我的经验，只要使用迭代器（必要时在调用站点进行转换），就可以得到简单、直接的解决方案：

pub fn f<T>(it_src: T) -> u32
where T: Iterator<Item = u32> {
    let it = it_src.into_iter();
    let result: u32 = 1;
    // more more usage
    result
}

pub fn f_with_feature<T>(it_src: T) -> u32
where T: Iterator<Item = u32> {
    let adjusted_values = it_src.into_iter()
        .map(|e| adjust(e));
    f(adjusted_values)
}

pub fn f（it_src:T）->u32
其中T：迭代器{
让it=it_src.into_iter（）；
let结果：u32=1；
//更多使用
结果
}
带功能的发布fn f_（it_src:T）->u32
其中T：迭代器{
让调整后的_值=it_src.into_iter（）
.map（|e | adjust（e））；
f（调整后的_值）
}

我已经转向了迭代器方法，但是很遗憾强制传递迭代器，而不是&Vec，后者实现了IntoIterator并且不使用向量

pub fn f<T>(it_src: T) -> u32
where T: IntoIterator<Item = u32> {
    let it = it_src.into_iter();
    let result: u32 = 1;
    // more more usage
    result
}

pub fn f_with_feature<T>(it_src: T) -> u32
where T: IntoIterator<Item = u32> {
    let adjusted_values = it_src.into_iter()
        .map(|e| adjust(e));
    f(adjusted_values)
}

pub fn f<T>(it_src: T) -> u32
where T: Iterator<Item = u32> {
    let it = it_src.into_iter();
    let result: u32 = 1;
    // more more usage
    result
}

pub fn f_with_feature<T>(it_src: T) -> u32
where T: Iterator<Item = u32> {
    let adjusted_values = it_src.into_iter()
        .map(|e| adjust(e));
    f(adjusted_values)
}