如何在Rust中为泛型类型实现TryFrom trait？

我定义了泛型类型A<T>，希望能从T类型转换而来，但该转换可能返回错误，因此选择使用TryFrom而非From：

struct A<T> {
    x: T,
}

struct MyError;

impl<T> TryFrom<T> for A<T> {
    type Error = MyError;
    
    fn try_from(x: T) -> Result<Self, MyError> { Ok(A{x}) }
}

编译这段代码时出现如下错误：

error[E0119]: conflicting implementations of trait `TryFrom<_>` for type `A<_>`
 --> src/main.rs:7:1
  |
7 | impl<T> TryFrom<T> for A<T> {
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: conflicting implementation in crate `core`:
          - impl<T, U> TryFrom<U> for T
            where U: Into<T>;

For more information about this error, try `rustc --explain E0119`.

若将TryFrom替换为From则可正常编译，但这不符合我的需求，因为我需要错误处理机制。我有两个疑问：

1. 引发冲突的Into实现来自何处？我并未编写相关代码。
2. 若存在引发冲突的Into实现，为何From实现不会产生冲突？

疑问解答 #

1. 冲突的Into实现来源 #

这个Into的实现是Rust标准库（core crate）提供的** blanket 实现**（即针对满足条件的所有类型自动生成的实现）。标准库有两条关键规则：

• 若类型U实现了Into<T>，则自动为T实现TryFrom<U>（因为Into转换是无错的，所以TryFrom必然成功）。
• 只要为类型实现了From<T>，就会自动获得对应的Into<T>实现（这是From和Into的互推规则）。

你的代码中，impl<T> TryFrom<T> for A<T>是一个覆盖所有T的 blanket 实现。而标准库的impl<T, U> TryFrom<U> for T where U: Into<T>也是 blanket 实现，当U=T时（所有类型都满足T: Into<T>，因为标准库默认实现了impl<T> Into<T> for T），两个实现会对TryFrom<T> for A<T>产生冲突——编译器无法确定该选用哪一个。

2. From实现为何不冲突 #

标准库中From的 blanket 实现是impl<T> From<T> for T（所有类型可以从自身转换而来），而你写的impl<T> From<T> for A<T>覆盖的是T转换为A<T>的场景，两者的覆盖范围完全不重叠，不存在同一类型同时满足两个实现的情况，因此编译器不会判定冲突。

解决方法 #

要避免TryFrom的冲突，需要缩小自己实现的泛型约束范围，不要覆盖所有T类型，以下是几种可行方案：

方案1：添加特定约束缩小范围 #

只允许满足自定义 trait 的T转换为A<T>：

trait ValidForA {}

struct A<T> {
    x: T,
}

struct MyError;

impl<T: ValidForA> TryFrom<T> for A<T> {
    type Error = MyError;
    
    fn try_from(x: T) -> Result<Self, MyError> { Ok(A{x}) }
}

方案2：针对具体类型逐个实现 #

如果A只需要支持特定几个T类型的转换，可以逐个编写实现：

struct A<T> {
    x: T,
}

struct MyError;

// 针对i32实现转换
impl TryFrom<i32> for A<i32> {
    type Error = MyError;
    
    fn try_from(x: i32) -> Result<Self, MyError> { Ok(A{x}) }
}

// 针对String实现转换
impl TryFrom<String> for A<String> {
    type Error = MyError;
    
    fn try_from(x: String) -> Result<Self, MyError> { Ok(A{x}) }
}

方案3：使用新类型包装 #

如果必须保留泛型的 blanket 实现，可以给T加一层新类型包装，避免和标准库的实现冲突：

struct Wrapped<T>(T);

struct A<T> {
    x: T,
}

struct MyError;

impl<T> TryFrom<Wrapped<T>> for A<T> {
    type Error = MyError;
    
    fn try_from(wrapped: Wrapped<T>) -> Result<Self, MyError> { Ok(A{x: wrapped.0}) }
}

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