Rust 为什么我需要定义一个trait来定义外部类型的实现？

std:：iter

库有一个只有一个

impl

：

pub trait AdditiveIterator<A> {
  fn sum(&mut self) -> A;
}

impl<A: Add<A, A> + Zero, T: Iterator<A>> AdditiveIterator<A> for T {
  fn sum(&mut self) -> A {
      let zero: A = Zero::zero();
      self.fold(zero, |s, x| s + x)
  }
}

有没有一种方法可以让两者兼得呢？我可以写

sum

以便：

• 我可以使用

  foo.iter（）.sum（）

  语法；及

• 我不必复制

  fn sum（&mut self）->A

  类型签名

---

迭代器不是一种类型，它实际上是一种特性。如果它是一种类型，那么这是可能的，类似于：

impl<A: Add<A, A> + Zero> Iterator<A> {
  fn sum(&mut self) -> A {
      let zero: A = Zero::zero();
      self.fold(zero, |s, x| s + x)
  }
}

impl迭代器{
fn和（&mut self）->A{
设零：A=零：：零（）；
自折叠（零，| s，x | s+x）
}
}

如果我们可以在泛型类型上实现方法，我们可以做到：

impl<A: Add<A, A> + Zero, T: Iterator<A>> T {
  fn sum(&mut self) -> A {
      let zero: A = Zero::zero();
      self.fold(zero, |s, x| s + x)
  }
}

impl T{
fn和（&mut self）->A{
设零：A=零：：零（）；
自折叠（零，| s，x | s+x）
}
}

---

但是编译器不喜欢这样，它迫使我们定义一个新的特性。
UFCS，当它出现时，将对此有很大帮助。为什么Rust编译器不允许您描述的第二种形式？我不确定。我认为这可能与它如何跟踪方法实现有关。

impl<A: Add<A, A> + Zero, T: Iterator<A>> T {
  fn sum(&mut self) -> A {
      let zero: A = Zero::zero();
      self.fold(zero, |s, x| s + x)
  }
}