函数指针类型匹配却触发Rust E0308类型不匹配错误的原因

需求是传递一个接收结构体可变引用的函数指针（或闭包），由调用方完成结构体初始化，编写的简化Rust代码如下：

use std::future::Future;

struct Data {
    value: u32
}

async fn initialize(data: &mut Data) {
    // ... do some async work ...
    data.value = 1;
}

fn do_work<Fut>(init: fn(&mut Data) -> Fut) 
where
    Fut: Future<Output = ()>,
{
    pollster::block_on(async {
        let mut data = Data { value:0 };
        init(&mut data).await;
        // ... do other stuff with `data`
    })
}

fn main() {
    do_work(initialize);
}

运行时触发编译器错误：

error[E0308]: mismatched types
  --> src/main.rs:29:13
   |
29 |     do_work(initialize);
   |     ------- ^^^^^^^^^^ one type is more general than the other
   |     |
   |     arguments to this function are incorrect
   |
   = note: expected fn pointer `for<'a> fn(&'a mut Data) -> _`
                 found fn item `for<'a> fn(&'a mut Data) -> impl Future<Output = ()> {initialize}`
note: function defined here
  --> src/main.rs:17:4
   |
17 | fn do_work<Fut>(init: fn(&mut Data) -> Fut) 
   |    ^^^^^^^      --------------------------

For more information about this error, try `rustc --explain E0308`.
error: could not compile `playground` due to previous error

问题原因 #

这个错误的核心在于async函数返回的Future类型依赖于输入引用的生命周期，而原代码中do_work的泛型约束无法匹配这种依赖关系：

• initialize作为async函数，实际签名为for<'a> fn(&'a mut Data) -> impl Future<Output = ()> + 'a——返回的Future持有输入引用的生命周期'a，不同的'a对应不同的Future类型。
• 但do_work定义的fn(&mut Data) -> Fut要求：对于任意生命周期'a，函数返回的都是同一个Fut类型，这和async函数的返回特性冲突，单一泛型类型Fut无法覆盖所有依赖不同生命周期的Future。

非async函数可以正常运行，是因为它们的返回类型固定（比如()），不依赖输入引用的生命周期，能满足函数指针的单一类型要求。

解决方案 #

修改do_work的参数约束，使用**高阶 trait 边界（HRTB）**让闭包/函数的返回Future关联输入引用的生命周期，同时放弃函数指针，改用更灵活的Fn trait：

方案1：使用impl Future简化约束 #

use std::future::Future;
use pollster;

struct Data {
    value: u32
}

async fn initialize(data: &mut Data) {
    // ... do some async work ...
    data.value = 1;
}

fn do_work<F>(init: F) 
where
    F: for<'a> Fn(&'a mut Data) -> impl Future<Output = ()> + 'static,
{
    pollster::block_on(async {
        let mut data = Data { value:0 };
        init(&mut data).await;
        println!("Data value: {}", data.value);
        // ... do other stuff with `data`
    })
}

fn main() {
    do_work(initialize);
}

方案2：显式关联生命周期与Future #

如果需要更明确的生命周期控制，可使用带生命周期参数的Future类型：

use std::future::Future;
use pollster;

struct Data {
    value: u32
}

async fn initialize(data: &mut Data) {
    // ... do some async work ...
    data.value = 1;
}

fn do_work<F, Fut>(init: F) 
where
    F: for<'a> Fn(&'a mut Data) -> Fut,
    Fut: Future<Output = ()>,
{
    pollster::block_on(async {
        let mut data = Data { value:0 };
        init(&mut data).await;
        println!("Data value: {}", data.value);
        // ... do other stuff with `data`
    })
}

fn main() {
    do_work(initialize);
}

两种方案都能让编译器正确处理async函数返回的生命周期依赖，解决类型不匹配问题。

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