async-trait | Type erasure for async trait methods | Reactive Programming library

A friend of mine figured out what the problem was:

The problem wasn't surf directly, but the tracing crate with the log feature enabled, on which surf indirectly depends. There is already an issue on github on it, but it's not yet resolved.

The problem gets triggered by matrix-sdk because it also uses tracing, but usually without the log feature. The line that triggers it is this:

You've declared init to take 2 generic parameters: T and E.

This means that the code that calls init has to provide the concrete types to fill in those parameters. For example, if someone was using your library, it would be totally feasible for them to write init::(), and your code should deal with that.

Because of that, when you define your impl DB for FavouritesDB, you write this:

The problem is, like explained by the compiler, that &impl NetFuncs may not necessarily impl Send but the async_recursion macro by default requires it, so, you have two options:

• Require impl NetFuncs to be Sync, so that &impl NetFuncs is Send. This can be done either with &(impl NetFuncs + Sync) or by requiring every implementor to implement Send: trait NetFuncs: Sync.
• Not requiring the resulting future to be Send. As documented in the async_recursion documentation, this can be done by changing #[async_recursion] to #[async_recursion(?Send)].

Without the macro it works since the compiler make the resulting future Send depend on whether all types kept across .await points are Send: if they are, the future is also Send. If they are not, it is not too. The macro changes the async fn to fn ...() -> Pin>, and unfortunately, it is not possible to have the same behavior as with async fn - this is something only the compiler can implement. Thus, the macro allows you to choose whether you want the resulting future to be Send - meaning all types should be too, or not.

You are trying to execute a directory "/volume/target/x86_64-unknown-linux-musl/release". I advise you use cargo install:

The concrete problem is that

You have to modify your Automobile definition:

From the async_trait documentation:

Async fns get transformed into methods that return Pin> and delegate to a private async freestanding function.

Not all async traits need futures that are dyn Future + Send. To avoid having Send and Sync bounds placed on the async trait methods, invoke the async trait macro as #[async_trait(?Send)] on both the trait and the impl blocks.

Applied to your case:

You've already recognized the problem: a reference to an object owned by the PluginManager is being moved into a future that is being spawned, and thus may run on another thread than the one which owns the PluginManager. The compiler cannot know that the future will not outlive the PluginManager.

There are a number of possible solutions to this, for example:

• Store the plugin instances inside Arc>, so that they are reference counted in runtime. Then even if the plugin manager did not live as long as the futures you are spawning, it would not matter

• Make the PluginManager an immutable static singleton

In this case I suspect you want the PluginManager to be a singleton. You can do that by replacing the new constructor with a get method that lazily constructs the instance and returns a reference to it:

While the type syn::Path is available when either the feature full or derive is enabled, some of the traits implemented for that type aren't.

In particular, as per syn's documentation of optional features, the extra-traits feature is required to get PartialEq:

extra-traits — Debug, Eq, PartialEq, Hash impls for all syntax tree types.

Therefore you only need adjust your Cargo.toml with