如何在 RUST 中将枚举变量的名称转换为字符串？

Question

I am wondering how to implement a method for any enum that will return the variant identifier as a String or &'static str, without using any external crate. Something like:

pub enum MyEnum {

    EnumVariant1
    EnumVariant2
}

impl MyEnum {

    fn to_string(&self) -> String {
        // do Rust stuff here
    }
}

Answer 1

As stated in my comment I believe a custom derive macro may be the easiest option (although I could be missing something) so here is a basic implementation of one:

// lib.rs in enum_name

extern crate self as enum_name;

pub use enum_name_derive::EnumName;

pub trait EnumName {
    fn enum_name(&self) -> &'static str;
}

#[cfg(test)]
mod tests {
    use super::*;

    #[derive(EnumName)]
    #[allow(dead_code)]
    enum MyEnum<'a, T> {
        VariantA,
        VariantB(T, i32),
        AnotherOne { x: &'a str },
    }

    #[test]
    fn test_enum_name() {
        assert_eq!("VariantA", MyEnum::VariantA::<u32>.enum_name());
        assert_eq!("VariantB", MyEnum::VariantB(1, 2).enum_name());
        assert_eq!(
            "AnotherOne",
            MyEnum::AnotherOne::<u8> { x: "test" }.enum_name()
        );
    }
}

// lib.rs in enum_name_derive

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, Data, DeriveInput, Fields};

#[proc_macro_derive(EnumName)]
pub fn derive_proto_read(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    let ident = input.ident;
    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
    let variants = match input.data {
        Data::Enum(data) => data.variants.into_iter().map(|variant| {
            let ident = variant.ident;
            let ident_string = ident.to_string();
            let fields = match variant.fields {
                Fields::Named(_) => quote!({ .. }),
                Fields::Unnamed(_) => quote!((..)),
                Fields::Unit => quote!(),
            };

            quote! {
                Self::#ident#fields => #ident_string
            }
        }),
        _ => panic!("not an enum"),
    };

    (quote! {
        impl #impl_generics enum_name::EnumName for #ident #ty_generics #where_clause {
            fn enum_name(&self) -> &'static str {
                match self {
                    #(#variants),*
                }
            }
        }
    })
    .into()
}