Ch. 19: discuss while let referencing ch. 17

This is no longer the first time people see `while let` in the book, so
(a) update the text to mention Chapter 17, and (b) change the example to
show a `Result`-based scenario in addition to the an `Option`-based that
readers saw back in Chapter 17, to make it clear that `while let` is not
limited to working with `Option`.

Author: chriskrycho

listings/ch19-patterns-and-matching/listing-19-02/src/main.rs

@@ -1,13 +1,14 @@
 fn main() {
     // ANCHOR: here
-    let mut stack = Vec::new();
+    let (tx, rx) = std::sync::mpsc::channel();
+    std::thread::spawn(move || {
+        for val in [1, 2, 3] {
+            tx.send(val).unwrap();
+        }
+    });
 
-    stack.push(1);
-    stack.push(2);
-    stack.push(3);
-
-    while let Some(top) = stack.pop() {
-        println!("{top}");
+    while let Ok(value) = rx.recv() {
+        println!("{value}");
     }
     // ANCHOR_END: here
 }

src/ch17-02-concurrency-with-async.md

@@ -242,8 +242,6 @@ loop is the loop version of the `if let` construct we saw back in Chapter 6. The
 loop will continue executing as long as the pattern it specifies continues to
 match the value.
 
-<!-- TODO: update text in ch. 19 to account for our having introduced this. -->
-
 The `rx.recv` call produces a `Future`, which we await. The runtime will pause
 the `Future` until it is ready. Once a message arrives, the future will resolve
 to `Some(message)`, as many times as a message arrives. When the channel closes,

src/ch19-01-all-the-places-for-patterns.md

@@ -98,23 +98,25 @@ not alert us to the possible logic bug.
 ### `while let` Conditional Loops
 
 Similar in construction to `if let`, the `while let` conditional loop allows a
-`while` loop to run for as long as a pattern continues to match. In Listing
-19-2 we code a `while let` loop that uses a vector as a stack and prints the
-values in the vector in the opposite order in which they were pushed.
+`while` loop to run for as long as a pattern continues to match. We first saw a
+`while let` loop in Chapter 17, where we used it to keep looping as long as a
+stream produced new values. Similarly, in Listing 19-2 we show a `while let`
+loop that waits on messages sent between threads, but in this case checking a
+`Result` instead of an `Option`.
 
-<Listing number="19-2" caption="Using a `while let` loop to print values for as long as `stack.pop()` returns `Some`">
+<Listing number="19-2" caption="Using a `while let` loop to print values for as long as `rx.recv()` returns `Ok`">
 
 ```rust
 {{#rustdoc_include ../listings/ch19-patterns-and-matching/listing-19-02/src/main.rs:here}}
 ```
 
 </Listing>
 
-This example prints 3, 2, and then 1. The `pop` method takes the last element
-out of the vector and returns `Some(value)`. If the vector is empty, `pop`
-returns `None`. The `while` loop continues running the code in its block as
-long as `pop` returns `Some`. When `pop` returns `None`, the loop stops. We can
-use `while let` to pop every element off our stack.
+This example prints 1, 2, and 3. When we saw `recv` back in Chapter 16, we
+unwrapped the error directly, or interacted with it as an iterator using a `for`
+loop. As Listing 19-2 shows, though, we can also use `while let`, because the
+`recv` method returns `Ok` as long as the sender is producing messages, and then
+produces an `Err` once the sender side disconnects.
 
 ### `for` Loops