如何在Rust中高效存储统一枚举变体的集合？

针对你的需求，这里提供几种可行的替代方案，既能强制集合元素类型统一，又能避免重复存储枚举变体：

1. 类型标记+同质字节存储 #

定义包含类型标识和统一字节容器的结构体，只在顶部存储一次类型信息，数据部分为同类型的序列化字节流：

// 先定义类型枚举，对应Value的所有基础类型
enum ValueType {
    Bool,
    Int,
    Float,
    Str,
    // ... 其余20+类型
}

// 同质数组
struct TypedArray {
    ty: ValueType,
    data: Vec<u8>, // 存储同类型序列化后的字节数据
}

// 同质映射（需同时标记键和值的类型）
struct TypedMap {
    key_ty: ValueType,
    val_ty: ValueType,
    data: Vec<(Vec<u8>, Vec<u8>)>, // 键值对的字节存储
}

这种方式需要自行实现基础类型与字节流的序列化/反序列化逻辑，确保类型一致性，同时大幅减少冗余存储。

2. 泛型+Trait约束实现编译时类型安全 #

如果解析阶段能提前确定集合类型，可用泛型结构体配合Trait约束来保证元素类型统一：

// 定义标记Trait，为所有基础类型实现
trait ValueMarker {}
impl ValueMarker for bool {}
impl ValueMarker for i32 {}
impl ValueMarker for f32 {}
impl ValueMarker for String {}
// ... 其余基础类型的Trait实现

// 同质数组
struct TypedArray<T: ValueMarker>(Vec<T>);
// 同质映射
struct TypedMap<K: ValueMarker, V: ValueMarker>(std::collections::HashMap<K, V>);

若要将这类集合纳入Value枚举，可通过Trait对象实现动态分发：

enum Value {
    Bool(bool),
    Int(i32),
    Float(f32),
    Str(String),
    Array(Box<dyn ArrayOps>),
    Map(Box<dyn MapOps>),
    // ...
}

// 定义数组的通用操作Trait
trait ArrayOps {
    fn element_type(&self) -> ValueType;
    // 按需添加其他通用方法，比如获取长度、遍历等
}

// 为所有TypedArray实现Trait
impl<T: ValueMarker + 'static> ArrayOps for TypedArray<T> {
    fn element_type(&self) -> ValueType {
        match std::any::TypeId::of::<T>() {
            id if id == std::any::TypeId::of::<bool>() => ValueType::Bool,
            id if id == std::any::TypeId::of::<i32>() => ValueType::Int,
            // ... 其余类型匹配
            _ => unreachable!(),
        }
    }
}

这种方式在编译时保证类型统一，运行时通过Trait对象处理通用逻辑，无需重复存储类型信息。

3. 宏自动生成枚举变体（针对映射场景） #

如果仍想保留枚举形式，可借助Rust宏自动生成所有ValueMap的变体，避免手动编写N*N种组合：

use std::collections::HashMap;

macro_rules! generate_uniform_map {
    ($($key:ty => $val:ty),*) => {
        enum UniformValueMap {
            $(
                $(stringify!($key))[0..1].to_uppercase()+stringify!($val))(HashMap<$key, $val>),
            )*
        }
    };
}

// 自动生成所有键值类型组合的变体
generate_uniform_map! {
    bool => bool, bool => i32, bool => f32, bool => String,
    i32 => bool, i32 => i32, i32 => f32, i32 => String,
    f32 => bool, f32 => i32, f32 => f32, f32 => String,
    String => bool, String => i32, String => f32, String => String
    // ... 其余类型组合
}

宏会自动帮你生成命名规范的枚举变体，既保证类型统一，又减少手动重复代码。

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