@shd101wyy/yo 0.1.29 → 0.1.30

package/std/libc/time.yo

@@ -1,4 +1,5 @@
 //! C11 `<time.h>` — date and time functions.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<time.h>",
   // Types

package/std/libc/unistd.yo

@@ -1,4 +1,5 @@
 //! POSIX `<unistd.h>` — standard symbolic constants and types.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<unistd.h>",
   // Types

package/std/libc/wctype.yo

@@ -1,4 +1,5 @@
 //! C11 `<wctype.h>` — wide character classification and conversion functions.
+pragma(Pragma.AllowUnsafe);
 { wint_t } :: import("./stdint");
 c_include(
   "<wctype.h>",

package/std/libc/windows.yo

@@ -1,6 +1,8 @@
 //! Windows-specific C API bindings.
 //! Only available when compiling for Windows.
 // Windows type aliases (using Yo types that match the C types)
+pragma(Pragma.AllowUnsafe);
+pragma(Pragma.AllowUnsafe);
 DWORD :: ulong; // unsigned long on Windows
 WCHAR :: ushort; // unsigned short (UTF-16 code unit)
 BOOL :: int; // int

package/std/log.yo

@@ -1,4 +1,5 @@
 //! Structured logging with configurable level and output destination.
+pragma(Pragma.AllowUnsafe);
 open(import("./string"));
 { ToString } :: import("./fmt");
 { fwrite, stdout, stderr, FILE } :: import("./libc/stdio");
@@ -7,9 +8,9 @@ Level :: enum(Trace, Debug, Info, Warn, Error);
 impl(
   Level,
   ToString(
-    to_string : (fn(self : *(Self)) -> String)(
+    to_string : (fn(ref(self) : Self) -> String)(
       match(
-        self.*,
+        self,
         .Trace => String.from("TRACE"),
         .Debug => String.from("DEBUG"),
         .Info => String.from("INFO "),
@@ -60,7 +61,7 @@ _write_string :: (fn(s : String, dest : *(FILE)) -> unit)({
   cond(
     (bytes.len() > usize(0)) => {
       ptr := bytes.ptr().unwrap();
-      fwrite(*(void)(ptr), usize(1), bytes.len(), dest);
+      unsafe(fwrite(*(void)(ptr), usize(1), bytes.len(), dest));
     },
     true => ()
   );
@@ -79,11 +80,11 @@ log :: (fn(level : Level, msg : String) -> unit)({
     .Stderr => stderr
   );
   // Write "[LEVEL] msg\n"
-  fwrite(*(void)(*(u8)("[")), usize(1), usize(1), dest);
+  unsafe(fwrite(*(void)(*(u8)("[")), usize(1), usize(1), dest));
   _write_string(level_str, dest);
-  fwrite(*(void)(*(u8)("] ")), usize(1), usize(2), dest);
+  unsafe(fwrite(*(void)(*(u8)("] ")), usize(1), usize(2), dest));
   _write_string(msg, dest);
-  fwrite(*(void)(*(u8)("\n")), usize(1), usize(1), dest);
+  unsafe(fwrite(*(void)(*(u8)("\n")), usize(1), usize(1), dest));
 });
 export(log);
 // ============================================================================

package/std/net/addr.yo

@@ -7,6 +7,7 @@
 //   { IpAddr, SocketAddr } :: import "std/net/addr";
 //
 //   addr := SocketAddr.new(IpAddr.loopback_v4(), u16(8080));
+pragma(Pragma.AllowUnsafe);
 open(import("../string"));
 { ToString } :: import("../fmt");
 { Writer } :: import("../fmt/writer");
@@ -40,7 +41,7 @@ impl(
     val := u32(0);
     i := usize(0);
     while(runtime(i < bytes.len()), {
-      ch := bytes.get(i).unwrap();
+      ch := bytes(i);
       cond(
         (ch == _ASCII_DOT) => {
           // '.' separator
@@ -145,10 +146,10 @@ impl(
       self -> {
         return(
           match(
-            self.*,
+            self,
             .V4(a, b, c, d) => {
               buf := Array(u8, usize(16)).fill(u8(0));
-              snprintf(*(char)(&(buf(usize(0)))), usize(16), "%d.%d.%d.%d", i32(a), i32(b), i32(c), i32(d));
+              unsafe(snprintf(*(char)(&(buf(usize(0)))), usize(16), "%d.%d.%d.%d", i32(a), i32(b), i32(c), i32(d)));
               String.from_cstr(&(buf(usize(0)))).unwrap()
             },
             .V6(segs) => {
@@ -205,7 +206,7 @@ impl(
       self -> {
         ip_str := self.ip.to_string();
         buf := Array(u8, usize(8)).fill(u8(0));
-        snprintf(*(char)(&(buf(usize(0)))), usize(8), "%d", i32(self.port));
+        unsafe(snprintf(*(char)(&(buf(usize(0)))), usize(8), "%d", i32(self.port)));
         port_str := String.from_cstr(&(buf(usize(0)))).unwrap();
         return(
           match(

package/std/net/dns.yo

@@ -9,14 +9,15 @@
 //   { IpAddr } :: import "std/net/addr";
 //   { Exception } :: import "std/error";
 //
-//   main :: (fn(io : IO, exn : Exception) -> unit)({
+//   main :: (fn(io : Io, exn : Exception) -> unit)({
 //     addrs := io.await(lookup_host(`localhost`, io), { io, exn });
 //     i := usize(0);
 //     while runtime((i < addrs.len())), {
-//       println(addrs.get(i).unwrap().to_string());
+//       println(addrs(i).to_string());
 //       i = (i + usize(1));
 //     };
 //   });
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
 { ArrayList } :: import("../collections/array_list");
@@ -24,14 +25,14 @@ open(import("../string"));
 open(import("../fmt"));
 { NetError } :: import("./errors");
 { IpAddr, SocketAddr } :: import("./addr");
-{ Error, AnyError, Exception, IOErr } :: import("../error");
+{ Error, AnyError, Exception, IoExn } :: import("../error");
 IO_dns :: import("../sys/dns");
 { AF_INET, AF_INET6 } :: import("../sys/socket");
 // ============================================================================
 // DNS lookup
 // ============================================================================
 /// Resolve a hostname to a list of IP addresses.
-lookup_host :: (fn(host : String, io : IO) -> Impl(Future(ArrayList(IpAddr), IOErr)))(
+lookup_host :: (fn(host : String, io : Io) -> Impl(Future(ArrayList(IpAddr), IoExn)))(
   io.async((e) => {
     host_cstr_bytes := host.to_cstr();
     host_cstr := host_cstr_bytes.ptr().unwrap();
@@ -82,13 +83,13 @@ lookup_host :: (fn(host : String, io : IO) -> Impl(Future(ArrayList(IpAddr), IOE
   })
 );
 /// Resolve a hostname and port to a list of socket addresses.
-resolve :: (fn(host : String, port : u16, io : IO) -> Impl(Future(ArrayList(SocketAddr), IOErr)))(
+resolve :: (fn(host : String, port : u16, io : Io) -> Impl(Future(ArrayList(SocketAddr), IoExn)))(
   io.async((e) => {
     addrs := e.io.await(lookup_host(host, io), e);
     result := ArrayList(SocketAddr).new();
     i := usize(0);
     while(runtime(i < addrs.len()), {
-      ip := addrs.get(i).unwrap();
+      ip := addrs(i);
       result.push(SocketAddr.new(ip, port));
       i = (i + usize(1));
     });

package/std/net/errors.yo

@@ -1,12 +1,12 @@
 //! Network error types.
 // std/net/errors.yo - Network error type
 //
-// Higher-level network error that wraps IOError with network-specific variants.
+// Higher-level network error that wraps IoError with network-specific variants.
 //
 // Example:
 //   { NetError } :: import "std/net/errors";
 open(import("../string"));
-{ IOError } :: import("../sys/errors");
+{ IoError } :: import("../sys/errors");
 { ToString } :: import("../fmt");
 { Error, AnyError, Exception } :: import("../error");
 // ============================================================================
@@ -33,14 +33,14 @@ NetError :: enum(
   /// DNS resolution failed.
   DNSFailed(msg : String),
   /// A wrapped lower-level I/O error.
-  IO(err : IOError),
+  Io(err : IoError),
   /// An unclassified network error with a message.
   Other(msg : String)
 );
 impl(
   NetError,
-  /// Convert an `IOError` into the corresponding `NetError` variant.
-  from_io : (fn(err : IOError) -> Self)(
+  /// Convert an `IoError` into the corresponding `NetError` variant.
+  from_io : (fn(err : IoError) -> Self)(
     match(
       err,
       .ConnectionRefused =>.ConnectionRefused,
@@ -51,7 +51,7 @@ impl(
       .TimedOut =>.TimedOut,
       .HostUnreachable =>.HostUnreachable,
       .NetworkUnreachable =>.NetworkUnreachable,
-      _ =>.IO(err)
+      _ =>.Io(err)
     )
   )
 );
@@ -71,7 +71,7 @@ impl(
           .HostUnreachable => String.from("host unreachable"),
           .NetworkUnreachable => String.from("network unreachable"),
           .DNSFailed(msg) => `DNS lookup failed: ${msg}`,
-          .IO(err) => err.to_string(),
+          .Io(err) => err.to_string(),
           .Other(msg) => msg
         );
         return(s);
@@ -87,7 +87,7 @@ impl(
   check : (fn(result : i32, exn : Exception) -> i32)(
     cond(
       (result >= i32(0)) => result,
-      true => exn.throw(dyn(Self.from_io(IOError.from_errno(i32(0) - result))))
+      true => exn.throw(dyn(Self.from_io(IoError.from_errno(i32(0) - result))))
     )
   )
 );

package/std/net/tcp.yo

@@ -9,21 +9,22 @@
 //   { SocketAddr, IpAddr } :: import "std/net/addr";
 //   { Exception } :: import "std/error";
 //
-//   main :: (fn(io : IO, exn : Exception) -> unit)({
+//   main :: (fn(io : Io, exn : Exception) -> unit)({
 //     addr := SocketAddr.new(IpAddr.any_v4(), u16(8080));
 //     listener := io.await(TcpListener.bind(addr, io), { io, exn });
 //     stream := io.await(listener.accept(io), { io, exn });
 //     // ...
 //   });
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
 { ArrayList } :: import("../collections/array_list");
 open(import("../string"));
 open(import("../fmt"));
 { NetError } :: import("./errors");
-{ IOError } :: import("../sys/errors");
+{ IoError } :: import("../sys/errors");
 { IpAddr, SocketAddr } :: import("./addr");
-{ Error, AnyError, Exception, IOErr } :: import("../error");
+{ Error, AnyError, Exception, IoExn } :: import("../error");
 IO_tcp :: import("../sys/tcp");
 { AF_INET, AF_INET6, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR, IPPROTO_TCP, TCP_NODELAY, SO_KEEPALIVE } :: import("../sys/socket");
 // ============================================================================
@@ -37,7 +38,7 @@ _make_sockaddr :: (fn(addr : SocketAddr) -> IO_tcp.SockAddr)(
       // Build the IP string "a.b.c.d"
       { snprintf } :: import("../libc/stdio");
       buf := Array(u8, usize(16)).fill(u8(0));
-      snprintf(*(char)(&(buf(usize(0)))), usize(16), "%d.%d.%d.%d", i32(a), i32(b), i32(c), i32(d));
+      unsafe(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(_) =>
@@ -46,7 +47,7 @@ _make_sockaddr :: (fn(addr : SocketAddr) -> IO_tcp.SockAddr)(
   )
 );
 _throw_io :: (fn(errno_val : i32, exn : Exception) -> unit)(
-  exn.throw(dyn(NetError.from_io(IOError.from_errno(errno_val))))
+  exn.throw(dyn(NetError.from_io(IoError.from_errno(errno_val))))
 );
 // ============================================================================
 // TcpStream (declared before TcpListener so accept can reference it)
@@ -69,7 +70,7 @@ TcpListener :: object(
 impl(
   TcpListener,
   /// Bind to a socket address and start listening.
-  bind : (fn(addr : SocketAddr, io : IO) -> Impl(Future(TcpListener, IOErr)))(
+  bind : (fn(addr : SocketAddr, io : Io) -> Impl(Future(TcpListener, IoExn)))(
     io.async((e) => {
       domain := cond(
         addr.ip.is_v4() => AF_INET,
@@ -106,7 +107,7 @@ impl(
     })
   ),
   /// Accept an incoming connection, returning a new `TcpStream`.
-  accept : (fn(self : Self, io : IO) -> Impl(Future(TcpStream, IOErr)))({
+  accept : (fn(self : Self, io : Io) -> Impl(Future(TcpStream, IoExn)))({
     fd := self._fd;
     io.async((e) => {
       // Allocate space for the peer address
@@ -141,7 +142,7 @@ impl(
     self._local_addr
   ),
   /// Close the listener socket.
-  close : (fn(self : Self, io : IO) -> Impl(Future(unit, IOErr)))({
+  close : (fn(self : Self, io : Io) -> Impl(Future(unit, IoExn)))({
     fd := self._fd;
     io.async((e) => {
       cond(
@@ -186,7 +187,7 @@ export(TcpListener);
 impl(
   TcpStream,
   /// Connect to a remote address, returning a new `TcpStream`.
-  connect : (fn(addr : SocketAddr, io : IO) -> Impl(Future(TcpStream, IOErr)))(
+  connect : (fn(addr : SocketAddr, io : Io) -> Impl(Future(TcpStream, IoExn)))(
     io.async((e) => {
       domain := cond(
         addr.ip.is_v4() => AF_INET,
@@ -215,7 +216,7 @@ impl(
   ),
   /// Read bytes from the stream into `buf`.
   /// Returns the number of bytes read, or 0 if the peer closed the connection.
-  read : (fn(self : Self, buf : *(u8), size : usize, io : IO) -> Impl(Future(i32, IOErr)))({
+  read : (fn(self : Self, buf : *(u8), size : usize, io : Io) -> Impl(Future(i32, IoExn)))({
     fd := self._fd;
     io.async((e) => {
       r := e.io.await(IO_tcp.recv(fd, buf, size, i32(0)), e.io);
@@ -224,7 +225,7 @@ impl(
   }),
   /// Write a `str` to the stream.
   /// Returns the number of bytes written.
-  write_str : (fn(self : Self, data : str, io : IO) -> Impl(Future(i32, IOErr)))({
+  write_str : (fn(self : Self, data : str, io : Io) -> Impl(Future(i32, IoExn)))({
     fd := self._fd;
     s := String.from(data);
     s_bytes := s.as_bytes();
@@ -235,7 +236,7 @@ impl(
   }),
   /// Write a `String` to the stream.
   /// Returns the number of bytes written.
-  write_string : (fn(self : Self, data : String, io : IO) -> Impl(Future(i32, IOErr)))({
+  write_string : (fn(self : Self, data : String, io : Io) -> Impl(Future(i32, IoExn)))({
     fd := self._fd;
     data_bytes := data.as_bytes();
     io.async((e) => {
@@ -245,7 +246,7 @@ impl(
   }),
   /// Write raw bytes from an `ArrayList(u8)` to the stream.
   /// Returns the number of bytes written.
-  write_bytes : (fn(self : Self, data : ArrayList(u8), io : IO) -> Impl(Future(i32, IOErr)))({
+  write_bytes : (fn(self : Self, data : ArrayList(u8), io : Io) -> Impl(Future(i32, IoExn)))({
     fd := self._fd;
     io.async((e) => {
       r := e.io.await(IO_tcp.send(fd, data.ptr().unwrap(), data.len(), i32(0)), e.io);
@@ -253,7 +254,7 @@ impl(
     })
   }),
   /// Read all available data from the stream into a byte list.
-  read_bytes : (fn(self : Self, io : IO) -> Impl(Future(ArrayList(u8), IOErr)))({
+  read_bytes : (fn(self : Self, io : Io) -> Impl(Future(ArrayList(u8), IoExn)))({
     fd := self._fd;
     io.async((e) => {
       buf_size := usize(4096);
@@ -286,7 +287,7 @@ impl(
   }),
   /// Shut down part or all of the connection.
   /// `how`: 0 = read, 1 = write, 2 = both.
-  shutdown : (fn(self : Self, how : i32, io : IO) -> Impl(Future(unit, IOErr)))({
+  shutdown : (fn(self : Self, how : i32, io : Io) -> Impl(Future(unit, IoExn)))({
     fd := self._fd;
     io.async((e) => {
       r := e.io.await(IO_tcp.shutdown(fd, how), e.io);
@@ -299,7 +300,7 @@ impl(
     })
   }),
   /// Close the stream.
-  close : (fn(self : Self, io : IO) -> Impl(Future(unit, IOErr)))({
+  close : (fn(self : Self, io : Io) -> Impl(Future(unit, IoExn)))({
     fd := self._fd;
     io.async((e) => {
       cond(
@@ -326,7 +327,7 @@ impl(
     self._fd
   ),
   /// Enable or disable TCP_NODELAY (disables Nagle's algorithm).
-  set_nodelay : (fn(self : Self, nodelay : bool, io : IO) -> Impl(Future(unit, IOErr)))({
+  set_nodelay : (fn(self : Self, nodelay : bool, io : Io) -> Impl(Future(unit, IoExn)))({
     sock_fd := self._fd;
     io.async((e) => {
       val := cond(nodelay => i32(1), true => i32(0));
@@ -341,7 +342,7 @@ impl(
     })
   }),
   /// Enable or disable SO_KEEPALIVE on the socket.
-  set_keepalive : (fn(self : Self, enabled : bool, io : IO) -> Impl(Future(unit, IOErr)))({
+  set_keepalive : (fn(self : Self, enabled : bool, io : Io) -> Impl(Future(unit, IoExn)))({
     sock_fd := self._fd;
     io.async((e) => {
       val := cond(enabled => i32(1), true => i32(0));

package/std/net/udp.yo

@@ -9,20 +9,21 @@
 //   { SocketAddr, IpAddr } :: import "std/net/addr";
 //   { Exception } :: import "std/error";
 //
-//   main :: (fn(io : IO, exn : Exception) -> unit)({
+//   main :: (fn(io : Io, exn : Exception) -> unit)({
 //     addr := SocketAddr.new(IpAddr.loopback_v4(), u16(9999));
 //     sock := io.await(UdpSocket.bind(addr, io), { io, exn });
 //     io.await(sock.close(io), { io, exn });
 //   });
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
 { ArrayList } :: import("../collections/array_list");
 open(import("../string"));
 open(import("../fmt"));
 { NetError } :: import("./errors");
-{ IOError } :: import("../sys/errors");
+{ IoError } :: import("../sys/errors");
 { IpAddr, SocketAddr } :: import("./addr");
-{ Error, AnyError, Exception, IOErr } :: import("../error");
+{ Error, AnyError, Exception, IoExn } :: import("../error");
 IO_udp :: import("../sys/udp");
 IO_tcp :: import("../sys/tcp");
 { AF_INET, AF_INET6, SOCK_DGRAM, SOL_SOCKET, SO_BROADCAST } :: import("../sys/socket");
@@ -35,7 +36,7 @@ _make_sockaddr :: (fn(addr : SocketAddr) -> IO_tcp.SockAddr)(
     addr.ip,
     .V4(a, b, c, d) => {
       buf := Array(u8, usize(16)).fill(u8(0));
-      snprintf(*(char)(&(buf(usize(0)))), usize(16), "%d.%d.%d.%d", i32(a), i32(b), i32(c), i32(d));
+      unsafe(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(_) =>
@@ -43,7 +44,7 @@ _make_sockaddr :: (fn(addr : SocketAddr) -> IO_tcp.SockAddr)(
   )
 );
 _throw_net_io :: (fn(errno_val : i32, exn : Exception) -> unit)(
-  exn.throw(dyn(NetError.from_io(IOError.from_errno(errno_val))))
+  exn.throw(dyn(NetError.from_io(IoError.from_errno(errno_val))))
 );
 // ============================================================================
 // UdpSocket
@@ -57,7 +58,7 @@ UdpSocket :: object(
 impl(
   UdpSocket,
   /// Create and bind a UDP socket to the given address.
-  bind : (fn(addr : SocketAddr, io : IO) -> Impl(Future(UdpSocket, IOErr)))(
+  bind : (fn(addr : SocketAddr, io : Io) -> Impl(Future(UdpSocket, IoExn)))(
     io.async((e) => {
       domain := cond(
         addr.ip.is_v4() => AF_INET,
@@ -80,7 +81,7 @@ impl(
   ),
   /// Send a datagram to a specific address.
   /// Returns the number of bytes sent.
-  send_to : (fn(self : Self, data : ArrayList(u8), addr : SocketAddr, io : IO) -> Impl(Future(i32, IOErr)))({
+  send_to : (fn(self : Self, data : ArrayList(u8), addr : SocketAddr, io : Io) -> Impl(Future(i32, IoExn)))({
     fd := self._fd;
     io.async((e) => {
       saddr := _make_sockaddr(addr);
@@ -91,7 +92,7 @@ impl(
   }),
   /// Receive a datagram into the provided buffer.
   /// Returns the number of bytes received.
-  recv : (fn(self : Self, buf : *(u8), size : usize, io : IO) -> Impl(Future(i32, IOErr)))({
+  recv : (fn(self : Self, buf : *(u8), size : usize, io : Io) -> Impl(Future(i32, IoExn)))({
     fd := self._fd;
     io.async((e) => {
       r := e.io.await(IO_udp.recv(fd, buf, size, i32(0)), e.io);
@@ -100,7 +101,7 @@ impl(
   }),
   /// Receive a datagram and retrieve the sender's address.
   /// Returns the number of bytes received.
-  recv_from : (fn(self : Self, buf : *(u8), size : usize, src_addr : *(u8), src_addr_len : *(u32), io : IO) -> Impl(Future(i32, IOErr)))({
+  recv_from : (fn(self : Self, buf : *(u8), size : usize, src_addr : *(u8), src_addr_len : *(u32), io : Io) -> Impl(Future(i32, IoExn)))({
     fd := self._fd;
     io.async((e) => {
       r := e.io.await(IO_udp.recvfrom(fd, buf, size, i32(0), src_addr, src_addr_len), e.io);
@@ -108,7 +109,7 @@ impl(
     })
   }),
   /// Send data on a connected socket (requires prior connect).
-  send : (fn(self : Self, data : ArrayList(u8), io : IO) -> Impl(Future(i32, IOErr)))({
+  send : (fn(self : Self, data : ArrayList(u8), io : Io) -> Impl(Future(i32, IoExn)))({
     fd := self._fd;
     io.async((e) => {
       r := e.io.await(IO_udp.send(fd, data.ptr().unwrap(), data.len(), i32(0)), e.io);
@@ -116,7 +117,7 @@ impl(
     })
   }),
   /// Close the socket.
-  close : (fn(self : Self, io : IO) -> Impl(Future(unit, IOErr)))({
+  close : (fn(self : Self, io : Io) -> Impl(Future(unit, IoExn)))({
     fd := self._fd;
     io.async((e) => {
       cond(
@@ -135,7 +136,7 @@ impl(
     })
   }),
   /// Enable or disable SO_BROADCAST on the socket.
-  set_broadcast : (fn(self : Self, enabled : bool, io : IO) -> Impl(Future(unit, IOErr)))({
+  set_broadcast : (fn(self : Self, enabled : bool, io : Io) -> Impl(Future(unit, IoExn)))({
     fd := self._fd;
     io.async((e) => {
       val := cond(enabled => i32(1), true => i32(0));

package/std/os/signal.yo

@@ -10,7 +10,7 @@
 //! handler :: (fn(data: *(u8)) -> unit)({ println("Caught SIGINT"); });
 //! on_signal(.Interrupt, handler);
 //! ```
-{ IOError } :: import("../sys/errors");
+{ IoError } :: import("../sys/errors");
 { on_signal : _on_signal, off_signal : _off_signal, SignalHandler } :: import("../sys/signal");
 { platform, Platform } :: import("../process");
 { Error, AnyError, Exception } :: import("../error");
@@ -83,7 +83,7 @@ on_signal :: (fn(sig : Signal, handler : SignalHandler, exn : Exception) -> unit
   r := _on_signal(num, handler);
   cond(
     (r < i32(0)) => {
-      exn.throw(dyn(IOError.from_errno(i32(0) - r)));
+      exn.throw(dyn(IoError.from_errno(i32(0) - r)));
     },
     true => ()
   );
@@ -94,7 +94,7 @@ off_signal :: (fn(sig : Signal, exn : Exception) -> unit)({
   r := _off_signal(num);
   cond(
     (r < i32(0)) => {
-      exn.throw(dyn(IOError.from_errno(i32(0) - r)));
+      exn.throw(dyn(IoError.from_errno(i32(0) - r)));
     },
     true => ()
   );

package/std/path.yo

@@ -1,4 +1,5 @@
 //! Cross-platform filesystem path manipulation.
+pragma(Pragma.AllowUnsafe);
 open(import("./string"));
 open(import("./fmt"));
 open(import("./collections/array_list"));