如何为包含异步函数的Rust trait实现抽象？

问题重现 #

我在构建应用时，希望核心组件Brain通过 trait 对象与子系统解耦，但异步方法返回impl Future导致无法创建 trait 对象，最小复现代码如下：

use std::future::Future;

trait ReturnsFutures {
    fn futuristic(&self) -> impl Future<Output = ()>;
}

struct FutureReturner {}

impl ReturnsFutures for FutureReturner {
    async fn futuristic(&self) {
        println!("just fake async");
    }
}

struct OtherFutureReturner {}

impl ReturnsFutures for OtherFutureReturner {
    async fn futuristic(&self) {
        println!("also fakin' it");
    }
}

struct FuturisticService {
    future_returner: Box<dyn ReturnsFutures>,
}

编译时会触发错误：

the trait ReturnsFutures cannot be made into an object
consider moving futuristic to another trait
the following types implement the trait, consider defining an enum where each variant holds one of these types, implementing ReturnsFutures for this new enum and using it instead:
FutureReturner
OtherFutureReturner

可行解决方案 #

1. 改用Box<dyn Future>作为返回类型 #

将 trait 方法的返回值从impl Future改为装箱的 future trait 对象，满足对象安全要求：

use std::future::Future;

trait ReturnsFutures {
    // 用Box<dyn Future>统一返回类型，生命周期绑定到&self
    fn futuristic(&self) -> Box<dyn Future<Output = ()> + '_>;
}

struct FutureReturner {}

impl ReturnsFutures for FutureReturner {
    fn futuristic(&self) -> Box<dyn Future<Output = ()> + '_> {
        // 用Box::pin包裹异步块，处理!Unpin的future
        Box::pin(async {
            println!("just fake async");
        })
    }
}

struct OtherFutureReturner {}

impl ReturnsFutures for OtherFutureReturner {
    fn futuristic(&self) -> Box<dyn Future<Output = ()> + '_> {
        Box::pin(async {
            println!("also fakin' it");
        })
    }
}

struct FuturisticService {
    future_returner: Box<dyn ReturnsFutures>,
}

关键说明：

• Box<dyn Future>让所有实现返回的不同 future 类型统一为 trait 对象，符合对象安全的要求
• Box::pin用于处理异步块生成的!Unpin类型 future，确保能安全装箱
• 生命周期'_绑定到&self，避免悬垂引用

2. 使用泛型替代 trait 对象 #

如果编译时就能确定所有可能的实现类型，用泛型参数代替 trait 对象，完全避免动态分发开销：

use std::future::Future;

trait ReturnsFutures {
    fn futuristic(&self) -> impl Future<Output = ()>;
}

struct FutureReturner {}

impl ReturnsFutures for FutureReturner {
    async fn futuristic(&self) {
        println!("just fake async");
    }
}

struct OtherFutureReturner {}

impl ReturnsFutures for OtherFutureReturner {
    async fn futuristic(&self) {
        println!("also fakin' it");
    }
}

// 用泛型参数约束实现类型，不需要trait对象
struct FuturisticService<T: ReturnsFutures> {
    future_returner: T,
}

适用场景：不需要在运行时切换不同子系统实现，所有使用场景的实现类型编译时已知。

3. 用枚举封装所有实现 #

如果实现类型数量有限且固定，定义枚举包裹所有变体，再为枚举实现目标 trait：

use std::future::Future;

trait ReturnsFutures {
    fn futuristic(&self) -> impl Future<Output = ()>;
}

struct FutureReturner {}

impl ReturnsFutures for FutureReturner {
    async fn futuristic(&self) {
        println!("just fake async");
    }
}

struct OtherFutureReturner {}

impl ReturnsFutures for OtherFutureReturner {
    async fn futuristic(&self) {
        println!("also fakin' it");
    }
}

// 枚举封装所有可能的实现类型
enum Returner {
    First(FutureReturner),
    Second(OtherFutureReturner),
}

impl ReturnsFutures for Returner {
    async fn futuristic(&self) {
        match self {
            Returner::First(r) => r.futuristic().await,
            Returner::Second(r) => r.futuristic().await,
        }
    }
}

struct FuturisticService {
    future_returner: Returner,
}

优点：兼顾静态分发的性能和有限范围内的动态切换，避免 trait 对象的运行时开销。

错误原因解析 #

Rust 要求 trait 对象必须满足对象安全，而原代码中返回impl Future的方法违反了这一规则：

• impl Future是不透明类型，每个 trait 实现返回的 future 具体类型都可能不同，无法在 trait 对象的虚表（vtable）中统一存储返回类型信息
• 对象安全的方法必须返回固定大小的类型，或者能被统一装箱的 trait 对象

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