如何在Rust中通过const泛型条件启用/禁用枚举变体？

我定义了一个表示各类可执行操作的枚举，但其中部分变体仅在编译期已知的特定上下文中有效。为限制对特定变体的访问，我希望为该枚举添加const泛型参数，实现类似如下代码的效果：

enum Action<const COND1: bool, const COND2: bool> {
    A,
    B,
    C<enable if COND1>,
    D<enable if COND2>,
}

let action1 = Action<false, false>::A;
match action1 {
    Action<false, false>::A => {}
    Action<false, false>::B => {}
}

let action2 = Action<true, false>::A;
match action2 {
    Action<true, false>::A => {}
    Action<true, false>::B => {}
    Action<true, false>::C => {}
}

let action3 = Action<false, true>::A;
match action3 {
    Action<false, true>::A => {}
    Action<false, true>::B => {}
    Action<false, true>::D => {}
}

请问该需求能否在Rust中实现？若为每种组合单独创建枚举会产生大量重复代码。

目前Rust原生不支持直接为枚举变体添加条件编译的const泛型约束，你写的C<enable if COND1>这种语法在当前稳定版和夜间版中都不存在。不过可以通过几种方式近似实现需求，避免重复代码：

1. 使用enum_dispatch结合特征约束（推荐） #

借助enum_dispatch宏，先为不同条件下的变体定义特征，再通过const泛型控制特征的包含范围：

use enum_dispatch::enum_dispatch;

// 基础操作特征
trait BaseAction {
    fn execute(&self);
}

// 仅COND1为true时可用的操作特征
#[cfg_attr(feature = "cond1", enum_dispatch)]
trait Cond1Action: BaseAction {}

// 仅COND2为true时可用的操作特征
#[cfg_attr(feature = "cond2", enum_dispatch)]
trait Cond2Action: BaseAction {}

// 根据const泛型组合特征生成枚举
#[enum_dispatch(BaseAction, Cond1Action, Cond2Action)]
enum Action<const COND1: bool, const COND2: bool> {
    A,
    B,
    #[cfg(COND1)]
    C,
    #[cfg(COND2)]
    D,
}

// 实现基础操作逻辑
impl BaseAction for Action<_, _> {
    fn execute(&self) {
        match self {
            Action::A => println!("Executing A"),
            Action::B => println!("Executing B"),
            #[cfg(COND1)]
            Action::C => println!("Executing C"),
            #[cfg(COND2)]
            Action::D => println!("Executing D"),
        }
    }
}

// 仅COND1为true时实现Cond1Action特征
#[cfg(COND1)]
impl Cond1Action for Action<true, _> {}

// 仅COND2为true时实现Cond2Action特征
#[cfg(COND2)]
impl Cond2Action for Action<_, true> {}

这种方式能在编译期严格约束：当COND1=false时，Action<false, _>::C无法被构造或匹配，否则直接触发编译错误。

2. 使用宏生成条件变体 #

通过自定义宏根据const泛型参数生成对应枚举变体，避免手动编写重复枚举代码：

macro_rules! action_enum {
    ($cond1:expr, $cond2:expr) => {
        enum Action {
            A,
            B,
            $(
                #[cfg($cond1)]
                C,
            )*
            $(
                #[cfg($cond2)]
                D,
            )*
        }
    };
}

// 生成不同条件组合的枚举并定义类型别名
action_enum!(false, false);
type ActionFalseFalse = Action;

action_enum!(true, false);
type ActionTrueFalse = Action;

action_enum!(false, true);
type ActionFalseTrue = Action;

这种方式通过宏封装重复逻辑，编译期能精准控制每个枚举变体的可见性，仅需为不同组合定义类型别名即可。

3. 使用夜间版feature(generic_const_exprs)（实验性） #

如果可以使用Rust夜间版，可开启generic_const_exprs特性，通过const表达式限制变体的构造入口：

#![feature(generic_const_exprs)]

enum Action<const COND1: bool, const COND2: bool> {
    A,
    B,
    C,
    D,
}

impl<const COND1: bool, const COND2: bool> Action<COND1, COND2> {
    // 仅当COND1=true时允许构造C
    pub fn c() -> Self where [(); 1]: Sized<{ if COND1 { 0 } else { 1 } }> {
        Action::C
    }

    // 仅当COND2=true时允许构造D
    pub fn d() -> Self where [(); 1]: Sized<{ if COND2 { 0 } else { 1 } }> {
        Action::D
    }
}

这种方式下，当COND1=false时调用Action::c()会触发编译错误，但匹配时仍能看到所有变体，可配合#[non_exhaustive]和文档说明避免误用。

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