futures-await

> Async/await is releasing next year, hopefully in Q1. This will simplify future asyncio development and make it much more legible I started using some of the async/await syntax using https://github.com/alexcrichton/futures-await about 6 months ago. I had much problems with understanding the compiler errors because async functions were created using macros, and the compiler was not going a very good job at showing the errors (Or maybe I was missing some information about how to do this). However, if you are willing to work with nightly Rust, you will be able to start using Futures 0.3 with async and await!. Using the async and await! syntax gave me such a huge boost to productivity that I am willing to walk on the edge and use the alpha version with nightly Rust (futures-preview = "0.3.0-alpha.10"). The integration with things like clock

We did implement it out of tree at first. [0] Because Rust requires annotations on macros to distinguish them from built in syntax, they are less ergonomic to use. In general, we believe in adopting a path of beginning as an out-of-tree macro, and then deciding to elevate that to first class syntax if its clear that they will be extremely commonly used. [0]: https://github.com/alexcrichton/futures-await

Pretty much like your good old sync code. Some examples how it might look like you can read from the async/await macro crate [0], somebody might be able to provide more recent examples... [0] https://github.com/alexcrichton/futures-await

the effort to add async/await to Rust is ongoing, with an experimental RFC [1]. There is also a working implementation using procedural macros [2]. [1] https://github.com/rust-lang/rfcs/pull/2033 [2] https://github.com/alexcrichton/futures-await

Nightly rust can use this async / await crate, but it will likely be deprecated once language support is available (later this year iirc) https://github.com/alexcrichton/futures-await/blob/master/RE...

> You would be crazy to write a UI-heavy app in rust. (note: I'm talking about high level DOM-like manipulation, not about rendering engines) I think the jury is still out on that one. I agree with the current state of things but the potential to ease and facilitate this is tremendous through the use of syntax extensions (procedural macros) which can dramatically simplify that use case. In general I think procedural macros add a _lot_ of versatility/flexibility to the language. I anticipate that there will be a huge boom in that area once they stabilize, and it will catch many people by surprise. An example of the versatility that they enable is the work-in-progress async/await [0], whereas in other languages they would usually have to be implemented in the language itself. Note that this does not preclude their implementation in the lang

There's a ton of work being done at the compiler level to make Tokio more pleasant. This includes: 1. async/await. This is analogous to async/await in C# and ES6, and should make the syntax a lot nicer. https://github.com/alexcrichton/futures-await 2. Coroutines. This is the supporting technology for async/await. https://github.com/rust-lang/rfcs/blob/master/text/2033-expe... 3. 'impl Trait'. This provides a way to say, "Look, my return type implements 'Trait', but the actual type declaration is way to tedious to write out, and anyway, it's private. This will help a lot with cleaning up complex Tokio types. https://github.com/rust-lang/rfcs/blob/master/text/1522-cons... At work, we use Rust, but we're avoiding using Tokio until these features land.