Traits with async methods can be used as trait objects as long as they meet the

usual requirements for dyn -- no methods with type parameters, no self by value,

no associated types, etc.

#[async_trait]

pub trait ObjectSafe {

async fn f(&self);

async fn g(&mut self);

}

impl ObjectSafe for MyType {...}

let value: MyType = ...;

let object = &value as &dyn ObjectSafe; // make trait object

The one wrinkle is in traits that provide default implementations of async

methods. In order for the default implementation to produce a future that is

Send, the async\_trait macro must emit a bound of `Self: Sync` on trait methods

that take `&self` and a bound `Self: Send` on trait methods that take `&mut

self`. An example of the former is visible in the expanded code in the

explanation section above.

If you make a trait with async methods that have default implementations,

everything will work except that the trait cannot be used as a trait object.

Creating a value of type `&dyn Trait` will produce an error that looks like

this:

For traits that need to be object safe and need to have default implementations

for some async methods, there are two resolutions. Either you can add Send

and/or Sync as supertraits (Send if there are `&mut self` methods with default

implementations, Sync if there are `&self` methods with default implementations)

to constrain all implementors of the trait such that the default implementations

are applicable to them:

#[async_trait]

pub trait ObjectSafe: Sync { // added supertrait

async fn can_dyn(&self) {}

}

let object = &value as &dyn ObjectSafe;

or you can strike the problematic methods from your trait object by bounding

them with `Self: Sized`:

#[async_trait]

pub trait ObjectSafe {

async fn cannot_dyn(&self) where Self: Sized {}

// presumably other methods

}

let object = &value as &dyn ObjectSafe;

<br>