Rust structs that have Box fields and that impl async traits

Question

I'm running into an issue with structs that have Box fields and that impl async traits. Specifically

error: future cannot be sent between threads safely

It looks like the error occurs because I use a Box field in a struct that impl's an async trait.

The following is a minimal example of what I'm trying to accomplish and the issue I'm running into. You can find a playground of it here.

use async_trait::async_trait;

// My traits
#[async_trait]
pub trait InnerTrait {
    async fn inner_fn(&self) -> Result<(), ()>;
}

#[async_trait]
pub trait OuterTrait {
    async fn outer_fn(&self) -> Result<(), ()>;
}

// My structs
pub struct InnerStruct {}

impl InnerStruct {
    pub fn new() -> impl InnerTrait {
        InnerStruct {}
    }
}

pub struct OuterStruct {
    inner_trait: Box<dyn InnerTrait>,
}

impl OuterStruct {
    pub fn new(inner_trait: Box<dyn InnerTrait>) -> impl OuterTrait {
        OuterStruct { inner_trait }
    }
}

// My trait impls
#[async_trait]
impl InnerTrait for InnerStruct {
    async fn inner_fn(&self) -> Result<(), ()> {
        println!("InnerStruct.inner_fn");
        Ok(())
    }
}

#[async_trait]
impl OuterTrait for OuterStruct {
    async fn outer_fn(&self) -> Result<(), ()> {
        println!("OuterStruct.outer_fn");
        self.inner_trait.inner_fn().await;
        Ok(())
    }
}

#[tokio::main]
async fn main() {
    let inner_trait: Box<dyn InnerTrait> = Box::new(InnerStruct::new());
    let outter_trait: Box<dyn OuterTrait> = Box::new(OuterStruct::new(inner_trait));
    outter_trait.outer_fn().await;
}

First, how do I solve this issue?

And second, I'm essentially trying to write traits for structs so that the impl'ing structs can be easily swapped out with others, similarly to how I might write interfaces for objects in Java. I realize this is probably not the way I should be thinking about component design in Rust but I'm a beginner and not sure what's the correct way to approach trait-based design. If this is not idiomatic Rust, how would you redesign this so that it still accomplishes the design goal (create and use traits up and down the stack to allow easy impl swapping)?

Thanks.

Answer 1

Some type are safe to send between threads and some others are not. The way this is expressed in Rust is by whether or not the type implements the Send trait. There is another trait, Sync, which marks that a type is safe to share between threads by reference.

To express that your trait object must be safe to send, you can add a constraint:

pub struct OuterStruct {
    inner_trait: Box<dyn InnerTrait + Send>,
}

However, OuterStruct contains a reference to a the InnerTrait object so, if OuterStruct is sent between threads, the reference to the trait object inside is being shared at the same time. Therefore, for OuterStruct to be Send, the implementation if InnerTrait must be Sync.

So it needs to be:

pub struct OuterStruct {
    inner_trait: Box<dyn InnerTrait + Sync + Send>,
}

You'll need to add those constraints everywhere that the trait object type is used.

Answer 2

Async fns get transformed by async_trait into the following:

fn your_function<'async_trait>(
        &'async_trait self,
    ) -> Pin<Box<dyn std::future::Future<Output = ()> + Send + 'async_trait>>
    where
        Self: Sync + 'async_trait,

Note the Send and Sync requirements, which tells the compiler that the future can be transferred and shared between threads. This is useful if you are using a multi-threaded executor like tokio.

If you do not need thread-safe futures, you can avoid having Send and Sync bounds placed on the async trait methods by using #[async_trait(?Send)]:

#[async_trait(?Send)]
pub trait InnerTrait {
    async fn inner_fn(&self) -> Result<(), ()>;
}

#[async_trait(?Send)]
impl InnerTrait for InnerStruct {
    async fn inner_fn(&self) -> Result<(), ()> {
        println!("InnerStruct.inner_fn");
        Ok(())
    }
}

On the other hand, if you need thread-safe futures, you can add the Send and Sync bounds to your structs which will fulfill async_trait future requirements:

pub struct OuterStruct {
    inner_trait: Box<dyn InnerTrait + Send + Sync>,
}