如何规范存储可按名称引用的Rust结构体预定义实例？

我希望将多个结构体的预定义实例作为常量存储，并能按名称引用它们。我尝试了两种实现方式，但觉得不够规范，想知道标准做法是什么？

我的两种尝试：

方式一：使用HashMap（编译不通过） #

use std::collections::HashMap;

struct MyStruct {
    // ...
}

const INSTANCES: HashMap<&str, MyStruct> = [
    ("Instance1", MyStruct {
        // fields...
    }),
    ("Instance2", MyStruct {
        // fields...
    }),
    ("Instance3", MyStruct {
        // fields...
    }),
    // Add more instances as needed
].iter().cloned().collect();

fn main() {
    let instance = INSTANCES.get("Instance1");
    // ...
}

方式二：使用枚举包裹 #

struct MyStruct {
    // ...
}

enum MyStructInstance {
    Instance1,
    Instance2,
    Instance3,
    // Add more instances as needed
}

impl MyStructInstance {
    fn get_instance(&self) -> MyStruct {
        match self {
            MyStructInstance::Instance1 => MyStruct {
                // fields...
            },
            MyStructInstance::Instance2 => MyStruct {
                // fields...
            },
            MyStructInstance::Instance3 => MyStruct {
                // fields...
            },
            // ...
        }
    }
}

fn main() {
    let instance1 = MyStructInstance::Instance1.get_instance();
    // ...
}

现有方式的问题 #

• 方式一：HashMap::collect不是const fn，无法在编译期完成HashMap初始化，代码直接编译失败。
• 方式二：每次调用get_instance都会创建新的MyStruct实例，复杂结构体场景下会有性能浪费，且无法保证实例全局唯一性。

标准实现方案 #

方案1：静态HashMap（结合lazy_static或once_cell）

适合需要动态字符串查找的场景，通过第三方库实现运行时一次性初始化，保证实例全局唯一且只读：

use lazy_static::lazy_static;
use std::collections::HashMap;

#[derive(Debug, Clone)]
struct MyStruct {
    name: &'static str,
    value: u32,
}

lazy_static! {
    static ref INSTANCES: HashMap<&'static str, MyStruct> = {
        let mut map = HashMap::new();
        map.insert("Instance1", MyStruct { name: "Instance1", value: 10 });
        map.insert("Instance2", MyStruct { name: "Instance2", value: 20 });
        map.insert("Instance3", MyStruct { name: "Instance3", value: 30 });
        map
    };
}

fn main() {
    if let Some(instance) = INSTANCES.get("Instance1") {
        println!("{:?}", instance);
    }
}

需在Cargo.toml添加依赖：

[dependencies]
lazy_static = "1.4.0"

方案2：枚举关联静态常量（类型安全首选）

不需要动态字符串查找时，推荐这种编译期检查、无运行时开销的方式：

#[derive(Debug)]
struct MyStruct {
    name: &'static str,
    value: u32,
}

enum MyStructInstance {
    Instance1,
    Instance2,
    Instance3,
}

impl MyStructInstance {
    const INSTANCE1: MyStruct = MyStruct { name: "Instance1", value: 10 };
    const INSTANCE2: MyStruct = MyStruct { name: "Instance2", value: 20 };
    const INSTANCE3: MyStruct = MyStruct { name: "Instance3", value: 30 };

    fn get(&self) -> &'static MyStruct {
        match self {
            MyStructInstance::Instance1 => &Self::INSTANCE1,
            MyStructInstance::Instance2 => &Self::INSTANCE2,
            MyStructInstance::Instance3 => &Self::INSTANCE3,
        }
    }
}

fn main() {
    let instance = MyStructInstance::Instance1.get();
    println!("{:?}", instance);

    // 也可直接访问静态常量
    println!("{:?}", MyStructInstance::INSTANCE2);
}

优势：编译期检查引用合法性，无运行时开销，实例全局唯一。

方案3：直接定义独立静态常量

实例数量较少时，最直观的实现方式：

#[derive(Debug)]
struct MyStruct {
    name: &'static str,
    value: u32,
}

static INSTANCE1: MyStruct = MyStruct { name: "Instance1", value: 10 };
static INSTANCE2: MyStruct = MyStruct { name: "Instance2", value: 20 };
static INSTANCE3: MyStruct = MyStruct { name: "Instance3", value: 30 };

fn main() {
    println!("{:?}", INSTANCE1);
}

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