Let’s set everything up for our next version of this example:

• Create a new folder called b-coroutines-references and copy everything from a-coroutines-variables over to it
• You can change the name of the project so that it corresponds with the folder by changing the name attribute in the package section in Cargo.toml, but it’s not something you need to do for the example to work

Note

You can find this example in this book’s GitHub repository in the ch10/b-coroutines-references folder.

This time, we’ll learn how to store references to variables in our coroutines by using the following coroutine/wait example program:
use std::fmt::Write;
coroutine fn async_main() {
let mut buffer = String::from(
“
\nBUFFER:\n—-\n
“
);
    let writer = &mut buffer;
    println!(“Program starting”);
    let txt = http::Http::get(“/600/HelloAsyncAwait”).wait;
writeln!(writer,
“
{txt}
“
).unwrap();
    let txt = http::Http::get(“/400/HelloAsyncAwait”).wait;
writeln!(writer,
“
{txt}
“
).unwrap();
println!(
“
{}
“
, buffer);
}

So, in this example, we create a buffer variable of the String type that we initialize with some text, and we take a &mut reference to that and store it in a writer variable.

Every time we receive a response, we write the response to the buffer through the &mut reference we hold in writer before we print the buffer to the terminal at the end of the program.

Let’s take a look at what we need to do to get this working.

The first thing we do is pull in the fmt::Write trait so that we can write to our buffer using the writeln! macro.

Add this to the top of main.rs:

ch09/b-coroutines-references/src/main.rs
use std::fmt::Write;

Next, we need to change our Stack0 struct so that it represents what we must store across wait points in our updated example:

 ch09/b-coroutines-references/src/main.rs
#[derive(Default)]
struct Stack0 {
    buffer: Option<String>,
    writer: Option<*mut String>,
}

An important thing to note here is that writer can’t be Option<&mut String> since we know it will be referencing the buffer field in the same struct. A struct where a field takes a reference on &self is called a self-referential struct and there is no way to represent that in Rust since the lifetime of the self-reference is impossible to express.

The solution is to cast the &mut self-reference to a pointer instead and ensure that we manage the lifetimes correctly ourselves.

The only other thing we need to change is the Future::poll implementation:

ch09/b-coroutines-references/src/main.rs
State0::Start => {
                    // initialize stack (hoist variables)
                    self.stack.buffer = Some(String::from(“\nBUFFER:\n—-\n”));
                    self.stack.writer = Some(self.stack.buffer.as_mut().unwrap());
                    // —- Code you actually wrote —-
                    println!(“Program starting”);
                    // ———————————
                    let fut1 = Box::new(http::Http::get(“/600/HelloAsyncAwait”));
                    self.state = State0::Wait1(fut1);
                    // save stack
                }

Okay, so this looks a bit odd. The first line we change is pretty straightforward. We initialize our buffer variable to a new String type, just like we did at the top of our coroutine/wait program.

The next line, however, looks a bit dangerous.

We cast the &mut reference to our buffer to a *mut pointer.