如何编写匹配特定标识符的Rust宏以实现内联查找？

我正在开发第一个Rust项目，当前用PHF存储静态键值对，代码如下：

use phf;
use std::str;

struct Values {
    a: Option<char>,
    b: Option<char>,
    c: Option<char>
}

static MAPPING: phf::Map<&'static str, Values> = phf::phf_map! {
    "some_key" => Values {
        a: Some('a'),
        b: Some('b'),
        c: None
    },

    "some_other_key" => Values {
        a: Some('1'),
        b: None,
        c: None
    },

    "some_third_key" => Values {
        a: None,
        b: Some('x'),
        c: Some('y')
    }
};

static NULL_VALUES: Values = Values {
    a: None,
    b: None,
    c: None
};

// 当前宏在运行时查找值
#[macro_export]
macro_rules! get_value {
    ($key: ident, $val: ident) => {{
        use crate::values::MAPPING;
        use std::str;
        let result = MAPPING.get("$key");
        if let Some(r) = result {
            if let Some(c) = r.$val {
                if let Ok(s) = str::from_utf8(&[c as u8]) { s } else { "" }
            } else { "" }
        } else { "" }
    }};
}

这段代码能正常运行，但存在不必要的运行时开销。实际场景中这类静态值数量很多，都是原始码点，我希望实现一个宏，接收特定key/val后直接内联已知值或空值，避免运行时查找，但目前的宏只能匹配任意标识符，不知道能不能把查找逻辑转移到编译时？

解决方案 #

方案1：手动编写匹配宏（零运行时开销，适合小规模场景）

直接在宏中硬编码所有key与字段的组合，让编译器在编译时直接将宏调用展开为对应的字符串字面量，完全消除运行时查找开销。

#[macro_export]
macro_rules! get_value {
    // 匹配具体的key和字段组合
    ("some_key", a) => { "a" };
    ("some_key", b) => { "b" };
    ("some_key", c) => { "" };
    
    ("some_other_key", a) => { "1" };
    ("some_other_key", b) => { "" };
    ("some_other_key", c) => { "" };
    
    ("some_third_key", a) => { "" };
    ("some_third_key", b) => { "x" };
    ("some_third_key", c) => { "y" };
    
    // 默认分支，处理未知key或字段，返回空字符串
    ($_key:expr, $_val:ident) => { "" };
}

使用示例：

fn main() {
    assert_eq!(get_value!("some_key", a), "a");
    assert_eq!(get_value!("some_third_key", c), "y");
    assert_eq!(get_value!("unknown_key", a), "");
}

这种方法的优势是完全没有运行时开销，编译器会直接替换宏调用为对应字符串；缺点是如果key和字段数量极多，手动编写宏分支会比较繁琐。

方案2：过程宏自动生成匹配逻辑（适合大规模场景）

如果静态值数量非常多，可以用**过程宏（proc-macro）**自动生成匹配逻辑：

1. 定义自定义属性宏，标记存储静态值的结构体或常量
2. 在过程宏中解析静态值的内容
3. 自动生成包含所有匹配分支的get_value!宏

不过过程宏需要单独创建proc-macro crate，对新手来说有一定学习成本，适合值数量特别多的场景。

方案3：优化PHF实现（折中方案）

如果不想手动编写大量宏分支，又想尽可能降低运行时开销，可以保留PHF并优化宏：
PHF的get方法本身是编译时生成的高效查找，返回&'static Values，可以简化宏逻辑并消除不必要的运行时判断：

#[macro_export]
macro_rules! get_value {
    ($key:expr, $val:ident) => {{
        use crate::values::{MAPPING, NULL_VALUES};
        let values = MAPPING.get($key).unwrap_or(&NULL_VALUES);
        match &values.$val {
            Some(c) => {
                // 已知是有效UTF-8码点，用unsafe跳过运行时检查
                static STR: &'static str = unsafe { std::str::from_utf8_unchecked(&[*c as u8]) };
                STR
            }
            None => "",
        }
    }};
}

这里使用unsafe是因为已知所有字符都是原始码点，必然是有效的UTF-8，所以安全。该方案保留了PHF的维护便利性，同时大幅降低了运行时开销。

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