We’ll continue to build our knowledge and understanding from the ground up. The first thing we’ll do is create a task that we can stop and resume by modeling it
A lazy future is one where no work happens before it’s polled the first time. This will come up a lot if you read about futures in Rust, and since
Most often you’ll see stackless coroutines simply referred to as coroutines. To try to keep some consistency (you remember I don’t like to introduce terms that mean different things based
Now that you’ve gotten a brief introduction to Rust’s async model, it’s time to take a look at how this fits in the context of everything else we’ve covered in
Rust only provides what’s necessary to model asynchronous operations in the language. Basically, it provides the following: That’s really what Rust’s standard library does. As you see there is no
I find it easier to reason about how futures work by creating a high-level mental model we can use. To do that, I have to introduce the concept of a
Leaf futures Runtimes create leaf futures, which represent a resource such as a socket. This is an example of a leaf future:let mut stream = tokio::net::TcpStream::connect(“127.0.0.1:3000”); Operations on these resources,
Note I promised to point out where we close the impl Runtime block, and we do that after the spawn function. The upcoming functions are “free” functions that don’t belong
We need to explain the new concepts we introduced here. The assembly calls the function switch (the function is tagged with #[no_mangle] so we can call it by name). The
yield is a reserved word in Rust, so we can’t name our function that. If that was not the case, it would be my preferred name for it over the