The first thing we need to change in executor.rs is our dependencies. This time, we only rely on types from the standard library, and our dependencies section should now look like this:

ch10/a-rust-futures/src/runtime/executor.rs
use std::{
    cell::{Cell, RefCell},
    collections::HashMap,
future::Future
,
    pin::Pin,
    sync::{Arc, Mutex},
task::{Poll, Context, Wake, Waker},
    thread::{self, Thread},
};

Our coroutines will no longer be limited to only output String, so we can safely use a more sensible Output type for our top-level futures:

ch10/a-rust-futures/src/runtime/executor.rs
type Task = Pin<Box<dyn Future<Output =
()
>>>;

The next thing we’ll dive straight into is Waker since the changes we make here will result in several other changes to this file.

Creating a waker in Rust can be quite a complex task since Rust wants to give us maximum flexibility on how we choose to implement wakers. The reason for this is twofold:

• Wakers must work just as well on a server as it does on a microcontroller
• A waker must be a zero-cost abstraction

Realizing that most programmers never need to create their own wakers, the cost that the lack of ergonomics has was deemed acceptable.

Until quite recently, the only way to construct a waker in Rust was to create something very similar to a trait object without being a trait object. To do so, you had to go through quite a complex process of constructing a v-table (a set of function pointers), combining that with a pointer to the data that the waker stored, and creating RawWaker.

Fortunately, we don’t actually have to go through this process anymore as Rust now has the Wake trait. The Wake trait works if the Waker type we create is placed in Arc.

Wrapping Waker in an Arc results in a heap allocation, but for most Waker implementations on the kind of systems we’re talking about in this book, that’s perfectly fine and what most production runtimes do. This simplifies things for us quite a bit.