如何为通用类型 Vec 的向量实现特征<T>？

Question

如何为泛型Vec<T>的向量实现以下特征？

例如，如何以通用方式实现以下(工作)Difference特征(例如，使其对Vec<i32>、Vec<f32>、Vec<f64>有效)？

trait Difference {
fn diff(&self) -> Vec<f64>;
}
impl Difference for Vec<f64> {
fn diff(&self) -> Vec<f64> {
self.windows(2)
.map(|slice| (slice[0] - slice[1]))
.collect()
}
}
fn main() {
let vector = vec![1.025_f64, 1.028, 1.03, 1.05, 1.051];
println!("{:?}", vector.diff());
}

从文档来看，它似乎应该是这样的：

trait Difference<Vec<T>> {
fn diff(&self) -> Vec<T>;
}
impl Difference for Vec<T> {
fn diff(&self) -> Vec<T> {
self.windows(2)
.map(|slice| (slice[0] - slice[1]))
.collect()
}
}
fn main() {
let vector = vec![1.025_f64, 1.028, 1.03, 1.05, 1.051];
println!("{:?}", vector.diff());
}

但是，上述结果是：

error: expected one of `,`, `:`, `=`, or `>`, found `<`
--> src/main.rs:2:21
|
2 | trait Difference<Vec<T>> {
|                     ^ expected one of `,`, `:`, `=`, or `>` here

我尝试了其他一些变体，但是所有这些都会导致更长的错误消息。

Answer 1

正确的语法是：

trait Difference<T> { /* ... */ }
impl<T> Difference<T> for Vec<T> { /* ... */ }

然后，您需要要求T实现减法：

error[E0369]: binary operation `-` cannot be applied to type `T`
--> src/main.rs:9:26
|
9 |             .map(|slice| (slice[0] - slice[1]))
|                          ^^^^^^^^^^^^^^^^^^^^^
|
= note: `T` might need a bound for `std::ops::Sub`

并且您可以复制值：

error[E0508]: cannot move out of type `[T]`, a non-copy slice
--> src/main.rs:10:27
|
10 |             .map(|slice| (slice[0] - slice[1]))
|                           ^^^^^^^^ cannot move out of here

impl<T> Difference<T> for Vec<T>
where
T: std::ops::Sub<Output = T> + Copy,
{
// ...
}

或者可以减去对T的引用：

impl<T> Difference<T> for Vec<T>
where
for<'a> &'a T: std::ops::Sub<Output = T>,
{
fn diff(&self) -> Vec<T> {
self.windows(2)
.map(|slice| &slice[0] - &slice[1])
.collect()
}
}

另请参阅：

• 如何在具有泛型参数的结构上实现非泛型特征
• 在结构中使用泛型并通过特征实现
• 要求在泛型函数中实现 Mul
• for<> 语法与常规生存期绑定有何不同？

Answer 2

您需要参数化T而不是Vec<T>。然后，您还需要约束T以便可以进行减法(使用Sub特征)，以便可以将值复制到内存中(使用Copy特征)。数值类型将主要实现这些特征。

use std::ops::Sub;
trait Difference<T> {
fn diff(&self) -> Vec<T>;
}
impl<T> Difference<T> for Vec<T>
where
T: Sub<Output = T> + Copy,
{
fn diff(&self) -> Vec<T> {
self.windows(2).map(|slice| slice[0] - slice[1]).collect()
}
}
fn main() {
let vector = vec![1.025_f64, 1.028, 1.03, 1.05, 1.051];
println!("{:?}", vector.diff());
}