Macro enum_macro::em

macro_rules! em {
    ( $i:ident.$m:ident $p:path $(> $($a:expr),+)? ) => { ... };
    ( $i:ident.$m:ident $p:path[$(..)?] $(> $($a:expr),+)? ) => { ... };
    ( $i:ident.$m:ident $p:path[$($x:ident),+] $(> $($a:expr),+)? ) => { ... };
    ( $i:ident.$m:ident $p:path{$($($x:ident),+$(,)?)? $(..)?} $(> $($a:expr),+)? ) => { ... };
    ( $i:expr => $m:ident $p:path $(> $($a:expr),+)? ) => { ... };
    ( $i:expr => $m:ident $p:path[$(..)?] $(> $($a:expr),+)? ) => { ... };
    ( $i:expr => $m:ident $p:path[$($x:ident),+] $(> $($a:expr),+)? ) => { ... };
    ( $i:expr => $m:ident $p:path{$($($x:ident),+$(,)?)? $(..)?} $(> $($a:expr),+)? ) => { ... };
}

enum helper macro

use enum_macro::em;

#[derive(Clone, Debug, PartialEq)]
enum Enum {
    A(i32),
    B(i32, i32),
    C { x: i32, y: i32 },
}

let a = Enum::A(1);
let b = Enum::B(2, 3);
let c = Enum::C { x: 4, y: 5 };

// Get Inner Value

assert_eq!(em!(a.get Enum::A), Some(1));
assert_eq!(em!(Enum::A(1) => get Enum::A), Some(1));
assert_eq!(em!(b.get Enum::B[i, j]), Some((2, 3)));
assert_eq!(em!(c.get Enum::C{x, y}), Some((4, 5)));
assert_eq!(em!(c.get Enum::C{y, x}), Some((5, 4)));
assert_eq!(em!(c.get Enum::C{x, ..}), Some((4,)));

// Variants Detect

assert_eq!(em!(a.is Enum::A), true);
assert_eq!(em!(Enum::A(1) => is Enum::A), true);

assert_eq!(em!(b.is Enum::C{x, y}), false);
// or
assert_eq!(em!(b.is Enum::C{..}), false);
// or
assert_eq!(em!(b.is Enum::C{}), false);

assert_eq!(em!(c.is Enum::B[i, j]), false);
// or
assert_eq!(em!(c.is Enum::B[..]), false);
// or
assert_eq!(em!(c.is Enum::B[]), false);

// Map

let a2 = a.clone();
let b2 = b.clone();
assert_eq!(em!(a2.map Enum::A > |x| x + 1), Enum::A(2));
assert_eq!(em!(b2.map Enum::A > |x| x + 1), Enum::B(2, 3));

// And Then

let a2 = a.clone();
assert_eq!(em!(a2.and_then Enum::A > |x| Enum::B(x + 1, 0)), Enum::B(2, 0));

let b2 = b.clone();
assert_eq!(em!(b2.and_then Enum::B[x, y] > |x, y| Enum::C {x, y}), Enum::C { x: 2, y: 3 });

let b2 = b.clone();
// only care order
assert_eq!(em!(b2.and_then Enum::B[x, y] > |i, j| Enum::C {x: i, y: j}), Enum::C { x: 2, y: 3 });