如何让MyTrait的trait对象可比较，无需使用额外的MyTraitComparable

你完全不需要额外的MyTraitComparable子trait！我们可以把比较逻辑直接整合到MyTrait中，并且为dyn MyTrait实现标准的PartialEq trait，这样就能直接用==运算符比较trait对象，同时保证只能和同类型的trait对象比较。

具体实现代码 #

use std::any::Any;

// 保留你的原始MyTrait，只添加一个as_any方法
trait MyTrait {
    // 每个实现类型都要实现这个方法，用来转换为Any类型
    fn as_any(&self) -> &dyn Any;
}

// 定义一个私有辅助trait，用来处理具体类型的相等比较
// 这个trait会为所有实现PartialEq的类型自动实现
trait PrivateEq {
    fn private_eq(&self, other: &dyn Any) -> bool;
}

impl<T: PartialEq + Any> PrivateEq for T {
    fn private_eq(&self, other: &dyn Any) -> bool {
        // 尝试将other转换为当前类型，成功则比较值，失败返回false
        other.downcast_ref::<T>().map_or(false, |o| self == o)
    }
}

// 为dyn MyTrait实现PartialEq，这样就能用==运算符比较trait对象了
impl PartialEq for dyn MyTrait {
    fn eq(&self, other: &Self) -> bool {
        let self_any = self.as_any();
        let other_any = other.as_any();

        // 先检查两个对象的具体类型是否相同
        if self_any.type_id() != other_any.type_id() {
            return false;
        }

        // 类型相同的情况下，借助PrivateEq完成值比较
        self_any
            .downcast_ref::<dyn PrivateEq>()
            .map(|self_eq| self_eq.private_eq(other_any))
            .unwrap_or(false)
    }
}

// ------------------------------
// 测试用的具体类型实现
// ------------------------------
#[derive(PartialEq, Debug)]
struct MyStruct(i32);

impl MyTrait for MyStruct {
    fn as_any(&self) -> &dyn Any {
        self // 直接返回self即可，所有类型都自动实现Any
    }
}

#[derive(PartialEq, Debug)]
struct AnotherStruct(String);

impl MyTrait for AnotherStruct {
    fn as_any(&self) -> &dyn Any {
        self
    }
}

fn main() {
    let s1: &dyn MyTrait = &MyStruct(42);
    let s2: &dyn MyTrait = &MyStruct(42);
    let s3: &dyn MyTrait = &MyStruct(24);
    let a1: &dyn MyTrait = &AnotherStruct("hello".to_string());

    // 直接用==和!=运算符比较trait对象
    assert!(s1 == s2);
    assert!(s1 != s3);
    assert!(s1 != a1);

    // 尝试和非trait对象比较会编译错误，符合你的需求
    // assert!(s1 == MyStruct(42)); // 这行代码会编译失败，因为没有实现PartialEq<MyStruct> for dyn MyTrait
}

为什么这个方案有效？ #

1. 不需要额外子trait：所有逻辑都围绕MyTrait展开，你不需要在任何地方替换成MyTraitComparable，只需要使用原始的MyTrait即可。
2. 类型安全的比较：只有同具体类型的trait对象之间才能比较相等，不同类型的trait对象直接返回false，而且无法和非trait对象比较（编译错误），完全符合你的要求。
3. 使用标准运算符：实现了PartialEq后，你可以直接用熟悉的==和!=运算符，不需要调用自定义的equals方法。
4. 低侵入性：每个实现MyTrait的类型只需要添加一行as_any的实现，非常简单。

关键细节说明 #

• as_any方法：用来将具体类型转换为&dyn Any，这是Rust中动态类型检查的基础，所有类型都自动实现Any，所以实现起来只需要返回self。
• PrivateEq辅助trait：这是一个私有trait，用来为所有实现PartialEq的类型提供统一的比较逻辑，避免重复代码。
• PartialEq for dyn MyTrait：这是核心部分，它让trait对象支持标准的相等比较，内部先检查类型ID是否一致，再调用具体类型的比较逻辑。

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