@shd101wyy/yo 0.0.23 → 0.0.25

package/std/net/udp.yo

@@ -1,6 +1,6 @@
 // std/net/udp.yo - High-level UDP socket
 //
-// Wraps std/io/udp with typed UdpSocket object.
+// Wraps std/sys/udp with typed UdpSocket object.
 //
 // Example:
 //   { UdpSocket } :: import "std/net/udp";
@@ -23,13 +23,14 @@
 open import "../string";
 open import "../fmt";
 { NetError } :: import "./errors";
+{ IOError } :: import "../sys/errors";
 { IpAddr, SocketAddr } :: import "./addr";
-IO_udp :: import "../io/udp";
-IO_tcp :: import "../io/tcp";
+IO_udp :: import "../sys/udp";
+IO_tcp :: import "../sys/tcp";
 {
   AF_INET, AF_INET6, SOCK_DGRAM,
   SOL_SOCKET, SO_BROADCAST
-} :: import "../io/socket";
+} :: import "../sys/socket";
 { snprintf } :: import "../libc/stdio";
 
 // ============================================================================
@@ -40,12 +41,11 @@ _make_sockaddr :: (fn(addr: SocketAddr) -> IO_tcp.SockAddr)(
   match(addr.ip,
     .V4(a, b, c, d) => {
       buf := Array(u8, usize(16)).fill(u8(0));
-      snprintf(&(buf(usize(0))), usize(16), "%d.%d.%d.%d", i32(a), i32(b), i32(c), i32(d));
+      snprintf(*(char)(&(buf(usize(0)))), usize(16), "%d.%d.%d.%d", i32(a), i32(b), i32(c), i32(d));
       IO_tcp.make_sockaddr_in(&(buf(usize(0))), addr.port)
     },
-    .V6(_) => {
+    .V6(_) =>
       IO_tcp.make_sockaddr_in6(*(u8)("::1"), addr.port)
-    }
   )
 );
 
@@ -61,8 +61,8 @@ UdpSocket :: object(
 
 impl(UdpSocket,
   // Create and bind a UDP socket to the given address.
-  bind : (fn(addr: SocketAddr, using(io : IO)) -> Impl(Future(Result(UdpSocket, NetError))))({
-    task := io.async((using(io : IO)) => {
+  bind : (fn(addr: SocketAddr, using(io : IO)) -> Impl(Future(Result(UdpSocket, NetError), IO)))(
+    io.async((using(io : IO)) => {
       domain := cond(
         addr.ip.is_v4() => AF_INET,
         true => AF_INET6
@@ -70,7 +70,8 @@ impl(UdpSocket,
       fd := io.await(IO_udp.socket(domain, i32(0)));
       cond(
         (fd < i32(0)) => {
-          return .Err(NetError.from_result(fd).unwrap_err());
+          (ret : Result(UdpSocket, NetError)) = .Err(NetError.from_io(IOError.from_errno((i32(0) - fd))));
+          return ret;
         },
         true => ()
       );
@@ -80,81 +81,89 @@ impl(UdpSocket,
       cond(
         (bind_result < i32(0)) => {
           io.await(IO_udp.close(fd));
-          return .Err(NetError.from_result(bind_result).unwrap_err());
+          (ret : Result(UdpSocket, NetError)) = .Err(NetError.from_io(IOError.from_errno((i32(0) - bind_result))));
+          return ret;
         },
         true => ()
       );
-      return .Ok(UdpSocket(_fd: fd, _local_addr: addr, _is_closed: false));
-    });
-    return task;
-  }),
+      (ret : Result(UdpSocket, NetError)) = .Ok(UdpSocket(_fd: fd, _local_addr: addr, _is_closed: false));
+      return ret;
+    })
+  ),
 
   // Send a datagram to a specific address.
   // Returns the number of bytes sent.
-  send_to : (fn(self: Self, data: ArrayList(u8), addr: SocketAddr, using(io : IO)) -> Impl(Future(Result(i32, NetError))))({
+  send_to : (fn(self: Self, data: ArrayList(u8), addr: SocketAddr, using(io : IO)) -> Impl(Future(Result(i32, NetError), IO)))({
     fd := self._fd;
-    task := io.async((using(io : IO)) => {
+    io.async((using(io : IO)) => {
       saddr := _make_sockaddr(addr);
       result := io.await(IO_udp.sendto(fd, data.ptr().unwrap(), data.len(), i32(0), saddr.buf, saddr.len));
       IO_tcp.free_sockaddr(saddr);
       NetError.from_result(result)
-    });
-    return task;
+    })
   }),
 
   // Receive a datagram.
   // Returns the number of bytes received.
-  recv : (fn(self: Self, buf: *(u8), size: usize, using(io : IO)) -> Impl(Future(Result(i32, NetError))))({
+  recv : (fn(self: Self, buf: *(u8), size: usize, using(io : IO)) -> Impl(Future(Result(i32, NetError), IO)))({
     fd := self._fd;
-    task := io.async((using(io : IO)) => {
+    io.async((using(io : IO)) => {
       result := io.await(IO_udp.recv(fd, buf, size, i32(0)));
       NetError.from_result(result)
-    });
-    return task;
+    })
+  }),
+
+  // Receive a datagram and get the source address.
+  // Returns the number of bytes received.
+  recv_from : (fn(self: Self, buf: *(u8), size: usize, src_addr: *(u8), src_addr_len: *(u32), using(io : IO)) -> Impl(Future(Result(i32, NetError), IO)))({
+    fd := self._fd;
+    io.async((using(io : IO)) => {
+      result := io.await(IO_udp.recvfrom(fd, buf, size, i32(0), src_addr, src_addr_len));
+      NetError.from_result(result)
+    })
   }),
 
   // Send data on a connected socket (after connect()).
-  send : (fn(self: Self, data: ArrayList(u8), using(io : IO)) -> Impl(Future(Result(i32, NetError))))({
+  send : (fn(self: Self, data: ArrayList(u8), using(io : IO)) -> Impl(Future(Result(i32, NetError), IO)))({
     fd := self._fd;
-    task := io.async((using(io : IO)) => {
+    io.async((using(io : IO)) => {
       result := io.await(IO_udp.send(fd, data.ptr().unwrap(), data.len(), i32(0)));
       NetError.from_result(result)
-    });
-    return task;
+    })
   }),
 
   // Close the socket.
-  close : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(unit, NetError))))({
+  close : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(unit, NetError), IO)))({
     fd := self._fd;
-    task := io.async((using(io : IO)) => {
-      cond(
+    io.async((using(io : IO)) => {
+      (ret : Result(unit, NetError)) = cond(
         self._is_closed => .Ok(()),
         true => {
           result := io.await(IO_udp.close(fd));
           self._is_closed = true;
           cond(
-            (result < i32(0)) => .Err(NetError.from_result(result).unwrap_err()),
+            (result < i32(0)) => .Err(NetError.from_io(IOError.from_errno((i32(0) - result)))),
             true => .Ok(())
           )
         }
-      )
-    });
-    return task;
+      );
+      ret
+    })
   }),
 
   // Enable/disable SO_BROADCAST.
-  set_broadcast : (fn(self: Self, enabled: bool, using(io : IO)) -> Impl(Future(Result(unit, NetError))))({
+  set_broadcast : (fn(self: Self, enabled: bool, using(io : IO)) -> Impl(Future(Result(unit, NetError), IO)))({
     fd := self._fd;
-    task := io.async((using(io : IO)) => {
+    io.async((using(io : IO)) => {
       val := cond(enabled => i32(1), true => i32(0));
       val_ptr := &val;
       result := io.await(IO_udp.setsockopt(fd, SOL_SOCKET, SO_BROADCAST, *(u8)(val_ptr), u32(4)));
-      cond(
-        (result < i32(0)) => .Err(NetError.from_result(result).unwrap_err()),
+      (ret : Result(unit, NetError)) = cond(
+        (result < i32(0)) => .Err(NetError.from_io(IOError.from_errno((i32(0) - result)))),
         true => .Ok(())
-      )
-    });
-    return task;
+      );
+      ret
+    })
   }),
 
   // Get the local address.
@@ -172,7 +181,7 @@ impl(UdpSocket, Dispose(
   dispose : (fn(self: Self) -> unit)({
     cond(
       (!(self._is_closed)) => {
-        { close_sync } :: import "../io/file";
+        { close_sync } :: import "../sys/file";
         close_sync(self._fd);
         self._is_closed = true;
       },

package/std/os/env.yo

@@ -16,35 +16,33 @@ open import "../string";
 // ============================================================================
 
 // Return the current user's home directory, or .None if unavailable.
-home_dir :: (fn() -> ?String)(
+home_dir :: (fn() -> Option(String))(
   cond(
-    (platform == Platform.Win32) => {
-      match(env.get(String.from("USERPROFILE")),
-        .Some(p) => .Some(p),
-        .None    => match(env.get(String.from("HOMEDRIVE")),
+    (platform == Platform.Win32) => match(env.get(`USERPROFILE`),
+      .Some(p) => .Some(p),
+      .None    => match(env.get(`HOMEDRIVE`),
+        .None => .None,
+        .Some(drive) => match(env.get(`HOMEPATH`),
           .None => .None,
-          .Some(drive) => match(env.get(String.from("HOMEPATH")),
-            .None => .None,
-            .Some(path) => .Some(drive.concat(path))
-          )
+          .Some(path) => .Some(drive.concat(path))
         )
       )
-    },
-    true => env.get(String.from("HOME"))
+    ),
+    true => env.get(`HOME`)
   )
 );
 
 // Return the user-specific configuration directory.
 //   Linux/macOS: $XDG_CONFIG_HOME or $HOME/.config
 //   Windows:     %APPDATA%
-config_dir :: (fn() -> ?String)(
+config_dir :: (fn() -> Option(String))(
   cond(
-    (platform == Platform.Win32) => env.get(String.from("APPDATA")),
-    true => match(env.get(String.from("XDG_CONFIG_HOME")),
+    (platform == Platform.Win32) => env.get(`APPDATA`),
+    true => match(env.get(`XDG_CONFIG_HOME`),
       .Some(d) => .Some(d),
       .None => match(home_dir(),
         .None => .None,
-        .Some(h) => .Some(h.concat(String.from("/.config")))
+        .Some(h) => .Some(h.concat(`/.config`))
       )
     )
   )
@@ -54,18 +52,18 @@ config_dir :: (fn() -> ?String)(
 //   Linux:   $XDG_CACHE_HOME or $HOME/.cache
 //   macOS:   $HOME/Library/Caches
 //   Windows: %LOCALAPPDATA%
-cache_dir :: (fn() -> ?String)(
+cache_dir :: (fn() -> Option(String))(
   cond(
-    (platform == Platform.Win32) => env.get(String.from("LOCALAPPDATA")),
+    (platform == Platform.Win32) => env.get(`LOCALAPPDATA`),
     (platform == Platform.Darwin) => match(home_dir(),
       .None => .None,
-      .Some(h) => .Some(h.concat(String.from("/Library/Caches")))
+      .Some(h) => .Some(h.concat(`/Library/Caches`))
     ),
-    true => match(env.get(String.from("XDG_CACHE_HOME")),
+    true => match(env.get(`XDG_CACHE_HOME`),
       .Some(d) => .Some(d),
       .None => match(home_dir(),
         .None => .None,
-        .Some(h) => .Some(h.concat(String.from("/.cache")))
+        .Some(h) => .Some(h.concat(`/.cache`))
       )
     )
   )
@@ -74,11 +72,11 @@ cache_dir :: (fn() -> ?String)(
 // Return the system temporary directory.
 temp_dir :: (fn() -> String)(
   cond(
-    (platform == Platform.Win32) => match(env.get(String.from("TEMP")),
+    (platform == Platform.Win32) => match(env.get(`TEMP`),
       .Some(t) => t,
-      .None    => String.from("C:\\Temp")
+      .None    => `C:\Temp`
     ),
-    true => String.from("/tmp")
+    true => `/tmp`
   )
 );
 

package/std/os/signal.yo

@@ -1,16 +1,17 @@
 // std/os/signal.yo - High-level signal handling
 //
-// Wraps std/io/signal with typed Signal enum values.
+// Wraps std/sys/signal with typed Signal enum values.
 //
 // Example:
-//   { on_signal, Signal } :: import "std/os/signal";
+//   { on_signal, off_signal, Signal, SignalHandler } :: import "std/os/signal";
 //
-//   on_signal(.Interrupt, () => { println("Caught SIGINT"); });
+//   handler :: (fn(data: *(u8)) -> unit)({ println("Caught SIGINT"); });
+//   on_signal(.Interrupt, handler);
 
-{ IOError } :: import "../io/errors";
+{ IOError } :: import "../sys/errors";
 {
-  on_signal : _on_signal, off_signal : _off_signal
-} :: import "../io/signal";
+  on_signal : _on_signal, off_signal : _off_signal, SignalHandler
+} :: import "../sys/signal";
 { platform, Platform } :: import "../process";
 
 // ============================================================================
@@ -72,9 +73,9 @@ _signal_num :: (fn(sig: Signal) -> i32)(
 // ============================================================================
 
 // Register a handler for the given signal.
-on_signal :: (fn(sig: Signal, handler: Impl(Fn() -> unit)) -> Result(unit, IOError))({
+on_signal :: (fn(sig: Signal, handler: SignalHandler) -> Result(unit, IOError))({
   num := _signal_num(sig);
-  r   := _on_signal(num, (data) => { handler(); });
+  r   := _on_signal(num, handler);
   cond(
     (r < i32(0)) => .Err(IOError.from_errno((i32(0) - r))),
     true => .Ok(())
@@ -91,4 +92,4 @@ off_signal :: (fn(sig: Signal) -> Result(unit, IOError))({
   )
 });
 
-export on_signal, off_signal;
+export SignalHandler, on_signal, off_signal;

package/std/prelude.yo

@@ -94,6 +94,8 @@ extern "Yo",
   // slice related
   __yo_slice_len :
     fn(forall(T: Type), slice: Slice(T)) -> usize,
+  __yo_slice_new :
+    fn(forall(T: Type), ptr: *(T), length: usize) -> Slice(T),
 
   // C macro related
   __yo_c_macro_defined : (fn(comptime(name) : comptime_string) -> comptime(bool)),
@@ -118,10 +120,8 @@ export assert;
 
 // unsafe module
 unsafe :: impl {
-  drop :: (fn(forall(T : Type), own(value) : T) -> unit) {
-    ___drop(value);
-    ()
-  };
+  drop :: (fn(quote(value) : Expr) -> unquote(Expr))
+    quote(___drop(unquote(value)));
   export drop;
 };
 export unsafe;
@@ -3188,6 +3188,9 @@ impl(forall(T : Type), Slice(T), Acyclic());
 impl(forall(T : Type), where(T <: Comptime), Slice(T), Comptime());
 impl(forall(T : Type), where(T <: Runtime), Slice(T), Runtime());
 impl(forall(T : Type), Slice(T),
+  from_raw_parts : (fn(ptr : *(T), length : usize) -> Self)(
+    __yo_slice_new(ptr, length)
+  ),
   len : (fn(self : Self) -> usize)(
     __yo_slice_len(self)
   )
@@ -3198,10 +3201,65 @@ str :: newtype(
   bytes : Slice(u8)
 );
 impl(str,
+  from_raw_parts : (fn(ptr : *(u8), length : usize) -> Self)(
+    Self(bytes: __yo_slice_new(ptr, length))
+  ),
   len : (fn(self : Self) -> usize)(
     __yo_slice_len(self.bytes)
   )
 );
+
+impl(str, Eq(str)(
+  (==) : (fn(lhs: Self, rhs: Self) -> bool)({
+    lhs_len := lhs.len();
+    cond(
+      (lhs_len != rhs.len()) => {
+        return false;
+      },
+      true => ()
+    );
+    i := usize(0);
+    while (i < lhs_len), (i = (i + usize(1))), {
+      cond(
+        (lhs.bytes(i) != rhs.bytes(i)) => {
+          return false;
+        },
+        true => ()
+      );
+    };
+    true
+  }),
+  (!=) : (fn(lhs: Self, rhs: Self) -> bool)({
+    return !(Self.(==)(lhs, rhs));
+  })
+));
+
+impl(str, Ord(str)(
+  (<) : (fn(lhs: Self, rhs: Self) -> bool)({
+    lhs_len := lhs.len();
+    rhs_len := rhs.len();
+    min_len := cond((lhs_len < rhs_len) => lhs_len, true => rhs_len);
+    i := usize(0);
+    while (i < min_len), (i = (i + usize(1))), {
+      cond(
+        (lhs.bytes(i) < rhs.bytes(i)) => { return true; },
+        (lhs.bytes(i) > rhs.bytes(i)) => { return false; },
+        true => ()
+      );
+    };
+    (lhs_len < rhs_len)
+  }),
+  (<=) : (fn(lhs: Self, rhs: Self) -> bool)({
+    return !(rhs < lhs);
+  }),
+  (>) : (fn(lhs: Self, rhs: Self) -> bool)({
+    return (rhs < lhs);
+  }),
+  (>=) : (fn(lhs: Self, rhs: Self) -> bool)({
+    return !(lhs < rhs);
+  })
+));
+
 export str;
 
 
@@ -3380,6 +3438,13 @@ impl(forall(OkType : Type, ErrorType : Type), Result(OkType, ErrorType),
     )
   ),
 
+  unwrap_err : (fn(self : Self) -> ErrorType)(
+    match(self,
+      .Err(error) => error,
+      .Ok(_) => panic("Called unwrap_err on an Ok value")
+    )
+  ),
+
   is_ok : (fn(self : Self) -> bool)(
     match(self,
       .Ok(_) => true,
@@ -3487,6 +3552,14 @@ impl(forall(T : Type), Iso(T),
 });
 export (^);
 
+/// === Arc ===
+arc :: (fn(forall(T : Type), own(value) : T) -> Arc(T))
+  Arc(T)(value)
+;
+impl(forall(T : Type), Arc(T), Send());
+
+export arc;
+
 /// === MaybeUninit ===
 extern "Yo",
   __yo_maybe_uninit_new : 
@@ -3534,29 +3607,92 @@ export
 
 // === Traits again ===
 /// === Iterator ===
-Iterator :: (fn(comptime(Item) : Type) -> comptime(Trait)) {
-  return trait(
-    Item := Item,
-    next :
-      fn(self : *(Self)) -> Option(Self.Item)
-  );
-};
+Iterator :: trait(
+  Item : Type,
+  next :
+    fn(self : *(Self)) -> Option(Self.Item)
+);
 export Iterator;
 
 /// === IntoIterator ===
-IntoIterator :: (fn(
-  comptime(Item) : Type,
-  comptime(IntoIter) : Type,
-  where(IntoIter <: Iterator(Item))) -> comptime(Trait)) {
-  return trait(
-    Item := Item,
-    IntoIter := IntoIter,
-    into_iter : 
-      fn(self : Self) -> Self.IntoIter
-  );
-};
+IntoIterator :: trait(
+  Item : Type,
+  IntoIter : Type,
+  into_iter :
+    fn(self : Self) -> Self.IntoIter,
+  where(Self.IntoIter <: Iterator(Item := Self.Item))
+);
 export IntoIterator;
 
+/// === Array Iterator ===
+/**
+ * Pointer iterator for Array(T, N) - yields *(T) pointers to each element
+ * Used by Array.iter()
+ */
+ArrayIterPtr :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _ptr   : *(T),
+    _index : usize,
+    _len   : usize
+  )
+);
+
+impl(forall(T : Type), ArrayIterPtr(T), Iterator(
+  Item : *(T),
+  next : (fn(self : *(Self)) -> Option(*(T)))(
+    cond(
+      (self._index >= self._len) => .None,
+      true => {
+        element_ptr := (self._ptr &+ self._index);
+        self._index = (self._index + usize(1));
+        .Some(element_ptr)
+      }
+    )
+  )
+));
+
+impl(forall(T : Type, N : usize), Array(T, N),
+  iter : (fn(self : *(Self)) -> ArrayIterPtr(T))(
+    ArrayIterPtr(T)(_ptr: &((self.*)(usize(0))), _index: usize(0), _len: N)
+  )
+);
+
+export ArrayIterPtr;
+
+/// === Slice Iterator ===
+/**
+ * Pointer iterator for Slice(T) - yields *(T) pointers to each element
+ * Used by Slice.iter()
+ */
+SliceIterPtr :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _slice : Slice(T),
+    _index : usize
+  )
+);
+
+impl(forall(T : Type), SliceIterPtr(T), Iterator(
+  Item : *(T),
+  next : (fn(self : *(Self)) -> Option(*(T)))(
+    cond(
+      (self._index >= self._slice.len()) => .None,
+      true => {
+        ptr := &((self._slice)(self._index));
+        self._index = (self._index + usize(1));
+        .Some(ptr)
+      }
+    )
+  )
+));
+
+impl(forall(T : Type), Slice(T),
+  iter : (fn(self : *(Self)) -> SliceIterPtr(T))(
+    SliceIterPtr(T)(_slice: self.*, _index: usize(0))
+  )
+);
+
+export SliceIterPtr;
+
 // === Conversion ===
 TryFrom :: (fn(comptime(From) : Type) -> comptime(Trait))(
   trait(

package/std/string/string.yo

@@ -157,6 +157,17 @@ impl(String,
   //   return self._bytes;
   // }),
 
+  /**
+   * Get a str view into the string's UTF-8 bytes
+   * Returns a fat pointer (pointer + length) without copying
+   */
+  as_str : (fn(self: Self) -> str)(
+    match(self._bytes._ptr,
+      .Some(p) => str.from_raw_parts(p, self._bytes._length),
+      .None => str.from_raw_parts(*(u8)(""), usize(0))
+    )
+  ),
+
   /**
    * Decode a UTF-8 encoded rune starting at the given byte index
    * Internal helper method
@@ -1345,7 +1356,94 @@ impl(String, Eq(String)(
   })
 ));
 
+// === Iterator support ===
+
+/**
+ * Rune iterator for String - yields decoded Unicode runes
+ * Used by chars() and into_iter()
+ */
+StringChars :: struct(
+  _string     : String,
+  _byte_index : usize
+);
+
+impl(StringChars, Iterator(
+  Item : rune,
+  next : (fn(self : *(Self)) -> Option(rune))(
+    cond(
+      (self._byte_index >= self._string._bytes.len()) => .None,
+      true => {
+        first_byte_opt := self._string._bytes.get(self._byte_index);
+        match(first_byte_opt,
+          .Some(first_byte) => {
+            // Determine byte length of this UTF-8 character
+            (byte_len : usize) = cond(
+              (first_byte < u8(0x80)) => usize(1),
+              ((first_byte >= u8(0xC0)) && (first_byte < u8(0xE0))) => usize(2),
+              ((first_byte >= u8(0xE0)) && (first_byte < u8(0xF0))) => usize(3),
+              ((first_byte >= u8(0xF0)) && (first_byte < u8(0xF8))) => usize(4),
+              true => usize(1)
+            );
+            r := self._string._decode_rune_at(self._byte_index);
+            self._byte_index = (self._byte_index + byte_len);
+            r
+          },
+          .None => .None
+        )
+      }
+    )
+  )
+));
+
+/**
+ * Byte iterator for String - yields raw UTF-8 bytes
+ * Used by bytes()
+ */
+StringBytes :: struct(
+  _string : String,
+  _index  : usize
+);
+
+impl(StringBytes, Iterator(
+  Item : u8,
+  next : (fn(self : *(Self)) -> Option(u8))(
+    cond(
+      (self._index >= self._string._bytes.len()) => .None,
+      true => {
+        byte_opt := self._string._bytes.get(self._index);
+        self._index = (self._index + usize(1));
+        byte_opt
+      }
+    )
+  )
+));
+
+impl(String,
+  /**
+   * Returns a rune iterator over the string's Unicode characters
+   */
+  chars : (fn(self : Self) -> StringChars)(
+    StringChars(_string: self, _byte_index: usize(0))
+  ),
+
+  /**
+   * Returns a byte iterator over the string's raw UTF-8 bytes
+   */
+  bytes : (fn(self : Self) -> StringBytes)(
+    StringBytes(_string: self, _index: usize(0))
+  ),
+
+  /**
+   * Consume the string and return a rune iterator (default iteration)
+   */
+  into_iter : (fn(self : Self) -> StringChars)(
+    StringChars(_string: self, _byte_index: usize(0))
+  )
+);
+
 export
   String,
-  StringError
+  StringError,
+  StringChars,
+  StringBytes
 ;

package/std/sync/once.yo

@@ -39,7 +39,7 @@ impl(Once,
   // Note: The fast-path read of _done is not strictly atomic, but since _done
   // is only ever set from false to true and the double-check inside the lock
   // prevents the function from running twice, this is safe in practice.
-  call : (fn(self: Self, f: Fn(() -> unit)) -> unit)({
+  call : (fn(self: Self, f: Impl(Fn() -> unit)) -> unit)({
     // Fast path: already done
     cond(
       self._done => (),

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

@@ -1,4 +1,4 @@
-// std/io/advise.yo - Kernel advisory hints
+// std/sys/advise.yo - Kernel advisory hints
 //
 // Advisory wrappers for file and memory access pattern hints.
 // Returns 0 on success, -errno / negative platform error on failure.