Making a quick macro to easily write functions for enums that simply match an variant to a defined return type

match_prop.rs

// Example enum Material
pub enum Material {
    Grass,
    Sand,
    Rock,
    Water,
}

// match_prop macro
macro_rules! match_prop {
    // usage with normal return type
    ($s:ident.$p:ident() -> $t:tt, $($e:ident => $r:expr,)+) => {
        impl $s {
            fn $p(&self) -> $t {
                match self {
                    $($s::$e => $r,)*
                }
            }
        }
    };
    
    // usage with borrow return, using self lifetime
    ($s:ident.$p:ident() -> &$t:tt, $($e:ident => $r:expr,)+) => {
        impl $s {
            fn $p<'a>(&'a self) -> &'a $t {
                match self {
                    $($s::$e => $r,)*
                }
            }
        }
    }
}

// Usage with normal return type
match_prop![Material.identifier() -> u16,
    Grass => 0x01,
    Sand  => 0x02,
    Rock  => 0x03,
    Water => 0x04,
];

// Usage with borrow return type
match_prop![Material.string_name() -> &str,
    Grass => "grass",
    Sand  => "sand",
    Rock  => "rock",
    Water => "water",
];


fn main() {
    // Quick test
    let material = Material::Grass;
    assert_eq!(material.identifier(), 0x01);
    assert_eq!(material.string_name(), "grass");
    
    // Print for debugging
    println!("Identifier: {:?}",  Material::Rock.identifier());
    println!("String name: {:?}", Material::Rock.string_name());
}