Rust中enumerate搭配async块的编译错误排查与修复

代码示例 #

use std::error::Error;

#[derive(Debug)]
enum MyEnum {
    First,
    Second,
}

fn do_something(index: usize, m: &MyEnum) {
    eprintln!("do_something: {} {:?}", index, m);
}

async fn test() -> Result<(), Box<dyn Error>> {
    let myvec = vec![MyEnum::First, MyEnum::Second];
    let c = String::from("cap");

    let futures = myvec.iter().enumerate().map(|(index, el)| async {
        eprintln!("Element: {}", &c);
        do_something(index, el);
    });

    futures::future::join_all(futures).await;
    Ok(())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    test().await?;
    Ok(())
}

编译器报错 #

error[E0373]: async block may outlive the current function, but it borrows `index`, which is owned by the current function
  --> src/main.rs:17:62
   |
17 |     let futures = myvec.iter().enumerate().map(|(index, el)| async {
   |                                                              ^^^^^ may outlive borrowed value `index`
18 |         eprintln!("Element: {}", &c);
19 |         do_something(index, el);
   |                      ----- `index` is borrowed here
   |

疑问与解答 #

1. 为何编译器未对el变量报错？ #

el是myvec.iter()生成的引用，myvec的生命周期覆盖了从函数开始到join_all执行完毕的全过程——所有异步闭包都会在join_all中立即等待完成，编译器能明确推断出el的引用不会超出myvec的存活时间，因此不会报错。

而index的问题源于闭包的默认捕获规则：即使变量实现了Copy，闭包默认仍会以借用方式捕获它。编译器做保守的生命周期检查，它无法确定异步闭包是否会在外部map闭包结束后才执行（哪怕逻辑上我们知道join_all会立刻等待），因此判定借用的index可能失效。

2. 如何在保留迭代器、不移动字符串c的前提下修复代码？ #

有两种简洁可行的方案：

方案一：显式复制index转移所有权

利用usize的Copy特性，在异步闭包外显式复制index，让异步闭包拥有其所有权而非借用：

let futures = myvec.iter().enumerate().map(|(index, el)| {
    let index = index; // 显式复制，将所有权转移到异步闭包环境
    async {
        eprintln!("Element: {}", &c);
        do_something(index, el);
    }
});

方案二：给异步闭包添加move关键字

move会让异步闭包捕获变量的所有权（对于el这种引用，是转移引用的所有权，但其生命周期仍绑定到myvec），同时c以借用方式被捕获（&c的生命周期足够覆盖join_all执行）：

let futures = myvec.iter().enumerate().map(|(index, el)| async move {
    eprintln!("Element: {}", &c);
    do_something(index, el);
});

补充：为什么index是Copy类型还会报错？ #

Rust闭包遵循最小权限捕获原则：能借用就不获取所有权，哪怕变量实现Copy。异步闭包会生成Future对象，编译器无法保证这个对象不会被延后执行，因此判定借用的index可能在外部闭包销毁后失效。通过显式复制或move让异步闭包拥有index的所有权，就能消除生命周期冲突。

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