The first thing we need to do is pull in Pin from the standard library. The start of the file should look like this:

ch09/e-coroutines-pin/src/http.rs
use crate::{future::PollState, runtime::{self, reactor, Waker}, Future};
use mio::Interest;
use std::{io::{ErrorKind, Read, Write}, pin::Pin};

The only other place we need to make some changes is in the Future implementation for HttpGetFuture, so let’s locate that. We’ll start by changing the arguments in poll:

ch09/e-coroutines-pin/src/http.rs
fn poll(
mut self: Pin<&mut Self>
, waker: &Waker) -> PollState<Self::Output>

Since self is now Pin<&mut Self>, there are several small changes we need to make so that the borrow checker stays happy. Let’s start from the top:

ch09/e-coroutines-pin/src/http.rs
let id = self.id;
        if self.stream.is_none() {
            println!(“FIRST POLL – START OPERATION”);
            self.write_request();
            let stream =
(&mut self)
.stream.as_mut().unwrap();
            runtime::reactor().register(stream, Interest::READABLE,
id
);
            runtime::reactor().set_waker(waker, self.id);
        }

The reason for assigning id to a variable at the top is that the borrow checker gives us some minor trouble when trying to pass in both &mut self and &self as arguments to the register/deregister functions, so we just assign id to a variable at the top and everyone is happy.

There are only two more lines to change, and that is where we create a String type from our internal buffer and deregister interest with the reactor:

ch09/e-coroutines-pin/src/http.rs
let s = String::from_utf8_lossy(&self.buffer)
.to_string()
;
runtime::reactor().deregister(self.stream.as_mut().unwrap(),
id
);
break PollState::Ready(
s
);

Important

Notice that this future is Unpin. There is nothing that makes it unsafe to move HttpGetFuture around, and this is indeed the case for most futures like this. Only the ones created by async/await are self-referential by design. That means there is no need for any unsafe here.

Next, let’s move on to main.rs since there are some important changes we need to make there.

Main.rs

Let’s start from the top and make sure we have the correct imports:

ch09/e-coroutines-pin/src/main.rs
mod future;
mod http;
mod runtime;
use future::{Future, PollState};
use runtime::Waker;
use std::{fmt::Write,
marker::PhantomPinned, pin::Pin
};

This time, we need both the PhantomPinned marker and Pin.

The next thing we need to change is in our State0 enum. The futures we hold between states are now pinned:

ch09/e-coroutines-pin/src/main.rs
 Wait1(Pin<Box<dyn Future<Output = String>>>),
 Wait2(Pin<Box<dyn Future<Output = String>>>),

Next up is an important change. We need to make our coroutines !Unpin so that they can’t be moved once they have been pinned. We can do this by adding a marker trait to our Coroutine0 struct:

ch09/e-coroutines-pin/src/main.rs
struct Coroutine0 {
    stack: Stack0,
    state: State0,
_pin: PhantomPinned,
}

We also need to add the PhantomPinned marker to our new function:

ch09/e-coroutines-pin/src/main.rs
impl Coroutine0 {
    fn new() -> Self {
        Self {
            state: State0::Start,
            stack: Stack0::default(),
_pin: PhantomPinned,
        }
    }
}

The last thing we need to change is the poll method. Let’s start with the function signature:

ch09/e-coroutines-pin/src/main.rs
fn poll(
self: Pin<&mut Self>
, waker: &Waker) -> PollState<Self::Output>

The easiest way I found to change our code was to simply define a new variable at the very top of the function called this, which replaces self everywhere in the function body.

I won’t go through every line since the change is so trivial, but after the first line, it’s a simple search and replace everywhere self was used earlier, and change it to this:

ch09/e-coroutines-pin/src/main.rs
let this = unsafe { self.get_unchecked_mut() };
        loop {
            match
this.state
 {
                State0::Start => {
                    // initialize stack (hoist declarations – no stack yet)             
this
.stack.buffer = Some(String::from(“\nBUFFER:\n—-\n”));              
this
.stack.writer = Some(
this
.stack.buffer.as_mut().unwrap());
                    // —- Code you actually wrote —-
                    println!(“Program starting”);
…

The important line here was let this = unsafe { self.get_unchecked_mut() };. Here, we had to use unsafe since the pinned value is !Unpin because of the marker trait we added.

Getting to the pinned value is unsafe since there is no way for Rust to guarantee that we won’t move the pinned value.

The nice thing about this is that if we encounter any such problems later, we know we can search for the places where we used unsafe and that the problem must be there.

The next thing we need to change is to have the futures we store in our wait states pinned. We can do this by calling Box::pin instead of Box::new:

ch09/e-coroutines-pin/src/main.rs
let fut1 = Box::
pin
(http::Http::get(“/600/HelloAsyncAwait”));
let fut2 = Box::
pin
(http::Http::get(“/400/HelloAsyncAwait”));

The last place in main.rs where we need to make changes is in the locations where we poll our child futures since we now have to go through the Pin type to get a mutable reference:

ch09/e-coroutines-pin/src/main.rs
match f1
.as_mut()
.poll(waker)
match f2
.as_mut()
.poll(waker)

Note that we don’t need unsafe here since these futures are !Unpin.

The last place we need to change a few lines of code is in executor.rs, so let’s head over there as our last stop.