Macro case 

macro_rules! case {
    (
        $x:expr, $($ pa : pat $(if $ ga : expr)? => $ ba : block)+; $($ pb :
        pat $(if $ gb : expr)? => $ bb : block)+;
    ) => { ... };
    (
        $x:expr, $($ pa : pat $(if $ ga : expr)? => $ ba : block)+; $($ pb :
        pat $(if $ gb : expr)? => $ bb : block)+; $($ pc : pat $(if $ gc :
        expr)? => $ bc : block)+;
    ) => { ... };
    (
        $x:expr, $($ pa : pat $(if $ ga : expr)? => $ ba : block)+; $($ pb :
        pat $(if $ gb : expr)? => $ bb : block)+; $($ pc : pat $(if $ gc :
        expr)? => $ bc : block)+; $($ pd : pat $(if $ gd : expr)? => $ bd :
        block)+;
    ) => { ... };
    (
        $x:expr, $($ pa : pat $(if $ ga : expr)? => $ ba : block)+; $($ pb :
        pat $(if $ gb : expr)? => $ bb : block)+; $($ pc : pat $(if $ gc :
        expr)? => $ bc : block)+; $($ pd : pat $(if $ gd : expr)? => $ bd :
        block)+; $($ pe : pat $(if $ ge : expr)? => $ be : block)+;
    ) => { ... };
    (
        $x:expr, $($ pa : pat $(if $ ga : expr)? => $ ba : block)+; $($ pb :
        pat $(if $ gb : expr)? => $ bb : block)+; $($ pc : pat $(if $ gc :
        expr)? => $ bc : block)+; $($ pd : pat $(if $ gd : expr)? => $ bd :
        block)+; $($ pe : pat $(if $ ge : expr)? => $ be : block)+; $($ pf :
        pat $(if $ gf : expr)? => $ bf : block)+;
    ) => { ... };
    (
        $x:expr, $($ pa : pat $(if $ ga : expr)? => $ ba : block)+; $($ pb :
        pat $(if $ gb : expr)? => $ bb : block)+; $($ pc : pat $(if $ gc :
        expr)? => $ bc : block)+; $($ pd : pat $(if $ gd : expr)? => $ bd :
        block)+; $($ pe : pat $(if $ ge : expr)? => $ be : block)+; $($ pf :
        pat $(if $ gf : expr)? => $ bf : block)+; $($ pg : pat $(if $ gg :
        expr)? => $ bg : block)+;
    ) => { ... };
    (
        $x:expr, $($ pa : pat $(if $ ga : expr)? => $ ba : block)+; $($ pb :
        pat $(if $ gb : expr)? => $ bb : block)+; $($ pc : pat $(if $ gc :
        expr)? => $ bc : block)+; $($ pd : pat $(if $ gd : expr)? => $ bd :
        block)+; $($ pe : pat $(if $ ge : expr)? => $ be : block)+; $($ pf :
        pat $(if $ gf : expr)? => $ bf : block)+; $($ pg : pat $(if $ gg :
        expr)? => $ bg : block)+; $($ ph : pat $(if $ gh : expr)? => $ bh :
        block)+;
    ) => { ... };
    (
        $x:expr, $($ pa : pat $(if $ ga : expr)? => $ ba : block)+; $($ pb :
        pat $(if $ gb : expr)? => $ bb : block)+; $($ pc : pat $(if $ gc :
        expr)? => $ bc : block)+; $($ pd : pat $(if $ gd : expr)? => $ bd :
        block)+; $($ pe : pat $(if $ ge : expr)? => $ be : block)+; $($ pf :
        pat $(if $ gf : expr)? => $ bf : block)+; $($ pg : pat $(if $ gg :
        expr)? => $ bg : block)+; $($ ph : pat $(if $ gh : expr)? => $ bh :
        block)+; $($ pi : pat $(if $ gi : expr)? => $ bi : block)+;
    ) => { ... };
    (
        $x:expr, $($ pa : pat $(if $ ga : expr)? => $ ba : block)+; $($ pb :
        pat $(if $ gb : expr)? => $ bb : block)+; $($ pc : pat $(if $ gc :
        expr)? => $ bc : block)+; $($ pd : pat $(if $ gd : expr)? => $ bd :
        block)+; $($ pe : pat $(if $ ge : expr)? => $ be : block)+; $($ pf :
        pat $(if $ gf : expr)? => $ bf : block)+; $($ pg : pat $(if $ gg :
        expr)? => $ bg : block)+; $($ ph : pat $(if $ gh : expr)? => $ bh :
        block)+; $($ pi : pat $(if $ gi : expr)? => $ bi : block)+; $($ pj :
        pat $(if $ gj : expr)? => $ bj : block)+;
    ) => { ... };
    (
        $x:expr, $($ pa : pat $(if $ ga : expr)? => $ ba : block)+; $($ pb :
        pat $(if $ gb : expr)? => $ bb : block)+; $($ pc : pat $(if $ gc :
        expr)? => $ bc : block)+; $($ pd : pat $(if $ gd : expr)? => $ bd :
        block)+; $($ pe : pat $(if $ ge : expr)? => $ be : block)+; $($ pf :
        pat $(if $ gf : expr)? => $ bf : block)+; $($ pg : pat $(if $ gg :
        expr)? => $ bg : block)+; $($ ph : pat $(if $ gh : expr)? => $ bh :
        block)+; $($ pi : pat $(if $ gi : expr)? => $ bi : block)+; $($ pj :
        pat $(if $ gj : expr)? => $ bj : block)+; $($ pk : pat $(if $ gk :
        expr)? => $ bk : block)+;
    ) => { ... };
    (
        $x:expr, $($ pa : pat $(if $ ga : expr)? => $ ba : block)+; $($ pb :
        pat $(if $ gb : expr)? => $ bb : block)+; $($ pc : pat $(if $ gc :
        expr)? => $ bc : block)+; $($ pd : pat $(if $ gd : expr)? => $ bd :
        block)+; $($ pe : pat $(if $ ge : expr)? => $ be : block)+; $($ pf :
        pat $(if $ gf : expr)? => $ bf : block)+; $($ pg : pat $(if $ gg :
        expr)? => $ bg : block)+; $($ ph : pat $(if $ gh : expr)? => $ bh :
        block)+; $($ pi : pat $(if $ gi : expr)? => $ bi : block)+; $($ pj :
        pat $(if $ gj : expr)? => $ bj : block)+; $($ pk : pat $(if $ gk :
        expr)? => $ bk : block)+; $($ pl : pat $(if $ gl : expr)? => $ bl :
        block)+;
    ) => { ... };
}

Pattern matching against one_of types, similar to match

Groups of match arms are separated by ;

Unlike match, case only accepts blocks as values of match arms

Examples

matching against one of the integer types

use one_of::{case, one_of};
case!(<one_of!(i8, i64, u8, u64)>::from(42u64),
    // i8
    _ => {
        panic!("not i8");
    };

    // i64
    _ => {
        panic!("not i64");
    };

    // u8
    _ => {
        panic!("not u8");
    };

    // u64
    0 ..= 41 => {
        panic!("not less than 42");
    }
    n => {
        assert_eq!(n, 42);
    };
);

gaurds are also supported, just like match

case!(<one_of!(bool, &str, i64)>::from("Hello, world!"),
    // bool
    _ => {
        panic!("not bool");
    };

    // &str
    s if s.starts_with("Hello, ") => {
        assert_eq!(&s[7 ..], "world!");
    }
    _ => {
        panic!("not other strings");
    };

    // i64
    _ => {
        panic!("not i64");
    };
);

this is the equivalent using match and a custom enum

enum BoolStrOrInt<'a> {
    Bool(bool),
    Str(&'a str),
    Int(i64),
}

match BoolStrOrInt::Str("Hello, world!") {
    // bool
    BoolStrOrInt::Bool(_) => {
        panic!("not bool");
    }

    // &str
    BoolStrOrInt::Str(s) if s.starts_with("Hello, ") => {
        assert_eq!(&s[7 ..], "world!");
    }
    BoolStrOrInt::Str(_) => {
        panic!("not other strings");
    }

    // i64
    BoolStrOrInt::Int(_) => {
        panic!("not i64");
    }
}