代码之家 › 专栏 › 技术社区 › JamesThomasMoon

rust-match访问子变量字段

enums rust

-1

JamesThomasMoon · 技术社区 · 1 年前

tl;博士 在 match 的语句 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"),
    }
}

我想访问 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"),
    }
}

注意内部 火柴 语句替换了变量 v 用人工编码 where v = variant .

我如何简化这些 火柴 语句,以便轻松访问 变种 亚变体?

1 回复 | 直到 1 年前

kmdreko 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"),
    }
}