feat: enable concurrent HTTP requests with improved async coroutine interpreter and new example.

Author: zuisong

docs/index.html

@@ -37,6 +37,7 @@ <h1>Chen Lang <span>Playground</span></h1>
             <option value="closures">Closures</option>
             <option value="async_task">Coroutines</option>
             <option value="async_http">Async HTTP Request</option>
+            <option value="concurrent_http">Concurrent HTTP</option>
           </select>
         </div>
         <button id="run">

docs/index.js

@@ -327,6 +327,43 @@ let resp = http.request("GET", url)
 println("Status: " + resp.status)
 let data = json.parse(resp.body)
 println("Response JSON origin: " + data.origin)
+`,
+    concurrent_http: `# Feature: Concurrent HTTP Requests
+let http = import "stdlib/http"
+let json = import "stdlib/json"
+let println = import "stdlib/io".println
+
+println("Starting concurrent HTTP requests...")
+
+# Helper function to fetch URL and return status
+def fetch_status(url) {
+    let resp = http.request("GET", url)
+    return resp.status
+}
+
+# Create coroutines for parallel requests
+let co1 = coroutine.create(def() { fetch_status("https://httpbin.org/delay/1") })
+let co2 = coroutine.create(def() { fetch_status("https://httpbin.org/delay/1") })
+let co3 = coroutine.create(def() {
+    let resp = http.request("GET", "https://httpbin.org/uuid")
+    let data = json.parse(resp.body)
+    return data.uuid
+})
+
+# Spawn all coroutines (non-blocking)
+coroutine.spawn(co1)
+coroutine.spawn(co2)
+coroutine.spawn(co3)
+
+println("All requests started, waiting for completion...")
+
+# Wait for all to complete
+let results = coroutine.await_all([co1, co2, co3])
+
+println("All requests completed!")
+println("Request 1 status: " + results[0])
+println("Request 2 status: " + results[1])
+println("Request 3 UUID: " + results[2])
 `
 };
 

docs/pkg/chen_lang.d.ts

@@ -9,10 +9,10 @@ export interface InitOutput {
   readonly memory: WebAssembly.Memory;
   readonly run: (a: number, b: number) => void;
   readonly run_wasm: (a: number, b: number) => any;
-  readonly wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke______: (a: number, b: number) => void;
-  readonly wasm_bindgen_47816a2d43ec07ce___closure__destroy___dyn_core_3cd24c61823388c3___ops__function__FnMut_____Output_______: (a: number, b: number) => void;
   readonly wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke___wasm_bindgen_47816a2d43ec07ce___JsValue_____: (a: number, b: number, c: any) => void;
   readonly wasm_bindgen_47816a2d43ec07ce___closure__destroy___dyn_core_3cd24c61823388c3___ops__function__FnMut__wasm_bindgen_47816a2d43ec07ce___JsValue____Output_______: (a: number, b: number) => void;
+  readonly wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke______: (a: number, b: number) => void;
+  readonly wasm_bindgen_47816a2d43ec07ce___closure__destroy___dyn_core_3cd24c61823388c3___ops__function__FnMut_____Output_______: (a: number, b: number) => void;
   readonly wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke___wasm_bindgen_47816a2d43ec07ce___JsValue__wasm_bindgen_47816a2d43ec07ce___JsValue_____: (a: number, b: number, c: any, d: any) => void;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;

docs/pkg/chen_lang.js

@@ -208,14 +208,14 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-function wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke______(arg0, arg1) {
-    wasm.wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke______(arg0, arg1);
-}
-
 function wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke___wasm_bindgen_47816a2d43ec07ce___JsValue_____(arg0, arg1, arg2) {
     wasm.wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke___wasm_bindgen_47816a2d43ec07ce___JsValue_____(arg0, arg1, arg2);
 }
 
+function wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke______(arg0, arg1) {
+    wasm.wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke______(arg0, arg1);
+}
+
 function wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke___wasm_bindgen_47816a2d43ec07ce___JsValue__wasm_bindgen_47816a2d43ec07ce___JsValue_____(arg0, arg1, arg2, arg3) {
     wasm.wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke___wasm_bindgen_47816a2d43ec07ce___JsValue__wasm_bindgen_47816a2d43ec07ce___JsValue_____(arg0, arg1, arg2, arg3);
 }

docs/pkg/chen_lang_bg.wasm

@@ -3,10 +3,10 @@
 export const memory: WebAssembly.Memory;
 export const run: (a: number, b: number) => void;
 export const run_wasm: (a: number, b: number) => any;
-export const wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke______: (a: number, b: number) => void;
-export const wasm_bindgen_47816a2d43ec07ce___closure__destroy___dyn_core_3cd24c61823388c3___ops__function__FnMut_____Output_______: (a: number, b: number) => void;
 export const wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke___wasm_bindgen_47816a2d43ec07ce___JsValue_____: (a: number, b: number, c: any) => void;
 export const wasm_bindgen_47816a2d43ec07ce___closure__destroy___dyn_core_3cd24c61823388c3___ops__function__FnMut__wasm_bindgen_47816a2d43ec07ce___JsValue____Output_______: (a: number, b: number) => void;
+export const wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke______: (a: number, b: number) => void;
+export const wasm_bindgen_47816a2d43ec07ce___closure__destroy___dyn_core_3cd24c61823388c3___ops__function__FnMut_____Output_______: (a: number, b: number) => void;
 export const wasm_bindgen_47816a2d43ec07ce___convert__closures_____invoke___wasm_bindgen_47816a2d43ec07ce___JsValue__wasm_bindgen_47816a2d43ec07ce___JsValue_____: (a: number, b: number, c: any, d: any) => void;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;

docs/pkg/chen_lang_bg.wasm.d.ts

@@ -16,20 +16,6 @@ fn run_code(code: &str) -> String {
 fn test_timer_sleep() {
     // Tests that we can sleep for a duration
     // And that the VM waits for it.
-    let code = r#"
-    let timer = import "stdlib/timer"
-    let start = stdlib.date.now()
-    timer.sleep(200)
-    let end = stdlib.date.now()
-    
-    # Check if time passed is at least 200ms
-    # Using a small margin for error (Rust test env might be slow or fast, but delta should be positive)
-    if (end - start) >= 200 { 
-        return "OK" 
-    } else {
-        return "Too fast: " + (end - start)
-    }
-    "#;
 
     // NOTE: stdlib.date.now() returns milliseconds.
     // importing stdlib/date implicitly? No, `stdlib.date` is not standard.
@@ -70,3 +56,42 @@ fn test_async_interleaving() {
     "#;
     assert_eq!(run_code(code), "Done");
 }
+
+#[test]
+fn test_spawn_closure_with_sleep() {
+    let code = r#"
+    let timer = import "stdlib/timer"
+    let co = coroutine.create(def() {
+        # 匿名函数直接调用 native async，这会触发 Yield
+        timer.sleep(50)
+        return "WakeUp"
+    })
+    
+    coroutine.spawn(co)
+    let results = coroutine.await_all([co])
+    
+    return results[0]
+    "#;
+
+    assert_eq!(run_code(code), "WakeUp");
+}
+
+#[test]
+fn test_spawn_closure_captures_and_sleep() {
+    let code = r#"
+    let timer = import "stdlib/timer"
+    let msg = "Capturing"
+    
+    let co = coroutine.create(def() {
+        timer.sleep(10)
+        return msg + " Works"
+    })
+    
+    coroutine.spawn(co)
+    let results = coroutine.await_all([co])
+    
+    return results[0]
+    "#;
+
+    assert_eq!(run_code(code), "Capturing Works");
+}

src/tests/async_timer_test.rs

@@ -64,23 +64,38 @@ impl VM {
                     last_res = self.execute_from(self.pc);
 
                     // 4. Check fiber completion and save result
-                    {
+                    // Only if execution finished successfully (not yielded)
+                    if let Ok(ref result) = last_res {
                         let mut f = fiber.borrow_mut();
-                        if f.state == FiberState::Dead || f.call_stack.is_empty() {
-                            if let Ok(ref result) = last_res {
-                                f.result = Some(result.clone());
-                            }
+
+                        // We consider the fiber finished if:
+                        // 1. It is explicitly marked Dead (by Return instruction)
+                        // 2. It is still Running but call stack is empty (ran off end of script)
+                        // IMPORTANT: If it is Suspended, it yielded (e.g. async I/O), so we must NOT mark it dead.
+                        let is_finished =
+                            f.state == FiberState::Dead || (f.state == FiberState::Running && f.call_stack.is_empty());
+
+                        if is_finished {
+                            f.result = Some(result.clone());
                             f.state = FiberState::Dead;
                             if f.is_spawned {
-                                *self.async_state.pending_tasks.borrow_mut() -= 1;
+                                let mut pt = self.async_state.pending_tasks.borrow_mut();
+                                // println!("DEBUG: Fiber finished. Decrementing pending: {} -> {}", *pt, *pt - 1);
+                                *pt -= 1;
                             }
                             self.async_state.notify.notify_waiters();
                         }
                     }
 
                     // 5. Check if we need to propagate error
-                    if let Err(_) = last_res {
-                        return last_res;
+                    if let Err(e) = &last_res {
+                        // If it's just a Yield, we don't propagate it as a VM error
+                        // The fiber is already suspended.
+                        if matches!(e.error, VMRuntimeError::Yield) {
+                            // Continue loop
+                        } else {
+                            return last_res;
+                        }
                     }
                 }
             }
@@ -1061,8 +1076,11 @@ impl VM {
                             .checked_sub(*arg_count)
                             .ok_or(VMRuntimeError::StackUnderflow("CallStack native: missing args".into()))?;
                         let args: Vec<Value> = self.stack.drain(start_index..).collect();
-                        let result = native_fn(self, args)?;
-                        self.stack.push(result);
+
+                        let result = native_fn(self, args);
+                        let val = result?;
+
+                        self.stack.push(val);
                         Ok(true)
                     }
                     _ => Err(VMRuntimeError::ValueError(ValueError::InvalidOperation {

src/vm/interpreter.rs

@@ -445,8 +445,12 @@ fn native_coroutine_spawn(vm: &mut VM, args: Vec<Value>) -> Result<Value, VMRunt
         .ready_queue
         .borrow_mut()
         .push_back((fiber_rc.clone(), Value::Null));
+
     *vm.async_state.pending_tasks.borrow_mut() += 1;
 
+    // 通知事件循环有新任务
+    vm.async_state.notify.notify_waiters();
+
     // 立即返回协程对象（不阻塞）
     Ok(args[0].clone())
 }