@shd101wyy/yo 0.1.28 → 0.1.30

package/std/thread.yo

@@ -1,4 +1,5 @@
-//! OS thread creation and management with per-thread IO event loops.
+//! OS thread creation and management with per-thread Io event loops.
+pragma(Pragma.AllowUnsafe);
 extern(
   "Yo",
   __yo_thread_get_hardware_threads : (fn() -> usize),
@@ -8,23 +9,23 @@ 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.
+/// OS thread handle. Each spawned thread gets its own Io event loop.
 Thread :: struct(
   handle : __yo_thread_t
 );
 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)({
+  /// The closure receives its own per-thread Io event loop.
+  spawn : (fn(cb : Impl(Fn(io : Io) -> unit, Send)) -> Self)({
     raw := __yo_thread_spawn(cb);
     Self(raw)
   }),
   /// Block the current thread until this thread completes.
-  join : (fn(self : *(Self)) -> unit)(
+  join : (fn(ref(self) : Self) -> unit)(
     __yo_thread_join(self.handle)
   )
 );

package/std/time/datetime.yo

@@ -8,6 +8,7 @@
 //! now := DateTime.now_utc();
 //! println(now.to_string());   // "2026-02-26T17:41:24Z"
 //! ```
+pragma(Pragma.AllowUnsafe);
 { String } :: import("../string");
 { ToString } :: import("../fmt");
 { CLOCK_REALTIME, clock_gettime } :: import("../sys/clock");
@@ -111,7 +112,7 @@ impl(
     _from_unix_secs(secs, nanos)
   ),
   // Convert back to a Unix timestamp (seconds since epoch).
-  to_unix : (fn(self : *(Self)) -> i64)({
+  to_unix : (fn(ref(self) : Self) -> i64)({
     // Compute days since epoch using the inverse Gregorian algorithm
     y := i64(self.year);
     m := i64(self.month);
@@ -136,11 +137,11 @@ impl(
     (days * i64(86400)) + time_secs
   }),
   // True if this year is a leap year.
-  is_leap_year : (fn(self : *(Self)) -> bool)(
+  is_leap_year : (fn(ref(self) : Self) -> bool)(
     _is_leap_year(self.year)
   ),
   // Day of week: 0 = Monday, 6 = Sunday (ISO 8601).
-  day_of_week : (fn(self : *(Self)) -> u8)({
+  day_of_week : (fn(ref(self) : Self) -> u8)({
     // Tomohiko Sakamoto's algorithm
     t := Array(i32, usize(12))(
       i32(0),
@@ -171,7 +172,7 @@ impl(
     )
   }),
   // Day of year (1-based).
-  day_of_year : (fn(self : *(Self)) -> u16)({
+  day_of_year : (fn(ref(self) : Self) -> u16)({
     m := i32(self.month);
     d := i32(self.day);
     // Sum days in preceding months
@@ -194,19 +195,21 @@ impl(
 impl(
   DateTime,
   ToString(
-    to_string : (fn(self : *(Self)) -> String)({
+    to_string : (fn(ref(self) : Self) -> String)({
       buf := Array(u8, usize(32)).fill(u8(0));
       buf_ptr := &(buf(usize(0)));
-      snprintf(
-        *(char)(buf_ptr),
-        usize(32),
-        "%04d-%02u-%02uT%02u:%02u:%02uZ",
-        self.year,
-        self.month,
-        self.day,
-        self.hour,
-        self.minute,
-        self.second
+      unsafe(
+        snprintf(
+          *(char)(buf_ptr),
+          usize(32),
+          "%04d-%02u-%02uT%02u:%02u:%02uZ",
+          self.year,
+          self.month,
+          self.day,
+          self.hour,
+          self.minute,
+          self.second
+        )
       );
       String.from_cstr(buf_ptr).unwrap()
     })

package/std/time/duration.yo

@@ -9,6 +9,7 @@
 //! println(d.as_secs());    // 0
 //! println(d.as_millis());  // 500
 //! ```
+pragma(Pragma.AllowUnsafe);
 { String } :: import("../string");
 { ToString } :: import("../fmt");
 { snprintf } :: import("../libc/stdio");
@@ -40,27 +41,27 @@ impl(
     Self(secs : (nanos / i64(1000000000)), nanos : (nanos % i64(1000000000)))
   ),
   // Total whole seconds in the duration.
-  as_secs : (fn(self : *(Self)) -> i64)(
+  as_secs : (fn(ref(self) : Self) -> i64)(
     self.secs
   ),
   // Total milliseconds (truncated).
-  as_millis : (fn(self : *(Self)) -> i64)(
+  as_millis : (fn(ref(self) : Self) -> i64)(
     (self.secs * i64(1000)) + (self.nanos / i64(1000000))
   ),
   // Total microseconds (truncated).
-  as_micros : (fn(self : *(Self)) -> i64)(
+  as_micros : (fn(ref(self) : Self) -> i64)(
     (self.secs * i64(1000000)) + (self.nanos / i64(1000))
   ),
   // Total nanoseconds.
-  as_nanos : (fn(self : *(Self)) -> i64)(
+  as_nanos : (fn(ref(self) : Self) -> i64)(
     (self.secs * i64(1000000000)) + self.nanos
   ),
   // Total seconds as a floating-point number.
-  as_secs_f64 : (fn(self : *(Self)) -> f64)(
+  as_secs_f64 : (fn(ref(self) : Self) -> f64)(
     f64(self.secs) + (f64(self.nanos) / f64(1000000000.0))
   ),
   // Add two durations together.
-  add : (fn(self : *(Self), other : Duration) -> Duration)({
+  add : (fn(ref(self) : Self, other : Duration) -> Duration)({
     total_nanos := (self.nanos + other.nanos);
     carry := (total_nanos / i64(1000000000));
     Duration(
@@ -69,7 +70,7 @@ impl(
     )
   }),
   // Subtract another duration (saturates to zero if negative).
-  sub : (fn(self : *(Self), other : Duration) -> Duration)({
+  sub : (fn(ref(self) : Self, other : Duration) -> Duration)({
     self_ns := self.as_nanos();
     other_ns := other.as_nanos();
     cond(
@@ -78,17 +79,17 @@ impl(
     )
   }),
   // Return true if this duration is zero.
-  is_zero : (fn(self : *(Self)) -> bool)(
+  is_zero : (fn(ref(self) : Self) -> bool)(
     (self.secs == i64(0)) && (self.nanos == i64(0))
   )
 );
 impl(
   Duration,
   ToString(
-    to_string : (fn(self : *(Self)) -> String)({
+    to_string : (fn(ref(self) : Self) -> String)({
       buf := Array(u8, usize(64)).fill(u8(0));
       buf_ptr := &(buf(usize(0)));
-      snprintf(*(char)(buf_ptr), usize(64), "%llds %lldns", self.secs, self.nanos);
+      unsafe(snprintf(*(char)(buf_ptr), usize(64), "%llds %lldns", self.secs, self.nanos));
       String.from_cstr(buf_ptr).unwrap()
     })
   )

package/std/time/instant.yo

@@ -10,6 +10,7 @@
 //! elapsed := start.elapsed();
 //! println(elapsed.as_millis());
 //! ```
+pragma(Pragma.AllowUnsafe);
 { Duration } :: import("./duration");
 { CLOCK_MONOTONIC, clock_gettime } :: import("../sys/clock");
 /// Snapshot from the monotonic clock. Use `elapsed` to measure durations.
@@ -29,7 +30,7 @@ impl(
   }),
   // Duration between this instant and an earlier one.
   // Returns Duration.zero() if `earlier` is actually later.
-  duration_since : (fn(self : *(Self), earlier : Instant) -> Duration)({
+  duration_since : (fn(ref(self) : Self, earlier : Instant) -> Duration)({
     self_ns := ((self.secs * i64(1000000000)) + self.nanos);
     earlier_ns := ((earlier.secs * i64(1000000000)) + earlier.nanos);
     cond(
@@ -38,10 +39,9 @@ impl(
     )
   }),
   // Duration elapsed since this instant was created.
-  elapsed : (fn(self : *(Self)) -> Duration)({
+  elapsed : (fn(ref(self) : Self) -> Duration)({
     current := Instant.now();
-    cur_ptr := (&(current));
-    cur_ptr.duration_since(self.*)
+    current.duration_since(self)
   })
 );
 export(Instant);

package/std/time/sleep.yo

@@ -6,6 +6,7 @@
 //! { sleep } :: import "std/time/sleep";
 //! sleep(usize(100)); // sleep 100ms
 //! ```
+pragma(Pragma.AllowUnsafe);
 extern(
   "Yo",
   __yo_ms_sleep : (fn(ms : usize) -> unit)

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));
@@ -234,7 +234,7 @@ impl(
             after_bracket := (bracket_end + usize(1));
             cond(
               ((after_bracket < auth_end) && (s.bytes(after_bracket) == _COLON)) => {
-                port =.Some(_parse_port(s, after_bracket + usize(1), auth_end));
+                port =.Some(_parse_port(s, after_bracket + usize(1), auth_end, exn));
               },
               true => ()
             );
@@ -264,7 +264,7 @@ impl(
                   hh2 = (hh2 + usize(1));
                 });
                 host =.Some(String.from_bytes(host_b));
-                port =.Some(_parse_port(s, cp_val + usize(1), auth_end));
+                port =.Some(_parse_port(s, cp_val + usize(1), auth_end, exn));
               },
               .None => {
                 // No port, entire range is host
@@ -363,7 +363,7 @@ impl(
     );
     // Ensure authority-based URLs have a path starting with "/" or empty
     cond(
-      (has_authority && ((!(path_str.is_empty())) && (path_str.as_bytes().get(usize(0)).unwrap() != _SLASH))) => {
+      (has_authority && ((!(path_str.is_empty())) && (path_str.as_bytes()(usize(0)) != _SLASH))) => {
         exn.throw(dyn(UrlError.Other(`authority path must start with '/'`)));
       },
       true => ()

package/std/worker.yo

@@ -1,16 +1,17 @@
 //! Thread pool with per-core thread affinity and round-robin task distribution.
 //!
 //! Each task is pinned to a worker thread (no work stealing).
-//! Each worker thread has its own GC heap and async IO event loop.
+//! Each worker thread has its own GC heap and async Io event loop.
+pragma(Pragma.AllowUnsafe);
 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.