@shd101wyy/yo 0.0.23 → 0.0.25

package/std/{io → sys}/socketpair.yo

@@ -1,4 +1,4 @@
-// std/io/socketpair.yo - Connected socket pair
+// std/sys/socketpair.yo - Connected socket pair
 //
 // Synchronous wrapper for socketpair-like behavior.
 // Returns 0 on success, negative error on failure.

package/std/{io → sys}/sockinfo.yo

@@ -1,4 +1,4 @@
-// std/io/sockinfo.yo - Socket address and option query helpers
+// std/sys/sockinfo.yo - Socket address and option query helpers
 //
 // Synchronous wrappers for socket metadata operations.
 // Returns 0 on success, -errno (or negative platform socket error) on failure.

package/std/{io → sys}/statfs.yo

@@ -1,4 +1,4 @@
-// std/io/statfs.yo - Filesystem statistics
+// std/sys/statfs.yo - Filesystem statistics
 //
 // Provides a synchronous wrapper around statfs and typed accessors
 // for the statfs buffer returned by the C runtime.
@@ -8,7 +8,7 @@
 //   - Negative value: -errno on failure
 //
 // Example:
-//   statfs :: import "std/io/statfs";
+//   statfs :: import "std/sys/statfs";
 //
 //   buf_size := statfs.statfs_buf_size();
 //   buf := *(u8)(malloc(buf_size).unwrap());

package/std/{io → sys}/statx.yo

@@ -1,4 +1,4 @@
-// std/io/statx.yo - Statx file status type
+// std/sys/statx.yo - Statx file status type
 //
 // Object wrapper around the C statx buffer, providing
 // accessor methods for file metadata.

package/std/{io → sys}/sysinfo.yo

@@ -1,4 +1,4 @@
-// std/io/sysinfo.yo - Runtime system identification
+// std/sys/sysinfo.yo - Runtime system identification
 //
 // Synchronous wrappers for uname/gethostname.
 // Returns 0 on success, -errno / negative platform error on failure.

package/std/{io → sys}/tcp.yo

@@ -1,4 +1,4 @@
-// std/io/tcp.yo - Async TCP socket operations
+// std/sys/tcp.yo - Async TCP socket operations
 //
 // Provides TCP socket wrappers around the low-level C runtime externs.
 // Uses the socket address helpers to construct sockaddr_in/sockaddr_in6 buffers.
@@ -10,8 +10,8 @@
 // Example:
 //   { GlobalAllocator } :: import "../allocator.yo";
 //   { malloc, free } :: GlobalAllocator;
-//   tcp :: import "std/io/tcp";
-//   { AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR, IPPROTO_TCP } :: import "std/io/socket";
+//   tcp :: import "std/sys/tcp";
+//   { AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR, IPPROTO_TCP } :: import "std/sys/socket";
 //
 //   async {
 //     // Create a TCP socket

package/std/{io → sys}/temp.yo

@@ -1,4 +1,4 @@
-// std/io/temp.yo - Temporary file/directory operations
+// std/sys/temp.yo - Temporary file/directory operations
 //
 // Synchronous wrappers for mkdtemp/mkstemp.
 // These are inherently synchronous on all platforms.

package/std/{io → sys}/time.yo

@@ -1,4 +1,4 @@
-// std/io/time.yo - File timestamp operations
+// std/sys/time.yo - File timestamp operations
 //
 // Provides synchronous wrappers for utime/futime/lutime to change file timestamps.
 // All operations return i32 directly (no IOFuture overhead).
@@ -12,7 +12,7 @@
 // or UTIME_OMIT (0x3ffffffe) to leave a timestamp unchanged.
 //
 // Example:
-//   time :: import "std/io/time";
+//   time :: import "std/sys/time";
 //
 //   // Set both atime and mtime to specific values
 //   ret := time.utime(*(u8)("/tmp/test.txt"), i64(1000000), i64(0), i64(2000000), i64(0));

package/std/{io → sys}/timer.yo

@@ -1,4 +1,4 @@
-// std/io/timer.yo - Async timer operations
+// std/sys/timer.yo - Async timer operations
 //
 // Provides high-level async timer functions:
 //   sleep(ms)   - async sleep for the given number of milliseconds

package/std/{io → sys}/tty.yo

@@ -1,4 +1,4 @@
-// std/io/tty.yo - TTY operations
+// std/sys/tty.yo - TTY operations
 
 { __yo_tty_init, __yo_tty_set_mode, __yo_tty_reset_mode, __yo_tty_get_winsize, __yo_isatty } :: import "./externs.yo";
 { TTY_MODE_NORMAL, TTY_MODE_RAW, TTY_MODE_IO } :: import "./events.yo";

package/std/{io → sys}/udp.yo

@@ -1,4 +1,4 @@
-// std/io/udp.yo - Async UDP socket operations
+// std/sys/udp.yo - Async UDP socket operations
 //
 // Provides UDP socket wrappers around the low-level C runtime externs.
 // Reuses SockAddr and address helpers from tcp.yo.
@@ -10,9 +10,9 @@
 // Example:
 //   { GlobalAllocator } :: import "../allocator.yo";
 //   { malloc, free } :: GlobalAllocator;
-//   udp :: import "std/io/udp";
-//   tcp :: import "std/io/tcp";
-//   { AF_INET, SOCK_DGRAM } :: import "std/io/socket";
+//   udp :: import "std/sys/udp";
+//   tcp :: import "std/sys/tcp";
+//   { AF_INET, SOCK_DGRAM } :: import "std/sys/socket";
 //
 //   async {
 //     sockfd := await udp.socket(AF_INET, i32(0));

package/std/{io → sys}/umask.yo

@@ -1,4 +1,4 @@
-// std/io/umask.yo - Process file creation mask
+// std/sys/umask.yo - Process file creation mask
 //
 // Synchronous wrapper for setting process umask.
 // Returns previous mask value.

package/std/{io → sys}/unix.yo

@@ -1,4 +1,4 @@
-// std/io/unix.yo - Unix domain socket operations
+// std/sys/unix.yo - Unix domain socket operations
 //
 // Provides Unix domain socket wrappers around the low-level C runtime externs.
 // Reuses the socket ops (bind/listen/accept/connect/send/recv/close) from the

package/std/time/datetime.yo

@@ -11,7 +11,7 @@
 
 { String } :: import "../string";
 { ToString } :: import "../fmt";
-{ CLOCK_REALTIME, clock_gettime } :: import "../io/clock";
+{ CLOCK_REALTIME, clock_gettime } :: import "../sys/clock";
 { snprintf } :: import "../libc/stdio";
 
 // ============================================================================
@@ -46,9 +46,13 @@ _from_unix_secs :: (fn(secs: i64, nanos: i64) -> DateTime)({
   rem  := (secs % i64(86400));
 
   // Normalise negative remainders
-  (rem_adj, days_adj) := cond(
-    (rem < i64(0)) => struct(rem_v: (rem + i64(86400)), days_v: (days - i64(1))),
-    true => struct(rem_v: rem, days_v: days)
+  rem_adj := cond(
+    (rem < i64(0)) => (rem + i64(86400)),
+    true => rem
+  );
+  days_adj := cond(
+    (rem < i64(0)) => (days - i64(1)),
+    true => days
   );
 
   hour   := u8((rem_adj / i64(3600)));
@@ -65,7 +69,7 @@ _from_unix_secs :: (fn(secs: i64, nanos: i64) -> DateTime)({
   );
   doe  := (z - (era * i64(146097)));
   yoe  := (((doe - (doe / i64(1460))) + (doe / i64(36524))) - (doe / i64(146096)));
-  yoe  := (yoe / i64(365));
+  yoe  = (yoe / i64(365));
   y    := (yoe + (era * i64(400)));
   doy  := (doe - (((i64(365) * yoe) + (yoe / i64(4))) - (yoe / i64(100))));
   mp   := (((i64(5) * doy) + i64(2)) / i64(153));
@@ -96,7 +100,7 @@ impl(DateTime,
   now_utc : (fn() -> Self)({
     sec  := i64(0);
     nsec := i64(0);
-    clock_gettime(CLOCK_REALTIME, &sec, &nsec);
+    clock_gettime(CLOCK_REALTIME, (&sec), (&nsec));
     _from_unix_secs(sec, nsec)
   }),
 
@@ -131,8 +135,8 @@ impl(DateTime,
     );
     doy := ((((i64(153) * mp) + i64(2)) / i64(5)) + (d - i64(1)));
     doe := ((((yoe * i64(365)) + (yoe / i64(4))) - (yoe / i64(100))) + doy);
-    days := ((era * i64(146097)) + doe - i64(719468));
-    time_secs := ((i64(self.hour) * i64(3600)) + (i64(self.minute) * i64(60)) + i64(self.second));
+    days := (((era * i64(146097)) + doe) - i64(719468));
+    time_secs := (((i64(self.hour) * i64(3600)) + (i64(self.minute) * i64(60))) + i64(self.second));
     ((days * i64(86400)) + time_secs)
   }),
 
@@ -152,7 +156,8 @@ impl(DateTime,
       (i32(self.month) < i32(3)) => (self.year - i32(1)),
       true => self.year
     );
-    dow := ((y + (y / i32(4)) - (y / i32(100)) + (y / i32(400)) + t(usize((i32(self.month) - i32(1)))) + i32(self.day)) % i32(7));
+    sum := (((((y + (y / i32(4))) - (y / i32(100))) + (y / i32(400))) + t(usize((i32(self.month) - i32(1))))) + i32(self.day));
+    dow := (sum % i32(7));
     // Convert: 0=Sun → remap to 0=Mon
     u8(cond(
       (dow == i32(0)) => i32(6),
@@ -179,9 +184,10 @@ impl(DateTime,
       );
     };
     u16(days)
-  }),
+  })
+);
 
-  // Format as ISO 8601 UTC string: "YYYY-MM-DDTHH:MM:SSZ"
+impl(DateTime, ToString(
   to_string : (fn(self: *(Self)) -> String)({
     buf := Array(u8, usize(32)).fill(u8(0));
     buf_ptr := &(buf(usize(0)));
@@ -189,18 +195,7 @@ impl(DateTime,
       self.year, self.month, self.day,
       self.hour, self.minute, self.second);
     String.from_cstr(buf_ptr).unwrap()
-  }),
-
-  // Alias to to_string.
-  format : (fn(self: *(Self), _fmt: str) -> String)(
-    self.to_string()
-  )
-);
-
-impl(DateTime, ToString(
-  to_string : (fn(self: *(Self)) -> String)(
-    self.to_string()
-  )
+  })
 ));
 
 export DateTime;

package/std/time/instant.yo

@@ -12,7 +12,7 @@
 //   println(elapsed.as_millis());
 
 { Duration } :: import "./duration";
-{ CLOCK_MONOTONIC, clock_gettime } :: import "../io/clock";
+{ CLOCK_MONOTONIC, clock_gettime } :: import "../sys/clock";
 
 // ============================================================================
 // Instant - monotonic clock snapshot
@@ -26,16 +26,11 @@ Instant :: struct(
 impl(Instant,
   // Capture the current monotonic time.
   now : (fn() -> Self)({
-    sec  := i64(0);
-    nsec := i64(0);
-    clock_gettime(CLOCK_MONOTONIC, &sec, &nsec);
-    Self(secs: sec, nanos: nsec)
-  }),
-
-  // Duration elapsed since this instant was created.
-  elapsed : (fn(self: *(Self)) -> Duration)({
-    now := Instant.now();
-    now.duration_since(self.*)
+    clk    := CLOCK_MONOTONIC;
+    out_s  := i64(0);
+    out_ns := i64(0);
+    clock_gettime(clk, (&out_s), (&out_ns));
+    Self(secs: out_s, nanos: out_ns)
   }),
 
   // Duration between this instant and an earlier one.
@@ -47,6 +42,13 @@ impl(Instant,
       (self_ns <= earlier_ns) => Duration.zero(),
       true => Duration.from_nanos((self_ns - earlier_ns))
     )
+  }),
+
+  // Duration elapsed since this instant was created.
+  elapsed : (fn(self: *(Self)) -> Duration)({
+    current := Instant.now();
+    cur_ptr := (&(current));
+    cur_ptr.duration_since(self.*)
   })
 );