The current async/await implementation in Rust, which was introduced in Rust 1.39, is a major improvement over the previous generations of Rust futures. However, there are still some limitations of the current async/await implementation which can be addressed in future versions of the language.
One of the main limitations of the current async/await implementation is that it is not yet possible to cancel an async task that is running in the background. This makes it hard to implement some use cases such as timeouts and cancellations, which can be important in real-world applications. To address this limitation, the Rust community is actively working on a mechanism to enable cancellation of async tasks. This mechanism will likely involve introducing a new Future trait, which incorporates some form of cancellation functionality.
Another limitation of the current async/await implementation is that it relies heavily on runtime systems such as Tokio or async-std to provide the underlying infrastructure for asynchronous IO. While these runtime systems provide a lot of powerful abstractions, they can also add significant overhead to Rust programs. To address this limitation, the Rust community is working on an async runtime system that is more lightweight and integrated with the language itself. This runtime system (tentatively called "Smol") will be tailored to low-level systems programming and high-performance networking, among other use cases.
A third limitation of the current async/await implementation is that it can be difficult to reason about parallelism and concurrency in a Rust program that uses async/await. For example, it can be hard to tell which operations are actually running in parallel and which are simply blocked on IO. To address this limitation, it may be helpful to introduce new language constructs that enable more fine-grained control over parallelism and concurrency. For example, the "Parallel Patterns" proposal aims to introduce new language constructs for explicitly parallel code, which may help developers reason about parallelism more effectively.
In summary, while the current async/await implementation in Rust is a significant improvement over the previous generations of Rust futures, there are still some limitations that can be addressed in future versions of the language. These include mechanisms for task cancellation, a more lightweight and integrated async runtime, and new language constructs for parallelism and concurrency. The Rust community is actively working on addressing these limitations, and we can expect to see many improvements in future versions of the language.