Rust中match如何处理未覆盖分支？骰子代码编译报错求解

以下几种方法可以在不添加冗余代码的前提下，让编译器认可你的match分支覆盖逻辑：

方法一：debug断言兜底 #

利用debug_assert!在debug模式下做错误检查，release模式下该断言会被自动优化掉，不会产生冗余代码。在match的兜底分支中加入断言，同时返回一个任意有效枚举值即可：

enum Dice {
    One, Two, Three, Four, Five, Six,
}

impl Dice {
    fn _rnd() -> u8 {
        rand::thread_rng().gen_range(1..=6)
    }

    fn from_rnd() -> Self {
        let val = Self::_rnd();
        match val {
            1 => Dice::One,
            2 => Dice::Two,
            3 => Dice::Three,
            4 => Dice::Four,
            5 => Dice::Five,
            6 => Dice::Six,
            _ => {
                debug_assert!(false, "骰子数值超出预期范围: {}", val);
                Dice::One
            }
        }
    }
}

这个方法完全安全，debug阶段能及时发现异常，release阶段没有额外开销。

方法二：使用unwrap_unchecked（unsafe但无冗余） #

先给枚举实现TryFrom<u8> trait，再利用unwrap_unchecked跳过错误检查——因为你明确知道_rnd只会返回1-6的数值，所以这个unsafe操作是安全的：

use std::convert::TryFrom;

enum Dice {
    One, Two, Three, Four, Five, Six,
}

impl TryFrom<u8> for Dice {
    type Error = ();

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            1 => Ok(Dice::One),
            2 => Ok(Dice::Two),
            3 => Ok(Dice::Three),
            4 => Ok(Dice::Four),
            5 => Ok(Dice::Five),
            6 => Ok(Dice::Six),
            _ => Err(()),
        }
    }
}

impl Dice {
    fn _rnd() -> u8 {
        rand::thread_rng().gen_range(1..=6)
    }

    fn from_rnd() -> Self {
        let val = Self::_rnd();
        unsafe { val.try_into().unwrap_unchecked() }
    }
}

这种方法没有任何冗余代码，性能最优，但需要你确保_rnd的返回值绝对不会超出范围。

方法三：用范围匹配简化分支（可选） #

如果你的枚举变体和数值一一对应，也可以直接用范围匹配合并有效分支，再配合断言兜底：

enum Dice {
    One, Two, Three, Four, Five, Six,
}

impl Dice {
    fn _rnd() -> u8 {
        rand::thread_rng().gen_range(1..=6)
    }

    fn from_rnd() -> Self {
        let val = Self::_rnd();
        match val {
            1..=6 => unsafe { std::mem::transmute(val - 1) },
            _ => {
                debug_assert!(false, "无效骰子值: {}", val);
                Dice::One
            }
        }
    }
}

注意这里用了mem::transmute，需要确保枚举的内存布局和数值对应，适合简单的连续变体枚举。

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