如何约束Rust的Matches trait自反实现以避免类型冲突？

你的问题核心在于：当手动实现Matches<T> for T时，泛型反向实现impl<S, T> Matches<T> for S where T: Matches<S>会同时满足S=T的场景，导致两个impl优先级相同，编译器无法抉择。下面分两种场景给出解决方案：

稳定版Rust方案 #

如果需要兼容稳定版，最直接的办法是避免写泛型的自匹配实现，转而针对具体类型手动实现Matches<T> for T。具体类型的impl优先级高于泛型impl，编译器会优先选择手动实现，不会产生冲突。

示例代码：

pub trait Matches<T> {
    fn matches(&self, t: &T) -> bool;
}

// 反向自动实现：只要T实现了Matches<S>，就自动为S实现Matches<T>
impl<S, T> Matches<T> for S where T: Matches<S> {
    fn matches(&self, t: &T) -> bool {
        t.matches(self)
    }
}

// 针对具体类型实现自匹配（优先级高于泛型反向实现）
impl Matches<i32> for i32 {
    fn matches(&self, t: &i32) -> bool {
        self == t
    }
}

impl Matches<String> for String {
    fn matches(&self, t: &String) -> bool {
        self.eq(t)
    }
}

// 测试反向实现
struct User {
    id: u64
}

struct UserId(u64);

impl Matches<UserId> for User {
    fn matches(&self, id: &UserId) -> bool {
        self.id == id.0
    }
}

fn main() {
    // 自匹配正常工作
    assert!(123.matches(&123));
    assert!(String::from("hello").matches(&String::from("hello")));
    
    // 反向自动实现生效
    let user = User { id: 456 };
    let user_id = UserId(456);
    assert!(user_id.matches(&user));
}

如果必须写泛型的自匹配实现，稳定版Rust暂时没有完美的语法支持，需要依赖nightly特性。

Nightly版Rust方案 #

使用负约束（negative_impls特性）可以直接限制反向实现仅在S未实现Matches<T>时生效，从根源避免冲突：

#![feature(negative_impls)]

pub trait Matches<T> {
    fn matches(&self, t: &T) -> bool;
}

// 反向实现：仅当S没有实现Matches<T>时才生效
impl<S, T> Matches<T> for S where T: Matches<S>, S: !Matches<T> {
    fn matches(&self, t: &T) -> bool {
        t.matches(self)
    }
}

// 泛型自匹配实现，不会与反向实现冲突
impl<T> Matches<T> for T {
    fn matches(&self, t: &T) -> bool {
        // 这里可以写通用的自匹配逻辑，比如PartialEq
        self == t
    }
}

// 测试
fn main() {
    assert!(123.matches(&123));
    
    struct A;
    struct B;
    
    impl Matches<B> for A {
        fn matches(&self, _: &B) -> bool { true }
    }
    
    assert!(B.matches(&A)); // 反向自动实现生效
}

另外也可以使用specialization特性，通过默认实现和具体实现的优先级区分，但负约束的方案更直接。

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