为类型参数传达 Rust 生命周期

Question

我正在研究一个简单的复数示例，并尝试如下实现 ref-value/value-ref 操作：

use std::ops::*;

#[derive(Clone, PartialEq)]
pub struct Complex<T: Sized + Clone> {
    pub re: T,
    pub im: T,
}

// Ref-Ref Multiplication
impl<'a, 'b, T: Sized + Clone> Mul<&'b Complex<T>> for &'a Complex<T>
where
    T: Add<T, Output = T>,
    T: Sub<T, Output = T>,
    &'a T: Add<&'b T, Output = T>,
    &'a T: Mul<&'b T, Output = T>,
    &'a T: Sub<&'b T, Output = T>,
{
    type Output = Complex<T>;
    fn mul(self, rhs: &'b Complex<T>) -> Complex<T> {
        panic!("// Details irrelevant")
    }
}

// Ref-Value Multiplication
impl<'a, 'b, T: Sized + Clone> Mul<Complex<T>> for &'a Complex<T>
where
    T: 'static,
    T: Add<T, Output = T>,
    T: Sub<T, Output = T>,
    &'a T: Add<&'b T, Output = T>,
    &'a T: Mul<&'b T, Output = T>,
    &'a T: Sub<&'b T, Output = T>,
{
    type Output = Complex<T>;
    fn mul(self, rhs: Complex<T>) -> Complex<T> {
        let t = &rhs;
        self.mul(t)
    }
}

ref-ref 实现有效，据我了解，它需要两个不同生命周期的引用，并返回一个复杂的值类型。 ref-value 部分是我遇到问题的地方；当我编译时，错误是rhs 的寿命不够长。我相信我知道为什么已经这样了，那就是当返回值时 T 可以持有对 rhs 的引用（直接或间接），因此rhs 超出范围，但T 可以持有对还是这样。

我的问题是如何传达T 不会以某种形式或形式对rhs 进行某些引用。

关于我迄今为止尝试过或看过的东西的一些注释：

1. 更改了任一 Mul 实现的生命周期规范。
2. 尝试了生命周期继承，但这指定了 T 持有的引用将至少与 T 一样长，所以我认为我需要更多的“最多”行。
3. 查看了其他实现；要么不实现案例，要么只使用克隆绕过问题。

Answer 1

正如 Peter Hall 在 cmets 中所建议的，最简单的解决方案是为您的复杂类型派生 Copy，并实现值的操作。对于 ref-ref 实现和 ref-val 实现，您可以简单地取消引用引用并使用 val-val 实现。

如果你想让你开始的方法奏效，你需要更高等级的特征界限：

use std::ops::*;

#[derive(Clone, PartialEq)]
pub struct Complex<T: Clone> {
    pub re: T,
    pub im: T,
}

// Ref-Ref Multiplication
impl<'a, 'b, T: Clone> Mul<&'b Complex<T>> for &'a Complex<T>
where
    T: Add<T, Output = T>,
    T: Sub<T, Output = T>,
    &'a T: Add<&'b T, Output = T>,
    &'a T: Mul<&'b T, Output = T>,
    &'a T: Sub<&'b T, Output = T>,
{
    type Output = Complex<T>;
    fn mul(self, rhs: &'b Complex<T>) -> Complex<T> {
        Complex {
            re: &self.re * &rhs.re - &self.im * &rhs.im,
            im: &self.re * &rhs.im + &self.im * &rhs.re,
        }
    }
}

// Ref-Value Multiplication
impl<'a, T: Clone> Mul<Complex<T>> for &'a Complex<T>
where
    T: Add<T, Output = T>,
    T: Sub<T, Output = T>,
    &'a T: for<'b> Add<&'b T, Output = T>,
    &'a T: for<'b> Mul<&'b T, Output = T>,
    &'a T: for<'b> Sub<&'b T, Output = T>,
{
    type Output = Complex<T>;
    fn mul(self, rhs: Complex<T>) -> Complex<T> {
        let t = &rhs;
        self.mul(t)
    }
}

在您的版本中，引用值实现中的生命周期'b 由特征用户选择。由于用户可以使用 'b 的任何生命周期，rhs 需要静态生命周期才能使您的代码有效。相反，您想要的是 *'a T 满足给定生命周期 'b 的 any 的给定特征界限，这正是 HRTB 的用途。

为第二个实现编写特征边界的另一种较少重复的方法是：

impl<'a, T: Clone> Mul<Complex<T>> for &'a Complex<T>
where
    Self: for<'b> Mul<&'b Complex<T>, Output = Complex<T>>,
{
    type Output = Complex<T>;
    fn mul(self, rhs: Complex<T>) -> Complex<T> {
        self.mul(&rhs)
    }
}

Answer 2

内置数字类型使用macro 实现这些排列。手动操作，我会从您将两个值相乘而不是任何引用的情况开始，并确保您的 Complex 结构是 Copy：

impl<T: Copy> Mul<Complex<T>> for Complex<T>
where
    T: Add<T, Output = T>,
    T: Sub<T, Output = T>,
    T: Mul<T, Output = T>,
{
    type Output = Complex<T>;
    fn mul(self, rhs: Complex<T>) -> Complex<T> {
        unimplemented!()
    }
}

请注意，您不需要对&T 进行任何限制——无论如何您都不能返回对T 的引用，因此您必须复制它们，这就是我指定T: Copy 的原因。

其余的实现现在很简单，可以委托给最简单的情况：

impl<'a, T: Copy> Mul<Complex<T>> for &'a Complex<T>
where
    T: Add<T, Output = T>,
    T: Sub<T, Output = T>,
    T: Mul<T, Output = T>,
{
    type Output = Complex<T>;
    fn mul(self, rhs: Complex<T>) -> Complex<T> {
        (*self).mul(rhs)
    }
}

impl<'a, T: Copy> Mul<&'a Complex<T>> for Complex<T>
where
    T: Add<T, Output = T>,
    T: Sub<T, Output = T>,
    T: Mul<T, Output = T>,
{
    type Output = Complex<T>;
    fn mul(self, rhs: &'a Complex<T>) -> Complex<T> {
        self.mul(*rhs)
    }
}

impl<'a, 'b, T: Copy> Mul<&'a Complex<T>> for &'b Complex<T>
where
    T: Add<T, Output = T>,
    T: Sub<T, Output = T>,
    T: Mul<T, Output = T>,
{
    type Output = Complex<T>;
    fn mul(self, rhs: &'a Complex<T>) -> Complex<T> {
        (*self).mul(*rhs)
    }
}