Rust库开发：如何避免用户为第三方异步通道编写trait包装器？

我正在开发一个Rust库，该库需要异步mpsc通道，但不想依赖特定的async运行时（如tokio、smol），因此让用户自行选择运行时。我定义了如下trait：

struct Job { ... }

trait Sender {
    fn send(&mut self, job: Job);
}

trait Receiver {
    fn recv(&mut self) -> Future<Output = Option<Job>>;
}

fn foo(tx: impl Sender, rx: impl Receiver) {
    // ...
}

然而库的使用者必须为实际使用的运行时创建大量包装器，例如使用tokio时：

// 必须创建包装器，因为`mylib::Sender`和`tokio::Sender`都来自第三方库，无法直接为`tokio::Sender`实现`mylib::Sender`

struct TokioSender(tokio::Sender);
struct TokioReceiver(tokio::Receiver);

impl mylib::Sender for TokioSender { ... }
impl mylib::Receiver for TokioReceiver { ... }


// 最终才能调用库函数
fn run() {
    ...
    let (tx, rx) = tokio::channel();
    mylib::foo(TokioSender(tx), TokioReceiver(rx));
    ...
}

若trait包含大量方法，编写包装器会非常繁琐。在Go语言中，若类型T拥有接口I定义的所有方法，则T会自动实现I，无需额外操作即可作为I类型传递。请问在Rust中是否有类似的隐式实现方式，让符合trait方法的类型自动实现该trait以避免包装器？或者有其他可行的解决办法？

Rust没有Go语言那种自动隐式实现接口的机制，核心原因是孤儿规则：只能为以下场景实现trait：要么trait是你定义的，要么被实现的类型是你定义的。这就是无法直接为tokio的通道类型实现自定义trait的根本原因。不过有几种可行的替代方案：

1. 提供自动生成包装器的宏 #

为了减少用户编写重复包装代码的工作量，可以在库中定义宏，自动生成包装结构体和对应的trait实现。示例如下：

#[macro_export]
macro_rules! impl_sender_wrapper {
    ($wrapper_name:ident, $inner_type:ty) => {
        pub struct $wrapper_name($inner_type);

        impl $wrapper_name {
            pub fn new(inner: $inner_type) -> Self {
                Self(inner)
            }
        }

        impl $crate::Sender for $wrapper_name {
            fn send(&mut self, job: $crate::Job) {
                // 根据实际运行时的send方法签名调整逻辑，比如处理返回的Future
                let _ = self.0.send(job).await;
            }
        }
    };
}

// 同理为Receiver编写类似的宏

用户使用时只需一行代码就能生成所需的包装器：

mylib::impl_sender_wrapper!(TokioSender, tokio::sync::mpsc::Sender<mylib::Job>);
mylib::impl_receiver_wrapper!(TokioReceiver, tokio::sync::mpsc::Receiver<mylib::Job>);

2. 依赖中立的通道抽象库 #

直接使用社区中已有的运行时中立通道库，比如async-channel。它不绑定任何特定运行时，同时兼容tokio、smol等主流异步运行时。你可以在库中直接使用async-channel的Sender和Receiver类型，用户可以轻松将各自运行时的通道适配到async-channel，或者直接使用该库的通道实现。

3. 调整trait设计以支持适配 #

重新设计trait，让其方法签名对齐主流运行时的通道方法，同时利用泛型来兼容不同的返回类型。例如：

trait AsyncSender {
    type SendFuture: Future<Output = Result<(), ()>>;
    fn send(&mut self, job: Job) -> Self::SendFuture;
}

trait AsyncReceiver {
    type RecvFuture: Future<Output = Option<Job>>;
    fn recv(&mut self) -> Self::RecvFuture;
}

这样用户可以更轻松地为目标运行时的通道类型实现这些trait，或者你可以为常见运行时提供预定义的适配（如果允许依赖可选特性的话）。

4. 谨慎使用trait对象 #

如果场景允许动态分发，可以将trait改为对象安全的形式，使用dyn Sender这样的 trait 对象来传递实例。例如调整trait定义：

trait Sender: Send {
    fn send(&mut self, job: Job) -> Box<dyn Future<Output = ()> + Send + '_>;
}

这种方式会带来一定的性能开销（动态分发），适合对性能要求不高的场景。

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