Rust 用“扩展迭代器”；“平均值”；方法

我正在尝试为迭代器实现一个

mean

方法，就像使用

sum

一样。 然而，

sum

是

Iterator

方法，所以我决定为实现

Iterator

的任何类型实现trait：

pub trait Mean<A = Self>: Sized {
    fn mean<I: Iterator<Item = A>>(iter: I) -> f64;
}

impl Mean for u64 {
    fn mean<I: Iterator<Item = u64>>(iter: I) -> f64 {
        //use zip to start enumeration from 1, not 0
        iter.zip((1..))
            .fold(0., |s, (e, i)| (e as f64 + s * (i - 1) as f64) / i as f64)
    }
}

impl<'a> Mean<&'a u64> for u64 {
    fn mean<I: Iterator<Item = &'a u64>>(iter: I) -> f64 {
        iter.zip((1..))
            .fold(0., |s, (&e, i)| (e as f64 + s * (i - 1) as f64) / i as f64)
    }
}

trait MeanIterator: Iterator {
    fn mean(self) -> f64;
}

impl<T: Iterator> MeanIterator for T {
    fn mean(self) -> f64 {
        Mean::mean(self)
    }
}

fn main() {
    assert_eq!([1, 2, 3, 4, 5].iter().mean(), 3.);
}

---

有没有办法修复代码，或者在Rust中是不可能的？

您可以这样做，例如：

pub trait Mean {
    fn mean(self) -> f64;
}

impl<F, T> Mean for T
    where T: Iterator<Item = F>,
          F: std::borrow::Borrow<f64>
{
    fn mean(self) -> f64 {
        self.zip((1..))
            .fold(0.,
                  |s, (e, i)| (*e.borrow() + s * (i - 1) as f64) / i as f64)
    }
}

fn main() {
    assert_eq!([1f64, 2f64, 3f64, 4f64, 5f64].iter().mean(), 3.);
    assert_eq!(vec![1f64, 2f64, 3f64, 4f64, 5f64].iter().mean(), 3.);
    assert_eq!(vec![1f64, 2f64, 3f64, 4f64, 5f64].into_iter().mean(), 3.);
}

pub特征平均值{
fn平均值（自身）->f64；
}
T的impl平均值
其中T:Iterator，
F:std:：借用：：借用
{
fn平均值（自身）->f64{
self.zip（（1..）
.折叠（0。，
|s、 （e，i）|（*e.borrow（）+s*（i-1）作为f64）/i作为f64）
}
}
fn main（）{
assert_eq！（[1f64,2f64,3f64,4f64,5f64].iter（）.mean（），3.）；
断言（vec！[1f64，2f64，3f64，4f64，5f64].iter（）.mean（），3.）；
断言（vec！[1f64，2f64，3f64，4f64，5f64]。插入到iter（）.mean（），3。）；
}

我使用

借用

trait来支持

f64

和

&f64

上的迭代器

就像是用

sum

让我们回顾一下

sum

的工作原理：

pub fn sum（self）->S
哪里
S:求和，

sum

在任何迭代器上实现，只要结果类型

S

为迭代值实现

sum

。调用方可以选择结果类型<代码>总和定义为：

pub属性和{
pub fn sum（iter:I）->Self
哪里
I：迭代器；
}

Sum：：Sum

接受一个

A

的迭代器，并生成一个它从中实现的类型的值

我们可以复制粘贴结构，为

Mean

更改

Sum

，并将简单的实现：

trait-MeanExt:迭代器{
fn平均值（自身）->M
哪里
M：我的意思是，
自我：大小，
{
M：：平均值（自我）
}
}
I{}的impl MeanExt
性状平均数{
fn平均值（iter:I）->Self
哪里
I：迭代器；
}
f64的impl平均值{
fn平均值（iter:I）->Self
哪里
I：迭代器，
{
设mut和=0.0；
让mut计数：usize=0；
iter中的v{
总和+=v；
计数+=1；
}
如果计数>0{
总和/（计为f64）
}否则{
0
}
}
}
f64的impl{
fn平均值（iter:I）->Self
哪里
I:Iterator将0作为空集的平均值返回有点…任意。