Ch. 17§04 initial edits on Building Our Own Async Abstractions

Eliminate `trpl::timeout` entirely. Instead, just build the `timeout`
directly (as the rest of the section already did). Restructure the
listings as well, eliminating duplication and extraneous bits.

listings/ch17-async-await/listing-17-32/src/main.rs → listings/ch17-async-await/listing-17-26/src/main.rs

@@ -4,11 +4,11 @@ fn main() {
     trpl::block_on(async {
         // ANCHOR: here
         let slow = async {
-            trpl::sleep(Duration::from_secs(5)).await;
+            trpl::sleep(Duration::from_millis(100)).await;
             "I finished!"
         };
 
-        match trpl::timeout(Duration::from_secs(2), slow).await {
+        match timeout(slow, Duration::from_millis(10)).await {
             Ok(message) => println!("Succeeded with '{message}'"),
             Err(duration) => {
                 println!("Failed after {} seconds", duration.as_secs())

listings/ch17-async-await/listing-17-33/src/main.rs → listings/ch17-async-await/listing-17-27/src/main.rs

@@ -7,15 +7,20 @@ fn main() {
             "Finally finished"
         };
 
-        // Here we will actually use the new `timeout` with `slow`.
+        match timeout(slow, Duration::from_millis(10)).await {
+            Ok(message) => println!("Succeeded with '{message}'"),
+            Err(duration) => {
+                println!("Failed after {} seconds", duration.as_secs())
+            }
+        }
     });
 }
 
 // ANCHOR: declaration
 async fn timeout<F: Future>(
-    max_time: Duration,
     future: F,
+    max_time: Duration,
 ) -> Result<F::Output, Duration> {
-    // ANCHOR_END: declaration
-    unimplemented!()
+    // Here is where our implementation will go!
 }
+// ANCHOR_END: declaration

listings/ch17-async-await/listing-17-35/src/main.rs → listings/ch17-async-await/listing-17-28/src/main.rs

@@ -9,9 +9,7 @@ fn main() {
             "Finally finished"
         };
 
-        // ANCHOR: main
         match timeout(Duration::from_secs(2), slow).await {
-            // ANCHOR_END: main
             Ok(message) => println!("Succeeded with '{message}'"),
             Err(duration) => {
                 println!("Failed after {} seconds", duration.as_secs())
@@ -24,8 +22,10 @@ async fn timeout<F: Future>(
     max_time: Duration,
     future: F,
 ) -> Result<F::Output, Duration> {
+    // ANCHOR: implementation
     match trpl::race(future, trpl::sleep(max_time)).await {
         Either::Left(output) => Ok(output),
         Either::Right(_) => Err(max_time),
     }
+    // ANCHOR_END: implementation
 }