Make async code testable

This moves all non-trivial examples in the async part of the course to
self-contained Rust files. This ensures that we can test them in CI.

Author: mgeisler

Cargo.lock

@@ -23,6 +23,9 @@ members = [
   "src/std-traits",
   "src/std-types",
   "src/testing",
+  "src/concurrency/async",
+  "src/concurrency/async-control-flow",
+  "src/concurrency/async-pitfalls",
   "src/tuples-and-arrays",
   "src/types-and-values",
   "src/unsafe-rust",

Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "async-control-flow"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "join"
+path = "join.rs"
+
+[[bin]]
+name = "select"
+path = "select.rs"
+
+[dependencies]
+anyhow = "1.0.81"
+async-trait = "0.1.79"
+futures = { version = "0.3.30", default-features = false }
+reqwest = { version = "0.12.1", default-features = false }
+tokio = { version = "1.36.0", features = ["full"] }

src/concurrency/async-control-flow/Cargo.toml

@@ -7,31 +7,7 @@ minutes: 8
 Several crates have support for asynchronous channels. For instance `tokio`:
 
 ```rust,editable,compile_fail
-use tokio::sync::mpsc::{self, Receiver};
-
-async fn ping_handler(mut input: Receiver<()>) {
-    let mut count: usize = 0;
-
-    while let Some(_) = input.recv().await {
-        count += 1;
-        println!("Received {count} pings so far.");
-    }
-
-    println!("ping_handler complete");
-}
-
-#[tokio::main]
-async fn main() {
-    let (sender, receiver) = mpsc::channel(32);
-    let ping_handler_task = tokio::spawn(ping_handler(receiver));
-    for i in 0..10 {
-        sender.send(()).await.expect("Failed to send ping.");
-        println!("Sent {} pings so far.", i + 1);
-    }
-
-    drop(sender);
-    ping_handler_task.await.expect("Something went wrong in ping handler task.");
-}
+{{#include channels.rs}}
 ```
 
 <details>

src/concurrency/async-control-flow/channels.md

@@ -9,30 +9,7 @@ collection of their results. This is similar to `Promise.all` in JavaScript or
 `asyncio.gather` in Python.
 
 ```rust,editable,compile_fail
-use anyhow::Result;
-use futures::future;
-use reqwest;
-use std::collections::HashMap;
-
-async fn size_of_page(url: &str) -> Result<usize> {
-    let resp = reqwest::get(url).await?;
-    Ok(resp.text().await?.len())
-}
-
-#[tokio::main]
-async fn main() {
-    let urls: [&str; 4] = [
-        "https://google.com",
-        "https://httpbin.org/ip",
-        "https://play.rust-lang.org/",
-        "BAD_URL",
-    ];
-    let futures_iter = urls.into_iter().map(size_of_page);
-    let results = future::join_all(futures_iter).await;
-    let page_sizes_dict: HashMap<&str, Result<usize>> =
-        urls.into_iter().zip(results.into_iter()).collect();
-    println!("{:?}", page_sizes_dict);
-}
+{{#include join.rs}}
 ```
 
 <details>

src/concurrency/async-control-flow/join.md

@@ -0,0 +1,24 @@
+use anyhow::Result;
+use futures::future;
+use reqwest;
+use std::collections::HashMap;
+
+async fn size_of_page(url: &str) -> Result<usize> {
+    let resp = reqwest::get(url).await?;
+    Ok(resp.text().await?.len())
+}
+
+#[tokio::main]
+async fn main() {
+    let urls: [&str; 4] = [
+        "https://google.com",
+        "https://httpbin.org/ip",
+        "https://play.rust-lang.org/",
+        "BAD_URL",
+    ];
+    let futures_iter = urls.into_iter().map(size_of_page);
+    let results = future::join_all(futures_iter).await;
+    let page_sizes_dict: HashMap<&str, Result<usize>> =
+        urls.into_iter().zip(results.into_iter()).collect();
+    println!("{:?}", page_sizes_dict);
+}

src/concurrency/async-control-flow/join.rs

@@ -16,44 +16,7 @@ the resulting variables. The `statement` result becomes the result of the
 `select!` macro.
 
 ```rust,editable,compile_fail
-use tokio::sync::mpsc::{self, Receiver};
-use tokio::time::{sleep, Duration};
-
-#[derive(Debug, PartialEq)]
-enum Animal {
-    Cat { name: String },
-    Dog { name: String },
-}
-
-async fn first_animal_to_finish_race(
-    mut cat_rcv: Receiver<String>,
-    mut dog_rcv: Receiver<String>,
-) -> Option<Animal> {
-    tokio::select! {
-        cat_name = cat_rcv.recv() => Some(Animal::Cat { name: cat_name? }),
-        dog_name = dog_rcv.recv() => Some(Animal::Dog { name: dog_name? })
-    }
-}
-
-#[tokio::main]
-async fn main() {
-    let (cat_sender, cat_receiver) = mpsc::channel(32);
-    let (dog_sender, dog_receiver) = mpsc::channel(32);
-    tokio::spawn(async move {
-        sleep(Duration::from_millis(500)).await;
-        cat_sender.send(String::from("Felix")).await.expect("Failed to send cat.");
-    });
-    tokio::spawn(async move {
-        sleep(Duration::from_millis(50)).await;
-        dog_sender.send(String::from("Rex")).await.expect("Failed to send dog.");
-    });
-
-    let winner = first_animal_to_finish_race(cat_receiver, dog_receiver)
-        .await
-        .expect("Failed to receive winner");
-
-    println!("Winner is {winner:?}");
-}
+{{#include select.rs}}
 ```
 
 <details>

src/concurrency/async-control-flow/select.md

@@ -0,0 +1,38 @@
+use tokio::sync::mpsc::{self, Receiver};
+use tokio::time::{sleep, Duration};
+
+#[derive(Debug, PartialEq)]
+enum Animal {
+    Cat { name: String },
+    Dog { name: String },
+}
+
+async fn first_animal_to_finish_race(
+    mut cat_rcv: Receiver<String>,
+    mut dog_rcv: Receiver<String>,
+) -> Option<Animal> {
+    tokio::select! {
+        cat_name = cat_rcv.recv() => Some(Animal::Cat { name: cat_name? }),
+        dog_name = dog_rcv.recv() => Some(Animal::Dog { name: dog_name? })
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    let (cat_sender, cat_receiver) = mpsc::channel(32);
+    let (dog_sender, dog_receiver) = mpsc::channel(32);
+    tokio::spawn(async move {
+        sleep(Duration::from_millis(500)).await;
+        cat_sender.send(String::from("Felix")).await.expect("Failed to send cat.");
+    });
+    tokio::spawn(async move {
+        sleep(Duration::from_millis(50)).await;
+        dog_sender.send(String::from("Rex")).await.expect("Failed to send dog.");
+    });
+
+    let winner = first_animal_to_finish_race(cat_receiver, dog_receiver)
+        .await
+        .expect("Failed to receive winner");
+
+    println!("Winner is {winner:?}");
+}

src/concurrency/async-control-flow/select.rs

@@ -0,0 +1,24 @@
+[package]
+name = "async-pitfalls"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[[bin]]
+name = "async-traits"
+path = "async-traits.rs"
+
+[[bin]]
+name = "cancellation"
+path = "cancellation.rs"
+
+[[bin]]
+name = "pin"
+path = "pin.rs"
+
+[dependencies]
+anyhow = "1.0.81"
+async-trait = "0.1.79"
+futures = { version = "0.3.30", default-features = false }
+reqwest = { version = "0.12.1", default-features = false }
+tokio = { version = "1.36.0", features = ["full"] }

src/concurrency/async-pitfalls/Cargo.toml

@@ -20,48 +20,7 @@ The [async_trait] crate provides a workaround for `dyn` support through a macro,
 with some caveats:
 
 ```rust,editable,compile_fail
-use async_trait::async_trait;
-use std::time::Instant;
-use tokio::time::{sleep, Duration};
-
-#[async_trait]
-trait Sleeper {
-    async fn sleep(&self);
-}
-
-struct FixedSleeper {
-    sleep_ms: u64,
-}
-
-#[async_trait]
-impl Sleeper for FixedSleeper {
-    async fn sleep(&self) {
-        sleep(Duration::from_millis(self.sleep_ms)).await;
-    }
-}
-
-async fn run_all_sleepers_multiple_times(
-    sleepers: Vec<Box<dyn Sleeper>>,
-    n_times: usize,
-) {
-    for _ in 0..n_times {
-        println!("Running all sleepers...");
-        for sleeper in &sleepers {
-            let start = Instant::now();
-            sleeper.sleep().await;
-            println!("Slept for {} ms", start.elapsed().as_millis());
-        }
-    }
-}
-
-#[tokio::main]
-async fn main() {
-    let sleepers: Vec<Box<dyn Sleeper>> = vec![
-        Box::new(FixedSleeper { sleep_ms: 50 }),
-        Box::new(FixedSleeper { sleep_ms: 100 }),
-    ];
-    run_all_sleepers_multiple_times(sleepers, 5).await;
-}
+{{#include async-traits.rs}}
 ```
 
 <details>