如何优化Rust结构体加减乘除的所有权与借用组合实现？

问题背景 #

我定义了一个简单的结构体MyType，需要实现基础数学运算符。为了避免消耗操作数，一开始给引用实现了Add trait：

impl<'a, 'b> Add<&'b MyType> for &'a MyType {
    type Output = MyType;

    fn add(self, rhs: &'b MyType) -> Self::Output {
        // 实现逻辑...
    }
}

这样能支持let result = &v1 + &v2;（v1、v2为MyType类型），但链式调用&v1 + &v2 + &v3无法编译，必须写成&v1 + &(&v2 + &v3)。为了支持所有权与借用的所有组合，我不得不写大量重复的样板代码。

尝试用Borrow trait简化，写了如下代码但编译失败，报错“type parameter B必须用作某些本地类型的类型参数”：

impl<B> Add<B> for B
where
    B: Borrow<MyType>,
{
    type Output = MyType;

    fn add(self, rhs: B) -> Self::Output {
        // 实现逻辑...
    }
}

已有的改进方案 #

@EvilTak提出了一种减少样板的实现方式，通过为MyType和&MyType分别实现带Borrow约束的Add trait：

impl<'a, B> Add<B> for &'a MyType
where
    B: Borrow<MyType>,
{
    type Output = MyType;

    fn add(self, rhs: B) -> Self::Output {
        // 核心实现逻辑...
    }
}

impl<B> Add<B> for MyType
where
    B: Borrow<MyType>,
{
    type Output = MyType;

    fn add(self, rhs: B) -> Self::Output {
        &self + rhs
    }
}

这种方式只需要写两份实现，就能支持所有常见的组合：

• &v1 + &v2
• v1 + &v2
• &v1 + v2
• v1 + v2
• 以及流畅的链式调用&v1 + &v2 + &v3

其他避免样板代码的技巧 #

1. 自定义宏批量生成实现 #

可以编写自定义宏来批量生成Add/Sub/Mul/Div等运算符的实现，避免重复编写相似逻辑。例如：

macro_rules! impl_op_for_mytype {
    ($trait:ident, $method:ident) => {
        impl<'a, B> $trait<B> for &'a MyType
        where
            B: Borrow<MyType>,
        {
            type Output = MyType;

            fn $method(self, rhs: B) -> Self::Output {
                // 对应运算符的核心逻辑，示例用数值相加
                MyType {
                    value: self.value + rhs.borrow().value
                }
            }
        }

        impl<B> $trait<B> for MyType
        where
            B: Borrow<MyType>,
        {
            type Output = MyType;

            fn $method(self, rhs: B) -> Self::Output {
                &self.$method(rhs)
            }
        }
    };
}

// 批量生成运算符实现
impl_op_for_mytype!(Add, add);
impl_op_for_mytype!(Sub, sub);
impl_op_for_mytype!(Mul, mul);
impl_op_for_mytype!(Div, div);

只需要调用宏就能生成所有需要的运算符实现，大幅减少重复代码。

2. 使用derive_more crate自动派生 #

社区的derive_more crate提供了一系列派生宏，可以自动为结构体实现常见运算符，包括支持引用的版本。首先在Cargo.toml添加依赖：

[dependencies]
derive_more = "0.99"

然后在结构体上添加对应的派生属性：

use derive_more::{Add, Sub, Mul, Div};

#[derive(Add, Sub, Mul, Div, Debug, Clone)]
struct MyType {
    value: i32,
}

derive_more会自动生成所有需要的trait实现，涵盖所有权和引用的各种组合，无需手动编写任何样板代码。这个 crate 还支持自定义输出类型、指定运算符逻辑等高级功能，适合快速实现数学运算符。

3. 结合Cow优化所有权处理 #

如果需要灵活处理所有权和借用，可以用Cow（Clone-on-Write）来实现运算符，在某些场景下减少不必要的克隆：

use std::borrow::Cow;

impl<'a> Add<Cow<'a, MyType>> for Cow<'a, MyType> {
    type Output = MyType;

    fn add(self, rhs: Cow<'a, MyType>) -> Self::Output {
        MyType {
            value: self.value + rhs.value
        }
    }
}

这种方式可以接受借用或所有权的MyType，需要时通过Cow::Borrowed或Cow::Owned包装值，适合对性能有较高要求的场景。

内容的提问来源于stack exchange，提问作者James Thurley