Rust中为Choice<T,T>实现Into trait的冲突问题及可行方案问询

问题背景 #

定义了如下泛型枚举：

enum Choice<A, B> {
    A(A),
    B(B),
} 

需要在枚举的两个泛型参数均为T时，为其实现Into<T> trait，但直接尝试两种方案均失败：

尝试方案1：直接实现Into<T> #

impl<T> Into<T> for Choice<T, T> {
    fn into(self) -> T {
        let (Choice::A(x) | Choice::B(x)) = self;
        x
    }
}

报错：

conflicting implementation in crate `core`:
            - impl<T, U> Into<U> for T
              where U: From<T>;

原因：core中已有通用的Into实现，当Choice<T,T>与T存在类型重叠时（例如递归类型），两个实现会产生冲突。

尝试方案2：通过From间接实现Into #

impl<T> From<Choice<T, T>> for T {
    fn from(x: Choice<T, T>) -> Self {
        let (Choice::A(x) | Choice::B(x)) = x;
        x
    }
}

报错：

implementing a foreign trait is only possible if at least one of the types  
for which it is implemented is local, and no uncovered type parameters  
appear before that first local type

原因：违反Rust的孤儿规则——实现外部trait（From属于core）时，必须至少有一个关联类型是本地定义的，且未被约束的泛型参数不能出现在第一个本地类型之前。这里T是未约束的泛型，不符合要求。

可行解决方案 #

方案1：自定义转换方法（稳定、推荐） #

绕过Into trait的限制，直接为Choice<T,T>实现一个自定义的转换方法，效果与Into<T>一致：

impl<T> Choice<T, T> {
    pub fn into_inner(self) -> T {
        match self {
            Choice::A(x) => x,
            Choice::B(x) => x,
        }
    }
}

使用方式：

let choice = Choice::A(42);
let value: i32 = choice.into_inner();

方案2：使用不稳定的特化特性（需启用nightly） #

如果你可以使用Rust nightly版本，可通过特化特性来实现Into<T>：

1. 启用特化特性：

#![feature(specialization)]

2. 先实现通用的Into默认实现，再特化Choice<T,T>的情况：

use std::convert::Into;

enum Choice<A, B> {
    A(A),
    B(B),
}

impl<T, U> Into<U> for Choice<T, U> {
    default fn into(self) -> U {
        unreachable!("This default implementation is never used for Choice<T,T>");
    }
}

impl<T> Into<T> for Choice<T, T> {
    fn into(self) -> T {
        match self {
            Choice::A(x) => x,
            Choice::B(x) => x,
        }
    }
}

注意：特化是不稳定特性，未来可能发生变更，不建议在生产环境中使用。

方案3：自定义转换trait（灵活扩展） #

定义一个本地的转换trait，为Choice<T,T>实现该trait，可根据需求扩展更多转换逻辑：

pub trait IntoChoiceT {
    type Output;
    fn into_t(self) -> Self::Output;
}

impl<T> IntoChoiceT for Choice<T, T> {
    type Output = T;
    fn into_t(self) -> T {
        match self {
            Choice::A(x) => x,
            Choice::B(x) => x,
        }
    }
}

使用方式：

let choice = Choice::B("hello");
let value: &str = choice.into_t();

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