@shd101wyy/yo 0.1.29 → 0.1.30

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

@@ -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(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(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.