Rust中为泛型包装类型实现Add<T>与Add<Wrap<U>>的类型冲突解决

我尝试为作为数值容器的包装类型实现std::ops::Add trait，定义的包装类型如下：

struct Wrap<T>(T);

我希望当T实现Add<U>时，为Wrap<T>实现Add<Wrap<U>>，编写的代码运行正常：

impl<T, U> Add<Wrap<U>> for Wrap<T>
where
    T: Add<U>,
{
    type Output = Wrap<<T as Add<U>>::Output>;

    fn add(self, rhs: Wrap<U>) -> Self::Output {
        Wrap(self.0 + rhs.0)
    }
}

但当我尝试为Wrap<T>实现Add<U>（类似标量加法操作）时，代码报错提示存在trait实现冲突：

impl<T, U> Add<U> for Wrap<T>
where
    T: Add<U>,
{
    type Output = Wrap<<T as Add<U>>::Output>;

    fn add(self, rhs: U) -> Self::Output {
        Wrap(self.0 + rhs)
    }
}

我已知错误原因，想了解该问题的解决方法或通用方案。

1. 用负向约束排除冲突类型 #

利用Rust 1.59+支持的负向约束，直接在Add<U>的实现中排除U是Wrap类型的情况，让两个实现的条件互斥：

impl<T, U> Add<U> for Wrap<T>
where
    T: Add<U>,
    U: !Wrap<_>, // 排除U为Wrap任意类型的情况
{
    type Output = Wrap<<T as Add<U>>::Output>;

    fn add(self, rhs: U) -> Self::Output {
        Wrap(self.0 + rhs)
    }
}

2. 为特定标量类型单独实现 #

如果不需要支持所有U类型，只为常用的数值标量（如i32、f64等）单独实现Add<U>，这样不会和Add<Wrap<U>>的实现产生冲突：

// 为i32实现标量加法
impl<T> Add<i32> for Wrap<T>
where
    T: Add<i32>,
{
    type Output = Wrap<<T as Add<i32>>::Output>;

    fn add(self, rhs: i32) -> Self::Output {
        Wrap(self.0 + rhs)
    }
}

// 同理扩展到其他标量类型，如f32、u64等

3. 反向实现Add（让标量支持与Wrap相加） #

不给Wrap<T>实现Add<U>，转而给U实现Add<Wrap<T>>，同样能实现类似的加法效果，且避免冲突：

impl<T, U> Add<Wrap<T>> for U
where
    U: Add<T>,
{
    type Output = Wrap<<U as Add<T>>::Output>;

    fn add(self, rhs: Wrap<T>) -> Self::Output {
        Wrap(self + rhs.0)
    }
}

这样可以写出5 + Wrap(10)的代码；如果需要Wrap(10) + 5，可以结合Into转换（如Wrap(10) + 5.into()），或者额外实现AddAssign来补充。

4. 自定义标记Trait限制范围 #

定义一个标记Trait，仅用于区分非Wrap类型，然后在Add<U>的实现中添加该Trait约束：

// 定义标记Trait
auto trait NotWrap {}
impl<T> !NotWrap for Wrap<T> {} // 排除Wrap类型

// 调整标量加法实现
impl<T, U> Add<U> for Wrap<T>
where
    T: Add<U>,
    U: NotWrap,
{
    type Output = Wrap<<T as Add<U>>::Output>;

    fn add(self, rhs: U) -> Self::Output {
        Wrap(self.0 + rhs)
    }
}

内容的提问来源于stack exchange，提问作者いわんこ