如何在Rust Async中实现多组不同类型Future的try_join？

要实现同时运行多组返回异构Result类型的Future，并在任意Future出错时立即返回、全部成功则返回所有结果的功能，核心思路是统一错误类型+包装异构Future，结合futures库的try_join_all完成批量异步等待。

关键步骤与实现 #

1. 统一错误类型

try_join_all要求所有Future的错误类型必须一致，因此需要将不同Future的错误转换为同一类型，可选两种方案：

• 自定义错误枚举，覆盖所有可能的错误类型；
• 使用anyhow::Error这类动态错误类型简化处理。

2. 包装异构Future

将不同类型的Future包装为统一的BoxFuture（即Pin<Box<dyn Future<Output = Result<T, E>> + Send + 'static>>），这样就能将所有Future放入同一个集合中同时运行。

3. 批量异步等待

使用futures::future::try_join_all驱动所有Future：

• 该函数会同时执行所有传入的Future；
• 一旦任意Future返回错误，立即终止并返回该错误；
• 所有Future成功时，返回所有结果的集合。

代码示例 #

方式一：自定义错误枚举

use std::error::Error;
use std::fmt;
use futures::future::{self, BoxFuture, FutureExt};

// 自定义统一错误类型
#[derive(Debug)]
enum UnifiedError {
    Io(std::io::Error),
    Parse(std::num::ParseIntError),
    Custom(CustomError),
}

impl fmt::Display for UnifiedError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            UnifiedError::Io(e) => write!(f, "IO错误: {}", e),
            UnifiedError::Parse(e) => write!(f, "解析错误: {}", e),
            UnifiedError::Custom(e) => write!(f, "自定义错误: {}", e),
        }
    }
}

impl Error for UnifiedError {}

// 示例自定义错误
#[derive(Debug)]
struct CustomError;
impl fmt::Display for CustomError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "自定义错误")
    }
}
impl Error for CustomError {}

// 保存所有成功结果的枚举
enum SuccessResult {
    Int(i32),
    String(String),
    Bool(bool),
}

async fn run_all_futures() -> Result<Vec<SuccessResult>, UnifiedError> {
    // 模拟多组异构Future
    let fut1 = async { std::fs::read_to_string("test.txt").await }
        .map_err(UnifiedError::Io)
        .map(SuccessResult::String);
    
    let fut2 = async { "123".parse::<i32>() }
        .map_err(UnifiedError::Parse)
        .map(SuccessResult::Int);
    
    let fut3 = async { Ok(true) }
        .map_err(UnifiedError::Custom)
        .map(SuccessResult::Bool);

    // 包装为统一类型的Future集合
    let futures: Vec<BoxFuture<'_, Result<SuccessResult, UnifiedError>>> = vec![
        fut1.boxed(),
        fut2.boxed(),
        fut3.boxed(),
    ];

    // 批量等待，出错立即返回，成功则返回所有结果
    let results = future::try_join_all(futures).await?;

    Ok(results)
}

方式二：使用anyhow简化错误处理

如果不需要精确区分错误类型，anyhow可以大幅简化代码：

use anyhow::{Context, Result};
use futures::future::{self, BoxFuture, FutureExt};

enum SuccessResult {
    FileContent(String),
    ParsedNumber(i32),
    Flag(bool),
}

async fn run_all_futures() -> Result<Vec<SuccessResult>> {
    let fut1 = async {
        std::fs::read_to_string("test.txt")
            .await
            .context("读取文件失败")
            .map(SuccessResult::FileContent)
    };

    let fut2 = async {
        "123".parse::<i32>()
            .context("解析数字失败")
            .map(SuccessResult::ParsedNumber)
    };

    let fut3 = async {
        Ok(true)
            .context("状态检查失败")
            .map(SuccessResult::Flag)
    };

    let futures: Vec<BoxFuture<'_, Result<SuccessResult>>> = vec![
        fut1.boxed(),
        fut2.boxed(),
        fut3.boxed(),
    ];

    future::try_join_all(futures).await
}

核心说明 #

• try_join_all会同时驱动所有Future，满足"所有Future必须同时处于活跃状态"的要求，不会逐组执行；
• 包装Future时，boxed()方法会将具体类型的Future转换为 trait 对象，实现异构类型的统一；
• 如果不需要保留成功结果，可将每个Future的结果映射为Result<(), E>，进一步简化处理逻辑。

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