@shd101wyy/yo 0.1.28 → 0.1.30

package/std/sys/file.yo

@@ -2,64 +2,65 @@
 //!
 //! Provides low-level file I/O wrappers around the C runtime externs.
 //!
-//! Async operations return `IOFuture` which resolves to:
+//! Async operations return `IoFuture` which resolves to:
 //! - Positive value: success (fd for open, bytes for read/write, 0 for others)
 //! - Negative value: -errno on failure
-// Use IOError.from_result() to convert results to Result(i32, IOError).
+// Use IoError.from_result() to convert results to Result(i32, IoError).
 //
 // Example:
-//   IO :: import "std/io";
+//   Io :: import "std/io";
 //
 //   task := async {
 //     (path : *(u8)) = "test.txt";
-//     fd_result := await IO.openat(IO.AT_FDCWD, path, IO.O_RDONLY, i32(0));
-//     fd := IOError.from_result(fd_result).unwrap();
-//     close_result := await IO.close(fd);
+//     fd_result := await Io.openat(Io.AT_FDCWD, path, Io.O_RDONLY, i32(0));
+//     fd := IoError.from_result(fd_result).unwrap();
+//     close_result := await Io.close(fd);
 //   };
-{ IOFuture } :: import("./future.yo");
+pragma(Pragma.AllowUnsafe);
+{ IoFuture } :: import("./future.yo");
 { __yo_async_read_start, __yo_async_write_start, __yo_async_openat_start, __yo_async_close_start, __yo_async_statx_start, __yo_async_fsync_start, __yo_async_fdatasync_start, __yo_async_ftruncate_start, __yo_file_open, __yo_file_close, __yo_file_size } :: import("./externs.yo");
 // ============================================================================
-// Async File Operations (return IOFuture, use with await)
+// Async File Operations (return IoFuture, use with await)
 // ============================================================================
 // Open a file relative to dirfd. Use AT_FDCWD for current directory.
 // Returns fd on success, -errno on failure.
-openat :: (fn(dirfd : i32, path : *(u8), flags : i32, mode : i32) -> IOFuture)(
+openat :: (fn(dirfd : i32, path : *(u8), flags : i32, mode : i32) -> IoFuture)(
   __yo_async_openat_start(dirfd, path, flags, mode)
 );
 // Close a file descriptor.
 // Returns 0 on success, -errno on failure.
-close :: (fn(fd : i32) -> IOFuture)(
+close :: (fn(fd : i32) -> IoFuture)(
   __yo_async_close_start(fd)
 );
 // Read from fd into buffer at the given offset.
 // Returns number of bytes read on success, -errno on failure.
-read :: (fn(fd : i32, buffer : *(u8), size : u32, offset : u64) -> IOFuture)(
+read :: (fn(fd : i32, buffer : *(u8), size : u32, offset : u64) -> IoFuture)(
   __yo_async_read_start(fd, buffer, size, offset)
 );
 // Write buffer to fd at the given offset.
 // Returns number of bytes written on success, -errno on failure.
-write :: (fn(fd : i32, buffer : *(u8), size : u32, offset : u64) -> IOFuture)(
+write :: (fn(fd : i32, buffer : *(u8), size : u32, offset : u64) -> IoFuture)(
   __yo_async_write_start(fd, buffer, size, offset)
 );
 // Get file metadata via statx. Results are written to statxbuf.
 // Use Statx object to wrap and read the buffer.
 // Returns 0 on success, -errno on failure.
-statx :: (fn(dirfd : i32, path : *(u8), flags : i32, mask : u32, statxbuf : *(u8)) -> IOFuture)(
+statx :: (fn(dirfd : i32, path : *(u8), flags : i32, mask : u32, statxbuf : *(u8)) -> IoFuture)(
   __yo_async_statx_start(dirfd, path, flags, mask, statxbuf)
 );
 // Sync file data and metadata to disk.
 // Returns 0 on success, -errno on failure.
-fsync :: (fn(fd : i32) -> IOFuture)(
+fsync :: (fn(fd : i32) -> IoFuture)(
   __yo_async_fsync_start(fd)
 );
 // Sync file data (but not metadata) to disk.
 // Returns 0 on success, -errno on failure.
-fdatasync :: (fn(fd : i32) -> IOFuture)(
+fdatasync :: (fn(fd : i32) -> IoFuture)(
   __yo_async_fdatasync_start(fd)
 );
 // Truncate file to the given length.
 // Returns 0 on success, -errno on failure.
-ftruncate :: (fn(fd : i32, length : i64) -> IOFuture)(
+ftruncate :: (fn(fd : i32, length : i64) -> IoFuture)(
   __yo_async_ftruncate_start(fd, length)
 );
 // ============================================================================

package/std/sys/future.yo

@@ -1,13 +1,14 @@
-//! `IOFuture` type — opaque handle to a C async I/O future struct.
+//! `IoFuture` type — opaque handle to a C async I/O future struct.
 // ============================================================================
 // Extern type for I/O Future
 // ============================================================================
+pragma(Pragma.AllowUnsafe);
 extern(
   "Yo",
   __yo_io_future_t : Type
 );
-IOFuture :: Impl(Concrete(__yo_io_future_t), Future(i32));
+IoFuture :: Impl(Concrete(__yo_io_future_t), Future(i32));
 export(
   __yo_io_future_t,
-  IOFuture
+  IoFuture
 );

package/std/sys/iov.yo

@@ -2,6 +2,7 @@
 //!
 //! Synchronous wrappers for vectored file descriptor I/O.
 //! Returns byte count on success, -errno / negative platform error on failure.
+pragma(Pragma.AllowUnsafe);
 { __yo_sync_readv, __yo_sync_writev, __yo_sync_preadv, __yo_sync_pwritev, __yo_iovec_size, __yo_iovec_set } :: import("./externs.yo");
 iovec_size :: (fn() -> usize)(
   __yo_iovec_size()

package/std/sys/mmap.yo

@@ -6,6 +6,7 @@
 //! - Mapped pointer on success
 //! - Encoded error pointer on failure (negative errno cast to pointer)
 // Use is_error(ptr) and error_code(ptr) to detect/decode mmap failures.
+pragma(Pragma.AllowUnsafe);
 { platform, Platform } :: import("../process");
 { __yo_sync_mmap, __yo_sync_mmap_is_error, __yo_sync_mmap_errno, __yo_sync_munmap, __yo_sync_mprotect, __yo_sync_msync } :: import("./externs.yo");
 // Protection constants

package/std/sys/path.yo

@@ -2,6 +2,7 @@
 //!
 //! Synchronous wrapper for `realpath`.
 //! Returns 0 on success, -errno on failure.
+pragma(Pragma.AllowUnsafe);
 { __yo_sync_realpath } :: import("./externs.yo");
 // Resolve a path to its canonical absolute form (resolves symlinks, . and ..).
 // Writes result to `resolved` buffer (must be at least PATH_MAX bytes).

package/std/sys/perm.yo

@@ -1,7 +1,7 @@
 //! File permission and access operations.
 //!
 //! Provides synchronous wrappers for `chmod`, `chown`, and `access` operations.
-//! All operations return `i32` directly (no `IOFuture` overhead).
+//! All operations return `i32` directly (no `IoFuture` overhead).
 //!
 //! Returns:
 //! - 0: success
@@ -18,6 +18,7 @@
 //   // Change file permissions to 0644
 //   ret2 := perm.chmodat(AT_FDCWD, *(u8)("/tmp/test.txt"), u32(0o644), i32(0));
 //   assert(ret2 == i32(0));
+pragma(Pragma.AllowUnsafe);
 { __yo_sync_access, __yo_sync_fchmod, __yo_sync_fchmodat, __yo_sync_fchown, __yo_sync_fchownat } :: import("./externs.yo");
 // ============================================================================
 // chmod — Change file permissions

package/std/sys/pipe.yo

@@ -7,6 +7,7 @@
 //!
 //! - `pipe`: 0 on success, -errno on failure
 //! - `dup`/`dup2`: new fd on success, -errno on failure
+pragma(Pragma.AllowUnsafe);
 { __yo_sync_pipe, __yo_sync_dup, __yo_sync_dup2 } :: import("./externs.yo");
 // Create a pipe pair (pipefd[0] = read, pipefd[1] = write).
 // Returns 0 on success, -errno on failure.

package/std/sys/process.yo

@@ -1,13 +1,14 @@
 //! Child process management.
 //!
 //! Provides cross-platform child process spawning, waiting, and signal delivery.
-//! All async operations return `IOFuture` which resolves to:
+//! All async operations return `IoFuture` which resolves to:
 //! - Positive value: success (pid for spawn, status for waitpid)
 //! - Negative value: -errno on failure
 //!
 //! `argv`/`envp` are NULL-terminated arrays of C strings.
 // Use `?*(u8)` for entries so .None can be used as the terminator.
-{ IOFuture } :: import("./future.yo");
+pragma(Pragma.AllowUnsafe);
+{ IoFuture } :: import("./future.yo");
 { __yo_async_spawn_start, __yo_async_waitpid_start, __yo_process_exit_status, __yo_process_term_signal, __yo_kill } :: import("./externs.yo");
 // Spawn a child process.
 // Returns the child pid on success, -errno on failure.
@@ -22,13 +23,13 @@ spawn :: (
     stdin_fd : i32,
     stdout_fd : i32,
     stderr_fd : i32
-  ) -> IOFuture
+  ) -> IoFuture
 )(
   __yo_async_spawn_start(file, argv, envp, stdin_fd, stdout_fd, stderr_fd)
 );
 // Wait for a child process to exit.
 // Returns the exit status (encoded; use exit_status/term_signal helpers).
-waitpid :: (fn(pid : i32, options : i32) -> IOFuture)(
+waitpid :: (fn(pid : i32, options : i32) -> IoFuture)(
   __yo_async_waitpid_start(pid, options)
 );
 // Send a signal to a process.

package/std/sys/signal.yo

@@ -1,6 +1,7 @@
 //! Signal handling functions.
 //!
 //! Provides low-level wrappers for signal registration and delivery.
+pragma(Pragma.AllowUnsafe);
 { __yo_signal_start, __yo_signal_stop, __yo_kill } :: import("./externs.yo");
 SignalHandler :: (fn(data : *(u8)) -> unit);
 // Register a signal handler.

package/std/sys/socketpair.yo

@@ -2,6 +2,7 @@
 //!
 //! Synchronous wrapper for `socketpair`-like behavior.
 //! Returns 0 on success, negative error on failure.
+pragma(Pragma.AllowUnsafe);
 { __yo_sync_socketpair } :: import("./externs.yo");
 // Create a pair of connected sockets.
 // Writes two socket fds into `sv` (sv[0], sv[1]).

package/std/sys/sockinfo.yo

@@ -2,6 +2,7 @@
 //!
 //! Synchronous wrappers for socket metadata operations.
 //! Returns 0 on success, -errno (or negative platform socket error) on failure.
+pragma(Pragma.AllowUnsafe);
 { __yo_sync_getsockname, __yo_sync_getpeername, __yo_sync_getsockopt, __yo_sync_setsockopt } :: import("./externs.yo");
 // Get local address of a socket.
 // Writes the address into `addr` buffer and updates `addrlen` with actual size.

package/std/sys/statfs.yo

@@ -3,7 +3,7 @@
 //! Provides a synchronous wrapper around `statfs` and typed accessors
 //! for the statfs buffer returned by the C runtime.
 //!
-//! All operations return `i32` directly (no `IOFuture` overhead):
+//! All operations return `i32` directly (no `IoFuture` overhead):
 //! - 0 on success
 //! - Negative value: -errno on failure
 //
@@ -16,6 +16,7 @@
 //   assert(ret == i32(0));
 //   block_size := statfs.statfs_bsize(buf);
 //   free(.Some(*(void)(buf)));
+pragma(Pragma.AllowUnsafe);
 { __yo_sync_statfs, __yo_statfs_buf_size, __yo_statfs_type, __yo_statfs_bsize, __yo_statfs_blocks, __yo_statfs_bfree, __yo_statfs_bavail, __yo_statfs_files, __yo_statfs_ffree } :: import("./externs.yo");
 // ============================================================================
 // statfs — Filesystem statistics (sync)

package/std/sys/statx.yo

@@ -2,6 +2,7 @@
 //!
 //! Object wrapper around the C statx buffer, providing
 //! accessor methods for file metadata.
+pragma(Pragma.AllowUnsafe);
 { S_IFMT, S_IFREG, S_IFDIR, S_IFLNK } :: import("./constants.yo");
 { __yo_statx_mode, __yo_statx_size, __yo_statx_uid, __yo_statx_gid, __yo_statx_ino, __yo_statx_nlink, __yo_statx_mtime_sec, __yo_statx_mtime_nsec, __yo_statx_atime_sec, __yo_statx_atime_nsec, __yo_statx_ctime_sec, __yo_statx_ctime_nsec } :: import("./externs.yo");
 // ============================================================================

package/std/sys/sysinfo.yo

@@ -2,6 +2,7 @@
 //!
 //! Synchronous wrappers for `uname`/`gethostname`.
 //! Returns 0 on success, -errno / negative platform error on failure.
+pragma(Pragma.AllowUnsafe);
 { platform, Platform } :: import("../process");
 { __yo_sync_uname, __yo_sync_gethostname } :: import("./externs.yo");
 // uname() layout constants.

package/std/sys/tcp.yo

@@ -3,7 +3,7 @@
 //! Provides TCP socket wrappers around the low-level C runtime externs.
 //! Uses the socket address helpers to construct `sockaddr_in`/`sockaddr_in6` buffers.
 //!
-//! All async operations return `IOFuture` which resolves to:
+//! All async operations return `IoFuture` which resolves to:
 //! - Positive value: success (fd for socket/accept, bytes for send/recv, 0 for others)
 //! - Negative value: -errno on failure
 //
@@ -33,9 +33,10 @@
 //     client_fd := await tcp.accept(sockfd);
 //     // ...
 //   };
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator.yo");
 { malloc, free } :: GlobalAllocator;
-{ IOFuture } :: import("./future.yo");
+{ IoFuture } :: import("./future.yo");
 { __yo_async_socket_start, __yo_async_bind_start, __yo_async_listen_start, __yo_async_accept_start, __yo_async_connect_start, __yo_async_send_start, __yo_async_recv_start, __yo_async_shutdown_start, __yo_async_setsockopt_start, __yo_async_getsockopt_start, __yo_async_close_start, __yo_sockaddr_set_family, __yo_sockaddr_get_family, __yo_sockaddr_in_set_port, __yo_sockaddr_in_get_port, __yo_sockaddr_in_set_addr, __yo_sockaddr_in_get_addr, __yo_sockaddr_in6_set_port, __yo_sockaddr_in6_get_port, __yo_sockaddr_in6_set_addr, __yo_sockaddr_in6_get_addr, __yo_inet_pton, __yo_inet_ntop, __yo_htons, __yo_ntohs, __yo_htonl, __yo_ntohl } :: import("./externs.yo");
 { AF_INET, AF_INET6, SOCK_STREAM, sockaddr_in_size, sockaddr_in6_size } :: import("./socket.yo");
 // ============================================================================
@@ -47,55 +48,55 @@ SockAddr :: struct(
 );
 export(SockAddr);
 // ============================================================================
-// Core TCP Operations (return IOFuture, use with await)
+// Core TCP Operations (return IoFuture, use with await)
 // ============================================================================
 // Create a TCP socket.
 // domain: AF_INET or AF_INET6
 // Returns fd on success, -errno on failure.
-socket :: (fn(domain : i32, sock_type : i32, protocol : i32) -> IOFuture)(
+socket :: (fn(domain : i32, sock_type : i32, protocol : i32) -> IoFuture)(
   __yo_async_socket_start(domain, sock_type, protocol)
 );
 // Bind a socket to a local address.
 // Returns 0 on success, -errno on failure.
-bind :: (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IOFuture)(
+bind :: (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IoFuture)(
   __yo_async_bind_start(sockfd, addr, addrlen)
 );
 // Listen for incoming connections on a socket.
 // backlog: maximum length of the pending connections queue.
 // Returns 0 on success, -errno on failure.
-listen :: (fn(sockfd : i32, backlog : i32) -> IOFuture)(
+listen :: (fn(sockfd : i32, backlog : i32) -> IoFuture)(
   __yo_async_listen_start(sockfd, backlog)
 );
 // Accept an incoming connection on a listening socket.
 // Returns the new connection fd on success, -errno on failure.
 // addr/addrlen can be used to retrieve the peer address.
-accept :: (fn(sockfd : i32, addr : *(u8), addrlen : *(u32)) -> IOFuture)(
+accept :: (fn(sockfd : i32, addr : *(u8), addrlen : *(u32)) -> IoFuture)(
   __yo_async_accept_start(sockfd, addr, addrlen)
 );
 // Connect to a remote address.
 // Returns 0 on success, -errno on failure.
-connect :: (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IOFuture)(
+connect :: (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IoFuture)(
   __yo_async_connect_start(sockfd, addr, addrlen)
 );
 // Send data on a connected socket.
 // Returns number of bytes sent on success, -errno on failure.
-send :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IOFuture)(
+send :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IoFuture)(
   __yo_async_send_start(sockfd, buf, len, flags)
 );
 // Receive data from a connected socket.
 // Returns number of bytes received on success (0 = peer closed), -errno on failure.
-recv :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IOFuture)(
+recv :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IoFuture)(
   __yo_async_recv_start(sockfd, buf, len, flags)
 );
 // Shut down part of a full-duplex connection.
 // how: SHUT_RD (0), SHUT_WR (1), or SHUT_RDWR (2).
 // Returns 0 on success, -errno on failure.
-shutdown :: (fn(sockfd : i32, how : i32) -> IOFuture)(
+shutdown :: (fn(sockfd : i32, how : i32) -> IoFuture)(
   __yo_async_shutdown_start(sockfd, how)
 );
 // Close a socket file descriptor.
 // Returns 0 on success, -errno on failure.
-close :: (fn(fd : i32) -> IOFuture)(
+close :: (fn(fd : i32) -> IoFuture)(
   __yo_async_close_start(fd)
 );
 // ============================================================================
@@ -103,12 +104,12 @@ close :: (fn(fd : i32) -> IOFuture)(
 // ============================================================================
 // Set a socket option (raw).
 // Returns 0 on success, -errno on failure.
-setsockopt :: (fn(sockfd : i32, level : i32, optname : i32, optval : *(u8), optlen : u32) -> IOFuture)(
+setsockopt :: (fn(sockfd : i32, level : i32, optname : i32, optval : *(u8), optlen : u32) -> IoFuture)(
   __yo_async_setsockopt_start(sockfd, level, optname, optval, optlen)
 );
 // Get a socket option (raw).
 // Returns 0 on success, -errno on failure.
-getsockopt :: (fn(sockfd : i32, level : i32, optname : i32, optval : *(u8), optlen : *(u32)) -> IOFuture)(
+getsockopt :: (fn(sockfd : i32, level : i32, optname : i32, optval : *(u8), optlen : *(u32)) -> IoFuture)(
   __yo_async_getsockopt_start(sockfd, level, optname, optval, optlen)
 );
 // ============================================================================

package/std/sys/temp.yo

@@ -7,6 +7,7 @@
 //!
 //! - `mkdtemp`: 0 on success, -errno on failure
 //! - `mkstemp`: fd on success, -errno on failure
+pragma(Pragma.AllowUnsafe);
 { __yo_sync_mkdtemp, __yo_sync_mkstemp } :: import("./externs.yo");
 // Create a temporary directory from template (e.g., "/tmp/myapp-XXXXXX").
 // The template is modified in-place with the actual path.

package/std/sys/time.yo

@@ -1,7 +1,7 @@
 //! File timestamp operations.
 //!
 //! Provides synchronous wrappers for `utime`/`futime`/`lutime` to change file timestamps.
-//! All operations return `i32` directly (no `IOFuture` overhead).
+//! All operations return `i32` directly (no `IoFuture` overhead).
 //!
 //! Returns:
 //! - 0: success
@@ -21,6 +21,7 @@
 //   // Set timestamps on an open fd
 //   ret2 := time.futime(fd, i64(1000000), i64(0), i64(2000000), i64(0));
 //   assert(ret2 == i32(0));
+pragma(Pragma.AllowUnsafe);
 { __yo_sync_utime, __yo_sync_futime, __yo_sync_lutime } :: import("./externs.yo");
 // ============================================================================
 // utime — Change file timestamps by path

package/std/sys/timer.yo

@@ -3,21 +3,21 @@
 //! Provides high-level async timer functions:
 //! - `sleep(ms)` — async sleep for the given number of milliseconds
 //!
-//! Returns an `IOFuture` that resolves to a positive value on success
+//! Returns an `IoFuture` that resolves to a positive value on success
 //! or a negative errno. Use with `await` in async contexts.
 //
 // Example:
-//   IO :: import "std/io";
+//   Io :: import "std/io";
 //
 //   task := async {
 //     // Sleep for 100 milliseconds
-//     result := await IO.sleep(u64(100));
+//     result := await Io.sleep(u64(100));
 //     printf("Woke up! result=%d\n", result);
 //   };
-{ IOFuture } :: import("./future.yo");
-{ IOError } :: import("./errors.yo");
+{ IoFuture } :: import("./future.yo");
+{ IoError } :: import("./errors.yo");
 { __yo_async_sleep_start } :: import("./externs.yo");
-sleep :: (fn(milliseconds : u64) -> IOFuture)(
+sleep :: (fn(milliseconds : u64) -> IoFuture)(
   __yo_async_sleep_start(milliseconds)
 );
 export(sleep);

package/std/sys/tty.yo

@@ -1,4 +1,5 @@
 //! TTY operations.
+pragma(Pragma.AllowUnsafe);
 { __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");
 /// Terminal window size.
@@ -13,7 +14,7 @@ WinSize :: struct(
 tty_init :: (fn(fd : i32) -> i32)(
   __yo_tty_init(fd)
 );
-/// Set TTY mode (normal, raw, IO).
+/// Set TTY mode (normal, raw, Io).
 /// Returns 0 on success, -errno on failure.
 tty_set_mode :: (fn(fd : i32, mode : i32) -> i32)(
   __yo_tty_set_mode(fd, mode)

package/std/sys/udp.yo

@@ -3,7 +3,7 @@
 //! Provides UDP socket wrappers around the low-level C runtime externs.
 //! Reuses `SockAddr` and address helpers from `tcp.yo`.
 //!
-//! All async operations return `IOFuture` which resolves to:
+//! All async operations return `IoFuture` which resolves to:
 //! - Positive value: success (fd for socket, bytes for sendto/recvfrom, 0 for others)
 //! - Negative value: -errno on failure
 //
@@ -26,48 +26,49 @@
 //     await udp.close(sockfd);
 //     tcp.free_sockaddr(addr);
 //   };
-{ IOFuture } :: import("./future.yo");
+pragma(Pragma.AllowUnsafe);
+{ IoFuture } :: import("./future.yo");
 { __yo_async_socket_start, __yo_async_bind_start, __yo_async_send_start, __yo_async_recv_start, __yo_async_sendto_start, __yo_async_recvfrom_start, __yo_async_close_start, __yo_async_setsockopt_start, __yo_async_getsockopt_start } :: import("./externs.yo");
 { SOCK_DGRAM } :: import("./socket.yo");
 // ============================================================================
-// Core UDP Operations (return IOFuture, use with await)
+// Core UDP Operations (return IoFuture, use with await)
 // ============================================================================
 // Create a UDP socket.
 // domain: AF_INET or AF_INET6
 // protocol: typically 0
 // Returns fd on success, -errno on failure.
-socket :: (fn(domain : i32, protocol : i32) -> IOFuture)(
+socket :: (fn(domain : i32, protocol : i32) -> IoFuture)(
   __yo_async_socket_start(domain, SOCK_DGRAM, protocol)
 );
 // Bind a UDP socket to a local address.
 // Returns 0 on success, -errno on failure.
-bind :: (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IOFuture)(
+bind :: (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IoFuture)(
   __yo_async_bind_start(sockfd, addr, addrlen)
 );
 // Send a datagram to a specific destination address.
 // Returns number of bytes sent on success, -errno on failure.
-sendto :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32, dest_addr : *(u8), addrlen : u32) -> IOFuture)(
+sendto :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32, dest_addr : *(u8), addrlen : u32) -> IoFuture)(
   __yo_async_sendto_start(sockfd, buf, len, flags, dest_addr, addrlen)
 );
 // Receive a datagram and get the source address.
 // src_addr/addrlen are filled with the sender's address.
 // Returns number of bytes received on success, -errno on failure.
-recvfrom :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32, src_addr : *(u8), addrlen : *(u32)) -> IOFuture)(
+recvfrom :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32, src_addr : *(u8), addrlen : *(u32)) -> IoFuture)(
   __yo_async_recvfrom_start(sockfd, buf, len, flags, src_addr, addrlen)
 );
 // Send data on a connected UDP socket (after connect()).
 // Returns number of bytes sent on success, -errno on failure.
-send :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IOFuture)(
+send :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IoFuture)(
   __yo_async_send_start(sockfd, buf, len, flags)
 );
 // Receive data on a connected UDP socket (after connect()).
 // Returns number of bytes received on success, -errno on failure.
-recv :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IOFuture)(
+recv :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IoFuture)(
   __yo_async_recv_start(sockfd, buf, len, flags)
 );
 // Close a UDP socket file descriptor.
 // Returns 0 on success, -errno on failure.
-close :: (fn(fd : i32) -> IOFuture)(
+close :: (fn(fd : i32) -> IoFuture)(
   __yo_async_close_start(fd)
 );
 // ============================================================================
@@ -75,12 +76,12 @@ close :: (fn(fd : i32) -> IOFuture)(
 // ============================================================================
 // Set a socket option (raw).
 // Returns 0 on success, -errno on failure.
-setsockopt :: (fn(sockfd : i32, level : i32, optname : i32, optval : *(u8), optlen : u32) -> IOFuture)(
+setsockopt :: (fn(sockfd : i32, level : i32, optname : i32, optval : *(u8), optlen : u32) -> IoFuture)(
   __yo_async_setsockopt_start(sockfd, level, optname, optval, optlen)
 );
 // Get a socket option (raw).
 // Returns 0 on success, -errno on failure.
-getsockopt :: (fn(sockfd : i32, level : i32, optname : i32, optval : *(u8), optlen : *(u32)) -> IOFuture)(
+getsockopt :: (fn(sockfd : i32, level : i32, optname : i32, optval : *(u8), optlen : *(u32)) -> IoFuture)(
   __yo_async_getsockopt_start(sockfd, level, optname, optval, optlen)
 );
 export(

package/std/sys/unix.yo

@@ -3,9 +3,10 @@
 //! 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
 //! generic socket externs. Uses `sockaddr_un` helpers to build address buffers.
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator.yo");
 { malloc, free } :: GlobalAllocator;
-{ IOFuture } :: import("./future.yo");
+{ IoFuture } :: import("./future.yo");
 { __yo_async_socket_start, __yo_async_bind_start, __yo_async_listen_start, __yo_async_accept_start, __yo_async_connect_start, __yo_async_send_start, __yo_async_recv_start, __yo_async_close_start, __yo_sockaddr_un_set_path, __yo_sockaddr_un_get_path, __yo_sockaddr_set_family } :: import("./externs.yo");
 { AF_UNIX, SOCK_STREAM, SOCK_DGRAM, sockaddr_un_size } :: import("./socket.yo");
 // ============================================================================
@@ -17,51 +18,51 @@ UnixAddr :: struct(
 );
 export(UnixAddr);
 // ============================================================================
-// Core Unix Socket Operations (return IOFuture, use with await)
+// Core Unix Socket Operations (return IoFuture, use with await)
 // ============================================================================
 // Create a Unix domain socket (SOCK_STREAM).
 // Returns fd on success, -errno on failure.
-socket_stream :: (fn() -> IOFuture)(
+socket_stream :: (fn() -> IoFuture)(
   __yo_async_socket_start(AF_UNIX, SOCK_STREAM, i32(0))
 );
 // Create a Unix domain socket (SOCK_DGRAM).
 // Returns fd on success, -errno on failure.
-socket_dgram :: (fn() -> IOFuture)(
+socket_dgram :: (fn() -> IoFuture)(
   __yo_async_socket_start(AF_UNIX, SOCK_DGRAM, i32(0))
 );
 // Bind a socket to a local Unix address.
 // Returns 0 on success, -errno on failure.
-bind :: (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IOFuture)(
+bind :: (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IoFuture)(
   __yo_async_bind_start(sockfd, addr, addrlen)
 );
 // Listen for incoming connections on a Unix socket.
 // Returns 0 on success, -errno on failure.
-listen :: (fn(sockfd : i32, backlog : i32) -> IOFuture)(
+listen :: (fn(sockfd : i32, backlog : i32) -> IoFuture)(
   __yo_async_listen_start(sockfd, backlog)
 );
 // Accept an incoming connection.
 // Returns fd on success, -errno on failure.
-accept :: (fn(sockfd : i32, addr : *(u8), addrlen : *(u32)) -> IOFuture)(
+accept :: (fn(sockfd : i32, addr : *(u8), addrlen : *(u32)) -> IoFuture)(
   __yo_async_accept_start(sockfd, addr, addrlen)
 );
 // Connect to a Unix socket address.
 // Returns 0 on success, -errno on failure.
-connect :: (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IOFuture)(
+connect :: (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IoFuture)(
   __yo_async_connect_start(sockfd, addr, addrlen)
 );
 // Send data on a connected Unix socket.
 // Returns number of bytes sent on success, -errno on failure.
-send :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IOFuture)(
+send :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IoFuture)(
   __yo_async_send_start(sockfd, buf, len, flags)
 );
 // Receive data from a connected Unix socket.
 // Returns number of bytes received on success, -errno on failure.
-recv :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IOFuture)(
+recv :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IoFuture)(
   __yo_async_recv_start(sockfd, buf, len, flags)
 );
 // Close a Unix socket file descriptor.
 // Returns 0 on success, -errno on failure.
-close :: (fn(fd : i32) -> IOFuture)(
+close :: (fn(fd : i32) -> IoFuture)(
   __yo_async_close_start(fd)
 );
 // ============================================================================

package/std/testing/bench.yo

@@ -11,6 +11,7 @@
 //! result := bench(`sort`, u64(1000), () => { /* work */ });
 //! println(result.to_string());
 //! ```
+pragma(Pragma.AllowUnsafe);
 open(import("../string"));
 { ToString } :: import("../fmt");
 { snprintf } :: import("../libc/stdio");
@@ -36,19 +37,19 @@ BenchResult :: struct(
 _i64_to_string :: (fn(v : i64) -> String)({
   buf := Array(u8, usize(32)).fill(u8(0));
   buf_ptr := &(buf(usize(0)));
-  snprintf(*(char)(buf_ptr), usize(32), "%lld", v);
+  unsafe(snprintf(*(char)(buf_ptr), usize(32), "%lld", v));
   String.from_cstr(buf_ptr).unwrap()
 });
 _u64_to_string :: (fn(v : u64) -> String)({
   buf := Array(u8, usize(32)).fill(u8(0));
   buf_ptr := &(buf(usize(0)));
-  snprintf(*(char)(buf_ptr), usize(32), "%llu", v);
+  unsafe(snprintf(*(char)(buf_ptr), usize(32), "%llu", v));
   String.from_cstr(buf_ptr).unwrap()
 });
 impl(
   BenchResult,
   ToString(
-    to_string : (fn(self : *(Self)) -> String)({
+    to_string : (fn(ref(self) : Self) -> String)({
       prefix := String.from("bench '");
       part1 := prefix.concat(self.name);
       part2 := part1.concat(String.from("': iters="));