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 runtime more flexible. Improving our runtime is certainly possible, and while it can be a bit tricky at times to use the type system correctly and please the borrow checker, it has relatively little to do with async Rust and more to do with Rust being Rust.

Setting up our example

Tip

You’ll find this example in the book’s repository in the ch10/a-rust-futures folder.

We’ll continue where we left off in the last chapter, so let’s copy everything we had over to a new project:

1. Create a new folder called a-rust-futures.
2. Copy everything from the example in the previous chapter. If you followed the naming I suggested, it would be stored in the e-coroutines-pin folder.
3. You should now have a folder containing a copy of our previous example, so the last thing to do is to change the project name in Cargo.toml to a-rust-futures.

Okay, so let’s start with the program we want to run. Open main.rs.

main.rs

We’ll go back to the simplest version of our program and get it running before we try anything more complex. Open main.rs and replace all the code in that file with this:

ch10/a-rust-futures/src/main.rs
mod http;
mod runtime;
use crate::http::Http;
fn main() {
    let mut executor = runtime::init();
    executor.block_on(async_main());
}
async fn async_main() {
    println!(“Program starting”);
    let txt = Http::get(“/600/HelloAsyncAwait”).await;
    println!(“{txt}”);
    let txt = Http::get(“/400/HelloAsyncAwait”).await;
    println!(“{txt}”);
}

No need for corofy or anything special this time. The compiler will rewrite this for us.

Note

Notice that we’ve removed the declaration of the future module. That’s because we simply don’t need it anymore. The only exception is if you want to retain and use the join_all function we created to join multiple futures together. You can either try to rewrite that yourself or take a look in the repository and locate the ch10/a-rust-futures-bonus/src/future.rs file, where you’ll find the same version of our example, only this version retains the future module with a join_all function that works with Rust futures.

future.rs

You can delete this file altogether as we don’t need our own Future trait anymore.

Let’s move right along to http.rs and see what we need to change there.

http.rs

The first thing we need to change is our dependencies. We’ll no longer rely on our own Future, Waker, and PollState; instead, we’ll depend on Future, Context, and Poll from the standard library. Our dependencies should look like this now:

ch10/a-rust-futures/src/http.rs
use crate::runtime::{self, reactor};
use mio::Interest;
use std::{
    future::Future,
    io::{ErrorKind, Read, Write},
    pin::Pin,
    task::{Context, Poll},
};

We have to do some minor refactoring in the poll implementation for HttpGetFuture.

First, we need to change the signature of the poll function so it complies with the new Future trait:

ch10/a-rust-futures/src/http.rs
fn poll(mut self: Pin<&mut Self>,
cx: &mut Context
) ->
Poll<Self::Output>

Since we named the new argument cx, we have to change what we pass in to set_waker with the following:

ch10/a-rust-futures/src/http.rs
runtime::reactor().set_waker(
cx
, self.id);

Next, we need to change our future implementation so it returns Poll instead of PollState. To do that, locate the poll method and start by changing the signature so it matches the Future trait from the standard library:

ch10/a-rust-futures/src/http.rs
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) ->
Poll<Self::Output>

Next, we need to change our return types wherever we return from the function (I’ve only presented the relevant part of the function body here):

ch10/a-rust-futures/src/http.rs
loop {
            match self.stream.as_mut().unwrap().read(&mut buff) {
                Ok(0) => {
                    let s = String::from_utf8_lossy(&self.buffer).to_string();
                    runtime::reactor().deregister(self.stream.as_mut().unwrap(), id);
                    break
Poll::Ready(s.to_string())
;
                }
                Ok(n) => {
                    self.buffer.extend(&buff[0..n]);
                    continue;
                }
                Err(e) if e.kind() == ErrorKind::WouldBlock => {
                    // always store the last given Waker
                    runtime::reactor().set_waker(cx, self.id);
                    break
Poll::Pending
;
                }
                Err(e) => panic!(“{e:?}”),
            }
        }

That’s it for this file. Not bad, huh? Let’s take a look at what we need to change in our executor and open executor.rs.