Generics 如何使用'u32'或`&；的任何迭代器编写泛型函数；u32`？

我想写一个处理整数序列的函数

fn process_one(n: u32) {}

fn process<II>(ii: II)
where
    II: IntoIterator<Item = u32>,
{
    for n in ii {
        process_one(n);
    }
}

这样所有这些都可以编译：

fn test() {
    let v: Vec<u32> = vec![1, 2, 3, 4];
    process(&v);
    process(v);
    process(1..10);
}

fn测试（）{
设v:Vec=Vec！[1,2,3,4]；
过程&v；
过程（五）；
过程（1..10）；
}

---

我知道我可以使用自定义特征来实现这一点，但我觉得应该有一种方法不需要所有的样板文件。

以下是我如何使用自定义特征来实现这一点

trait ToValue<V> {
    fn to_value(self) -> V;
}

impl<T> ToValue<T> for T {
    fn to_value(self) -> T {
        self
    }
}

impl<'a, T> ToValue<T> for &'a T
where
    T: Copy,
{
    fn to_value(self) -> T {
        *self
    }
}

fn process<N, II>(ii: II)
where
    II: IntoIterator<Item = N>,
    N: ToValue<u32>,
{
    for n in ii {
        process_one(n.to_value());
    }
}

trait值{
fn到_值（自）->V；
}
T的impl ToValue{
fn到_值（自身）->T{
自己
}
}
恳求{
*自我
}
}
新生力量进程（二：二）
哪里
II：输入迭代器，
N:ToValue，
{
第二部分中的n{
进程1（n.到值（））；
}
}

虽然这解决了我的问题，但让我相当不满意，我仍然认为应该有一个不涉及我自身特点的解决方案。

有效：

使用标准：：借用：：借用；
fn main（）{
设x=vec！[1,2,3]；
过程（x.iter（））；
过程（x）；
过程（1..3）；
}
fn流程一（n:u32）{
println！（“{}”，n）
}
fn工艺（iter:I）
哪里
I:迭代器，
I：：项目：借用，
{
iter中的x{
流程一（*x.借用（））；
}
}

问题的可能重复之处与此类似，但关键区别在于，那里的人只想对事情进行总结，而

Add

是为参考而实现的，而我需要将值传递给一个函数，该函数只需要一个

u32

。如果按值进行处理，这是一个消耗性迭代器。因此，为了使用向量，您必须拥有它，而不是借用它。您有不兼容的要求。@Boiethios我希望函数对使用或不使用序列是不可知的。@SebastianRedl啊，好的；我将收回我的反对票，但您可能希望调整问题，使其不会从其他人那里返回：）。如果编译器公开了自动取消引用功能，这将非常有用。类似这样：这本质上是

ToOwned

但仅限于

Copy

类型，对吗？是的，但是

ToOwned

有一个内部

类型Owned:Borrow

要求，这使得我无法使用它。

trait ToValue<V> {
    fn to_value(self) -> V;
}

impl<T> ToValue<T> for T {
    fn to_value(self) -> T {
        self
    }
}

impl<'a, T> ToValue<T> for &'a T
where
    T: Copy,
{
    fn to_value(self) -> T {
        *self
    }
}

fn process<N, II>(ii: II)
where
    II: IntoIterator<Item = N>,
    N: ToValue<u32>,
{
    for n in ii {
        process_one(n.to_value());
    }
}

use std::borrow::Borrow;

fn main() {
    let x = vec![1, 2, 3];
    process(x.iter());
    process(x);
    process(1..3);
}

fn process_one(n: u32) {
    println!("{}", n)
}

fn process<I>(iter: I)
where
    I: IntoIterator,
    I::Item: Borrow<u32>,
{
    for x in iter {
        process_one(*x.borrow());
    }
}