如何创建以带引用参数的函数为键的HashMap？

你遇到的核心问题在于：带泛型生命周期的函数指针（for<'r> fn(&'r u32) -> u32）并没有被Rust标准库实现Eq和Hash trait，而HashMap的键必须同时满足这两个约束才能插入元素。

为什么会这样？因为这种泛型函数指针要求对所有可能的生命周期'r都有效，Rust无法为这种“全生命周期兼容”的函数指针自动推导相等性和哈希逻辑——毕竟要保证在任意生命周期下函数的行为一致，编译器没法做这样的全局验证。

针对你的波函数坍缩场景，我推荐以下几种解决方案，按实用性排序：

方案1：用枚举代替函数指针作为键（最推荐） #

波函数坍缩中的邻居方向（比如一维的左右、二维的上下左右、六边形的六个方向等）本身就是有限的、可枚举的类型。用枚举作为HashMap的键，不仅天然满足Eq和Hash（Rust会为枚举自动实现这两个trait，只要成员都满足），还能让代码更清晰、可读性更强。

举个一维网格的例子：

use std::collections::HashMap;

// 定义邻居方向枚举，对应不同的邻居计算逻辑
enum NeighborDir {
    Left,
    Right,
}

// 示例网格类型（根据你的实际需求调整）
struct Grid {
    size: usize,
}

// 把枚举映射到对应的邻居计算函数
fn get_neighbor_calculator(dir: NeighborDir) -> impl Fn(&Grid, usize) -> Option<usize> {
    match dir {
        NeighborDir::Left => |grid, idx| {
            if idx > 0 { Some(idx - 1) } else { None }
        },
        NeighborDir::Right => |grid, idx| {
            if idx < grid.size - 1 { Some(idx + 1) } else { None }
        },
    }
}

fn main() {
    // 规则集：键是邻居方向，值是坍缩规则
    let mut rules: HashMap<NeighborDir, u32> = HashMap::new();
    rules.insert(NeighborDir::Left, 0);
    rules.insert(NeighborDir::Right, 1);

    // 使用时，根据枚举获取对应的计算函数
    let grid = Grid { size: 5 };
    let left_calc = get_neighbor_calculator(NeighborDir::Left);
    println!("Left neighbor of 1: {:?}", left_calc(&grid, 1)); // 输出 Some(0)
}

这种方式完全避开了函数指针作为键的问题，同时让规则集的语义更明确——你能直接从枚举值看出对应的邻居类型，而不是对着一个函数指针猜逻辑。

方案2：手动包装函数指针并实现Eq和Hash #

如果你确实需要用函数指针作为键，可以把它包装在一个结构体里，手动实现Eq和Hash trait。这里的核心是利用函数指针的内存地址来判断相等性和生成哈希值（因为无捕获的函数/闭包会被编译成静态函数，地址是固定的）。

示例代码：

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

// 包装函数指针的结构体
struct NeighborFn(fn(&u32) -> u32);

impl PartialEq for NeighborFn {
    fn eq(&self, other: &Self) -> bool {
        // 比较函数指针的内存地址
        self.0 as *const () == other.0 as *const ()
    }
}

impl Eq for NeighborFn {}

impl Hash for NeighborFn {
    fn hash<H: Hasher>(&self, state: &mut H) {
        // 用函数指针的地址生成哈希
        (self.0 as *const ()).hash(state);
    }
}

fn main() {
    let mut hm: HashMap<NeighborFn, u32> = HashMap::new();
    // 插入时用结构体包装函数/闭包
    hm.insert(NeighborFn(|v: &u32| v + 1), 0);
    
    // 测试查询
    let key = NeighborFn(|v: &u32| v + 1);
    println!("{:?}", hm.get(&key)); // 输出 Some(0)
}

⚠️ 注意：这种方式仅适用于无捕获的函数或闭包（因为只有它们能转换为fn类型）。如果你的邻居函数需要捕获环境（比如引用网格的某些参数），那么fn类型就不适用了，必须用闭包配合dyn Fn，但此时没法直接作为HashMap的键，还是得回到方案1的枚举思路。

方案3：固定生命周期（不推荐，适用性窄） #

如果你的函数参数的生命周期可以固定为'static（比如传入的网格是静态全局变量），那么可以把函数指针的生命周期写死，这样标准库会为它自动实现Eq和Hash：

use std::collections::HashMap;

fn main() {
    // 固定生命周期为'static的函数指针
    let mut hm: HashMap<fn(&'static u32) -> u32, u32> = HashMap::new();
    // 插入的函数必须接收'static引用
    hm.insert(|v: &'static u32| v + 1, 0);
}

但显然这对你的波函数坍缩场景不实用——网格几乎不可能是'static的，所以这个方案仅作知识补充。

内容的提问来源于stack exchange，提问作者Lack of a better name