如何编写可接收A或B trait对象的Rust函数？

现有分别接收&dyn A和&dyn B的函数ff、gg，想要编写一个能同时处理这两种 trait 对象的函数jj，以下是几种实用方案：

方案一：用枚举封装两种 trait 对象 #

通过枚举明确区分两种输入类型，逻辑直观且类型安全：

trait A {}
trait B {}

fn ff(arg: &dyn A) {}
fn gg(arg: &dyn B) {}

// 定义枚举包裹两种 trait 对象
enum EitherAB<'a> {
    A(&'a dyn A),
    B(&'a dyn B),
}

impl<'a> EitherAB<'a> {
    // 封装处理逻辑，调用对应的ff或gg
    fn process(&self) {
        match self {
            EitherAB::A(a) => ff(a),
            EitherAB::B(b) => gg(b),
        }
    }
}

// 目标函数接收枚举类型
fn jj(arg: EitherAB) {
    arg.process();
}

// 测试示例
struct ImplA;
impl A for ImplA {}

struct ImplB;
impl B for ImplB {}

fn main() {
    let a = ImplA;
    let b = ImplB;
    
    jj(EitherAB::A(&a));
    jj(EitherAB::B(&b));
}

这个方案的优点是边界清晰，后续扩展新类型只需新增枚举变体即可。

方案二：定义统一 trait 并实现适配 #

通过定义一个通用的处理 trait，让&dyn A和&dyn B都实现它，实现更简洁的调用：

trait A {}
trait B {}

fn ff(arg: &dyn A) {}
fn gg(arg: &dyn B) {}

// 定义通用处理 trait
trait Processable {
    fn process(&self);
}

// 为&dyn A实现Processable
impl Processable for &dyn A {
    fn process(&self) {
        ff(self);
    }
}

// 为&dyn B实现Processable
impl Processable for &dyn B {
    fn process(&self) {
        gg(self);
    }
}

// 目标函数接收统一的Processable trait对象
fn jj(arg: &dyn Processable) {
    arg.process();
}

// 测试示例
struct ImplA;
impl A for ImplA {}

struct ImplB;
impl B for ImplB {}

fn main() {
    let a = ImplA;
    let b = ImplB;
    
    jj(&&a as &dyn A);
    jj(&&b as &dyn B);
}

如果希望调用时无需显式转换为 trait 对象，可以改为为所有实现A/B的具体类型实现Processable：

// 为所有实现A的类型实现Processable
impl<T: A> Processable for T {
    fn process(&self) {
        ff(self as &dyn A);
    }
}

// 为所有实现B的类型实现Processable
impl<T: B> Processable for T {
    fn process(&self) {
        gg(self as &dyn B);
    }
}

// 调用更简洁
fn main() {
    let a = ImplA;
    let b = ImplB;
    
    jj(&a);
    jj(&b);
}

注意：如果有类型同时实现A和B，会出现编译歧义，需要手动指定实现逻辑。

方案三：泛型函数重载（适配具体类型） #

如果主要处理具体类型而非 trait 对象，可以用泛型重载实现：

trait A {}
trait B {}

fn ff(arg: &dyn A) {}
fn gg(arg: &dyn B) {}

// 处理实现A的类型
fn jj<T>(arg: &T)
where
    T: A + ?Sized,
{
    ff(arg);
}

// 重载处理实现B的类型
fn jj<T>(arg: &T)
where
    T: B + ?Sized,
{
    gg(arg);
}

// 测试示例
struct ImplA;
impl A for ImplA {}

struct ImplB;
impl B for ImplB {}

fn main() {
    let a = ImplA;
    let b = ImplB;
    
    jj(&a);
    jj(&b);
    
    // 如需处理trait对象，需显式转换
    jj(&&a as &dyn A);
    jj(&&b as &dyn B);
}

这个方案对具体类型调用友好，但处理 trait 对象时需要额外转换。

方案选择建议 #

• 若需严格区分两种 trait 对象且追求类型安全：优先选择枚举封装方案，逻辑清晰易扩展。
• 若希望调用简洁，且能接受少量转换代码：选择统一 trait 实现方案。
• 若主要处理具体类型而非 trait 对象：选择泛型重载方案。

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