Chapter review: streaming replies

The program prints: bye, Sam! Calling save only makes a future, a recipe for the work, and nothing ever awaits it, so it is thrown away uncooked and saving never prints. A forgotten .await is not an error; the work silently never happens. Lesson 10.1 has the recipe-and-meal picture.

It does not compile: E0373. A spawned task may run on after the code that started it is gone, so tokio will not let it borrow anything. Here the block only borrows banner, and the compiler says the async block may outlive the function. async move hands the task its own banner and it compiles (lesson 10.2).

error[E0373]: async block may outlive the current function, but it borrows `banner`, which is owned by the current function
 --> src/main.rs:4:29
  |
4 |     let task = tokio::spawn(async {
  |                             ^^^^^ may outlive borrowed value `banner`
5 |         println!("{banner}");
  |                    ------ `banner` is borrowed here
  |
  = note: async blocks are not executed immediately and must either take a reference or ownership of outside variables they use
help: to force the async block to take ownership of `banner` (and any other referenced variables), use the `move` keyword
  |
4 |     let task = tokio::spawn(async move {
  |                                   ++++

The program prints: data lines: 2, waiting: 0 bytes Three newlines make three lines: data: Hi, a blank line, and data: [DONE], whose two halves were glued back together in pending before anyone read them. The blank line is not a data line, so the count is 2, and nothing is left waiting. Lines come from newlines, never from chunks (lesson 10.3).

It does not compile: E0728. .await means "pause here", and only async code has somewhere to pause to. reply_twice is a plain fn, so the compiler refuses, the same error as a plain main in lesson 10.1. Make reply_twice async too, and await it in main.

error[E0728]: `await` is only allowed inside `async` functions and blocks
 --> src/main.rs:9:40
  |
8 | fn reply_twice(message: &str) -> String {
  | --------------------------------------- this is not `async`
9 |     let first = pretend_reply(message).await;
  |                                        ^^^^^ only allowed inside `async` functions and blocks

The program prints: stopped With its only Sender dropped, stop.recv() can never get a press, so it finishes at once with None. select! takes whichever arm finishes first, and the pattern _ accepts None too, so it prints stopped although nobody pressed anything. That is why the tests in lesson 10.4 keep a _press alive.

The program prints: slow answer, then fast answer Both waits run at once, so fast done prints first and slow done second. But tokio::join! hands back its results in the order you wrote the futures, not the order they finished, so a is the slow answer (lesson 10.1).

It compiles, then panics at run time. blocking_send waits the plain way, which is right on the keyboard thread of lesson 10.4 and wrong inside async code, where waiting the plain way would hold up every other task on that thread. The compiler cannot see the difference, so tokio checks while the program runs and panics. Inside async, use send(...).await.

The program prints: 2 pieces, then the channel closed Cloning a Sender gives the pipe a second way in; that is the multiple producer in mpsc. The channel closes only when every Sender is gone, so the first task finishing does not end the loop. Both items arrive, then recv gives None (lesson 10.2).