Function argument implementing two traits

So let's take this code with two structs implementing two traits. How can I make a function that takes as argument any struct that implement both traits ?

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");
    }
}

Here is the solution I tried:

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);
}

But this throws an error: mismatched types expected mutable reference "&mut Box<(dyn RouterAndLibrary + 'static)> found struct Pair1.

As noted in the comments, you should probably favor generics instead of trait objects when possible. Statically-dispatched generics make this situation easy.

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

That's the easy solution, and generally you should favor generics when possibly.

If you truly need a dyn trait object, then you've already discovered the best way to do it. You can't require multiple traits in a trait object type (with the exception of Send and Sync, which are baked into the compiler), because the virtual dispatch table in the wide pointer is associated to a single trait. so we need to make a new trait that contains the right dispatch information. We can easily do that and provide a blanket implementation, as you've already discovered.

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

You just got a little carried away with Box. References themselves can contain unsized types, so your dyn solution would look like this.

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

In either case, we can call the function as

my_fn(&pair);

The former function signature will monomorphize, and the latter will automatically produce a trait object for us with no explicit cast required.