Bring the Async Rust experience closer to parity with sync Rust

[nikomatsakis]

Metadata
Point of contact	@tmandry
Team(s)	compiler, lang, libs-api, spec, types
Goal document	2025h1/async

Summary

Over the next six months, we will continue bringing Async Rust up to par with "sync Rust" by doing the following:

• Telling a complete story for the use of async fn in traits, unblocking wide ecosystem adoption,
• Improving the ergonomics of Pin, which is frequently used in low-level async code, and
• Preparing to support asynchronous (and synchronous) generators in the language.

Why this goal?

This work continues our drive to improve support for async programming in Rust. In 2024H2 we stabilized async closures; explored the generator design space; and began work on the dynosaur crate, an experimental proc-macro to provide dynamic dispatch for async functions in traits. In 2025H1 our plan is to deliver (1) improved support for async-fn-in-traits, completely subsuming the functionality of the async-trait crate; (2) progress towards sync and async generators, simplifying the creation of iterators and async data streams; (3) and improve the ergonomics of Pin, making lower-level async coding more approachable. These items together start to unblock the creation of the next generation of async libraries in the wider ecosystem, as progress there has been blocked on a stable solution for async traits and streams.

Tasks and status

Overall program management

• AFIT story blog post (@tmandry)

Return type notation (rust-lang/rust#109417)

• Initial implementation (@compiler-errors)
• Author RFC (@nikomatsakis)
• RFC decision (lang )
• Finished implementation (@compiler-errors)
• Lang-team champion (lang )
• Standard reviews (types, compiler )
• Author stabilization report (@compiler-errors)
• Author specification 1st draft (@compiler-errors, @tmandry, @nikomatsakis)
• Finalize specification text (spec )
• Stabilization decision (lang, types )

Unsafe binders (rust-lang/rust#130516)

• Initial implementation (@compiler-errors)
• Author RFC (@nikomatsakis)
• Lang-team champion (lang )
• RFC decision (lang, types )

Implementable trait aliases

• Author RFC (@tmandry)
• Implementation (@compiler-errors)
• Lang-team champion (lang )
• Standard reviews (types, compiler )
• RFC decision (lang, types )

async fn in dyn Trait (rust-lang/rust#133119)

• Lang-team experiment (@nikomatsakis)
• Lang-team champion (lang )
• Implementation (@compiler-errors)

Pin ergonomics

• Implementation (@eholk)
• Author RFC (@eholk)
• Lang-team experiment (lang )
• Lang-team champion (lang )

Trait for generators (sync)

• Implementation (@eholk)
• Author RFC
• RFC decision (libs-api, lang )
• Design meeting (lang )
• Lang-team champion (lang )

Dynosaur 1.0

• Implementation (@spastorino)
• Standard reviews (@tmandry)

[nikomatsakis]

This issue is intended for status updates only.

For general questions or comments, please contact the owner(s) directly.

[tmandry]

Status update: July 30, 2024

Key developments

• Our project goal was merged :)
• Return type notation RFC was merged (RFC: Return Type Notation rfcs#3654)
• Async closures RFC is in final comment period (Async closures rfcs#3668)

Blockers

We are able to make some progress in each area, but the biggest upcoming blocker we can see is:

• Lang team deciding on final syntax for async closure bounds

Help wanted

There will be a call for testing async closures on the Inside Rust blog soon. Please check it out and give them a try in your own async code!

We'd like to see an updated RFC for implementable trait aliases that follows the guidelines laid out in this comment.

[nikomatsakis]

Executive summary.

We are generally on track with our marquee features: (1) Support for async closures is available on Nightly and the lang team arrived at a tentative consensus to keep the existing syntax (written rationale and formal decision are in progress). We issued a call for testing as well which has so far uncovered no issues. (2) Partial support for Return Type Notation is available on Nightly with the remainder under review. In addition, dynamic dispatch for async functions and experimental async drop work both made implementation progress. Async WG reorganization has made no progress.

Detailed updates

For this year's goal we are focused on three items:

• Stabilizing async closures:
  • The Async Closures RFC has been accepted and the feature is available for use on Nightly under the async_closure feature gate. We put out a call for testing; so far, no problems have been reported. Stabilization stalled because of a need to resolve the syntax. Lang team has reached a tentative internal consensus in favor of the syntax as implemented (impl async Fn). Next steps are (1) lang team to write up rationale and finalizing syntax decision; (2) author stabilization report.
• Resolving "Send Bounds" via Return Type Notation:
  • The Return Type Notation RFC has been accepted and partially implemented under the feature gate return_type_notation. Bounds like Trait<method(): Send> are available on Nightly; bounds like Trait::method(): Send will be available once PR #129629 is merged. Next steps are to (1) merge PR #129629; (2) call for testing; and (3) author stabilization report.
• Dyn dispatch for async functions in traits:
  • Async functions in traits were stabilized last year without support for dynamic dispatch. For this year we plan to release a procedural macro that can help users workaround this limitation; native support is planned for future years. The all important task of selecting a crate name was completed, with dynosaur being chosen. Basic support is now implemented (see this example). Next steps are polish and putting out a call for testing.
• Async drop experiments:
  • PRs with experimental implementation work for async drop are ready and awaiting review (PR list).

We have not made progress on Async WG reorganization.

[nikomatsakis]

Updates:

• Stabilizing async closures:
  • Lang team discussed syntax and reached preliminary consensus on async Fn, subject to also agreeing to include some of "async type" syntax. The rationale was documented in RFC: introduce the flavor syntactic design pattern rfcs#3710, which is now open and receiving feedback.
  • Next steps are for lang team to accept the RFC and to author stabilization report.
• Resolving "Send Bounds" via Return Type Notation:
  • A call for testing of RTN was issued and PR Implement Return Type Notation (RTN)'s path form in where clauses rust#129629 was merged.
  • Next steps is to author a stabilization report.
• Dyn dispatch for async functions in traits:
  • Preliminary implementation work on the dynosaur crate was done. Polish and public call for testing remain the next steps.
• Async drop experiments
  • There is a PR with pending work awaiting review. @nikomatsakis has agreed to review.
• Async WG reorganization.
  • No progress. A meeting was scheduled but deferred.

[tmandry]

Preliminary implementation work on the dynosaur crate was done. Polish and public call for testing remain the next steps.

The first version of dynosaur was published: https://docs.rs/dynosaur/latest/dynosaur/attr.dynosaur.html