@shd101wyy/yo 0.1.26 → 0.1.27

package/std/sys/fallocate.yo

@@ -2,23 +2,19 @@
 //!
 //! Synchronous wrapper for `fallocate`-style allocation.
 //! Returns 0 on success, -errno on failure.
-
-{ __yo_sync_fallocate } :: import "./externs.yo";
-
+{ __yo_sync_fallocate } :: import("./externs.yo");
 // Mode constants
-FALLOC_FL_KEEP_SIZE :: i32(0x01);  // Do not change file size
-FALLOC_FL_PUNCH_HOLE :: i32(0x02);  // Deallocate range (Linux-specific)
-FALLOC_FL_ZERO_RANGE :: i32(0x10);  // Zero range (Linux-specific)
-
+FALLOC_FL_KEEP_SIZE :: i32(0x01); // Do not change file size
+FALLOC_FL_PUNCH_HOLE :: i32(0x02); // Deallocate range (Linux-specific)
+FALLOC_FL_ZERO_RANGE :: i32(0x10); // Zero range (Linux-specific)
 // Pre-allocate disk space for a file range.
 // Ensures writes in [offset, offset + length) have space reserved.
-fallocate :: (fn(fd: i32, mode: i32, offset: i64, length: i64) -> i32)(
+fallocate :: (fn(fd : i32, mode : i32, offset : i64, length : i64) -> i32)(
   __yo_sync_fallocate(fd, mode, offset, length)
 );
-
-export
+export(
   fallocate,
   FALLOC_FL_KEEP_SIZE,
   FALLOC_FL_PUNCH_HOLE,
   FALLOC_FL_ZERO_RANGE
-;
+);

package/std/sys/fcntl.yo

@@ -6,39 +6,31 @@
 //!
 //! - `getfl`/`getfd`: flags on success, -errno on failure
 //! - `setfl`/`setfd`: 0 on success, -errno on failure
-
-{
-  __yo_sync_fcntl_getfl,
-  __yo_sync_fcntl_setfl,
-  __yo_sync_fcntl_getfd,
-  __yo_sync_fcntl_setfd
-} :: import "./externs.yo";
-{ O_NONBLOCK } :: import "./constants.yo";
-
+{ __yo_sync_fcntl_getfl, __yo_sync_fcntl_setfl, __yo_sync_fcntl_getfd, __yo_sync_fcntl_setfd } :: import("./externs.yo");
+{ O_NONBLOCK } :: import("./constants.yo");
 // POSIX FD_CLOEXEC value. On Windows this is interpreted by the runtime wrapper.
 FD_CLOEXEC :: i32(1);
-
 // Get file status flags (F_GETFL)
-getfl :: (fn(fd: i32) -> i32)(
+getfl :: (fn(fd : i32) -> i32)(
   __yo_sync_fcntl_getfl(fd)
 );
-
 // Set file status flags (F_SETFL)
-setfl :: (fn(fd: i32, flags: i32) -> i32)(
+setfl :: (fn(fd : i32, flags : i32) -> i32)(
   __yo_sync_fcntl_setfl(fd, flags)
 );
-
 // Get file descriptor flags (F_GETFD)
-getfd :: (fn(fd: i32) -> i32)(
+getfd :: (fn(fd : i32) -> i32)(
   __yo_sync_fcntl_getfd(fd)
 );
-
 // Set file descriptor flags (F_SETFD)
-setfd :: (fn(fd: i32, flags: i32) -> i32)(
+setfd :: (fn(fd : i32, flags : i32) -> i32)(
   __yo_sync_fcntl_setfd(fd, flags)
 );
-
-export
-  getfl, setfl, getfd, setfd,
-  O_NONBLOCK, FD_CLOEXEC
-;
+export(
+  getfl,
+  setfl,
+  getfd,
+  setfd,
+  O_NONBLOCK,
+  FD_CLOEXEC
+);

package/std/sys/file.yo

@@ -16,91 +16,77 @@
 //     fd := IOError.from_result(fd_result).unwrap();
 //     close_result := await IO.close(fd);
 //   };
-
-{ 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";
-
+{ 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)
 // ============================================================================
-
 // 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)
 );
-
 // ============================================================================
 // Sync File Helpers
 // ============================================================================
-
 // Open a file synchronously. Returns fd on success, -errno on failure.
-open_sync :: (fn(path: *(u8), flags: i32, mode: i32) -> i32)(
+open_sync :: (fn(path : *(u8), flags : i32, mode : i32) -> i32)(
   __yo_file_open(path, flags, mode)
 );
-
 // Close a file descriptor synchronously.
-close_sync :: (fn(fd: i32) -> unit)(
+close_sync :: (fn(fd : i32) -> unit)(
   __yo_file_close(fd)
 );
-
 // Get file size synchronously. Returns size on success, -errno on failure.
-file_size :: (fn(fd: i32) -> i64)(
+file_size :: (fn(fd : i32) -> i64)(
   __yo_file_size(fd)
 );
-
-export
-  openat, close, read, write,
-  statx, fsync, fdatasync, ftruncate,
-  open_sync, close_sync, file_size
-;
+export(
+  openat,
+  close,
+  read,
+  write,
+  statx,
+  fsync,
+  fdatasync,
+  ftruncate,
+  open_sync,
+  close_sync,
+  file_size
+);

package/std/sys/future.yo

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

package/std/sys/iov.yo

@@ -2,43 +2,30 @@
 //!
 //! Synchronous wrappers for vectored file descriptor I/O.
 //! Returns byte count on success, -errno / negative platform error on failure.
-
-{
-  __yo_sync_readv,
-  __yo_sync_writev,
-  __yo_sync_preadv,
-  __yo_sync_pwritev,
-  __yo_iovec_size,
-  __yo_iovec_set
-} :: import "./externs.yo";
-
+{ __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()
 );
-
-readv :: (fn(fd: i32, iov: *(u8), iovcnt: i32) -> i32)(
+readv :: (fn(fd : i32, iov : *(u8), iovcnt : i32) -> i32)(
   __yo_sync_readv(fd, iov, iovcnt)
 );
-
-writev :: (fn(fd: i32, iov: *(u8), iovcnt: i32) -> i32)(
+writev :: (fn(fd : i32, iov : *(u8), iovcnt : i32) -> i32)(
   __yo_sync_writev(fd, iov, iovcnt)
 );
-
-preadv :: (fn(fd: i32, iov: *(u8), iovcnt: i32, offset: i64) -> i32)(
+preadv :: (fn(fd : i32, iov : *(u8), iovcnt : i32, offset : i64) -> i32)(
   __yo_sync_preadv(fd, iov, iovcnt, offset)
 );
-
-pwritev :: (fn(fd: i32, iov: *(u8), iovcnt: i32, offset: i64) -> i32)(
+pwritev :: (fn(fd : i32, iov : *(u8), iovcnt : i32, offset : i64) -> i32)(
   __yo_sync_pwritev(fd, iov, iovcnt, offset)
 );
-
-iovec_set :: (fn(iov: *(u8), index: usize, base: *(u8), len: usize) -> unit)(
+iovec_set :: (fn(iov : *(u8), index : usize, base : *(u8), len : usize) -> unit)(
   __yo_iovec_set(iov, index, base, len)
 );
-
-export
+export(
   iovec_size,
-  readv, writev,
-  preadv, pwritev,
+  readv,
+  writev,
+  preadv,
+  pwritev,
   iovec_set
-;
+);

package/std/sys/lock.yo

@@ -5,22 +5,21 @@
 //!
 //! Operations can be OR'd with `LOCK_NB` for non-blocking.
 //! `LOCK_NB` returns -EWOULDBLOCK (-11) if the lock cannot be acquired immediately.
-
-{ __yo_sync_flock } :: import "./externs.yo";
-
+{ __yo_sync_flock } :: import("./externs.yo");
 // Lock operation constants
-LOCK_SH :: i32(1);  // Shared (read) lock
-LOCK_EX :: i32(2);  // Exclusive (write) lock
-LOCK_NB :: i32(4);  // Non-blocking (OR with LOCK_SH or LOCK_EX)
-LOCK_UN :: i32(8);  // Unlock
-
+LOCK_SH :: i32(1); // Shared (read) lock
+LOCK_EX :: i32(2); // Exclusive (write) lock
+LOCK_NB :: i32(4); // Non-blocking (OR with LOCK_SH or LOCK_EX)
+LOCK_UN :: i32(8); // Unlock
 // Acquire or release an advisory lock on a file descriptor.
 // Returns 0 on success, -errno on failure.
-flock :: (fn(fd: i32, operation: i32) -> i32)(
+flock :: (fn(fd : i32, operation : i32) -> i32)(
   __yo_sync_flock(fd, operation)
 );
-
-export
+export(
   flock,
-  LOCK_SH, LOCK_EX, LOCK_NB, LOCK_UN
-;
+  LOCK_SH,
+  LOCK_EX,
+  LOCK_NB,
+  LOCK_UN
+);

package/std/sys/mmap.yo

@@ -6,23 +6,13 @@
 //! - 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.
-
-{ 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";
-
+{ 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
-PROT_NONE  :: i32(0);
-PROT_READ  :: i32(1);
+PROT_NONE :: i32(0);
+PROT_READ :: i32(1);
 PROT_WRITE :: i32(2);
-PROT_EXEC  :: i32(4);
-
+PROT_EXEC :: i32(4);
 // Mapping flags
 MAP_SHARED :: i32(1);
 MAP_PRIVATE :: i32(2);
@@ -30,7 +20,6 @@ MAP_ANONYMOUS :: cond(
   (platform == Platform.Macos) => i32(0x1000),
   true => i32(0x20)
 );
-
 // msync flags
 MS_ASYNC :: i32(1);
 MS_INVALIDATE :: i32(2);
@@ -38,53 +27,59 @@ MS_SYNC :: cond(
   (platform == Platform.Macos) => i32(0x10),
   true => i32(4)
 );
-
 // Map a file or anonymous memory region.
 // For anonymous mappings, pass flags including MAP_ANONYMOUS and fd = -1.
-mmap :: (fn(
-  addr: ?*(u8),
-  length: usize,
-  prot: i32,
-  flags: i32,
-  fd: i32,
-  offset: i64
-) -> ?*(u8))(
+mmap :: (
+  fn(
+    addr : ?*(u8),
+    length : usize,
+    prot : i32,
+    flags : i32,
+    fd : i32,
+    offset : i64
+  ) -> ?*(u8)
+)(
   __yo_sync_mmap(addr, length, prot, flags, fd, offset)
 );
-
 // Returns true if mmap returned an encoded error pointer.
-is_error :: (fn(addr: ?*(u8)) -> bool)(
+is_error :: (fn(addr : ?*(u8)) -> bool)(
   __yo_sync_mmap_is_error(addr)
 );
-
 // Decode errno from an encoded mmap error pointer.
 // Returns 0 if addr is not an encoded error pointer.
-error_code :: (fn(addr: ?*(u8)) -> i32)(
+error_code :: (fn(addr : ?*(u8)) -> i32)(
   __yo_sync_mmap_errno(addr)
 );
-
 // Unmap a previously mapped region.
 // Returns 0 on success, -errno on failure.
-munmap :: (fn(addr: *(u8), length: usize) -> i32)(
+munmap :: (fn(addr : *(u8), length : usize) -> i32)(
   __yo_sync_munmap(addr, length)
 );
-
 // Change memory protection on a mapped region.
 // Returns 0 on success, -errno on failure.
-mprotect :: (fn(addr: *(u8), length: usize, prot: i32) -> i32)(
+mprotect :: (fn(addr : *(u8), length : usize, prot : i32) -> i32)(
   __yo_sync_mprotect(addr, length, prot)
 );
-
 // Flush mapped pages to storage.
 // Returns 0 on success, -errno on failure.
-msync :: (fn(addr: *(u8), length: usize, flags: i32) -> i32)(
+msync :: (fn(addr : *(u8), length : usize, flags : i32) -> i32)(
   __yo_sync_msync(addr, length, flags)
 );
-
-export
-  mmap, is_error, error_code,
-  munmap, mprotect, msync,
-  PROT_NONE, PROT_READ, PROT_WRITE, PROT_EXEC,
-  MAP_SHARED, MAP_PRIVATE, MAP_ANONYMOUS,
-  MS_ASYNC, MS_INVALIDATE, MS_SYNC
-;
+export(
+  mmap,
+  is_error,
+  error_code,
+  munmap,
+  mprotect,
+  msync,
+  PROT_NONE,
+  PROT_READ,
+  PROT_WRITE,
+  PROT_EXEC,
+  MAP_SHARED,
+  MAP_PRIVATE,
+  MAP_ANONYMOUS,
+  MS_ASYNC,
+  MS_INVALIDATE,
+  MS_SYNC
+);

package/std/sys/path.yo

@@ -2,16 +2,11 @@
 //!
 //! Synchronous wrapper for `realpath`.
 //! Returns 0 on success, -errno on failure.
-
-{ __yo_sync_realpath } :: import "./externs.yo";
-
+{ __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).
 // Returns 0 on success, -errno on failure.
-realpath :: (fn(path: *(u8), resolved: *(u8)) -> i32)(
+realpath :: (fn(path : *(u8), resolved : *(u8)) -> i32)(
   __yo_sync_realpath(path, resolved)
 );
-
-export
-  realpath
-;
+export(realpath);

package/std/sys/perm.yo

@@ -18,61 +18,47 @@
 //   // Change file permissions to 0644
 //   ret2 := perm.chmodat(AT_FDCWD, *(u8)("/tmp/test.txt"), u32(0o644), i32(0));
 //   assert(ret2 == i32(0));
-
-{
-  __yo_sync_access,
-  __yo_sync_fchmod, __yo_sync_fchmodat,
-  __yo_sync_fchown, __yo_sync_fchownat
-} :: import "./externs.yo";
-
+{ __yo_sync_access, __yo_sync_fchmod, __yo_sync_fchmodat, __yo_sync_fchown, __yo_sync_fchownat } :: import("./externs.yo");
 // ============================================================================
 // chmod — Change file permissions
 // ============================================================================
-
 // Change file permissions by fd.
 // Returns 0 on success, -errno on failure.
-fchmod :: (fn(fd: i32, mode: u32) -> i32)(
+fchmod :: (fn(fd : i32, mode : u32) -> i32)(
   __yo_sync_fchmod(fd, mode)
 );
-
 // Change file permissions by path relative to dirfd.
 // Use AT_FDCWD for current directory.
 // flags: 0 or AT_SYMLINK_NOFOLLOW
 // Returns 0 on success, -errno on failure.
-chmodat :: (fn(dirfd: i32, path: *(u8), mode: u32, flags: i32) -> i32)(
+chmodat :: (fn(dirfd : i32, path : *(u8), mode : u32, flags : i32) -> i32)(
   __yo_sync_fchmodat(dirfd, path, mode, flags)
 );
-
 // ============================================================================
 // chown — Change file ownership
 // ============================================================================
-
 // Change file ownership by fd.
 // Returns 0 on success, -errno on failure.
-fchown :: (fn(fd: i32, uid: u32, gid: u32) -> i32)(
+fchown :: (fn(fd : i32, uid : u32, gid : u32) -> i32)(
   __yo_sync_fchown(fd, uid, gid)
 );
-
 // Change file ownership by path relative to dirfd.
 // Use AT_FDCWD for current directory.
 // flags: 0 or AT_SYMLINK_NOFOLLOW
 // Returns 0 on success, -errno on failure.
-chownat :: (fn(dirfd: i32, path: *(u8), uid: u32, gid: u32, flags: i32) -> i32)(
+chownat :: (fn(dirfd : i32, path : *(u8), uid : u32, gid : u32, flags : i32) -> i32)(
   __yo_sync_fchownat(dirfd, path, uid, gid, flags)
 );
-
 // ============================================================================
 // access — Check file accessibility
 // ============================================================================
-
 // Check if file is accessible with given mode.
 // dirfd: AT_FDCWD for current directory, or an open directory fd
 // path: file path (relative to dirfd)
 // mode: F_OK (exists), R_OK (readable), W_OK (writable), X_OK (executable)
 //       Combine with bitwise OR: (R_OK | W_OK)
 // Returns 0 on success, -errno on failure (e.g. -ENOENT, -EACCES).
-access :: (fn(dirfd: i32, path: *(u8), mode: i32) -> i32)(
+access :: (fn(dirfd : i32, path : *(u8), mode : i32) -> i32)(
   __yo_sync_access(dirfd, path, mode)
 );
-
-export fchmod, chmodat, fchown, chownat, access;
+export(fchmod, chmodat, fchown, chownat, access);

package/std/sys/pipe.yo

@@ -7,25 +7,18 @@
 //!
 //! - `pipe`: 0 on success, -errno on failure
 //! - `dup`/`dup2`: new fd on success, -errno on failure
-
-{ __yo_sync_pipe, __yo_sync_dup, __yo_sync_dup2 } :: import "./externs.yo";
-
+{ __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.
-pipe :: (fn(pipefd: *(i32)) -> i32)(
+pipe :: (fn(pipefd : *(i32)) -> i32)(
   __yo_sync_pipe(pipefd)
 );
-
 // Duplicate a file descriptor. Returns new fd on success, -errno on failure.
-dup :: (fn(fd: i32) -> i32)(
+dup :: (fn(fd : i32) -> i32)(
   __yo_sync_dup(fd)
 );
-
 // Duplicate a file descriptor to a specific fd. Returns new fd on success, -errno on failure.
-dup2 :: (fn(oldfd: i32, newfd: i32) -> i32)(
+dup2 :: (fn(oldfd : i32, newfd : i32) -> i32)(
   __yo_sync_dup2(oldfd, newfd)
 );
-
-export
-  pipe, dup, dup2
-;
+export(pipe, dup, dup2);

package/std/sys/process.yo

@@ -7,53 +7,47 @@
 //!
 //! `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";
-{
-  __yo_async_spawn_start, __yo_async_waitpid_start,
-  __yo_process_exit_status, __yo_process_term_signal,
-  __yo_kill
-} :: import "./externs.yo";
-
+{ 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.
 // `argv` is a NULL-terminated array of argument strings.
 // `envp` is a NULL-terminated array of "KEY=VALUE" strings (or .None for inherit).
 // stdin_fd/stdout_fd/stderr_fd: fd redirections (-1 = inherit)
-spawn :: (fn(
-  file: *(u8),
-  argv: *(?*(u8)),
-  envp: ?*(?*(u8)),
-  stdin_fd: i32,
-  stdout_fd: i32,
-  stderr_fd: i32
-) -> IOFuture)(
+spawn :: (
+  fn(
+    file : *(u8),
+    argv : *(?*(u8)),
+    envp : ?*(?*(u8)),
+    stdin_fd : i32,
+    stdout_fd : i32,
+    stderr_fd : i32
+  ) -> 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.
 // Returns 0 on success, -errno on failure.
-kill :: (fn(pid: i32, signum: i32) -> i32)(
+kill :: (fn(pid : i32, signum : i32) -> i32)(
   __yo_kill(pid, signum)
 );
-
 // Helper: extract exit code from waitpid status.
-exit_status :: (fn(status: i32) -> i32)(
+exit_status :: (fn(status : i32) -> i32)(
   __yo_process_exit_status(status)
 );
-
 // Helper: check if process was terminated by signal.
-term_signal :: (fn(status: i32) -> i32)(
+term_signal :: (fn(status : i32) -> i32)(
   __yo_process_term_signal(status)
 );
-
-export
-  spawn, waitpid, kill,
-  exit_status, term_signal
-;
+export(
+  spawn,
+  waitpid,
+  kill,
+  exit_status,
+  term_signal
+);

package/std/sys/seek.yo

@@ -2,21 +2,19 @@
 //!
 //! Synchronous wrapper for `lseek`.
 //! Returns resulting absolute file offset on success, -errno on failure.
-
-{ __yo_sync_lseek } :: import "./externs.yo";
-
+{ __yo_sync_lseek } :: import("./externs.yo");
 // Whence constants
-SEEK_SET :: i32(0);  // Set offset to absolute position
-SEEK_CUR :: i32(1);  // Set offset relative to current position
-SEEK_END :: i32(2);  // Set offset relative to end of file
-
+SEEK_SET :: i32(0); // Set offset to absolute position
+SEEK_CUR :: i32(1); // Set offset relative to current position
+SEEK_END :: i32(2); // Set offset relative to end of file
 // Reposition read/write file offset.
 // Returns resulting offset from file start, or -errno on failure.
-lseek :: (fn(fd: i32, offset: i64, whence: i32) -> i64)(
+lseek :: (fn(fd : i32, offset : i64, whence : i32) -> i64)(
   __yo_sync_lseek(fd, offset, whence)
 );
-
-export
+export(
   lseek,
-  SEEK_SET, SEEK_CUR, SEEK_END
-;
+  SEEK_SET,
+  SEEK_CUR,
+  SEEK_END
+);