Technical requirements 259 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<My Waker> by calling the get_waker function just like we did before. 2. We convert My Waker into a simple Waker by specifying the type we expect with let waker: Waker and calling into() on My Waker. Since every instance of My Waker 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. reactor. rs 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: