如何确保集合中每个枚举变体对应唯一条目（HashMap、数组等）？

问题背景 #

模块A定义FragmentType枚举，模块B基于该枚举变体存储配置。当前Configuration的default字段采用HashMap，但该字段作为自定义配置缺失时的回退，可能存在未覆盖所有枚举变体的情况，存在风险。目标是通过类型系统确保default字段必须包含所有枚举变体的配置。目前采用数组替代，但需手动维护变体数量，寻求更优实现。

问题场景代码 #

模块A：

enum FragmentType {
    Content,
    Structure,
}

模块B：

use crate::module_a::FragmentType;

enum ConfigurationStrategy {
    Any(String),
    Parenthood {
        with_child: String,
        without_child: String,
    },
}

struct Configuration {
    default: HashMap<FragmentType, ConfigurationStrategy>,
    custom: HashMap<FragmentType, ConfigurationStrategy>,
}

临时解决方案代码 #

模块A：

enum FragmentType {
    Content,
    Structure,
}

const NB_VARIANT_FRAGMENT_TYPE: usize = 2; 
// 未找到稳定版替代mem::variant_count的更优方式

模块B：

use crate::module_a::{FragmentType, NB_VARIANT_FRAGMENT_TYPE};

enum ConfigurationStrategy {
    Any(String),
    Parenthood {
        with_child: String,
        without_child: String,
    },
}

struct Configuration {
    default: [ConfigurationStrategy; NB_VARIANT_FRAGMENT_TYPE],
    custom: HashMap<FragmentType, ConfigurationStrategy>,
}

impl Configuration {
    fn default_strategy(&self, _type: FragmentType) -> &ConfigurationStrategy {
        match _type {
            FragmentType::Content => &self.default[0],
            FragmentType::Structure => &self.default[1],
        }
    }
}

更优实现方案 #

方案1：自定义宏生成编译期检查的配置结构体 #

通过编写自定义宏，自动生成包含所有枚举变体对应配置的结构体，同时生成访问方法。新增枚举变体时，编译器会直接报错，强制开发者补充对应的配置，完全无需手动维护变体数量。

模块A：

enum FragmentType {
    Content,
    Structure,
}

// 宏：为指定枚举生成包含所有变体的默认配置结构体及访问逻辑
macro_rules! generate_full_default_config {
    ($enum_type:ty, $config_type:ty) => {
        #[derive(Debug, Clone)]
        pub struct FullDefaultConfig {
            pub content: $config_type,
            pub structure: $config_type,
        }

        impl FullDefaultConfig {
            pub fn get(&self, variant: $enum_type) -> &$config_type {
                match variant {
                    $enum_type::Content => &self.content,
                    $enum_type::Structure => &self.structure,
                }
            }
        }
    };
}

// 为FragmentType生成对应的全量默认配置结构体
generate_full_default_config!(FragmentType, ConfigurationStrategy);

模块B：

use crate::module_a::{FragmentType, FullDefaultConfig};
use std::collections::HashMap;

enum ConfigurationStrategy {
    Any(String),
    Parenthood {
        with_child: String,
        without_child: String,
    },
}

struct Configuration {
    default: FullDefaultConfig,
    custom: HashMap<FragmentType, ConfigurationStrategy>,
}

impl Configuration {
    fn get_strategy(&self, variant: FragmentType) -> &ConfigurationStrategy {
        self.custom.get(&variant).unwrap_or_else(|| self.default.get(variant))
    }
}

方案2：利用strum生态实现编译期/运行期检查 #

借助strum crate提供的枚举遍历、计数特性，可以自动处理枚举变体的完整性检查，无需手动维护数量。

首先在Cargo.toml中添加依赖：

strum = { version = "0.25", features = ["derive", "enum_iter", "enum_count"] }

模块A：

use strum::{EnumCount, EnumIter};
use strum_macros::EnumIter;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EnumIter, EnumCount)]
enum FragmentType {
    Content,
    Structure,
}

模块B：

use crate::module_a::FragmentType;
use strum::IntoEnumIterator;
use std::collections::HashMap;

enum ConfigurationStrategy {
    Any(String),
    Parenthood {
        with_child: String,
        without_child: String,
    },
}

// 封装确保全变体的默认配置类型
#[derive(Debug, Clone)]
struct FullDefaultConfig(HashMap<FragmentType, ConfigurationStrategy>);

impl FullDefaultConfig {
    // 构造函数：运行期检查是否包含所有变体，缺失则panic
    pub fn new(mut configs: HashMap<FragmentType, ConfigurationStrategy>) -> Self {
        for variant in FragmentType::iter() {
            if !configs.contains_key(&variant) {
                panic!("默认配置缺少变体 {:?} 的对应项", variant);
            }
        }
        FullDefaultConfig(configs)
    }

    pub fn get(&self, variant: FragmentType) -> &ConfigurationStrategy {
        self.0.get(&variant).unwrap()
    }
}

struct Configuration {
    default: FullDefaultConfig,
    custom: HashMap<FragmentType, ConfigurationStrategy>,
}

impl Configuration {
    fn get_strategy(&self, variant: FragmentType) -> &ConfigurationStrategy {
        self.custom.get(&variant).unwrap_or_else(|| self.default.get(variant))
    }
}

如果需要编译期检查完整性，可以启用strum的arrayvec特性，结合EnumArray生成固定大小的数组，确保每个变体都有对应配置：

strum = { version = "0.25", features = ["derive", "enum_array"] }

然后修改模块B的FullDefaultConfig为：

use strum::EnumArray;

#[derive(Debug, Clone)]
struct FullDefaultConfig(<FragmentType as EnumArray>::Array<ConfigurationStrategy>);

impl FullDefaultConfig {
    pub fn new(array: <FragmentType as EnumArray>::Array<ConfigurationStrategy>) -> Self {
        FullDefaultConfig(array)
    }

    pub fn get(&self, variant: FragmentType) -> &ConfigurationStrategy {
        &self.0[variant]
    }
}

此时创建FullDefaultConfig必须传入包含所有变体的数组，编译期就会检查数组长度是否匹配枚举变体数量，完全避免运行期错误。

方案对比 #

• 自定义宏方案：无需第三方依赖，编译期强检查，新增变体时编译器直接报错，最贴合原生类型安全需求。
• strum方案：生态成熟，代码更简洁，适合变体较多的枚举场景，可选编译期/运行期检查模式。

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