Let’s start by expanding our example slightly. Now that we have a program that writes out our state machines, it’s easier for us to create some examples and cover some more complex parts of our coroutine implementation.
We’ll base the following examples on the exact same code as we did in the first one. In the repository, you’ll find this example under ch07/b-async-await.
If you write every example from the book and don’t rely on the existing code in the repository, you can do one of two things:
- Keep changing the code in the first example
- Create a new cargo project called b-async-await and copy everything in the src folder and the dependencies section from Cargo.toml from the previous example over to the new one.
No matter what you choose, you should have the same code in front of you.
Let’s simply change the code in main.rs to this:
ch07/b-async-await/src/main.rs
use std::time::Instant;
mod http;
mod future;
use future::*;
use crate::http::Http;
fn get_path(i: usize) -> String {
format!(“/{}/HelloWorld{i}”, i * 1000)
}
coroutine fn async_main() {
println!(“Program starting”);
let txt = Http::get(&get_path(0)).wait;
println!(“{txt}”);
let txt = Http::get(&get_path(1)).wait;
println!(“{txt}”);
let txt = Http::get(&get_path(2)).wait;
println!(“{txt}”);
let txt = Http::get(&get_path(3)).wait;
println!(“{txt}”);
let txt = Http::get(&get_path(4)).wait;
println!(“{txt}”);
}
fn main() {
let start = Instant::now();
let mut future = async_main();
loop {
match future.poll() {
PollState::NotReady => (),
PollState::Ready(_) => break,
}
}
println!(“\nELAPSED TIME: {}”, start.elapsed().as_secs_f32());
}
This code contains a few changes. First, we add a convenience function for creating new paths for our GET request called get_path to create a path we can use in our GET request with a delay and a message based on the integer we pass in.
Next, in our async_main function, we create five requests with delays varying from 0 to 4 seconds.
The last change we’ve made is in our main function. We no longer print out a message on every call to poll, and therefore, we don’t use thread::sleep to limit the number of calls. Instead, we measure the time from when we enter the main function to when we exit it because we can use that as a way to prove whether our code runs concurrently or not.
Now that our main.rs looks like the preceding example, we can use corofy to rewrite it into a state machine, so assuming we’re in the root folder of ch07/b-async-await, we can write the following:
corofy ./src/main.rs
That should output a file called main_corofied.rs in the src folder that you can open and inspect.
Now, you can copy all the contents of main_corofied.rs in this file and paste it into main.rs.