@shd101wyy/yo 0.1.28 → 0.1.29

package/std/process/command.yo

@@ -9,23 +9,17 @@
 //! { Command } :: import "std/process/command";
 //! { Exception, AnyError } :: import "std/error";
 //!
-//! main :: (fn(using(io : IO)) -> unit)({
-//!   given(exn) := Exception(
-//!     throw : (fn(forall(T : Type), error: AnyError) -> T)(
-//!       { println(error); panic("Exception"); }
-//!     )
-//!   );
-//!
+//! main :: (fn(io : IO, exn : Exception) -> unit)({
 //!   cmd := Command.new(`echo`);
 //!   cmd.arg(`hello`);
 //!   cmd.arg(`world`);
-//!   out := io.await(cmd.output());
+//!   out := io.await(cmd.output(io), { io, exn });
 //!   assert(out.status.success(), "echo should succeed");
 //! });
 //! ```
 open(import("../collections/array_list"));
 open(import("../string"));
-{ Exception } :: import("../error");
+{ Exception, IOErr } :: import("../error");
 { IOError } :: import("../sys/errors");
 IO_process :: import("../sys/process");
 IO_file :: import("../sys/file");
@@ -155,10 +149,10 @@ _spawn_with_fds :: (
     stdin_fd : i32,
     stdout_fd : i32,
     stderr_fd : i32,
-    using(io : IO, exn : Exception)
-  ) -> Impl(Future(i32, IO, Exception))
+    io : IO
+  ) -> Impl(Future(i32, IOErr))
 )(
-  io.async((using(io, exn)) => {
+  io.async((e) => {
     storage := _build_cstr_storage(self);
     argc := storage.len();
     // Allocate argv buffer: argc entries + 1 null terminator.
@@ -188,25 +182,25 @@ _spawn_with_fds :: (
     (argv_buf &+ argc).* =.None;
     // Resolve program path C string (always present — _build_cstr_storage pushes program first).
     program_cstr := (argv_buf &+ usize(0)).*.unwrap();
-    pid := io.await(IO_process.spawn(program_cstr, argv_buf,.None, stdin_fd, stdout_fd, stderr_fd));
+    pid := e.io.await(IO_process.spawn(program_cstr, argv_buf,.None, stdin_fd, stdout_fd, stderr_fd), e.io);
     // Free argv buffer (storage is dropped naturally at scope end).
     free(.Some(argv_raw));
-    IOError.check(pid)
+    IOError.check(pid, e.exn)
   })
 );
 // Read all available bytes from `fd` into a freshly returned ArrayList(u8)
 // until EOF (read returns 0).
-_drain_fd :: (fn(fd : i32, using(io : IO, exn : Exception)) -> Impl(Future(ArrayList(u8), IO, Exception)))(
-  io.async((using(io, exn)) => {
+_drain_fd :: (fn(fd : i32, io : IO) -> Impl(Future(ArrayList(u8), IOErr)))(
+  io.async((e) => {
     buf_size := usize(4096);
     buf := *(u8)(malloc(buf_size).unwrap());
     out := ArrayList(u8).new();
     while(runtime(true), {
-      n := io.await(IO_file.read(fd, buf, u32(buf_size), u64(0)));
+      n := e.io.await(IO_file.read(fd, buf, u32(buf_size), u64(0)), e.io);
       cond(
         (n < i32(0)) => {
           free(.Some(*(void)(buf)));
-          exn.throw(dyn(IOError.from_errno(i32(0) - n)));
+          e.exn.throw(dyn(IOError.from_errno(i32(0) - n)));
         },
         (n == i32(0)) => break,
         true => {
@@ -229,24 +223,24 @@ impl(
   Command,
   /// Spawn the child with stdio inherited from the parent, wait for it to
   /// exit, and return its `ExitStatus`.
-  status : (fn(self : *(Self), using(io : IO)) -> Impl(Future(ExitStatus, IO, Exception)))(
-    io.async((using(io, exn)) => {
-      pid := io.await(_spawn_with_fds(self, i32(-(1)), i32(-(1)), i32(-(1))));
-      raw := io.await(IO_process.waitpid(pid, i32(0)));
-      IOError.check(raw);
+  status : (fn(self : *(Self), io : IO) -> Impl(Future(ExitStatus, IOErr)))(
+    io.async((e) => {
+      pid := e.io.await(_spawn_with_fds(self, i32(-(1)), i32(-(1)), i32(-(1)), io), e);
+      raw := e.io.await(IO_process.waitpid(pid, i32(0)), e.io);
+      IOError.check(raw, e.exn);
       ExitStatus(raw : raw)
     })
   ),
   /// Spawn the child with stdout and stderr captured through pipes. Waits for
   /// the child to exit and returns the exit status plus the captured bytes.
-  output : (fn(self : *(Self), using(io : IO)) -> Impl(Future(Output, IO, Exception)))(
-    io.async((using(io, exn)) => {
+  output : (fn(self : *(Self), io : IO) -> Impl(Future(Output, IOErr)))(
+    io.async((e) => {
       // Create stdout and stderr pipes.
       out_fd_buf := MaybeUninit(Array(i32, usize(2))).new();
       out_fd := *(i32)(out_fd_buf.as_ptr());
       pr1 := IO_pipe.pipe(out_fd);
       cond(
-        (pr1 < i32(0)) => exn.throw(dyn(IOError.from_errno(i32(0) - pr1))),
+        (pr1 < i32(0)) => e.exn.throw(dyn(IOError.from_errno(i32(0) - pr1))),
         true => ()
       );
       out_read := (out_fd &+ usize(0)).*;
@@ -256,26 +250,26 @@ impl(
       pr2 := IO_pipe.pipe(err_fd);
       cond(
         (pr2 < i32(0)) => {
-          io.await(IO_file.close(out_read));
-          io.await(IO_file.close(out_write));
-          exn.throw(dyn(IOError.from_errno(i32(0) - pr2)));
+          e.io.await(IO_file.close(out_read), e.io);
+          e.io.await(IO_file.close(out_write), e.io);
+          e.exn.throw(dyn(IOError.from_errno(i32(0) - pr2)));
         },
         true => ()
       );
       err_read := (err_fd &+ usize(0)).*;
       err_write := (err_fd &+ usize(1)).*;
       // Spawn child with the write ends of both pipes.
-      pid := io.await(_spawn_with_fds(self, i32(-(1)), out_write, err_write));
+      pid := e.io.await(_spawn_with_fds(self, i32(-(1)), out_write, err_write, io), e);
       // Close write ends in parent so reads see EOF when child exits.
-      io.await(IO_file.close(out_write));
-      io.await(IO_file.close(err_write));
+      e.io.await(IO_file.close(out_write), e.io);
+      e.io.await(IO_file.close(err_write), e.io);
       // Drain both pipes sequentially.
-      stdout_buf := io.await(_drain_fd(out_read));
-      stderr_buf := io.await(_drain_fd(err_read));
-      io.await(IO_file.close(out_read));
-      io.await(IO_file.close(err_read));
-      raw := io.await(IO_process.waitpid(pid, i32(0)));
-      IOError.check(raw);
+      stdout_buf := e.io.await(_drain_fd(out_read, io), e);
+      stderr_buf := e.io.await(_drain_fd(err_read, io), e);
+      e.io.await(IO_file.close(out_read), e.io);
+      e.io.await(IO_file.close(err_read), e.io);
+      raw := e.io.await(IO_process.waitpid(pid, i32(0)), e.io);
+      IOError.check(raw, e.exn);
       Output(
         status : ExitStatus(raw : raw),
         stdout : stdout_buf,

package/std/regex/parser.yo

@@ -176,7 +176,7 @@ impl(
     r.push(CharRange(low : u32(32), high : u32(32)));
     r
   }),
-  // Parse \xHH hex escape — reads exactly 2 hex digits and returns the codepoint.
+  // Parse \xHH hex unwind — reads exactly 2 hex digits and returns the codepoint.
   _parse_hex_byte : (fn(self : Self) -> Option(u32))({
     if((self._pos + usize(2)) > self._bytes.len(), {
       return(.None);
@@ -202,7 +202,7 @@ impl(
     self._pos = (self._pos + usize(2));
     .Some(u32((v1 << i32(4)) | v2))
   }),
-  _parse_class_escape : (fn(self : Self) -> Result(ArrayList(CharRange), String))({
+  _parse_class_unwind : (fn(self : Self) -> Result(ArrayList(CharRange), String))({
     b := self._advance();
     match(
       b,
@@ -273,7 +273,7 @@ impl(
                 // High end is an escape sequence (e.g. \x20, \0, \n)
                 self._pos = (self._pos + usize(1));
                 self._pos = (self._pos + usize(1));
-                esc := self._parse_class_escape();
+                esc := self._parse_class_unwind();
                 match(
                   esc,
                   .Ok(esc_ranges) => {
@@ -281,7 +281,7 @@ impl(
                       (high : u32) = esc_ranges.get(usize(0)).unwrap().low;
                       ranges.push(CharRange(low : low, high : high));
                     }, {
-                      // Multi-range escape like \d can't be range endpoint; treat dash as literal
+                      // Multi-range unwind like \d can't be range endpoint; treat dash as literal
                       ranges.push(CharRange(low : low, high : low));
                       ranges.push(CharRange(low : u32(45), high : u32(45)));
                       j := usize(0);
@@ -331,11 +331,11 @@ impl(
       },
       (b == u8(92)) => {
         self._pos = (self._pos + usize(1));
-        esc := self._parse_class_escape();
+        esc := self._parse_class_unwind();
         match(
           esc,
           .Ok(esc_ranges) => {
-            // If escape produced a single codepoint, check for range (e.g. \0-\x20)
+            // If unwind produced a single codepoint, check for range (e.g. \0-\x20)
             if((esc_ranges.len() == usize(1)) && (esc_ranges.get(usize(0)).unwrap().low == esc_ranges.get(usize(0)).unwrap().high), {
               (low : u32) = esc_ranges.get(usize(0)).unwrap().low;
               self._try_parse_char_range(ranges, low);
@@ -402,7 +402,7 @@ impl(
     });
     .Err(`Unterminated character class`)
   }),
-  // Parse \p{PropertyName} or \P{PropertyName} unicode property escape.
+  // Parse \p{PropertyName} or \P{PropertyName} unicode property unwind.
   // negated=true for \P (inverted match).
   _parse_unicode_property : (fn(self : Self, negated : bool) -> Result(RegexNode, String))({
     // Expect opening '{'
@@ -451,7 +451,7 @@ impl(
     });
     .Err(`Unterminated Unicode property \\p{...}`)
   }),
-  _parse_escape : (fn(self : Self) -> Result(RegexNode, String))({
+  _parse_unwind : (fn(self : Self) -> Result(RegexNode, String))({
     b := self._advance();
     match(
       b,
@@ -524,7 +524,7 @@ impl(
           (ch == u8(112)) => self._parse_unicode_property(false),
           // Negated unicode property \P{Name}
           (ch == u8(80)) => self._parse_unicode_property(true),
-          // Hex escape \xHH
+          // Hex unwind \xHH
           (ch == u8(120)) => match(
             self._parse_hex_byte(),
             .Some(v) =>.Ok(RegexNode.literal(v)),
@@ -627,7 +627,7 @@ impl(
           (ch == u8(94)) =>.Ok(RegexNode.anchor_node(.Start)),
           (ch == u8(36)) =>.Ok(RegexNode.anchor_node(.End)),
           (ch == u8(91)) => self._parse_char_class(),
-          (ch == u8(92)) => self._parse_escape(),
+          (ch == u8(92)) => self._parse_unwind(),
           true =>.Ok(RegexNode.literal(self._read_codepoint(ch)))
         ),
       .None =>.Err(`Unexpected end of pattern`)

package/std/sys/bufio/buf_reader.yo

@@ -10,7 +10,7 @@
 //! IO_file :: import "std/sys/file";
 //!
 //! reader := BufReader.new(fd);
-//! line := io.await(reader.read_line(using(io)));
+//! line := io.await(reader.read_line(io));
 //! match(line,
 //!   .Ok(.Some(s)) => println(s),
 //!   .Ok(.None) => println("EOF"),
@@ -68,9 +68,9 @@ impl(
   // Read a line from the reader (up to and including '\n').
   // Returns .None on EOF when no data is available.
   // Returns .Some(line) with the line content (without the trailing '\n').
-  read_line : (fn(self : Self, using(io : IO)) -> Impl(Future(Result(Option(String), IOError), IO)))({
+  read_line : (fn(self : Self, io : IO) -> Impl(Future(Result(Option(String), IOError), IO)))({
     the_fd := self._fd;
-    io.async((using(io : IO)) => {
+    io.async((io) => {
       line_bytes := ArrayList(u8).new();
       found_newline := false;
       hit_eof := false;
@@ -95,7 +95,7 @@ impl(
           },
           true => {
             raw_buf := *(u8)(malloc(self._capacity).unwrap());
-            n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset));
+            n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset), io);
             cond(
               (n < i32(0)) => {
                 free(.Some(*(void)(raw_buf)));
@@ -134,9 +134,9 @@ impl(
   }),
   // Read up to `size` bytes into a provided buffer.
   // Returns the number of bytes actually read.
-  read : (fn(self : Self, buf : *(u8), size : u32, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))({
+  read : (fn(self : Self, buf : *(u8), size : u32, io : IO) -> Impl(Future(Result(i32, IOError), IO)))({
     the_fd := self._fd;
-    io.async((using(io : IO)) => {
+    io.async((io) => {
       available := (self._filled - self._pos);
       (read_err : Option(IOError)) =.None;
       (read_n : i32) = i32(0);
@@ -163,7 +163,7 @@ impl(
       // Buffer is empty and large read: bypass buffer
       cond(
         ((!(done)) && (usize(size) >= self._capacity)) => {
-          n := io.await(IO_file.read(the_fd, buf, size, self._offset));
+          n := io.await(IO_file.read(the_fd, buf, size, self._offset), io);
           cond(
             (n < i32(0)) => {
               read_err =.Some(IOError.from_errno(i32(0) - n));
@@ -181,7 +181,7 @@ impl(
       cond(
         (!(done)) => {
           raw_buf := *(u8)(malloc(self._capacity).unwrap());
-          n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset));
+          n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset), io);
           cond(
             (n < i32(0)) => {
               free(.Some(*(void)(raw_buf)));
@@ -227,9 +227,9 @@ impl(
     })
   }),
   // Read all remaining data into an ArrayList of bytes.
-  read_bytes : (fn(self : Self, using(io : IO)) -> Impl(Future(Result(ArrayList(u8), IOError), IO)))({
+  read_bytes : (fn(self : Self, io : IO) -> Impl(Future(Result(ArrayList(u8), IOError), IO)))({
     the_fd := self._fd;
-    io.async((using(io : IO)) => {
+    io.async((io) => {
       result := ArrayList(u8).new();
       // First drain any buffered data
       cond(
@@ -247,7 +247,7 @@ impl(
       raw_buf := *(u8)(malloc(self._capacity).unwrap());
       (read_err : Option(IOError)) =.None;
       while(runtime(true), {
-        n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset));
+        n := io.await(IO_file.read(the_fd, raw_buf, u32(self._capacity), self._offset), io);
         cond(
           (n < i32(0)) => {
             read_err =.Some(IOError.from_errno(i32(0) - n));
@@ -273,9 +273,9 @@ impl(
     })
   }),
   // Read all remaining data as a String.
-  read_to_string : (fn(self : Self, using(io : IO)) -> Impl(Future(Result(String, IOError), IO)))(
-    io.async((using(io : IO)) => {
-      bytes_result := io.await(self.read_bytes(using(io)));
+  read_to_string : (fn(self : Self, io : IO) -> Impl(Future(Result(String, IOError), IO)))(
+    io.async((io) => {
+      bytes_result := io.await(self.read_bytes(io), io);
       match(
         bytes_result,
         .Ok(bytes) =>.Ok(String.from_bytes(bytes)),

package/std/sys/bufio/buf_writer.yo

@@ -9,8 +9,8 @@
 //! { BufWriter } :: import "std/sys/bufio/buf_writer";
 //!
 //! writer := BufWriter.new(fd);
-//! io.await(writer.write_string(`hello\n`, using(io)));
-//! io.await(writer.flush(using(io)));
+//! io.await(writer.write_string(`hello\n`, io));
+//! io.await(writer.flush(io));
 //! ```
 { ArrayList } :: import("../../collections/array_list");
 open(import("../../string"));
@@ -54,9 +54,9 @@ impl(
     self._buf.len()
   ),
   // Internal: flush the buffer contents to fd.
-  _flush_inner : (fn(self : Self, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))({
+  _flush_inner : (fn(self : Self, io : IO) -> Impl(Future(Result(unit, IOError), IO)))({
     the_fd := self._fd;
-    io.async((using(io : IO)) => {
+    io.async((io) => {
       (write_err : Option(IOError)) =.None;
       cond(
         (self._buf.len() > usize(0)) => {
@@ -65,7 +65,7 @@ impl(
           while(runtime((written < total) && write_err.is_none()), {
             remaining := u32(total - written);
             buf_ptr := self._buf.ptr().unwrap();
-            n := io.await(IO_file.write(the_fd, buf_ptr &+ written, remaining, self._offset));
+            n := io.await(IO_file.write(the_fd, buf_ptr &+ written, remaining, self._offset), io);
             cond(
               (n < i32(0)) => {
                 write_err =.Some(IOError.from_errno(i32(0) - n));
@@ -90,9 +90,9 @@ impl(
   // Write bytes from a pointer into the buffer.
   // Automatically flushes when the buffer is full.
   // Returns total number of bytes written.
-  write : (fn(self : Self, data : *(u8), size : u32, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))({
+  write : (fn(self : Self, data : *(u8), size : u32, io : IO) -> Impl(Future(Result(i32, IOError), IO)))({
     the_fd := self._fd;
-    io.async((using(io : IO)) => {
+    io.async((io) => {
       remaining := usize(size);
       src_pos := usize(0);
       (write_err : Option(IOError)) =.None;
@@ -101,7 +101,7 @@ impl(
         cond(
           (space == usize(0)) => {
             // Buffer full, flush it
-            flush_result := io.await(self._flush_inner(using(io)));
+            flush_result := io.await(self._flush_inner(io), io);
             match(
               flush_result,
               .Err(e) => {
@@ -133,24 +133,24 @@ impl(
     })
   }),
   // Write a String to the buffer.
-  write_string : (fn(self : Self, s : String, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))(
-    io.async((using(io : IO)) => {
+  write_string : (fn(self : Self, s : String, io : IO) -> Impl(Future(Result(i32, IOError), IO)))(
+    io.async((io) => {
       bytes := s.as_bytes();
-      result := io.await(self.write(bytes.ptr().unwrap(), u32(bytes.len()), using(io)));
+      result := io.await(self.write(bytes.ptr().unwrap(), u32(bytes.len()), io), io);
       result
     })
   ),
   // Write bytes from an ArrayList to the buffer.
-  write_bytes : (fn(self : Self, data : ArrayList(u8), using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))(
-    io.async((using(io : IO)) => {
-      result := io.await(self.write(data.ptr().unwrap(), u32(data.len()), using(io)));
+  write_bytes : (fn(self : Self, data : ArrayList(u8), io : IO) -> Impl(Future(Result(i32, IOError), IO)))(
+    io.async((io) => {
+      result := io.await(self.write(data.ptr().unwrap(), u32(data.len()), io), io);
       result
     })
   ),
   // Flush all buffered data to the underlying file descriptor.
-  flush : (fn(self : Self, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))(
-    io.async((using(io : IO)) => {
-      flush_result := io.await(self._flush_inner(using(io)));
+  flush : (fn(self : Self, io : IO) -> Impl(Future(Result(unit, IOError), IO)))(
+    io.async((io) => {
+      flush_result := io.await(self._flush_inner(io), io);
       flush_result
     })
   )

package/std/sys/errors.yo

@@ -171,7 +171,7 @@ impl(IOError, Error());
 impl(
   IOError,
   // Check a raw result code, throwing on error via Exception effect.
-  check : (fn(result : i32, using(exn : Exception)) -> i32)(
+  check : (fn(result : i32, exn : Exception) -> i32)(
     cond(
       (result >= i32(0)) => result,
       true => exn.throw(dyn(Self.from_errno(i32(0) - result)))

package/std/thread.yo

@@ -8,7 +8,7 @@ extern(
 extern(
   "Yo",
   __yo_thread_t : Type,
-  __yo_thread_spawn : (fn(cb : Impl(Fn(using(io : IO)) -> unit, Send)) -> __yo_thread_t),
+  __yo_thread_spawn : (fn(cb : Impl(Fn(io : IO) -> unit, Send)) -> __yo_thread_t),
   __yo_thread_join : (fn(t : __yo_thread_t) -> unit)
 );
 /// OS thread handle. Each spawned thread gets its own IO event loop.
@@ -19,7 +19,7 @@ impl(
   Thread,
   /// Spawn a new OS thread running the given closure.
   /// The closure receives its own per-thread IO event loop.
-  spawn : (fn(cb : Impl(Fn(using(io : IO)) -> unit, Send)) -> Self)({
+  spawn : (fn(cb : Impl(Fn(io : IO) -> unit, Send)) -> Self)({
     raw := __yo_thread_spawn(cb);
     Self(raw)
   }),

package/std/url/index.yo

@@ -51,7 +51,7 @@ _DOT :: u8(46); // '.'
 // ============================================================================
 // Helper: parse port number from bytes
 // ============================================================================
-_parse_port :: (fn(s : str, start : usize, end : usize, using(exn : Exception)) -> u16)({
+_parse_port :: (fn(s : str, start : usize, end : usize, exn : Exception) -> u16)({
   cond(
     (start >= end) => {
       exn.throw(dyn(UrlError.InvalidPort));
@@ -95,7 +95,7 @@ impl(
   // Parse a URL string.
   // Supports: scheme://[userinfo@]host[:port]/path[?query][#fragment]
   // Also supports scheme:path (opaque URIs like mailto:user@example.com)
-  parse : (fn(s : str, using(exn : Exception)) -> Url)({
+  parse : (fn(s : str, exn : Exception) -> Url)({
     cond(
       (s.len() == usize(0)) => {
         exn.throw(dyn(UrlError.EmptyInput));

package/std/worker.yo

@@ -4,13 +4,13 @@
 //! Each worker thread has its own GC heap and async IO event loop.
 extern(
   "Yo",
-  __yo_worker_spawn : (fn(cb : Impl(Fn(using(io : IO)) -> unit, Send)) -> unit),
+  __yo_worker_spawn : (fn(cb : Impl(Fn(io : IO) -> unit, Send)) -> unit),
   __yo_worker_get_num_threads : (fn() -> usize),
   __yo_worker_set_num_threads : (fn(num : usize) -> unit)
 );
 /// Spawn a task on the thread pool. Returns immediately; the task runs in the background.
 /// Tasks are distributed round-robin to worker threads.
-spawn :: (fn(cb : Impl(Fn(using(io : IO)) -> unit, Send)) -> unit)({
+spawn :: (fn(cb : Impl(Fn(io : IO) -> unit, Send)) -> unit)({
   __yo_worker_spawn(cb);
 });
 /// Get the number of worker threads in the pool.