added more examples to ch11

Author: cfsamson

ch11/a-async-await/Cargo.toml

@@ -6,4 +6,5 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-mio = { version = "0.8", features = ["net", "os-poll"] }
+isahc = "1.7"
+mio = { version = "0.8", features = ["net", "os-poll"] }

ch11/a-async-await/src/main.rs

@@ -4,14 +4,12 @@ mod runtime;
 use crate::http::Http;
 use std::fmt::Write;
 
-
 fn main() {
     let mut executor = runtime::init();
     executor.block_on(async_main());
 }
 
-
-async fn async_main() -> String {
+async fn async_main() {
     let mut buffer = String::from("\nBUFFER:\n----\n");
     let writer = &mut buffer;
     println!("Program starting");
@@ -21,112 +19,33 @@ async fn async_main() -> String {
     writeln!(writer, "{txt}").unwrap();
 
     println!("{}", buffer);
-    String::new()
 }
 
-// // =================================
-// // Into this:
-// // =================================
-
-// fn async_main() -> impl Future<Output = String> {
-//     Coroutine0::new()
-// }
+// use isahc::prelude::*;
 
-// enum State0 {
-//     Start,
-//     Wait1(Pin<Box<dyn Future<Output = String>>>),
-//     Wait2(Pin<Box<dyn Future<Output = String>>>),
-//     Resolved,
-// }
+// async fn async_main2() {
+//     let mut buffer = String::from("\nBUFFER:\n----\n");
+//     let writer = &mut buffer;
+//     println!("Program starting");
+//     let mut res = isahc::get_async("http://127.0.0.1:8080/600/HelloAsyncAwait").await.unwrap();
+//     let txt = res.text().await.unwrap();
+//     writeln!(writer, "{txt}").unwrap();
+//     let mut res = isahc::get_async("http://127.0.0.1:8080/400/HelloAsyncAwait").await.unwrap();
+//     let txt = res.text().await.unwrap();
+//     writeln!(writer, "{txt}").unwrap();
 
-// #[derive(Default)]
-// struct Stack0 {
-//     buffer: Option<String>,
-//     writer: Option<*mut String>,
+//     println!("{}", buffer);
 // }
 
-// struct Coroutine0 {
-//     stack: Stack0,
-//     state: State0,
-//     _pin: PhantomPinned,
-// }
-
-// impl Coroutine0 {
-//     fn new() -> Self {
-//         Self {
-//             state: State0::Start,
-//             stack: Stack0::default(),
-//             _pin: PhantomPinned,
-//         }
-//     }
-// }
-
-// impl Future for Coroutine0 {
-//     type Output = String;
-
-//     fn poll(self: Pin<&mut Self>, waker: &mut Context) -> Poll<Self::Output> {
-//         let this = unsafe { self.get_unchecked_mut() };
-//         loop {
-//             match this.state {
-//                 State0::Start => {
-//                     // initialize stack (hoist declarations - no stack yet)
-
-//                     this.stack.buffer = Some(String::from("\nBUFFER:\n----\n"));
-//                     this.stack.writer = Some(this.stack.buffer.as_mut().unwrap());
-//                     // ---- Code you actually wrote ----
-//                     println!("Program starting");
-
-//                     // ---------------------------------
-//                     let fut1 = Box::pin(http::Http::get("/600/HelloAsyncAwait"));
-//                     this.state = State0::Wait1(fut1);
-
-//                     // save stack
-//                     // nothing to save
-//                 }
-
-//                 State0::Wait1(ref mut f1) => {
-//                     match f1.as_mut().poll(waker) {
-//                         Poll::Ready(txt) => {
-//                             // Restore stack
-//                             let writer = unsafe { &mut *this.stack.writer.unwrap() };
-
-//                             // ---- Code you actually wrote ----
-//                             writeln!(writer, "{txt}").unwrap();
-//                             // ---------------------------------
-//                             let fut2 = Box::pin(http::Http::get("/400/HelloAsyncAwait"));
-//                             this.state = State0::Wait2(fut2);
-
-//                             // save stack
-//                             this.stack.writer = Some(writer);
-//                         }
-//                         Poll::Pending => break Poll::Pending,
-//                     }
-//                 }
-
-//                 State0::Wait2(ref mut f2) => {
-//                     match f2.as_mut().poll(waker) {
-//                         Poll::Ready(txt) => {
-//                             // Restore stack
-//                             let buffer = this.stack.buffer.as_ref().take().unwrap();
-//                             let writer = unsafe { &mut *this.stack.writer.unwrap() };
-
-//                             // ---- Code you actually wrote ----
-//                             writeln!(writer, "{txt}").unwrap();
-
-//                             println!("{}", buffer);
-//                             // ---------------------------------
-//                             this.state = State0::Resolved;
-
-//                             // Save stack (all variables set to None already)
-
-//                             break Poll::Ready(String::new());
-//                         }
-//                         Poll::Pending => break Poll::Pending,
-//                     }
-//                 }
+// async fn spawn_many() {
+//     for i in 0..100 {
+//         let delay = i * 10;
+//         let req = format!("http://127.0.0.1:8080/{delay}/HelloAsyncAwait{i}");
 
-//                 State0::Resolved => panic!("Polled a resolved future"),
-//             }
-//         }
+//         runtime::spawn(async move {
+//             let mut res = isahc::get_async(&req).await.unwrap();
+//             let txt = res.text().await.unwrap();
+//             println!("{txt}");
+//         });
 //     }
 // }

ch11/a-async-await/src/runtime/executor.rs

@@ -4,11 +4,11 @@ use std::{
     future::Future,
     pin::Pin,
     sync::{Arc, Mutex},
-    task::{Poll, RawWaker, RawWakerVTable, Context, Waker},
+    task::{Poll, Context, Waker},
     thread::{self, Thread},
 };
 
-type Task = Pin<Box<dyn Future<Output = String>>>;
+type Task = Pin<Box<dyn Future<Output = ()>>>;
 
 thread_local! {
     static CURRENT_EXEC: ExecutorCore = ExecutorCore::default();
@@ -23,7 +23,7 @@ struct ExecutorCore {
 
 pub fn spawn<F>(future: F)
 where
-    F: Future<Output = String> + 'static,
+    F: Future<Output = ()> + 'static,
 {
     CURRENT_EXEC.with(|e| {
         let id = e.next_id.get();
@@ -66,7 +66,7 @@ impl Executor {
 
     pub fn block_on<F>(&mut self, future: F)
     where
-        F: Future<Output = String> + 'static,
+        F: Future<Output = ()> + 'static,
     {
         // ===== OPTIMIZATION, ASSUME READY
         // let waker = self.get_waker(usize::MAX);