如何限制Rust多遍函数参数，避免不必要的集合克隆？

我有一个需要对集合进行多遍迭代的数学函数，计算过程中要多次遍历集合。单遍函数通常会接受impl IntoIterator（或对I: IntoIterator泛型），这样可以灵活传入Vec、切片、迭代器或经过过滤的迭代器作为参数。

但当前的实现存在性能隐患：

pub fn my_func<I>(into_iter: I) -> f64
where I: IntoIterator<Item=f64>, I::IntoIter: Clone {
   let iter1 = into_iter.into_iter();
   let iter2 = iter1.clone();
   // 第一遍迭代逻辑
   let res1: f64 = iter1.filter(|&x| x > 1.0).sum();
   // 第二遍迭代逻辑
   let res2: f64 = iter2.filter(|&x| x > 2.0).sum();
   res1 / res2
}

当用户直接传入Vec或v.into_iter()时，Vec的IntoIter持有集合的所有权，克隆这个迭代器会导致整个Vec被完整复制——对于大Vec来说，这会带来巨大的性能开销。我希望用户只能通过my_func(vec.iter().copied())这类方式调用函数，同时保留接受切片、普通迭代器（包括过滤后的）的灵活性，禁止传入Vec本身或v.into_iter()。

可行解决方案 #

方案1：Marker Trait + 负向Trait Bound（推荐，支持任意可克隆迭代器）

通过定义标记Trait，为不允许的迭代器类型（比如Vec的IntoIter）实现它，再用负向Bound排除这些类型。需要Rust 1.59及以上版本支持负向Trait Bound。

// 定义标记Trait，标记不允许的迭代器类型
trait BadIterator {}
// 为Vec的IntoIter实现该Trait
impl<T> BadIterator for std::vec::IntoIter<T> {}

pub fn my_func<I>(into_iter: I) -> f64
where 
    I: IntoIterator<Item=f64>, 
    I::IntoIter: Clone + !BadIterator, // 排除实现了BadIterator的类型
{
    let iter1 = into_iter.into_iter();
    let iter2 = iter1.clone();
    
    let res1: f64 = iter1.filter(|&x| x > 1.0).sum();
    let res2: f64 = iter2.filter(|&x| x > 2.0).sum();
    res1 / res2
}

此时用户传入my_func(v)或my_func(v.into_iter())会触发编译错误，同时允许传入切片、vec.iter().copied()、过滤后的迭代器等合法类型。

方案2：直接接受Iterator + Clone类型

修改函数签名，强制用户传入已有的迭代器而非IntoIterator类型：

pub fn my_func<I>(iter: I) -> f64
where 
    I: Iterator<Item=f64> + Clone,
{
    let iter1 = iter.clone();
    let iter2 = iter;
    
    let res1: f64 = iter1.filter(|&x| x > 1.0).sum();
    let res2: f64 = iter2.filter(|&x| x > 2.0).sum();
    res1 / res2
}

这种方式下，用户直接传入my_func(v)会报错（因为Vec不是Iterator），但无法阻止用户传入my_func(v.into_iter())。如果需要彻底禁止后者，可以结合方案1的Marker Trait，在where子句中添加I: !BadIterator。

方案3：接受切片引用（仅支持可转为切片的集合）

如果函数只需要处理可以转为切片的集合（比如Vec、数组），可以直接接受&[f64]作为参数，内部自行创建多次迭代：

pub fn my_func(slice: &[f64]) -> f64 {
    let res1: f64 = slice.iter().copied().filter(|&x| x > 1.0).sum();
    let res2: f64 = slice.iter().copied().filter(|&x| x > 2.0).sum();
    res1 / res2
}

这种方式完全避免了迭代器克隆带来的Vec复制问题，因为切片的迭代器基于引用，开销极低，但缺点是无法接受过滤后的迭代器等非切片类型。

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