rust 匹配访问子变体字段

Question

tl;dr 在带有子变量的

match

的

enum

语句中，如何将该子变量分配给变量？

鉴于这些

enum

s

enum MySubVariant {
    A,
    B,
    C,
}
enum MyEnum {
    X { variant: MySubVariant },
    Y { variant: MySubVariant },
    Z,
}
fn main() {
    let x = MyEnum::X { variant: MySubVariant::A };
    match x {
        MyEnum::X { variant: MySubVariant::A }
        | MyEnum::X { variant: MySubVariant::B }
        | MyEnum::Y { variant: MySubVariant::A }
        | MyEnum::Y { variant: MySubVariant::B }
        => {
            // do something unique for A or B
            match x {
                MyEnum::X { variant } => {
                    print!("the variant was ");
                    match variant {
                        MySubVariant::A => println!("A"),
                        MySubVariant::B => println!("B"),
                        _ => unreachable!(),
                    }
                }
                _ => unreachable!(),
            }
        }
        MyEnum::X { variant: MySubVariant::C }
        | MyEnum::Y { variant: MySubVariant::C }
        => {
            // do something unique for C
            print!("the variant was ");
            match x {
                MyEnum::X { variant } | MyEnum::Y { variant } => {
                    match variant {
                        MySubVariant::A => println!("A"),
                        MySubVariant::B => println!("B"),
                        MySubVariant::C => println!("C"),
                    }
                }
                _ => unreachable!(),
            }
        }
        MyEnum::Z => println!("Z"),
    }
}

我想访问 match 语句中的

variant

子变体。 我想用变量替换内部

match

语句。

这是我想要的人为（且无效）的代码：

fn main() {
    let x = MyEnum::X { variant: MySubVariant::A };
    match x {
        MyEnum::X { variant: MySubVariant::A } where v = variant
        | MyEnum::X { variant: MySubVariant::B } where v = variant
        | MyEnum::Y { variant: MySubVariant::A } where v = variant
        | MyEnum::Y { variant: MySubVariant::B } where v = variant
        => {
            // do something unique for A or B
            println!("the variant was {:?}", v);
        }
        MyEnum::X { variant: MySubVariant::C } where v = variant
        | MyEnum::Y { variant: MySubVariant::C } where v = variant
        => {
            // do something unique for C
            println!("the variant was {:?}", v);
        }
        MyEnum::Z => println!("Z"),
    }
}

注意内部

match

语句用人为代码

v

替换了变量

where v = variant

。

如何简化这些

match

语句以轻松访问

variant

子变体？

Answer 1

您想要的示例非常接近。您可以使用

@

来匹配模式并同时绑定到新变量。这是实际操作：

fn main() {
    let x = MyEnum::X { variant: MySubVariant::A };
    match x {
        MyEnum::X { variant: v @ MySubVariant::A }
        | MyEnum::X { variant: v @ MySubVariant::B }
        | MyEnum::Y { variant: v @ MySubVariant::A }
        | MyEnum::Y { variant: v @ MySubVariant::B }
        => {
            // do something unique for A or B
            println!("the variant was {:?}", v);
        }
        MyEnum::X { variant: v @ MySubVariant::C }
        | MyEnum::Y { variant: v @ MySubVariant::C }
        => {
            // do something unique for C
            println!("the variant was {:?}", v);
        }
        MyEnum::Z => println!("Z"),
    }
}