Rust中如何通过实现AsyncWriter或BlockingWriter满足Writer trait？

问题背景 #

在Rust中，我们可以轻松定义一个同时要求实现AsyncWriter和BlockingWriter的新trait：

pub trait Writer: AsyncWriter + BlockingWriter {}

但实际需求是只需实现上述两个trait中的任意一个，就能满足Writer约束。现有枚举方案存在明显痛点：

现有枚举方案的问题 #

1. 泛型枚举必须携带两种类型信息，即使只使用其中一种实现：

pub enum Writer<A: AsyncWriter, B: BlockingWriter> {
    Async(A),
    Blocking(B),
}

2. 使用dyn擦除类型的枚举仅适用于对象安全的trait，若改用Box<dyn T>则无法在无堆的嵌入式环境中使用：

pub enum Writer<'async, 'blocking> {
    Async(&'async dyn AsyncWriter),
    Blocking(&'blocking dyn BlockingWriter),
}

可行解决方案 #

1. 关联类型+默认实现的Trait设计（推荐） #

通过重新设计Writer trait，利用关联类型让实现者自主选择提供异步或阻塞写入能力，同时通过默认实现适配两种场景，无需额外类型参数，也不依赖堆分配：

pub trait AsyncWriter {
    async fn async_write(&mut self, buf: &[u8]) -> std::io::Result<usize>;
}

pub trait BlockingWriter {
    fn blocking_write(&mut self, buf: &[u8]) -> std::io::Result<usize>;
}

// 核心Writer trait，用关联类型标记可选实现
pub trait Writer {
    // 默认用空类型标记未实现的能力
    type Async: AsyncWriter = UnimplementedAsync;
    type Blocking: BlockingWriter = UnimplementedBlocking;

    // 获取异步写入器，默认返回None
    fn as_async(&mut self) -> Option<&mut Self::Async> {
        None
    }

    // 获取阻塞写入器，默认返回None
    fn as_blocking(&mut self) -> Option<&mut Self::Blocking> {
        None
    }
}

// 空类型，用于标记未实现的写入能力
#[derive(Debug)]
pub struct UnimplementedAsync;
impl AsyncWriter for UnimplementedAsync {
    async fn async_write(&mut self, _buf: &[u8]) -> std::io::Result<usize> {
        Err(std::io::Error::new(std::io::ErrorKind::Unsupported, "异步写入未实现"))
    }
}

#[derive(Debug)]
pub struct UnimplementedBlocking;
impl BlockingWriter for UnimplementedBlocking {
    fn blocking_write(&mut self, _buf: &[u8]) -> std::io::Result<usize> {
        Err(std::io::Error::new(std::io::ErrorKind::Unsupported, "阻塞写入未实现"))
    }
}

// 为所有AsyncWriter自动实现Writer
impl<T: AsyncWriter> Writer for T {
    type Async = T;

    fn as_async(&mut self) -> Option<&mut Self::Async> {
        Some(self)
    }
}

// 为所有BlockingWriter自动实现Writer
impl<T: BlockingWriter> Writer for T {
    type Blocking = T;

    fn as_blocking(&mut self) -> Option<&mut Self::Blocking> {
        Some(self)
    }
}

这种方案下，任何实现了AsyncWriter或BlockingWriter的类型都会自动成为Writer的实现者，调用方可以通过as_async/as_blocking判断并使用对应的写入能力。

2. 静态分发枚举（适配对象安全场景） #

如果坚持使用枚举且trait是对象安全的，可以实现一个统一接口的枚举，避免冗余类型参数：

pub enum Writer {
    Async(Box<dyn AsyncWriter>),
    Blocking(Box<dyn BlockingWriter>),
}

impl Writer {
    // 统一的写入方法，自动匹配异步/阻塞逻辑
    pub async fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        match self {
            Writer::Async(writer) => writer.async_write(buf).await,
            Writer::Blocking(writer) => Ok(writer.blocking_write(buf)?),
        }
    }
}

若需适配无堆环境，可将Box<dyn T>替换为&'static dyn T或自定义固定大小的静态存储结构，确保不依赖堆分配。

3. 分离类型（简单直接的备选） #

如果上述方案都不适用，分离成两个包装类型也是可行的，各自实现统一的写入接口：

pub struct AsyncWriterWrapper<A: AsyncWriter>(pub A);
pub struct BlockingWriterWrapper<B: BlockingWriter>(pub B);

// 统一的写入接口
pub trait Write {
    async fn write(&mut self, buf: &[u8]) -> std::io::Result<usize>;
}

impl<A: AsyncWriter> Write for AsyncWriterWrapper<A> {
    async fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        self.0.async_write(buf).await
    }
}

impl<B: BlockingWriter> Write for BlockingWriterWrapper<B> {
    async fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        Ok(self.0.blocking_write(buf)?)
    }
}

这种方案逻辑简单，但会增加类型数量，适合对代码复杂度要求较低的场景。

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