Rust 实现迭代器的trait+；克隆：冲突的实现

我想为

迭代器
实现一个trait
Foo
（即，对于实现
迭代器的所有类型），所以我写了以下内容：

trait Foo {
    fn foo(&self);
}

impl<F, FI> Foo for FI
    where F: Foo,
          FI: Iterator<Item=F> + Clone,
{
    fn foo(&self) {
        // Just for demonstration
        for x in self.clone() {
            x.foo();
        }
    }
}

我收到以下错误消息：

t.rs:5:1: 7:2 error: conflicting implementations for trait `Foo` [E0119]
t.rs:5 impl Foo for u32 {
t.rs:6     fn foo(self) { println!("{} u32", self); }
t.rs:7 }
t.rs:9:1: 18:2 note: note conflicting implementation here
t.rs:9 impl<F, FI> Foo for FI
t.rs:10     where F: Foo,
t.rs:11           FI: Iterator<Item=F> + Clone,
t.rs:12 {
t.rs:13     fn foo(&self) {
t.rs:14         for x in self.clone() {

t.rs:5:1:7:2错误：trait`Foo`[E0119]的实现冲突
t、 rs:u32的5个impl Foo{
t、 rs:6 fn foo（self）{println！（“{}u32”，self）；}
t、 rs:7}
t、 rs:9:1:18:2注：注意此处的实现冲突
t、 rs:9对金融机构的建议
t、 rs:10，其中F:Foo，
t、 rs:11 FI:迭代器+克隆，
t、 rs:12{
t、 rs:13 fn foo（和self）{
t、 rsf.clone（）中的x为14{

我如何解决这个问题

简单的回答是，你不能。因为你不能确保
u32
在某个时候不会实现
Iterator
，实现确实是冲突的。如果你真的想为
Iterator
和
u32
实现它，你必须以某种方式将实现分开。一种方法是这样做的他的想法是为
&'a FI
实现它，因为
u32
永远不能成为参考。或者，你可以将迭代器包装在一个结构中，尽管这会使它的使用稍微不那么符合人体工程学。
我明白了，谢谢。Rust需要提供什么才能使其工作？否定的特征边界？专门的特征im实现？需要某种专门化。我们还不知道哪种解决方案最有效。但您如何知道
&'aU32
在某个时候不会实现
迭代器
？我认为这并不能真正解释为引用实现的原因？
t.rs:5:1: 7:2 error: conflicting implementations for trait `Foo` [E0119]
t.rs:5 impl Foo for u32 {
t.rs:6     fn foo(self) { println!("{} u32", self); }
t.rs:7 }
t.rs:9:1: 18:2 note: note conflicting implementation here
t.rs:9 impl<F, FI> Foo for FI
t.rs:10     where F: Foo,
t.rs:11           FI: Iterator<Item=F> + Clone,
t.rs:12 {
t.rs:13     fn foo(&self) {
t.rs:14         for x in self.clone() {