如何在Rust中为Either枚举实现From trait并避免类型冲突？

你定义了如下Either枚举，想要为Left和Right变体分别实现From trait，但直接实现会导致冲突，同时要求当L和R类型相同时，Either无法被实例化，类型不同时可正常使用From进行转换：

enum Either<L, R> {
  Left(L),
  Right(R),
}

直接实现两个From会出现冲突：

// 编译报错：存在From trait的冲突实现
impl<L, R> From<L> for Either<L, R> {
    fn from(l: L) -> Self {
        Self::Left(l)
    }
}
impl<L, R> From<R> for Either<L, R> {
    fn from(r: R) -> Self {
        Self::Right(r)
    }
}

你尝试了negative_bounds和negative_impls特性但未成功，以下是两种正确的实现方式：

方案一：利用类型ID+泛型常量表达式（依赖nightly特性） #

通过检查L和R的TypeId是否不同，限制Either只能在L≠R时被使用，同时避免From实现的冲突：

#![feature(generic_const_exprs)]

use std::any::TypeId;

// 约束L和R的类型ID必须不同
enum Either<L, R> where { TypeId::of::<L>() != TypeId::of::<R>() } {
    Left(L),
    Right(R),
}

impl<L, R> From<L> for Either<L, R> where { TypeId::of::<L>() != TypeId::of::<R>() } {
    fn from(l: L) -> Self {
        Self::Left(l)
    }
}

impl<L, R> From<R> for Either<L, R> where { TypeId::of::<L>() != TypeId::of::<R>() } {
    fn from(r: R) -> Self {
        Self::Right(r)
    }
}

方案二：使用负约束区分类型（依赖nightly特性） #

利用PartialEq的自反性（同一类型必然满足PartialEq），通过负约束限制L和R不能相等，同时分离两个From的实现范围：

#![feature(negative_bounds)]

use std::cmp::PartialEq;

// 约束L和R不能相等
enum Either<L, R> where L: !PartialEq<R> {
    Left(L),
    Right(R),
}

impl<L, R> From<L> for Either<L, R> where L: !PartialEq<R> {
    fn from(l: L) -> Self {
        Self::Left(l)
    }
}

impl<L, R> From<R> for Either<L, R> where L: !PartialEq<R> {
    fn from(r: R) -> Self {
        Self::Right(r)
    }
}

验证效果 #

按照你的需求测试：

1. 当L和R类型相同时，编译报错：

type EitherStringString = Either<String, String>; // 编译错误：约束不满足

2. 类型不同时正常定义：

type EitherStringInt = Either<String, i32>; // 编译通过

3. From转换测试正常：

#[test]
fn either_string_int_from_string() {
  let string: String = String::from("hello");
  assert_eq!(
    Either::<String, i32>::Left(string.clone()),
    string.into()
  );
}

#[test]
fn either_string_int_from_int() {
  let number: i32 = 42;
  assert_eq!(
    Either::<String, i32>::Right(number),
    number.into()
  );
}

注意：以上两种方案均依赖Rust nightly版本的不稳定特性，稳定版暂时无法直接实现类型不等的约束。

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