有没有办法匹配 rust 中枚举的所有变体？

Question

Is there something that is equivalent to this:

enum ABC {
    A(u32),
    B(i32),
    C(f64),
}

fn main() {
    let abc = ABC::A(42);

    match abc {
        _(foo) => foo,
    }
}

The reason why I'm asking is that sometimes, I want to use an enum for the different possible types, but most cases I need to handle the data in the enum variants the same exact way.

Answer 1

If you want to match against all possible variants and perform a common action you can write a macro for it and reduce code repetition:

enum ABC {
    A(u32),
    B(i32),
    C(f64),
}

#[macro_use]
macro_rules! per_letter {
    ($val:expr, $pattern:pat => { $res:expr }) => (
        match $val {
            $crate::ABC::A($pattern) => $res,
            $crate::ABC::B($pattern) => $res,
            $crate::ABC::C($pattern) => $res,
        }
    )
}

impl ABC {
    pub fn print_inner(&self) {
        per_letter!(self, letter => {println!("{}", letter)});
    }
    pub fn print_quad(&self) {
        per_letter!(self, letter => {println!("{}", *letter**letter)});
    }
}

Note that this is limited. You can't have multiple possible return types without wrapping them in an enum. But it's still useful if your inner types share a common functionality.

fn main() {
    let foo = ABC::A(2);
    foo.print_inner();
    foo.print_quad();
}