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 from the standard library. The dependencies section should look like this:

ch10/a-rust-futures/src/runtime/reactor.rs
use mio::{net::TcpStream, Events, Interest, Poll, Registry, Token};
use std::{
    collections::HashMap,
    sync::{
        atomic::{AtomicUsize, Ordering},
        Arc, Mutex, OnceLock,
    },
    thread,
task::{Context, Waker},
};

There are two minor changes we need to make. The first one is that our set_waker function now accepts Context from which it needs to get a Waker object:

ch10/a-rust-futures/src/runtime/reactor.rs
pub fn set_waker(&self,
cx: &Context
, id: usize) {
        let _ = self
            .wakers
            .lock()
            .map(|mut w| w.insert(id,
cx.waker().clone()
).is_none())
            .unwrap();
    }

The last change is that we need to call a slightly different method when calling wake in the event_loop function:

ch10/a-rust-futures/src/runtime/reactor.rs
if let Some(waker) = wakers.get(&id) {
    waker.
wake_by_ref()
;
}

Since calling wake now consumes self, we call the version that takes &self instead since we want to hold on to that waker for later.

That’s it. Our runtime can now run and take advantage of the full power of asynchronous Rust. Let’s try it out by typing cargo run in the terminal.

We should get the same output as we’ve seen before:
Program starting
FIRST POLL – START OPERATION
main: 1 pending tasks.
Sleep until notified.
HTTP/1.1 200 OK
content-length: 15
[==== ABBREVIATED ====]
HelloAsyncAwait
main: All tasks are finished

That’s pretty neat, isn’t it?

So, now we have created our own async runtime that uses Rust’s Future, Waker, Context, and async/await.

Now that we can pride ourselves on being runtime implementors, it’s time to do some experiments. I’ll choose a few that will also teach us a few things about runtimes and futures in Rust. We’re not done learning just yet.