我能最接近用字符区分枚举的方法是什么？

Question

我已经多次写出这个问题，终于意识到我最大的问题是我不知道我想如何表示这些数据，这使得很难推理其余的代码。

数据在 Python 中的表示方式：

class LSP():
    C_MASK_MAP={
        "A":"Ch A",
        "B":"Ch B",
        "C":"Ch C",
        "D":"Ch D",
        "T":"Tmpr",
        "Y":"Batt",
        "L":"Acc"
    }
    ADC_CHANS= (
        "Ch A",
        "Ch B",
        "Ch C",
        "Ch D",
        "Tmpr",
        "Batt"
    )
    ADC_MAJORS = (
        "Ch A",
        "Ch B",
        "Ch C",
    )

我想象中的 Rust 代码（我意识到名称需要更新，但为了清楚起见，这里是一样的）：

enum C_MASK_MAP {
    Ch_A = 'A',
    Ch_B = 'B',
    Ch_C = 'C',
    Ch_D = 'D',
    Tmpr = 'T',
    Batt = 'Y',
    Acc  = 'L'
}
//...
let ADC_CHANS = [
    C_MASK_MAP::Ch_A,
    C_MASK_MAP::Ch_B,
    C_MASK_MAP::Ch_C,
    C_MASK_MAP::Ch_D,
    C_MASK_MAP::Tmpr,
    C_MASK_MAP::Batt
];
ADC_MAJORS = [
    C_MASK_MAP::Ch_A,
    C_MASK_MAP::Ch_B,
    C_MASK_MAP::Ch_C,
];

我曾考虑过将C_MASK_MAP制作为HashMap<char, &'static str>，但后来我遇到了一个巨大的混乱，试图不到处制作一百万份str，并在避免制作String的同时处理生命周期，以及引用静态str（&&'static str或其他东西）的语法混乱。

我认为能够使用枚举（或类似）会有一个真正的好处，因为值不会那么大，并且更容易C_MASK_MAP.get(key).expect("invalid key")交换，而不是只是强制转换。

Answer 1

你的字符串是哨兵值;这是 Python 中的常见模式，但不是 Rust 中应该做的事情：枚举是这样的东西应该有的：你在类型系统中编码合法值。

你最终可能会得到这样的东西：

#[derive(Clone, Copy)]
#[repr(u8)]
pub enum Mask {
    ChA = b'A',
    ChB = b'B',
    ChC = b'C',
    ChD = b'D',
    Tmpr = b'T',
    Batt = b'Y',
    Acc  = b'L',
}
// e.g. Mask::ChA.into() == 'A'
impl Into<char> for Mask {
    fn into(self) -> char {
        self as u8 as char
    }
}
impl Mask {
    // e.g. Mask::from('A') == Ok(Mask::ChA)
    pub fn from(c: char) -> Result<Mask, ()> {
        match c {
            'A' => Ok(Mask::ChA),
            'B' => Ok(Mask::ChB),
            'C' => Ok(Mask::ChC),
            'D' => Ok(Mask::ChD),
            'T' => Ok(Mask::Tmpr),
            'Y' => Ok(Mask::Batt),
            'L' => Ok(Mask::Acc),
            _ => Err(()),
        }
    }
    // e.g. Mask::ChA.is_chan() == true
    pub fn is_chan(&self) -> bool {
        match *self {
            Mask::ChA | Mask::ChB | Mask::ChC | Mask::ChD | Mask::Tmpr | Mask::Batt => true,
            Mask::Acc => false,
        }
    }
    // e.g. Mask::ChD.is_major() == false
    pub fn is_major(&self) -> bool {
        match *self {
            Mask::ChA | Mask::ChB | Mask::ChC => true,
            Mask::ChD | Mask::Tmpr | Mask::Batt | Mask::Acc => false,
        }
    }
}

如果你愿意，你也可以为Mask实现std::str::FromStr，这将允许"A".parse() == Ok(Mask::ChA)：

impl FromStr for Mask {
    type Err = ();
    fn from_str(s: &str) -> Result<Mask, ()> {
        match s {
            "A" => Ok(Mask::ChA),
            "B" => Ok(Mask::ChB),
            "C" => Ok(Mask::ChC),
            "D" => Ok(Mask::ChD),
            "T" => Ok(Mask::Tmpr),
            "Y" => Ok(Mask::Batt),
            "L" => Ok(Mask::Acc),
            _ => Err(()),
        }
    }
}

我怀疑 is_chan 等人可能比 ADC_CHANS 等人更合适，但如果你确实需要它们，它们工作得很好（你也可以做[Mask; 6]，但如果你需要添加新元素，它会更改类型，如果公开，它会中断 API 兼容性）：

pub static ADC_CHANS: &'static [Mask] = &[
    Mask::ChA,
    Mask::ChB,
    Mask::ChC,
    Mask::ChD,
    Mask::Tmpr,
    Mask::Batt,
];
pub static ADC_MAJORS: &'static [Mask] = &[
    Mask::ChA,
    Mask::ChB,
    Mask::ChC,
];

Answer 2

复制&'static str（即仅复制引用）没有成本。字符串的深层副本将是克隆，并将键入为String。

如果&'static str对您来说太冗长，则始终可以定义类型别名。

type Str = &'static str;

HashMap<char, &'static str>与您的原始地图非常吻合。但是，如果您不需要键的全部char范围，并且除了索引地图之外，实际上不需要在任何地方将值键入为char，则应改用enum，因为这将限制可用作键的合法值。