如何编写接收同时实现两个Trait的结构体作为参数的Rust函数？

问题场景 #

现有两个结构体Pair1、Pair2，均实现了Router和Library两个Trait，需求是编写一个函数可以接收任何同时实现这两个Trait的结构体作为参数。尝试通过定义复合TraitRouterAndLibrary并为所有满足条件的类型自动实现该Trait，但调用函数时抛出类型不匹配错误：

mismatched types expected mutable reference "&mut Box<(dyn RouterAndLibrary + 'static)>" found struct Pair1

原Trait与结构体代码 #

pub trait Router {
    fn route(&self);
}

pub trait Library {
    fn do_math(&self);
}

pub struct Pair1 {}

impl Library for Pair1 {
    fn do_math(&self) {
        println!("Doing math");
    }
}

impl Router for Pair1 {
    fn route(&self) {
        println!("Routing");
    }
}

pub struct Pair2 {}

impl Library for Pair2 {
    fn do_math(&self) {
        println!("Doin math");
    }
}

impl Router for Pair2 {
    fn route(&self) {
        println!("Routin");
    }
}

尝试的错误解决方案代码 #

pub trait RouterAndLibrary: Router + Library {}
impl<T: Router + Library> RouterAndLibrary for T {}

pub fn my_fn(
    pair: &mut Box<dyn RouterAndLibrary>
) {
    println!("Hello");
}

pub fn wrapper_fn() {
    let pair = Pair1 {};
    my_fn(pair);
}

错误原因 #

my_fn的参数类型是&mut Box<dyn RouterAndLibrary>，但调用时直接传入了Pair1实例，两者类型完全不匹配：既没有用Box包裹实例，也没有传递可变引用类型。

解决方案 #

根据是否需要动态分发（即是否需要Trait对象的多态特性），有两种处理方式：

方案1：无需动态分发（推荐，性能更好） #

直接使用泛型约束，不需要额外的Trait对象，这种方式是编译时静态分发，性能更优。

可以直接用两个Trait的约束：

pub fn my_fn<T: Router + Library>(pair: T) {
    pair.do_math();
    pair.route();
    println!("Hello");
}

也可以用定义好的复合Trait作为约束：

pub trait RouterAndLibrary: Router + Library {}
impl<T: Router + Library> RouterAndLibrary for T {}

pub fn my_fn<T: RouterAndLibrary>(pair: T) {
    pair.do_math();
    pair.route();
    println!("Hello");
}

pub fn wrapper_fn() {
    let pair = Pair1 {};
    my_fn(pair); // 直接传入实例即可，类型完全匹配
}

方案2：需要动态分发（Trait对象） #

如果确实需要多态特性（比如要将不同类型的实例存入同一个数组或容器），则需要正确构造Box<dyn RouterAndLibrary>，并匹配函数的参数类型：

情况1：函数接收Box包裹的Trait对象

pub trait RouterAndLibrary: Router + Library {}
impl<T: Router + Library> RouterAndLibrary for T {}

pub fn my_fn(pair: Box<dyn RouterAndLibrary>) {
    pair.do_math();
    pair.route();
    println!("Hello");
}

pub fn wrapper_fn() {
    let pair = Pair1 {};
    my_fn(Box::new(pair)); // 用Box::new将实例包装成Trait对象
}

情况2：函数接收Box的可变引用（若业务需要）

如果函数必须操作可变的Trait对象引用：

pub trait RouterAndLibrary: Router + Library {}
impl<T: Router + Library> RouterAndLibrary for T {}

pub fn my_fn(pair: &mut Box<dyn RouterAndLibrary>) {
    pair.do_math();
    pair.route();
    println!("Hello");
}

pub fn wrapper_fn() {
    let mut pair_box = Box::new(Pair1 {});
    my_fn(&mut pair_box); // 传入Box的可变引用
}

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