rust - 有没有办法告诉编译器没有人会为引用泛型类型实现特征？

Question

这是演示该问题的玩具代码:

trait Foo {}

trait Boo<T> {
    fn f() -> T;
}

impl<T> Boo<T> for i32
where
    T: Foo,
{
    fn f() -> T {
        unimplemented!();
    }
}

impl<'a, T> Boo<&'a T> for i32
where
    T: Foo,
{
    fn f() -> T {
        unimplemented!();
    }
}

我想要 trait Boo 的两个通用实现，但它不编译:

error[E0119]: conflicting implementations of trait `Boo<&_>` for type `i32`:
  --> src/main.rs:16:1
   |
7  | / impl<T> Boo<T> for i32
8  | | where
9  | |     T: Foo,
10 | | {
...  |
13 | |     }
14 | | }
   | |_- first implementation here
15 | 
16 | / impl<'a, T> Boo<&'a T> for i32
17 | | where
18 | |     T: Foo,
19 | | {
...  |
22 | |     }
23 | | }
   | |_^ conflicting implementation for `i32`
   |
   = note: downstream crates may implement trait `Foo` for type `&_`

我不打算将这部分功能用于其他 crate。我试过:

将此代码移动到显然不能从其他 crate

使用的二进制 crate

将此移至私有(private) mod

将特征标记为 pub(crate)

都没有成功。

无论如何给编译器一个提示，它不应该关心任何人将实现 Foo有什么引用吗？

也许我的玩具例子不是最好的，所以这里是真正的代码。
它用于与我程序的C部分集成，所以有点
复杂。

impl<T: MyTrait> MyFrom<Option<T>> for *mut c_void {
    fn my_from(x: Option<T>) -> Self {
        match x {
            Some(x) => <T>::alloc_heap_for(x),
            None => ptr::null_mut(),
        }
    }
}

impl<'a, T: MyTrait> MyFrom<Option<&'a T>> for *mut c_void {
    fn my_from(x: Option<&'a T>) -> Self {
        match x {
            Some(x) => x as *const T as *mut c_void,
            None => ptr::null_mut(),
        }
    }
}

Answer 1

这里的冲突与后一种实现的引用性没有任何关系。问题是，在第一个实现中，T可以是任何类型，包括引用类型。假设您进行以下函数调用:

let x: i32 = 10;
let result: &u8 = x.f();

此时，类型解析器需要弄清楚正在调用什么函数。它发现了一个冲突的实现:

impl Boo<&u8> for i32 via Boo<T>  (T == &u8),
impl Boo<&u8> for i32 via Boo<&T> (T == u8),

如果您在后一个实现中使用具体类型，您将遇到完全相同的问题:

// This will fail to compile
impl<T> Boo<T> for i32 { ... }
impl Boo<String> for i32 { ... }

这种冲突意味着编译器不能允许这两种实现共存。

您在这里要做的具体事情称为“特化”；它指的是一组规则的提议，如果其中一个明显比另一个更“具体”，则允许存在这样的重叠实现，在这种情况下，编译器将选择更具体的实现。这被跟踪为 RFC #1210 .