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 a trait called ArcWake provided by the futures crate (https://github.com/rust-lang/futures-rs). The futures crate is not a part of the language but it’s in the rust-lang repository and can be viewed much like a toolbox and nursery for abstractions that might end up in the language at some point in the future.

To avoid confusion by having multiple things with the same name, let’s rename our concrete Waker type to MyWaker:

ch10/a-rust-futures/src/runtime/executor.rs
#[derive(Clone)]
pub struct
MyWaker
 {
    thread: Thread,
    id: usize,
    ready_queue: Arc<Mutex<Vec<usize>>>,
}

We can keep the implementation of wake pretty much the same, but we put it in the implementation of the Wake trait instead of just having a wake function on MyWaker:

ch10/a-rust-futures/src/runtime/executor.rs
impl Wake for MyWaker {
    fn wake(self: Arc<Self>) {
        self.ready_queue
            .lock()
            .map(|mut q| q.push(self.id))
            .unwrap();
        self.thread.unpark();
    }
}

You’ll notice that the wake function takes a self: Arc<Self> argument, much like we saw when working with the Pin type. Writing the function signature this way means that wake is only callable on MyWaker instances that are wrapped in Arc.

Since our waker has changed slightly, there are a few places we need to make some minor corrections. The first is in the get_waker function:

ch10/a-rust-futures/src/runtime/executor.rs
fn get_waker(&self, id: usize) ->
Arc<MyWaker>
 {
Arc::new(
MyWaker {
        id,
        thread: thread::current(),
        ready_queue: CURRENT_EXEC.with(|q| q.ready_queue.clone()),
    }
)
}

So, not a big change here. The only difference is that we heap-allocate the waker by placing it in Arc.

The next place we need to make a change is in the block_on function.

First, we need to change its signature so that it matches our new definition of a top-level future:

ch10/a-rust-futures/src/runtime/executor.rs
pub fn block_on<F>(&mut self, future: F)
    where
        F: Future<Output =
()
> + ‘static,
    {

The next step is to change how we create a waker and wrap it in a Context struct in the block_on function:

ch10/a-rust-futures/src/runtime/executor.rs
…
                // guard against false wakeups
                    None => continue,
                };
                let waker: Waker = self.get_waker(id).into();
                let mut cx = Context::from_waker(&waker);
                match future.as_mut().poll(&mut cx) {
…

This change is a little bit complex, so we’ll go through it step by step:

1. First, we get Arc<MyWaker> by calling the get_waker function just like we did before.
2. We convert MyWaker into a simple Waker by specifying the type we expect with let waker: Waker and calling into() on MyWaker. Since every instance of MyWaker is also a kind of Waker, this will convert it into the Waker type that’s defined in the standard library, which is just what we need.
3. Since Future::poll expects Context and not Waker, we create a new Context struct with a reference to the waker we just created.

The last place we need to make changes is to the signature of our spawn function so that it takes the new definition of top-level futures as well:

ch10/a-rust-futures/src/runtime/executor.rs
pub fn spawn<F>(future: F)
where
    F: Future<Output =
()
> + ‘static,

That was the last thing we needed to change in our executor, and we’re almost done. The last change we need to make to our runtime is in the reactor, so let’s go ahead and open reactor.rs.