生锈匹配：简单枚举上的“虚假”非穷举错误：如何“传播”枚举变量种类知识？

Question

我打了一个有趣的虚假的“匹配中匹配”非详尽的铁锈错误。做一个简单的小例子（当然生产案例更有趣）：

pub enum SomeEnum {
    Possibility1,
    Possibility2,
    Possibility3
}

pub fn do_something(some: &SomeEnum){
    match some {
        SomeEnum::Possibility1 => println!("this is possibility 1"),
        something_else => {
            println!("this is not possibility 1");

            match something_else {
                SomeEnum::Possibility2 => println!("but this is 2"),
                SomeEnum::Possibility3 => println!("but this is 3")
            }
        }
    }
}

未编译，但出现错误：

error[E0004]: non-exhaustive patterns: `&Possibility1` not covered
  --> src/main.rs:13:19
   |
1  | / pub enum SomeEnum {
2  | |     Possibility1,
   | |     ------------ not covered
3  | |     Possibility2,
4  | |     Possibility3
5  | | }
   | |_- `SomeEnum` defined here
...
13 |               match something_else {
   |                     ^^^^^^^^^^^^^^ pattern `&Possibility1` not covered
   |
   = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
   = note: the matched value is of type `&SomeEnum`

我理解这个错误，我知道如何“残酷地”修复它（类似于非详尽模式——通过添加一个生锈匹配表达式：

_ => unreachable!();

例如分支机构）。

尽管如此，我还是觉得这很可悲：编译器在第一次匹配时足够聪明，知道其他东西是某种可能性2或可能性3，而把这些知识扔掉？

因此，我的问题是：有没有一种简单、惯用的方法来迫使锈蚀将这种知识从外部匹配“传播”到内部匹配，这样我就可以在不残酷匹配所有输入的情况下抑制错误？同样，在这个简单的例子中，_匹配似乎是显而易见的，但是在一些更复杂的代码中，我希望编译器帮助检查我的逻辑是否正确，这就取消了使用<_匹配过滤器。

Answer 1

尽管如此，我还是觉得这很悲哀：编译器在第一次匹配时足够聪明，知道其他东西可能是2或3

不是，真的。从语义上来说，它只是一个接一个地尝试每一个匹配的手臂，然后拿走第一个。

因此，我的问题是：有没有一种简单、惯用的方法来迫使锈菌将这种知识从外部匹配“传播”到内部匹配

不。就类型级别而言，rustc的原因（主要是）someone是一个SomeEnum，而SomeEnum有一个SomeEnum:：posability1。如果你想要一个子枚举，你必须提供一个。

如果RFC2593枚举变量类型（或类似于OCaml样式多态变量的替代类型）再次被提交、接受和实现，这种事情最终可能是可行的。但除此之外，您必须在enum上“手动”实现它。

我所说的“手工完成”是指手动将你想要的语义编码为额外的枚举。

pub enum SomeEnum {
    Possibility1,
    Possibility2,
    Possibility3
}

enum IsOne { One, Other(Sub23) }
enum Sub23 {
    Sub2,
    Sub3
}
impl SomeEnum {
    fn is_one(&self) -> IsOne {
        match self {
            Self::Possibility1 => IsOne::One,
            Self::Possibility2 => IsOne::Other(Sub23::Sub2),
            Self::Possibility3 => IsOne::Other(Sub23::Sub3),
        }
    }
}

pub fn do_something(some: &SomeEnum){
    match some.is_one() {
        IsOne::One => println!("this is possibility 1"),
        IsOne::Other(sub) => {
            println!("this is not possibility 1");

            match sub {
                Sub23::Sub2 => println!("but this is 2"),
                Sub23::Sub3 => println!("but this is 3")
            }
        }
    }
}