Yes, I know we could have chosen another way of doing this since we can take a reference to buffer everywhere we need to instead of storing it in its variable, but that’s only because our example is very simple. Imagine that we use a library that needs to borrow data that’s local to the async function and we somehow have to manage the lifetimes manually like we do here but in a much more complex scenario.

The self.stack.buffer.as_mut().unwrap() line returns a &mut reference to the buffer field. Since self.stack.writer is of the Option<*mut String> type, the reference will be coerced to a pointer (meaning that Rust does this cast implicitly by inferring it from the context).

Note

We take *mut String here since we deliberately don’t want a string slice (&str), which is often what we get (and want) when using a reference to a String type in Rust.

Let’s take a look at what happens after the first wait point:

ch09/b-coroutines-references/src/main.rs
State0::Wait1(ref mut f1) => {
                    match f1.poll(waker) {
                        PollState::Ready(txt) => {
                            // Restore stack
let writer = unsafe { &mut *self.stack.writer.take().unwrap() };
                            // —- Code you actually wrote —-
writeln!(writer, «{txt}»).unwrap();
                            // ———————————
                            let fut2 = Box::new(http::Http::get(“/400/HelloAsyncAwait”));
                            self.state = State0::Wait2(fut2);
                            // save stack
self.stack.writer = Some(writer);
                        }
                        PollState::NotReady => break PollState::NotReady,
                    }
                }

The first change we make is regarding how we restore our stack. We need to restore our writer variable so that it holds a &mut String type that points to our buffer. To do this, we have to write some unsafe code that dereferences our pointer and lets us take a &mut reference to our buffer.

Note

Casting a reference to a pointer is safe. The unsafe part is dereferencing the pointer.

Next, we add the line of code that writes the response. We can keep this the same as how we wrote it in our coroutine/wait function.

Lastly, we save the stack state back since we need both variables to live across the wait point.

Note

We don’t have to take ownership over the pointer stored in the writer field to use it since we can simply copy it, but to be somewhat consistent, we take ownership over it, just like we did in the first example. It also makes sense since if there is no need to store the pointer for the next await point, we can simply let it go out of scope by not storing it back.

The last part is when we’ve reached Wait2 and our future returns PollState::Ready:
State0::Wait2(ref mut f2) => {
                    match f2.poll(waker) {
                        PollState::Ready(txt) => {
                            // Restore stack
let buffer = self.stack.buffer.as_ref().take().unwrap();
                            let writer = unsafe { &mut *self.stack.writer.take().unwrap() };
                            // —- Code you actually wrote —-
writeln!(writer, «{txt}»).unwrap();
                            println!(“{}”, buffer);
                            // ———————————
                            self.state = State0::Resolved;
                  // Save stack / free resources
let _ = self.stack.buffer.take();
                            break PollState::Ready(String::new());
                        }
                        PollState::NotReady => break PollState::NotReady,
                    }
                }

In this segment, we restore both variables since we write the last response through our writer variable, and then print everything that’s stored in our buffer to the terminal.

I want to point out that the println!(“{}”, buffer); line takes a reference in the original coroutine/wait example, even though it might look like we pass in an owned String. Therefore, it makes sense that we restore the buffer to a &String type, and not the owned version. Transferring ownership would also invalidate the pointer in our writer variable.

The last thing we do is drop the data we don’t need anymore. Our self.stack.writer field is already set to None since we took ownership over it when we restored the stack at the start, but we need to take ownership over the String type that self.stack.buffer holds as well so that it gets dropped at the end of this scope too. If we didn’t do that, we would hold on to the memory that’s been allocated to our String until the entire coroutine is dropped (which could be much later).

Now, we’ve made all our changes. If the rewrites we did previously were implemented in corofy, our coroutine/wait implementation could, in theory, support much more complex use cases.

Let’s take a look at what happens when we run our program by writing cargo run:
Program starting
FIRST POLL – START OPERATION
main: 1 pending tasks.
Sleep until notified.
FIRST POLL – START OPERATION
main: 1 pending tasks.
Sleep until notified.
BUFFER:
—-
HTTP/1.1 200 OK
content-length: 15
connection: close
content-type: text/plain; charset=utf-8
date: Thu, 30 Nov 2023 22:48:11 GMT
HelloAsyncAwait
HTTP/1.1 200 OK
content-length: 15
connection: close
content-type: text/plain; charset=utf-8
date: Thu, 30 Nov 2023 22:48:11 GMT
HelloAsyncAwait
main: All tasks are finished

Puh, great. All that dangerous unsafe turned out to work just fine, didn’t it? Good job. Let’s make one small improvement before we finish.