如何在Rust中定义接受带Trait约束泛型函数的泛型函数？

问题场景 #

我尝试编写一个接受泛型函数作为参数的函数，该参数（如下方的processor）的参数需带有Trait约束。代码如下：

fn process<P, T>(processor: &P)
where
    P: Fn(&T),
    T: ToString,
{
    processor("foo");
}

fn processor<T>(x: &T)
where
    T: ToString,
{
    println!("{}", x.to_string());
}

fn main() {
    process(&processor);
}

编译时出现以下错误：

error[E0308]: mismatched types
 --> src/main.rs:6:15
  |
1 | fn process<P, T>(processor: &P)
  |               - this type parameter
...
6 |     processor("foo");
  |     --------- ^^^^^ expected `&T`, found `&str`
  |     |
  |     arguments to this function are incorrect
  |
  = note: expected reference `&T`
             found reference `&'static str`
note: callable defined here
 --> src/main.rs:3:8
  |
3 |     P: Fn(&T),
  |        ^^^^^^

error[E0282]: type annotations needed
  --> src/main.rs:17:14
   |
17 |     process(&processor);
   |              ^^^^^^^^^ cannot infer type of the type parameter `T` declared on the function `processor`
   |
help: consider specifying the generic argument
   |
17 |     process(&processor::<T>);
   |                       +++++

错误分析与修复 #

错误原因 #

• 类型不匹配（E0308）：process中调用processor("foo")时传入的是&str，但函数签名要求processor接受&T（T是process的泛型参数），编译器无法将任意&T与&str划等号，因为T可以是任何实现ToString的类型。
• 类型推导失败（E0282）：processor是泛型函数，传递给process时，编译器无法自动推断出processor要使用的具体T类型。

修复方案 #

方式一：固定参数类型为&str

直接将process中processor的参数类型指定为&str，匹配实际传入的参数：

fn process<P>(processor: &P)
where
    P: Fn(&str),
{
    processor("foo");
}

fn processor<T>(x: &T)
where
    T: ToString,
{
    println!("{}", x.to_string());
}

fn main() {
    // 显式指定processor的泛型参数为str，编译器也可自动推导
    process(&processor::<str>);
}

方式二：支持任意ToString类型的灵活实现

如果需要process能适配更多类型，可调整约束让processor接受所有实现ToString的引用：

fn process<P>(processor: &P)
where
    P: Fn(&impl ToString),
{
    processor("foo");
}

fn processor<T>(x: &T)
where
    T: ToString,
{
    println!("{}", x.to_string());
}

fn main() {
    process(&processor);
}

或者使用动态分发（适合需要处理多种类型的场景）：

fn process<P>(processor: &P)
where
    P: for<'a> Fn(&'a dyn ToString),
{
    processor(&"foo");
}

fn processor<T>(x: &T)
where
    T: ToString,
{
    println!("{}", x.to_string());
}

fn main() {
    process(&processor);
}

说明 #

• 方式一简单直接，适合明确知道要传入&str的场景；
• 方式二更灵活，允许processor处理任何实现ToString的类型，同时process可传入不同的合规参数。

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