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
When creating HttpGetFuture, we don’t actually do anything related to the GET request, which means that the call to Http::get returns immediately with just a simple data structure. In contrast
In this module, we’ll implement a very simple HTTP client. This client can only make GET requests to our delayserver since we just use this as a representation of a
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,
In Chapter 5, we covered one of the most popular ways of modeling concurrency in a programming language: fibers/green threads. Fibers/green threads are an example of stackful coroutines. The other
I want to round off this chapter by pointing out some of the advantages and disadvantages of this approach, which we went through in Chapter 2, since we now have
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