如何在Rust中利用类型系统约束结构体合法组合并触发编译错误

要在编译阶段禁止{C, Three}这类非法组合，核心思路是通过类型设计让非法组合无法构造，而非依赖运行时检查。以下是两种可行的实现方案：

方案一：标记类型+关联类型约束 #

通过定义标记类型代表不同的Letter，并为每个标记绑定允许的Number类型，从根源上阻止非法组合的构造：

use std::marker::PhantomData;

// 标记类型，分别对应A、B、C三种Letter
struct A;
struct B;
struct C;

// 定义trait，关联每个Letter允许的Number类型
trait AllowedNumber {
    type Number;
}

// A允许所有Number
impl AllowedNumber for A {
    type Number = FullNumber;
}

// B允许所有Number
impl AllowedNumber for B {
    type Number = FullNumber;
}

// C仅允许排除Three的Number
impl AllowedNumber for C {
    type Number = RestrictedNumber;
}

// 完整的Number枚举（包含Three）
enum FullNumber { One, Two, Three }

// 受限的Number枚举（不含Three）
enum RestrictedNumber { One, Two }

// 重构Pair结构体，依赖Letter标记类型
struct Pair<L: AllowedNumber> {
    _letter: PhantomData<L>,
    number: L::Number,
}

// 为每个Letter实现专属的构造函数
impl Pair<A> {
    fn new(number: FullNumber) -> Self {
        Pair { _letter: PhantomData, number }
    }
}

impl Pair<B> {
    fn new(number: FullNumber) -> Self {
        Pair { _letter: PhantomData, number }
    }
}

impl Pair<C> {
    fn new(number: RestrictedNumber) -> Self {
        Pair { _letter: PhantomData, number }
    }
}

fn main() {
    // 合法构造：A搭配Three
    let _valid_a = Pair::<A>::new(FullNumber::Three);
    // 合法构造：C搭配Two
    let _valid_c = Pair::<C>::new(RestrictedNumber::Two);

    // 编译错误：FullNumber::Three无法传入Pair<C>的构造函数
    // let _invalid = Pair::<C>::new(FullNumber::Three);
}

方案二：嵌套枚举直接定义合法组合 #

如果需要保留原有的Letter和Number概念，可以直接在Pair枚举中定义所有合法组合，同时提供统一的访问方法：

#[derive(Debug, Clone)]
enum Letter { A, B, C }

#[derive(Debug, Clone)]
enum Number { One, Two, Three }

// 定义受限的Number（不含Three）
#[derive(Debug, Clone)]
enum RestrictedNumber { One, Two }

// 实现从受限Number到完整Number的转换
impl From<RestrictedNumber> for Number {
    fn from(n: RestrictedNumber) -> Self {
        match n {
            RestrictedNumber::One => Number::One,
            RestrictedNumber::Two => Number::Two,
        }
    }
}

// 直接定义所有合法的Pair组合
#[derive(Debug)]
enum Pair {
    A(Number),
    B(Number),
    C(RestrictedNumber),
}

impl Pair {
    // 为每种Letter提供专属构造函数
    fn new_a(number: Number) -> Self {
        Pair::A(number)
    }

    fn new_b(number: Number) -> Self {
        Pair::B(number)
    }

    fn new_c(number: RestrictedNumber) -> Self {
        Pair::C(number)
    }

    // 统一获取Letter的方法
    fn letter(&self) -> Letter {
        match self {
            Pair::A(_) => Letter::A,
            Pair::B(_) => Letter::B,
            Pair::C(_) => Letter::C,
        }
    }

    // 统一获取Number的方法
    fn number(&self) -> Number {
        match self {
            Pair::A(n) => n.clone(),
            Pair::B(n) => n.clone(),
            Pair::C(n) => n.clone().into(),
        }
    }
}

fn main() {
    // 合法构造
    let _valid = Pair::new_a(Number::Three);
    let _valid_c = Pair::new_c(RestrictedNumber::Two);

    // 编译错误：Number::Three不是RestrictedNumber类型，无法传入new_c
    // let _invalid = Pair::new_c(Number::Three);
}

这两种方案都能让编译器在编译阶段识别出非法组合，避免运行时panic。核心是通过类型系统的约束，让非法组合的参数类型不匹配，从而无法通过编译。

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