如何在Rust中实现类似C/C++支持超范围整数值的enum用法？

有两种符合Rust设计习惯的实现方式，分别适配不同的使用场景： #

方案1：单枚举整合所有变体（纯Rust场景首选） #

直接把ASCII字符、预定义枚举值合并到同一个枚举类型，无需拆分两个独立枚举，同时实现整数与枚举的双向转换，兼顾类型安全和使用便利性：

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TokenType {
    /// 小于256的ASCII字符值
    Ascii(u8),
    /// 对应原C枚举的Identifier = 256
    Identifier,
    KeywordFunc,
    KeywordReturn,
    KeywordIf,
    KeywordElse,
}

impl From<u32> for TokenType {
    fn from(value: u32) -> Self {
        match value {
            256 => Self::Identifier,
            257 => Self::KeywordFunc,
            258 => Self::KeywordReturn,
            259 => Self::KeywordIf,
            260 => Self::KeywordElse,
            0..=255 => Self::Ascii(value as u8),
            // 若需要支持260以上的未定义值，可新增Unknown(u32)变体替代panic
            _ => panic!("unexpected token type value: {}", value),
        }
    }
}

impl From<TokenType> for u32 {
    fn from(token: TokenType) -> Self {
        match token {
            TokenType::Ascii(c) => c as u32,
            TokenType::Identifier => 256,
            TokenType::KeywordFunc => 257,
            TokenType::KeywordReturn => 258,
            TokenType::KeywordIf => 259,
            TokenType::KeywordElse => 260,
        }
    }
}

使用示例：

// 从ASCII字符创建，等价于C的TokenType('{')
let brace_type = TokenType::from(b'{' as u32);
// 从预定义枚举值创建
let ident_type = TokenType::Identifier;
// 转换为整数和C侧交互
let raw_value: u32 = ident_type.into();

这个方案的优势是可以利用Rust编译器的穷尽性检查，匹配枚举时不会遗漏分支，类型安全性更高。 #

方案2：Newtype包装整数（FFI交互场景首选） #

如果需要和C代码做跨语言交互，要求完全对齐C枚举的内存布局和使用习惯，可以选择newtype模式包装原生整数：

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(transparent)] // 保证内存布局和u32完全一致，FFI交互零成本
pub struct TokenType(u32);

impl TokenType {
    // 预定义常量对齐C枚举的值
    pub const IDENTIFIER: Self = Self(256);
    pub const KEYWORD_FUNC: Self = Self(257);
    pub const KEYWORD_RETURN: Self = Self(258);
    pub const KEYWORD_IF: Self = Self(259);
    pub const KEYWORD_ELSE: Self = Self(260);

    /// 从ASCII字符创建实例，等价于C的TokenType(c)
    pub const fn from_ascii(c: u8) -> Self {
        Self(c as u32)
    }

    /// 获取对应的原始整数值
    pub const fn raw_value(&self) -> u32 {
        self.0
    }

    /// 判断是否为预定义的关键字类型
    pub const fn is_keyword(&self) -> bool {
        matches!(self.0, 256..=260)
    }
}

使用示例：

let brace_type = TokenType::from_ascii(b'{');
let ident_type = TokenType::IDENTIFIER;
let raw = brace_type.raw_value();

这个方案和C枚举的内存布局完全一致，跨语言交互没有额外开销，使用方式也和C侧写法高度对齐。 #

内容的提问来源于stack exchange，提问作者Nico van Bentum