均值函数的 Rust 泛型语法

Question

我正在尝试编写一个函数，该函数接受一段数字并计算平均值。

我尝试使用来自 Implementing mean function for generic types 的想法，但出现错误。

我的代码是：

extern crate num;

use num::{FromPrimitive, Zero};
use std::ops::{Add, Div};

fn main() {
    let mut numbers = [10, -21, 15, 20, 18, 14, 18];
    let err = "Slice is empty.";

    println!("Mean is {:.3}", mean(&numbers).expect(err));
}

fn mean<T>(numbers: &[T]) -> Option<f64>
where
    T: Copy + Zero + Add<T, Output = T> + Div<T, Output = T> + FromPrimitive,
{
    match numbers.len() {
        0 => None,
        _ => {
            let sum = numbers.iter().sum: ();
            let length = FromPrimitive::from_usize(numbers.len()).unwrap();
            Some(sum / length)
        }
    }
}

错误是：

error[E0658]: type ascription is experimental (see issue #23416)
  --> src/main.rs:20:23
   |
20 |             let sum = numbers.iter().sum: ();
   |                       ^^^^^^^^^^^^^^^^^^^^^^

有没有什么方法可以在不使用实验特性的情况下编写通用的均值函数？

Answer 1

您正在通用函数中执行 2 种不同的操作：

• 对 slice 中的所有值求和：您需要通过将 Sum<T> 边界添加到泛型类型参数来告诉您的元素是可求和的。
• 2 个元素的除法运算： 您的泛型类型需要转换为f64 或您想要限制的任何浮点类型。由于您使用的是 num crate 我添加了 ToPrimitive 作为边界，它告诉您的泛型类型可以转换为原始类型。

这里是实现：

fn mean<'a, T: 'a>(numbers: &'a [T]) -> Option<f64>
where
    T: ToPrimitive + Sum<&'a T>,
{
    match numbers.len() {
        0 => None,
        _ => {
            let sum = numbers.iter().sum::<T>();
            let length = f64::from_usize(numbers.len())?;

            T::to_f64(&sum).map(|sum| sum / length)
        }
    }
}

Playground

Answer 2

其他答案可能会帮助您解决通用编写此函数的真正问题。

---

您询问的实际错误只是语法错误。你写了这个：

let sum = numbers.iter().sum: ();

但几乎可以肯定是打算写：

let sum = numbers.iter().sum();

编译器看到了您不小心包含的:，并认为您正在尝试使用类型归属。类型归属是在表达式中内联使用类型注释的语法，而不仅仅是在变量声明中。

你写的很像：

let sum: () = numbers.iter().sum;

如果您要在每晚的 rustc 构建中启用类型归属，错误将会改变，因为现在编译器会告诉您 sum 是一个函数，并且肯定 不 具有类型 () .

Answer 3

这个怎么样：

use std::iter::Sum;

fn main() {
    let err = "Slice is empty.";

    // Test vector of integers
    let numbers = vec![10i32, -21, 15, 20, 18, 14, 18];
    println!("Mean is {:.3}", mean(numbers.into_iter()).expect(err));

    // Test vector of floating point numbers
    let numbers = vec![10f64, -21f64, 15f64, 20f64, 18f64, 14f64, 18f64];
    println!("Mean is {:.3}", mean(numbers.into_iter()).expect(err));

    // Test empty vector
    let numbers: Vec<i32> = Vec::new();    
    println!("Mean is {:.3}", mean(numbers.into_iter()).expect(err));
}

fn mean<T, I: Iterator<Item = T>>(iter: I) -> Option<f64>
where
    T: Into<f64> + Sum<T>,
{
    let mut len = 0;
    let sum = iter
        .map(|t| {
            len += 1;
            t
        })
        .sum::<T>();

    match len {
        0 => None,
        _ => Some(sum.into() / len as f64)
    }
}

Same code in the Rust Playground

与迄今为止发布的答案相比，它似乎具有以下优势：

1. 更简单的泛型类型定义。
2. 不依赖外部num crate。
3. 不需要像FromPrimitive 和Zero 这样难以猜测的特征。
4. 没有手动生命周期声明。

或者这个版本与上一个有以下不同：

1. 可以采用数组而不是向量。
2. 不消耗数组（或向量）。
3. 需要手动生命周期声明。

use std::iter::Sum;

fn main() {
    let err = "Slice is empty.";

    // Test aray of integers
    let numbers = [10, -21, 15, 20, 18, 14, 18];
    println!("Mean is {:.3}", mean(numbers.iter()).expect(err));

    // Test array of floating point numbers
    let numbers = [10f64, -21f64, 15f64, 20f64, 18f64, 14f64, 18f64];
    println!("Mean is {:.3}", mean(numbers.iter()).expect(err));

    // Test empty array
    let numbers: [i32; 0] = [];
    match mean(numbers.iter()) {
        Some(mean_) => println!("Mean is {:.3}", mean_),
        None => println!("Empty array"),
    }
}

fn mean<'a, T, I>(iter: I) -> Option<f64>
where
    T: Into<f64> + Sum<&'a T> + 'a,
    I: Iterator<Item = &'a T>,
{
    let mut len = 0;
    let sum = iter
        .map(|t| {
            len += 1;
            t
        })
        .sum::<T>();

    match len {
        0 => None,
        _ => Some(sum.into() / len as f64),
    }
}

感谢我的朋友 Sven 的代码贡献。

Answer 4

• 当编译器无法判断fn sum<S>(self) -> S的类型S时，要么需要写let foo: Bar = baz.sum();要么写let foo = baz.sum::<Bar>();

1234563否则，您可能需要使用参考。

• 你可以让你的函数更通用一点，返回Option<T>，但如果你真的想返回Option<f64>，你应该使用ToPrimitive trait 将T 转换为f64。喜欢this。