Rust中针对关联类型的trait blanket实现为何冲突？

这两个impl不存在可实际构造的重叠场景，编译器报E0119是Rust一致性规则的保守判定导致的：

• Rust的trait实现一致性要求：任意具体类型组合，最多只能对应一个trait实现。检查重叠时，编译器只会做语法层面的合一匹配，不会对抽象关联类型做结构判定，也不会考虑类型是否可实际实例化。
• 你的两个通用impl中，S::Stored是关联类型，属于抽象类型，编译器无法获知它的具体结构：即使Box是被标记为#[fundamental]的基础类型（编译器知道直接的泛型参数T和Box<T>不可能相等），但这个判定规则无法应用到抽象关联类型上。编译器只能保守认为：可能存在某个Storage实现，让它的Stored类型满足S::Stored == Box<S::Stored>，导致两个impl同时适用，因此判定冲突。
• 你之前为具体存储类型单独写impl不冲突，是因为那时候MakeInto的目标类型是直接暴露的泛型参数T和Box<T>，编译器可以直接应用fundamental类型的不相交规则，确认两者不会重叠。

方案1：为具体存储类型单独实现 #

放弃覆盖所有Storage的全通用blanket实现，回到你之前为BoxedStorage、UnboxedStorage等具体存储类型分别编写两个版本MakeInto实现的模式。如果存储类型较多，可以用声明宏批量生成impl，减少重复代码。
这种方案的优势是调用时不需要修改接口，和你之前的使用体验完全一致。

方案2：新类型包装绕开关联类型限制 #

如果一定要保留覆盖所有Storage的通用实现，可以通过自定义新类型标记装箱返回值，让两个impl的目标类型在结构上完全可区分，编译器可以直接判定不存在重叠。示例代码：

// 新类型，专门标记需要返回装箱值的场景
struct AsBoxed<T>(pub Box<T>);

enum MaybeBoxed<T> {
    Boxed(Box<T>),
    Unboxed(T),
}

trait Storage {
    type Stored;
    fn into_inner(self) -> MaybeBoxed<Self::Stored>;
}

struct BoxedStorage<T>(Box<T>);
impl<T> Storage for BoxedStorage<T> {
    type Stored = T;
    fn into_inner(self) -> MaybeBoxed<T> {
        MaybeBoxed::Boxed(self.0)
    }
}

struct UnboxedStorage<T>(T);
impl<T> Storage for UnboxedStorage<T> {
    type Stored = T;
    fn into_inner(self) -> MaybeBoxed<T> {
        MaybeBoxed::Unboxed(self.0)
    }
}

struct Container<S: Storage>(S);

trait MakeInto<T> {
    fn make_into(self) -> T;
}

// 返回未装箱值的通用实现
impl<S: Storage> MakeInto<S::Stored> for Container<S> {
    fn make_into(self) -> S::Stored {
        match self.0.into_inner() {
            MaybeBoxed::Boxed(boxed) => *boxed,
            MaybeBoxed::Unboxed(unboxed) => unboxed,
        }
    }
}

// 返回装箱值的通用实现，用新类型做区分，无冲突
impl<S: Storage> MakeInto<AsBoxed<S::Stored>> for Container<S> {
    fn make_into(self) -> AsBoxed<S::Stored> {
        match self.0.into_inner() {
            MaybeBoxed::Boxed(boxed) => AsBoxed(boxed),
            MaybeBoxed::Unboxed(unboxed) => AsBoxed(Box::new(unboxed)),
        }
    }
}

// 调用示例
fn main() {
    let container = Container(UnboxedStorage(42u32));
    let val: u32 = container.make_into(); // 取未装箱值
    let container2 = Container(UnboxedStorage(42u32));
    let boxed_val: Box<u32> = container2.make_into::<AsBoxed<u32>>().0; // 取装箱值
}

这种方案的代码改动量极小，只需要在调用装箱转换时多一步拆包，完全兼容稳定版Rust的所有规则。

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