如何在Rust静态变量中指定未知类型，创建通用HashMap？

我想要一个通用性极强的顶级HashMap，编写了如下代码：

static mut cache: HashMap<std::hash::Hash + Eq, MyBox<_>> = HashMap::new();

其中MyBox是一个智能指针。运行后出现了以下错误：

静态变量的类型签名中不允许使用占位符_
trait对象中仅允许使用自动trait作为附加trait
提示：建议创建一个包含Hash + Eq作为超trait的新trait来替代：trait NewTrait: Hash + Eq {}
traitEq无法被对象化

同时还有一条警告：“未显式使用dyn的trait对象已被弃用”。请问如何创建一个支持任意键和任意装箱值的static mut HashMap？

要实现支持任意键和任意装箱值的static mut HashMap，得先解决Rust类型系统的几个核心限制：静态变量必须有明确类型，Eq和Hash并非对象安全trait，不能直接作为trait对象使用。下面是两种可行的实现方案：

方案一：基于Any trait的通用实现 #

利用std::any::Any擦除类型信息，手动封装键的哈希与相等性检查，实现完全任意类型的键值存储：

use std::any::Any;
use std::collections::HashMap;
use std::hash::{Hash, Hasher};

// 自定义智能指针示例（替换为你实际的MyBox实现）
struct MyBox<T>(T);

// 包装任意类型的键，实现Hash和Eq
struct DynKey {
    value: Box<dyn Any>,
    hash: u64,
}

impl PartialEq for DynKey {
    fn eq(&self, other: &Self) -> bool {
        // 先匹配类型，再比较值
        self.value.type_id() == other.value.type_id() &&
            match (self.value.downcast_ref(), other.value.downcast_ref()) {
                (Some(a), Some(b)) => a == b,
                _ => false,
            }
    }
}

impl Eq for DynKey {}

impl Hash for DynKey {
    fn hash<H: Hasher>(&self, state: &mut H) {
        // 先哈希类型ID，再预计算的哈希值，保证一致性
        self.value.type_id().hash(state);
        self.hash.hash(state);
    }
}

// 辅助函数：生成DynKey
fn make_dyn_key<K: Any + Hash + Eq>(key: K) -> DynKey {
    let mut hasher = std::collections::hash_map::DefaultHasher::new();
    key.hash(&mut hasher);
    DynKey {
        value: Box::new(key),
        hash: hasher.finish(),
    }
}

// 定义静态HashMap，明确类型
static mut CACHE: HashMap<DynKey, MyBox<Box<dyn Any>>> = HashMap::new();

// 使用示例
fn main() {
    unsafe {
        // 插入不同类型的键值对
        CACHE.insert(make_dyn_key("test"), MyBox(Box::new(42)));
        CACHE.insert(make_dyn_key(123), MyBox(Box::new("hello".to_string())));
        
        // 查询并类型转换
        if let Some(val) = CACHE.get(&make_dyn_key("test")) {
            if let Some(num) = val.0.downcast_ref::<i32>() {
                println!("{}", num); // 输出42
            }
        }
    }
}

方案二：枚举固定支持的类型（更安全高效） #

如果不需要完全任意类型，可预先枚举支持的键值类型，避免动态类型转换的开销：

use std::collections::HashMap;

struct MyBox<T>(T);

// 枚举所有支持的键类型
#[derive(Hash, Eq, PartialEq)]
enum Key {
    Str(String),
    Int(i32),
    Bool(bool),
    // 按需添加更多类型
}

// 枚举所有支持的值类型
enum Value {
    Int(i32),
    String(String),
    Float(f64),
    // 按需添加更多类型
}

// 静态HashMap定义
static mut CACHE: HashMap<Key, MyBox<Value>> = HashMap::new();

// 使用示例
fn main() {
    unsafe {
        CACHE.insert(Key::Str("test".into()), MyBox(Value::Int(42)));
        CACHE.insert(Key::Int(123), MyBox(Value::String("hello".into())));
        
        if let Some(val) = CACHE.get(&Key::Str("test".into())) {
            if let Value::Int(num) = &val.0 {
                println!("{}", num); // 输出42
            }
        }
    }
}

重要注意事项 #

• static mut本身是不安全的，多线程环境下会引发数据竞争。实际开发中推荐用lazy_static或once_cell结合Mutex/RwLock实现线程安全的静态HashMap：

use lazy_static::lazy_static;
use std::sync::Mutex;
use std::collections::HashMap;

// 结合方案一的DynKey实现
lazy_static! {
    static ref CACHE: Mutex<HashMap<DynKey, MyBox<Box<dyn Any>>>> = Mutex::new(HashMap::new());
}

// 使用时通过lock()安全访问
fn main() {
    let mut cache = CACHE.lock().unwrap();
    cache.insert(make_dyn_key("test"), MyBox(Box::new(42)));
}

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