So, in this chapter, we did two things. First, we made some rather minor changes to our runtime so it works as an actual runtime for Rust futures. We tested
Read MoreCategory: Improving our base example
The future of asynchronous Rust – Creating Your Own Runtime
Some of the things that make async Rust different from other languages are unavoidable. Asynchronous Rust is very efficient, has low latency, and is backed by a very strong type
Read MoreCommon traits that everyone agrees about – Creating Your Own Runtime
The last topic that causes friction in async Rust is the lack of universally agreed-upon traits and interfaces for typical async operations. I want to preface this segment by pointing
Read Morereactor.rs – Creating Your Own Runtime
The first thing we do is to make sure our dependencies are correct. We have to remove the dependency on our old Waker implementation and instead pull in these types
Read MoreINFO – Creating Your Own Runtime
This is an example of Rust adopting what turns out to be best practices from the ecosystem. For a long time, a popular way to construct wakers was by implementing
Read Moreexecutor.rs – Creating Your Own Runtime
The first thing we need to change in executor.rs is our dependencies. This time, we only rely on types from the standard library, and our dependencies section should now look
Read MoreSetting up our example – Creating Your Own Runtime
Note Even though we create a runtime to run futures properly in Rust, we still try to keep this simple by avoiding error handling and not focusing on making our
Read MorePinning to the stack – Coroutines, Self-Referential Structs, and Pinning
Pinning to the stack can be somewhat difficult. In Chapter 5, we saw how the stack worked and we know that it grows and shrinks as values are popped and
Read MorePinning to the heap – Coroutines, Self-Referential Structs, and Pinning
Note The small code snippets we’ll present here can be found in this book’s GitHub repository in the ch09/d-pin folder. The different examples are implemented as different methods that you
Read MoreDiscovering self-referential structs – Coroutines, Self-Referential Structs, and Pinning
What happened is that we created a self-referential struct, initialized it so that it took a pointer to itself, and then moved it. Let’s take a closer look: You’ve now
Read More