如何创建具有互斥字段的Rust Record Struct？

要彻底避免双字段同时有效/无效的无效状态，核心思路是利用Rust的类型系统在编译期就保证互斥性，以下是几种实用方案：

方案1：枚举+辅助方法（无需宏，最推荐） #

枚举本身就是互斥变体的天然载体，完全符合"仅一个字段有效"的需求，再通过辅助方法模拟结构体的使用体验：

// 用枚举定义互斥的有效状态
enum UserIdentifier {
    Username(String),
    Email(String),
}

impl UserIdentifier {
    // 仅提供单个字段的构造函数，保证实例有效性
    pub fn username(name: String) -> Self {
        Self::Username(name)
    }

    pub fn email(address: String) -> Self {
        Self::Email(address)
    }

    // 安全的字段访问方法，返回Option表示是否有效
    pub fn get_username(&self) -> Option<&str> {
        match self {
            Self::Username(n) => Some(n),
            _ => None,
        }
    }

    pub fn get_email(&self) -> Option<&str> {
        match self {
            Self::Email(a) => Some(a),
            _ => None,
        }
    }
}

这种方式完全消除了无效实例的可能——你只能通过构造函数创建合法实例，枚举变体的互斥性由编译器保证，无需任何运行时错误处理。

方案2：自定义过程宏实现类结构体语法 #

如果你想要更接近结构体的定义方式（比如你设想的exclusive_record_struct宏），可以用过程宏将类结构体的定义转换成上述枚举，并自动生成构造、访问方法。

宏实现步骤 #

1. 在Cargo.toml中添加宏依赖：

[dependencies]
syn = { version = "2.0", features = ["full"] }
quote = "1.0"
proc-macro2 = "1.0"

[lib]
proc-macro = true

2. 编写宏代码：

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

#[proc_macro]
pub fn exclusive_record_struct(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let struct_name = &input.ident;
    
    // 仅处理带命名字段的结构体
    let fields = match &input.data {
        syn::Data::Struct(s) => match &s.fields {
            syn::Fields::Named(FieldsNamed { named, .. }) => named,
            _ => panic!("仅支持带命名字段的结构体"),
        },
        _ => panic!("仅支持结构体类型"),
    };

    // 生成枚举变体：字段名首字母大写作为变体名
    let variants = fields.iter().map(|field| {
        let field_name = field.ident.as_ref().unwrap();
        let variant_name = syn::Ident::new(
            &format!("{}", field_name.to_string().replace(|c: char| c.is_ascii_lowercase(), |c| c.to_ascii_uppercase())[0..1] 
                + &field_name.to_string()[1..]),
            field_name.span()
        );
        let field_ty = &field.ty;
        quote! { #variant_name(#field_ty) }
    });

    // 生成单个字段的构造函数
    let constructors = fields.iter().map(|field| {
        let field_name = field.ident.as_ref().unwrap();
        let variant_name = syn::Ident::new(
            &format!("{}", field_name.to_string().replace(|c: char| c.is_ascii_lowercase(), |c| c.to_ascii_uppercase())[0..1] 
                + &field_name.to_string()[1..]),
            field_name.span()
        );
        let field_ty = &field.ty;
        quote! {
            pub fn #field_name(value: #field_ty) -> Self {
                Self::#variant_name(value)
            }
        }
    });

    // 生成字段访问方法
    let getters = fields.iter().map(|field| {
        let field_name = field.ident.as_ref().unwrap();
        let getter_name = syn::Ident::new(&format!("get_{}", field_name), field_name.span());
        let variant_name = syn::Ident::new(
            &format!("{}", field_name.to_string().replace(|c: char| c.is_ascii_lowercase(), |c| c.to_ascii_uppercase())[0..1] 
                + &field_name.to_string()[1..]),
            field_name.span()
        );
        let field_ty = &field.ty;
        quote! {
            pub fn #getter_name(&self) -> Option<&#field_ty> {
                match self {
                    Self::#variant_name(val) => Some(val),
                    _ => None,
                }
            }
        }
    });

    // 拼接最终生成的代码
    let output = quote! {
        pub enum #struct_name {
            #(#variants),*
        }

        impl #struct_name {
            #(#constructors)*
            #(#getters)*
        }
    };

    TokenStream::from(output)
}

宏使用示例 #

use your_macro_crate::exclusive_record_struct;

// 用类结构体语法定义互斥类型
exclusive_record_struct! {
    struct UserIdentifier {
        username: String,
        email: String,
    }
}

fn main() {
    let user1 = UserIdentifier::username("johndoe".into());
    assert_eq!(user1.get_username(), Some("johndoe"));
    assert_eq!(user1.get_email(), None);

    let user2 = UserIdentifier::email("john@example.com".into());
    assert_eq!(user2.get_email(), Some("john@example.com"));
    assert_eq!(user2.get_username(), None);
}

方案3：私有结构体+密封构造（不推荐） #

如果不想用枚举，也可以通过封装实现有效性保证：将结构体字段设为私有，仅提供单个字段的构造函数，禁止直接修改或默认构造：

pub struct UserIdentifier {
    username: Option<String>,
    email: Option<String>,
}

impl UserIdentifier {
    pub fn username(name: String) -> Self {
        Self { username: Some(name), email: None }
    }

    pub fn email(address: String) -> Self {
        Self { username: None, email: Some(address) }
    }

    pub fn get_username(&self) -> Option<&str> {
        self.username.as_deref()
    }

    pub fn get_email(&self) -> Option<&str> {
        self.email.as_deref()
    }
}

// 禁止默认构造
impl Default for UserIdentifier {
    fn default() -> Self {
        panic!("请用username()或email()创建实例");
    }
}

这种方案本质是用封装保证运行时有效性，但不如枚举天然——结构体内部仍存在Option字段，只是用户无法修改而已。

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