Rust中如何让枚举模式匹配的内部分支实现穷尽性检查？

要解决非穷尽匹配的问题，核心是让编译器明确后续逻辑中仅需处理Exact/Lower/Greater三个变体，下面是两种简洁的实现方式：

方式一：提前模式绑定筛选 #

通过match先筛选出需要数值比较的变体并绑定，编译器会自动推断后续match的可能取值，无需处理Other：

enum MatchType {
    Exact,
    Lower,
    Greater,
    Other,
}

impl MatchType {
    fn compare(&self, a: &str, b: &str) -> bool {
        let cmp_type = match self {
            // 仅保留需要数值比较的变体
            t @ (MatchType::Exact | MatchType::Lower | MatchType::Greater) => t,
            // 其他变体直接返回false
            MatchType::Other => return false,
        };

        // 解析字符串为f64，失败则返回false
        let Ok(a_num) = a.parse::<f64>() else {
            return false;
        };
        let Ok(b_num) = b.parse::<f64>() else {
            return false;
        };

        // 此时编译器知道cmp_type只有三个可能，不会报非穷尽错误
        match cmp_type {
            MatchType::Exact => a_num == b_num,
            MatchType::Lower => a_num < b_num,
            MatchType::Greater => a_num > b_num,
        }
    }
}

方式二：用matches!提前判断 + unreachable!() #

先通过matches!宏判断当前变体类型，后续match中用unreachable!()处理逻辑上不可能出现的Other变体：

impl MatchType {
    fn compare(&self, a: &str, b: &str) -> bool {
        if matches!(self, MatchType::Exact | MatchType::Lower | MatchType::Greater) {
            let Ok(a_num) = a.parse::<f64>() else {
                return false;
            };
            let Ok(b_num) = b.parse::<f64>() else {
                return false;
            };

            match self {
                MatchType::Exact => a_num == b_num,
                MatchType::Lower => a_num < b_num,
                MatchType::Greater => a_num > b_num,
                // 逻辑上不可能走到这里，用unreachable!()告诉编译器
                _ => unreachable!("已提前过滤非数值比较的变体"),
            }
        } else {
            false
        }
    }
}

关键说明 #

• 两种方式都避免了冗余代码，把字符串解析逻辑提取到了公共部分
• 第一种方式通过模式绑定让编译器明确变体范围，是更安全的做法（无需依赖unreachable!()）
• 第二种方式更直观，适合快速实现，但unreachable!()在逻辑出错时会触发panic，需确保前置判断的准确性

内容的提问来源于stack exchange，提问作者Slava.In