Rust中如何将带生命周期的泛型函数转换为函数指针

这是实际问题的简化版本，初始代码如下：

fn my_func<'a, 'b>(a: &'a i32, b: &'b i32) -> i32 {
    a + b
}

fn my_func_generic<'a, 'b, T>(a: &'a T, b: &'b T) -> T
where
    &'a T: std::ops::Add<&'b T, Output = T>,
{
    a + b
}

fn apply_function(x: &i32, y: &i32, function: fn(&i32, &i32) -> i32) -> i32 {
    function(x, y)
}

fn main() {
    let x = 10;
    let y = 11;
    println!("{}", my_func(&x, &y));
    println!("{}", my_func_generic(&x, &y));

    println!("{}", apply_function(&x, &y, my_func));
    println!("{}", apply_function(&x, &y, my_func_generic));
}

编译时抛出如下错误：

error[E0308]: mismatched types
  --> src/main.rs:23:43
   |
23 |     println!("{}", apply_function(&x, &y, my_func_generic));
   |                                           ^^^^^^^^^^^^^^^ one type is more general than the other
   |
   = note: expected fn pointer `for<'r, 's> fn(&'r i32, &'s i32) -> _`
              found fn pointer `fn(&i32, &i32) -> _`

核心诉求：如何将my_func_generic作为函数指针传入apply_function中？
直接调用my_func_generic(&x, &y)可以正常运行，说明函数本身的入参出参逻辑符合调用要求。尝试直接赋值为函数指针、手动标注泛型类型都无法解决问题，两种失败尝试的代码如下：

// 尝试1：直接赋值为对应类型的函数指针
let function_pointer: fn(&i32, &i32) -> i32 = my_func_generic;

// 尝试2：手动标注泛型参数
let function_pointer: fn(&i32, &i32) -> i32 = my_func_generic::<'_, '_, i32>;

问题出在Rust的高阶生命周期（HRTB，Higher-Ranked Trait Bounds）机制和泛型函数单态化规则上：

1. apply_function要求的函数指针类型是for<'r, 's> fn(&'r i32, &'s i32) -> i32，也就是这个函数指针必须能适配任意生命周期的&i32输入，是全域量化的类型。
2. 非泛型的my_func本身就满足这个要求：它的签名自带两个独立生命周期参数，对任意输入生命周期都有效，所以可以直接转成对应的函数指针。
3. 但my_func_generic的生命周期'a、'b属于它的泛型参数，当你把它当成函数指针使用时，Rust无法在不把生命周期固定为某个具体值的前提下，证明「对任意可能的'r、's，&'r i32都满足Add约束」——因为Add的实现是绑定具体生命周期的，泛型参数的约束在单态化阶段就会确定，没法自动生成一个对所有生命周期都成立的函数指针实例。

之前手动指定'_生命周期的写法不生效，是因为'_会被编译器推断为当前作用域下某个具体的生命周期，而非要求的「对任意生命周期都有效」的高阶生命周期约束，因此无法匹配目标fn指针类型。

有两种可行的实现方式，可根据场景选择：

方案1：闭包包装调用（最简单，无需修改原有函数签名） #

不需要改动原有泛型函数的定义，传入闭包在闭包内部调用泛型函数即可，闭包会在调用点自动推导适配对应的生命周期：

fn main() {
    let x = 10;
    let y = 11;
    println!("{}", my_func(&x, &y));
    println!("{}", my_func_generic(&x, &y));

    println!("{}", apply_function(&x, &y, my_func));
    // 闭包包装，自动适配生命周期
    println!("{}", apply_function(&x, &y, |a, b| my_func_generic(a, b)));
}

该方案的缺点是闭包不能在所有场景下完全等价于裸函数指针，但在当前传参场景下完全可用。

方案2：将apply_function改为接受泛型回调（更通用，符合Rust惯例） #

Rust中编写接受回调的函数时，更推荐用泛型约束接受任意实现了Fn trait的类型，而非硬编码fn指针类型，这样既可以接受普通函数指针，也可以接受泛型函数、闭包：

// 修改apply_function为泛型版本，用Fn trait约束回调
fn apply_function<F>(x: &i32, y: &i32, function: F) -> i32
where
    F: Fn(&i32, &i32) -> i32,
{
    function(x, y)
}

fn main() {
    let x = 10;
    let y = 11;
    println!("{}", my_func(&x, &y));
    println!("{}", my_func_generic(&x, &y));

    println!("{}", apply_function(&x, &y, my_func));
    // 直接传入泛型函数即可，无需包装
    println!("{}", apply_function(&x, &y, my_func_generic));
}

这个写法是Rust生态中回调函数的标准写法，性能和裸函数指针完全一致：泛型会在编译期单态化，没有运行时开销，同时兼容性更强。

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