Rust枚举重复From实现优化及外部枚举派生async_graphql::Enum方法咨询

问题1：避免重复编写双向From实现 #

既然两个枚举的变体完全一致，你可以通过自定义宏一次性生成RolePublic定义和双向From实现，彻底避免重复编写匹配逻辑。

示例代码如下：

// 定义宏，接收变体列表后自动生成枚举和转换逻辑
macro_rules! define_role_public {
    ($($variant:ident),*) => {
        #[derive(async_graphql::Enum, Copy, Clone, Eq, PartialEq)]
        pub enum RolePublic {
            $($variant),*
        }

        // 从one::Role转换到RolePublic
        impl From<one::Role> for RolePublic {
            fn from(value: one::Role) -> Self {
                match value {
                    $(one::Role::$variant => RolePublic::$variant,)*
                }
            }
        }

        // 从RolePublic转换到one::Role
        impl From<RolePublic> for one::Role {
            fn from(value: RolePublic) -> Self {
                match value {
                    $(RolePublic::$variant => one::Role::$variant,)*
                }
            }
        }
    };
}

// 调用宏，只需列出一次所有变体即可
define_role_public!(Admin, User, Guest);

后续变体有增减时，只需要修改宏调用里的变体列表，无需手动修改两处From实现的匹配分支，减少重复劳动和出错概率。

问题2：直接为one::Role派生async_graphql::Enum #

可以直接使用one::Role而无需定义RolePublic，但因为无法修改crate one的代码，你需要手动实现async_graphql::Enum trait（或用简化的外部派生语法）。

方式1：用async-graphql的简化外部派生 #

这种方式代码更简洁，适合不需要自定义字段名的场景：

#[async_graphql::Enum]
impl one::Role {
    // 逐个列出所有枚举变体，与crate one中的定义一一对应
    async_graphql::enum_variant!(Admin);
    async_graphql::enum_variant!(User);
    async_graphql::enum_variant!(Guest);
}

方式2：完全手动实现Enum trait #

如果需要自定义GraphQL字段名或添加额外逻辑，可以手动实现整个trait：

use async_graphql::{Enum, EnumValue, Error, Value};
use std::borrow::Cow;

impl Enum for one::Role {
    type Inner = Self;

    // 指定GraphQL中的类型名称
    fn type_name() -> Cow<'static, str> {
        "Role".into()
    }

    // 定义所有枚举变体对应的GraphQL值
    fn values() -> &'static [EnumValue<Self::Inner>] {
        use one::Role;
        &[
            EnumValue::new("Admin", Role::Admin),
            EnumValue::new("User", Role::User),
            EnumValue::new("Guest", Role::Guest),
        ]
    }

    // 解析GraphQL输入值到枚举变体
    fn parse(value: &str) -> Result<Self::Inner, Error> {
        use one::Role;
        match value {
            "Admin" => Ok(Role::Admin),
            "User" => Ok(Role::User),
            "Guest" => Ok(Role::Guest),
            _ => Err(Error::new(format!("无效的Role值: {}", value))),
        }
    }

    // 将枚举变体转换为GraphQL输出值
    fn to_value(&self) -> Value {
        Value::String(match self {
            one::Role::Admin => "Admin".to_string(),
            one::Role::User => "User".to_string(),
            one::Role::Guest => "Guest".to_string(),
        })
    }
}

两种方式都能让one::Role直接用于async-graphql的schema定义，无需额外定义RolePublic。

内容的提问来源于stack exchange，提问作者Fred Hors