Creating Your Own Runtime 258 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 My Waker : ch10/a-rust-futures/src/runtime/executor. rs impl Wake for My Waker { fn wake(self: Arc<Self>) { self. ready_queue . lock() . map(|mut q| q. push(self. id)) . unwrap(); self. thread. unpark(); } } Y ou'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 My Waker 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<My Waker> { Arc::new( My Waker { 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, {