Rust中实现类似C++偏模板特化的函数重载适配不同闭包参数

需要编写一个可同时兼容两类lambda（闭包）传入的函数：

• 一类闭包按值接收参数
• 另一类闭包按引用接收参数

以近似计算函数导数的derivative函数为例，最初尝试通过定义两个同名、泛型约束不同的函数实现，代码如下：

fn derivative<F, R>(f: &F, x: f64) -> R
where F: Fn(f64) -> R,
      R: Div<f64, Output=R> + Sub<Output=R>

{
    let epsilon = 1e-7;
    (f(x + epsilon / 2.0) - f(x - epsilon / 2.0)) / epsilon
}

fn derivative<F, R>(f: &F, x: f64) -> R
    where F: Fn(&f64) -> R,
          R: Div<f64, Output=R> + Sub<Output=R>
{
    let epsilon: f64 = 1e-7;
    (f(&(x + epsilon / 2.0)) - f(&(x - epsilon / 2.0))) / epsilon
}

该实现预期让derivative同时支持Fn(f64)和Fn(&f64)两种闭包类型。在C++中这类逻辑可通过偏模板特化（本质是对模板参数做模式匹配）实现，但上述写法在Rust中会直接抛出derivative重复定义的错误[E4028]。

核心疑问：

• Rust中是否存在类似C++偏模板特化的对应特性？
• 是否有更简便的方案可以实现该需求？

Rust不支持仅靠泛型where约束区分同名函数的重载/偏特化逻辑，这类场景的标准实现方式是通过自定义trait抽象参数传递的差异，由编译器在编译期自动匹配对应trait实现，全程静态分派无运行时开销。

具体实现步骤如下：

1. 定义一个辅助trait，封装对f64类型参数的调用逻辑，屏蔽按值传参和按引用传参的差异
2. 分别为满足Fn(f64) -> R、Fn(&f64) -> R约束的闭包类型实现该辅助trait
3. 主derivative函数仅依赖辅助trait做约束，内部统一调用trait提供的方法即可，不需要重复编写导数计算逻辑

完整可运行代码：

use std::ops::{Div, Sub};

// 辅助trait，统一闭包调用接口
trait CallF64<R> {
    fn call(&self, val: f64) -> R;
}

// 为按值接收f64的闭包实现trait
impl<F, R> CallF64<R> for F
where F: Fn(f64) -> R
{
    fn call(&self, val: f64) -> R {
        self(val)
    }
}

// 为按引用接收f64的闭包实现trait
impl<F, R> CallF64<R> for F
where F: Fn(&f64) -> R
{
    fn call(&self, val: f64) -> R {
        self(&val)
    }
}

// 导数计算主函数，仅依赖统一的trait约束
fn derivative<F, R>(f: &F, x: f64) -> R
where
    F: CallF64<R>,
    R: Div<f64, Output = R> + Sub<Output = R>
{
    let epsilon = 1e-7;
    (f.call(x + epsilon / 2.0) - f.call(x - epsilon / 2.0)) / epsilon
}

// 调用示例
fn main() {
    // 传入按值接收参数的闭包
    let f1 = |x: f64| x * x;
    println!("f1 derivative at 2.0: {}", derivative(&f1, 2.0));

    // 传入按引用接收参数的闭包
    let f2 = |x: &f64| x * x;
    println!("f2 derivative at 2.0: {}", derivative(&f2, 2.0));
}

该实现的效果和C++偏模板特化完全一致：编译器会根据传入闭包的签名自动匹配对应的trait实现，不需要用户手动区分调用方式，两段测试代码都会输出约4.0的正确导数值。

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