🥮 mooncakes.io
    Sign in

    uv

    MoonBit binding to libuv

    Download zip
    Version
    0.12.12
    License
    Apache-2.0
    Repository
    Last updated
    8 months ago
    Downloads
    1K

    #tonyfettes/uv

    This is a MoonBit binding to the libuv library.

    #Quickstart

    1. Add this module as a dependency to your MoonBit project.

      moon update
moon add tonyfettes/uv

    2. Import tonyfettes/uv package where you need it.

      {
  "import": [
    "tonyfettes/uv"
  ]
}

    3. Use the tonyfettes/uv package in your MoonBit project.

      fn main {
        try {
          let uv = @uv.Loop::new()
          let options = @uv.ProcessOptions::new(
            "moon",
            ["moon", "version"],
            fn(process, exit_status, term_signal) {
              println(
                "Process exited with status \{exit_status} and signal \{term_signal}",
              )
              process.close(() => ())
            },
          )
          let process = uv.spawn(options)
          println("Launched process with ID \{(process).pid()}")
          uv.run(Default)
          uv.stop()
          uv.close()
        } catch {
          error => println("Error: \{error}")
        }
      }

    #Roadmap

    The following libuv APIs are not yet implemented in this library:

    #Handle Functions

    • uv_ref() - Reference counting for handles
    • uv_unref() - Unreference handles
    • uv_has_ref() - Check handle reference status

    #Process Functions

    • uv_get_osfhandle() - Get OS handle from file descriptor
    • uv_open_osfhandle() - Open file descriptor from OS handle

    Cancelable

    source
    pub trait Cancelable : ToReq {
      cancel(Self) -> Unit raise Errno
    }

    Share

    source
    pub trait Share {
      share(Self) -> Self
    }

    Shares an object safely between threads.

    In MoonBit, the default reference counting (RC) for objects is not atomic, so it is not safe to share most objects directly between threads.

    To enable safe sharing, we use a separate atomic reference counter (ARC) stored alongside the actual object data. The MoonBit object itself is managed by non-atomic RC, but the shared payload is managed by ARC.

    When you want to share an object:
    • The MoonBit object holds a pointer to a heap-allocated block containing both the ARC and the payload (e.g., a mutex or thread handle).
    • Copying the MoonBit object only copies the pointer; the ARC is incremented atomically (guarded by a mutex if needed).
    • When a copy is dropped, the ARC is decremented atomically. When ARC reaches zero, the payload is freed.

    Example: uv_thread_t stores an arc field and a uv_mutex_t object in a heap-allocated block. All increments/decrements of arc are protected by the mutex to ensure thread safety.

    Diagram:

                   (thread 0)                 (thread 1)
               +--------+                 +--------+
               | rc (M) |                 | rc (M) |
               +--------+                 +--------+
                     \                       /
                      \---> +---------+ <---/
                            | arc (F) |
                            +---------+
                            | mutex   |
                            +---------+
                            | payload |
                            +---------+

    The Share trait provides a share method to allow implementor of this trait to create a new MoonBit object pointing to the same shared payload, incrementing the ARC safely.

    ToHandle

    source
    pub trait ToHandle {
      to_handle(Self) -> Handle
      of_handle(Handle) -> Self
      close(Self, () -> Unit) -> Unit
      is_closing(Self) -> Bool
      loop_(Self) -> Loop
      fileno(Self) -> OsFd raise Errno
      os_sock(Self) -> OsSock raise Errno
      get_send_buffer_size(Self) -> Int raise Errno
      set_send_buffer_size(Self, Int) -> Unit raise Errno
      get_recv_buffer_size(Self) -> Int raise Errno
      set_recv_buffer_size(Self, Int) -> Unit raise Errno
    }

    ToReq

    source
    pub trait ToReq {
      to_req(Self) -> Req
      type_(self : Self) -> ReqType
    }

    ToSockaddr

    source
    pub trait ToSockaddr : ToJson {
      to_sockaddr(self : Self) -> Sockaddr
      of_sockaddr(self : Sockaddr) -> Self?
      ip_name(self : Self) -> Bytes raise Errno
    }

    ToStream

    source
    pub trait ToStream : ToHandle {
      to_stream(Self) -> Stream
      of_stream(Stream) -> Self
      read_start(Self, (Self, Int) -> BytesView, (Self, Int, BytesView) -> Unit, (Self, Errno) -> Unit) -> Unit raise Errno
      read_stop(Self) -> Unit raise Errno
      write(Self, Array[BytesView], () -> Unit, (Errno) -> Unit) -> Write raise Errno
      try_write(Self, Array[BytesView], () -> Unit, (Errno) -> Unit) -> Write raise Errno
      listen(Self, Int, (Self) -> Unit, (Self, Errno) -> Unit) -> Unit raise Errno
      is_readable(Self) -> Bool
      is_writable(Self) -> Bool
      shutdown(Self, () -> Unit, (Errno) -> Unit) -> Shutdown raise Errno
      set_blocking(Self, Bool) -> Unit raise Errno
      write_queue_size(Self) -> UInt64
    }

    DlError

    source
    type DlError

    Errno

    source
    pub(all) suberror Errno {
      E2BIG
      EACCES
      EADDRINUSE
      EADDRNOTAVAIL
      EAFNOSUPPORT
      EAGAIN
      EAI_ADDRFAMILY
      EAI_AGAIN
      EAI_BADFLAGS
      EAI_BADHINTS
      EAI_CANCELED
      EAI_FAIL
      EAI_FAMILY
      EAI_MEMORY
      EAI_NODATA
      EAI_NONAME
      EAI_OVERFLOW
      EAI_PROTOCOL
      EAI_SERVICE
      EAI_SOCKTYPE
      EALREADY
      EBADF
      EBUSY
      ECANCELED
      ECHARSET
      ECONNABORTED
      ECONNREFUSED
      ECONNRESET
      EDESTADDRREQ
      EEXIST
      EFAULT
      EFBIG
      EHOSTUNREACH
      EINTR
      EINVAL
      EIO
      EISCONN
      EISDIR
      ELOOP
      EMFILE
      EMSGSIZE
      ENAMETOOLONG
      ENETDOWN
      ENETUNREACH
      ENFILE
      ENOBUFS
      ENODEV
      ENOENT
      ENOMEM
      ENONET
      ENOPROTOOPT
      ENOSPC
      ENOSYS
      ENOTCONN
      ENOTDIR
      ENOTEMPTY
      ENOTSOCK
      ENOTSUP
      EOVERFLOW
      EPERM
      EPIPE
      EPROTO
      EPROTONOSUPPORT
      EPROTOTYPE
      ERANGE
      EROFS
      ESHUTDOWN
      ESPIPE
      ESRCH
      ETIMEDOUT
      ETXTBSY
      EXDEV
      UNKNOWN
      EOF
      ENXIO
      EMLINK
      EHOSTDOWN
      EREMOTEIO
      ENOTTY
      EFTYPE
      EILSEQ
      ESOCKTNOSUPPORT
      ENODATA
      EUNATCH
      ENOEXEC
    }

    impl Eq for Errno
    impl Hash for Errno
    impl Show for Errno

    Errno::to_bytes

    source
    fn Errno::to_bytes(self : Errno) -> Bytes

    AccessFlags

    source
    type AccessFlags

    AccessFlags::new

    source
    fn AccessFlags::new(read? : Bool, write? : Bool, execute? : Bool) -> AccessFlags

    AccessHint

    source
    pub(all) enum AccessHint {
      Random
      Sequential
    }

    AddrInfo

    source
    type AddrInfo

    AddrInfo::addr

    source
    fn AddrInfo::addr(self : AddrInfo) -> Sockaddr

    AddrInfo::canonname

    source
    fn AddrInfo::canonname(self : AddrInfo) -> Bytes?

    AddrInfo::family

    source
    fn AddrInfo::family(self : AddrInfo) -> AddressFamily raise Errno

    AddrInfo::protocol

    source
    fn AddrInfo::protocol(self : AddrInfo) -> Protocol raise Errno

    AddrInfo::socktype

    source
    fn AddrInfo::socktype(self : AddrInfo) -> SockType raise Errno

    AddrInfoFlags

    source
    type AddrInfoFlags

    AddrInfoFlags::new

    source
    fn AddrInfoFlags::new(passive? : Bool, canonname? : Bool, numeric_host? : Bool, numeric_serv? : Bool, all? : Bool, addrconfig? : Bool, v4mapped? : Bool) -> AddrInfoFlags

    AddrInfoHints

    source
    type AddrInfoHints

    AddrInfoHints::new

    source
    fn AddrInfoHints::new(flags? : AddrInfoFlags, family? : AddressFamily, socktype? : SockType, protocol? : Protocol) -> AddrInfoHints

    AddressFamily

    source
    pub(all) enum AddressFamily {
      Inet
      Inet6
    }

    Represents the address family for network communication, specifying the format of network addresses.

    Constructors:

    • Inet : IPv4 address family
    • Inet6 : IPv6 address family

    Example:

    let ipv4 = AddressFamily::inet()
    let ipv6 = AddressFamily::inet6()
    @assert.t(ipv4 is Inet)
    @assert.t(ipv6 is Inet6)

    AddressFamily::inet

    source

    AddressFamily::inet6

    source

    Async

    source
    type Async

    Wake up the event loop and call the async handle’s callback.

    RETURNS: 0 on success, or an error code < 0 on failure.

    Note: It’s safe to call this function from any thread. The callback will be called on the loop thread.

    Note: uv_async_send() is async-signal-safe. It’s safe to call this function from a signal handler.

    Warning: libuv will coalesce calls to uv_async_send(), that is, not every call to it will yield an execution of the callback. For example: if uv_async_send() is called 5 times in a row before the callback is called, the callback will only be called once. If uv_async_send() is called again after the callback was called, it will be called again.
    impl ToHandle for Async

    Async::new

    source
    fn Async::new(self : Loop, cb : (Async) -> Unit) -> Async raise Errno

    Create a new async handle.

    @param cb The callback to execute when the async handle is triggered @return A new Async handle @raise Errno if the async handle could not be created

    Async::send

    source
    fn Async::send(self : Async) -> Unit raise Errno

    Wake up the event loop and call the async handle's callback.

    This function is async-signal-safe and can be called from any thread. Multiple calls to send() may result in only one callback execution due to coalescing. The callback is guaranteed to be called at least once after send() is called.

    @return Unit @raise Errno if the send operation failed

    Barrier

    source
    type Barrier

    Barrier::new

    source
    fn Barrier::new(count : UInt) -> Barrier raise Errno

    Barrier::wait

    source
    fn Barrier::wait(self : Barrier) -> Bool raise Errno

    Check

    source
    type Check

    Handle for check watchers in the libuv event loop.

    Check watchers run their callbacks once per event loop iteration, right after the event loop has blocked for I/O. They are essentially the counterpart of prepare handles.

    Example:

    let uv = @uv.Loop::new()
    let check = @uv.Check::new(uv)
    let errors = []
    check.start(fn(_) {
      println("Check callback running")
      check.stop() catch {
        error => errors.push(error)
      }
      check.close(() => ())
    })
    uv.fs_open(
      "test/fixtures/example.txt",
      @uv.OpenFlags::read_only(),
      0o644,
      _ => (),
      error => errors.push(error),
    )
    |> ignore()
    uv.run(Default)
    uv.close()
    for error in errors {
      raise error
    }
    impl ToHandle for Check

    Check::new

    source
    fn Check::new(self : Loop) -> Check raise Errno

    Check::start

    source
    fn Check::start(self : Check, cb : (Check) -> Unit) -> Unit raise Errno

    Check::stop

    source
    fn Check::stop(self : Check) -> Unit raise Errno

    ClockId

    source
    pub(all) enum ClockId {
      Monotonic
      Realtime
    }

    Cond

    source
    type Cond

    Condition variable for thread synchronization.

    Condition variables are used in combination with mutexes to allow threads to wait for certain conditions to be met. A thread can wait on a condition variable while holding a mutex, and other threads can signal or broadcast to wake up waiting threads.

    Condition variables must always be used with mutexes. The typical pattern is:
    1. Lock the mutex
    2. Check the condition in a loop
    3. If condition not met, wait on the condition variable
    4. When signaled, the loop continues and rechecks the condition
    5. Unlock the mutex when done
    impl Share for Cond

    Cond::broadcast

    source
    fn Cond::broadcast(self : Cond) -> Unit

    Broadcast to all waiting threads.

    Wake up all threads that are waiting on this condition variable. If no threads are waiting, this call has no effect.

    Cond::new

    source
    fn Cond::new() -> Cond raise Errno

    Cond::signal

    source
    fn Cond::signal(self : Cond) -> Unit

    Signal one waiting thread.

    Wake up one thread that is waiting on this condition variable. If no threads are waiting, this call has no effect.

    Cond::timedwait

    source
    fn Cond::timedwait(self : Cond, mutex : Mutex, timeout_ns : UInt64) -> Unit raise Errno

    Wait on the condition variable with a timeout.

    Similar to wait(), but will return after the specified timeout (in nanoseconds) even if no signal was received.

    Returns:
    • Ok(()) if signaled before timeout
    • Err(ETIMEDOUT) if timeout occurred
    • Err(_) for other errors

    Note

    This function can experience spurious wakeups. Always use this in a loop that checks the actual condition.

    Cond::wait

    source
    fn Cond::wait(self : Cond, mutex : Mutex) -> Unit

    Wait on the condition variable.

    The calling thread will block until another thread calls signal() or broadcast() on this condition variable. The mutex must be locked by the calling thread prior to calling this function. The mutex will be automatically unlocked while waiting and re-locked before returning.

    Note

    This function can experience spurious wakeups. Always use this in a loop that checks the actual condition.

    Connect

    source
    type Connect

    impl ToReq for Connect

    CopyFileFlags

    source
    type CopyFileFlags

    CopyFileFlags::new

    source
    fn CopyFileFlags::new(allow_exists? : Bool, copy_on_write? : CopyOnWrite) -> CopyFileFlags

    CopyOnWrite

    source
    pub(all) enum CopyOnWrite {
      False
      True
      Force
    }

    CpuInfo

    source
    type CpuInfo

    CpuInfo::cpu_times

    source
    fn CpuInfo::cpu_times(self : CpuInfo) -> CpuTimes

    CpuInfo::model

    source
    fn CpuInfo::model(self : CpuInfo) -> Bytes

    CpuInfo::speed

    source
    fn CpuInfo::speed(self : CpuInfo) -> Int

    CpuSet

    source
    type CpuSet

    impl BitAnd for CpuSet
    impl BitOr for CpuSet
    impl BitXOr for CpuSet
    impl Eq for CpuSet

    CpuSet::clear

    source
    fn CpuSet::clear(self : CpuSet, cpu : Int) -> Unit

    CpuSet::count

    source
    fn CpuSet::count(self : CpuSet) -> Int

    CpuSet::intersect

    source
    fn CpuSet::intersect(self : CpuSet, other : CpuSet) -> CpuSet

    CpuSet::is_set

    source
    fn CpuSet::is_set(self : CpuSet, cpu : Int) -> Bool

    CpuSet::new

    source
    fn CpuSet::new() -> CpuSet raise Errno

    CpuSet::set

    source
    fn CpuSet::set(self : CpuSet, cpu : Int) -> Unit

    CpuSet::union

    source
    fn CpuSet::union(self : CpuSet, other : CpuSet) -> CpuSet

    CpuSet::xor

    source
    fn CpuSet::xor(self : CpuSet, other : CpuSet) -> CpuSet

    CpuSet::zero

    source
    fn CpuSet::zero(self : CpuSet) -> Unit

    CpuTimes

    source
    type CpuTimes

    CpuTimes::idle

    source
    fn CpuTimes::idle(self : CpuTimes) -> UInt64

    CpuTimes::irq

    source
    fn CpuTimes::irq(self : CpuTimes) -> UInt64

    CpuTimes::nice

    source
    fn CpuTimes::nice(self : CpuTimes) -> UInt64

    CpuTimes::sys

    source
    fn CpuTimes::sys(self : CpuTimes) -> UInt64

    CpuTimes::user

    source
    fn CpuTimes::user(self : CpuTimes) -> UInt64

    Dir

    source
    type Dir

    Dirent

    source
    type Dirent

    Dirent::name

    source
    fn Dirent::name(self : Dirent) -> Bytes

    Dirent::type_

    source
    fn Dirent::type_(self : Dirent) -> DirentType

    DirentType

    source
    pub enum DirentType {
      Unknown
      File
      Dir
      Link
      Fifo
      Socket
      Char
      Block
    }

    Type of directory entry, indicating the file system object kind.

    Environ

    source
    type Environ

    Environ::iter2

    source
    fn Environ::iter2(self : Environ) -> Iter2[Bytes, Bytes]

    File

    source
    type File

    File::of_int

    source
    fn File::of_int(fd : Int) -> File

    File::to_int

    source
    fn File::to_int(self : File) -> Int

    type Fs

    impl Cancelable for Fs
    impl ToReq for Fs

    FsEvent

    source
    type FsEvent

    impl ToHandle for FsEvent

    FsEvent::get_path

    source
    fn FsEvent::get_path(self : FsEvent) -> Bytes raise Errno

    FsEvent::new

    source
    fn FsEvent::new(self : Loop) -> FsEvent raise Errno

    FsEvent::start

    source
    fn FsEvent::start(self : FsEvent, path : Bytes, flags : FsEventFlags, event_cb : (FsEvent, Bytes?, Array[FsEventType]) -> Unit, error_cb : (FsEvent, Bytes?, Errno) -> Unit) -> Unit raise Errno

    FsEvent::stop

    source
    fn FsEvent::stop(self : FsEvent) -> Unit raise Errno

    FsEventFlags

    source
    type FsEventFlags

    FsEventFlags::new

    source
    fn FsEventFlags::new(recursive? : Bool) -> FsEventFlags

    FsEventType

    source
    pub enum FsEventType {
      Rename
      Change
    }

    FsPoll

    source
    type FsPoll

    impl ToHandle for FsPoll

    FsPoll::get_path

    source
    fn FsPoll::get_path(self : FsPoll) -> Bytes raise Errno

    FsPoll::new

    source
    fn FsPoll::new(self : Loop) -> FsPoll raise Errno

    FsPoll::start

    source
    fn FsPoll::start(self : FsPoll, path : Bytes, interval : UInt, poll_cb : (FsPoll, Stat, Stat) -> Unit, error_cb : (FsPoll, Errno) -> Unit) -> Unit raise Errno

    FsPoll::stop

    source
    fn FsPoll::stop(self : FsPoll) -> Unit raise Errno

    GetAddrInfo

    source
    type GetAddrInfo

    GetNameInfo

    source
    type GetNameInfo

    Gid

    source
    pub(all) type Gid UInt64

    Gid::inner

    source
    #deprecated("Use `struct T(A)` to declare a newtype and use `.0` access the underlying type instead.")
    fn Gid::inner(self : Gid) -> UInt64
    Convert newtype to its underlying type, automatically derived.

    Group

    source
    type Group

    Group::gid

    source
    fn Group::gid(group : Group) -> Gid

    Group::members

    source
    fn Group::members(group : Group) -> FixedArray[Bytes]

    Group::name

    source
    fn Group::name(group : Group) -> Bytes

    Handle

    source
    type Handle

    Handle::close

    source
    fn Handle::close(self : Handle, cb : () -> Unit) -> Unit

    Handle::is_closing

    source
    fn Handle::is_closing(self : Handle) -> Bool

    HandleType

    source
    pub enum HandleType {
      Unknown
      Async
      Check
      FsEvent
      FsPoll
      Handle
      Idle
      Pipe
      Poll
      Prepare
      Process
      Stream
      Tcp
      Timer
      Tty
      Udp
      Signal
      File
    }

    Idle

    source
    type Idle

    Handle for idle watchers in the libuv event loop.

    Idle watchers run their callbacks once per event loop iteration, right before the event loop blocks for I/O. They are useful for performing background tasks when the event loop is idle.

    Example:

    let uv = @uv.Loop::new()
    let errors = []
    let idle = @uv.Idle::new(uv)
    idle.start(fn(_) {
      println("Idle callback running")
      idle.stop() catch {
        error => errors.push(error)
      }
      idle.close(() => ())
    })
    uv.run(Default)
    uv.close()
    for error in errors {
      raise error
    }
    impl ToHandle for Idle

    Idle::new

    source
    fn Idle::new(self : Loop) -> Idle raise Errno

    Idle::start

    source
    fn Idle::start(self : Idle, cb : (Idle) -> Unit) -> Unit raise Errno

    Idle::stop

    source
    fn Idle::stop(self : Idle) -> Unit raise Errno

    IfIndex

    source
    type IfIndex

    impl Show for IfIndex
    impl ToJson for IfIndex

    IfIndex::to_iid

    source
    fn IfIndex::to_iid(self : IfIndex) -> Bytes raise

    IfIndex::to_name

    source
    fn IfIndex::to_name(self : IfIndex) -> Bytes raise

    In6Addr

    source
    type In6Addr

    impl ToJson for In6Addr

    In6Addr::new

    source
    fn In6Addr::new(h0 : UInt16, h1 : UInt16, h2 : UInt16, h3 : UInt16, h4 : UInt16, h5 : UInt16, h6 : UInt16, h7 : UInt16) -> In6Addr

    In6Addr::ntop

    source
    fn In6Addr::ntop(self : In6Addr) -> Bytes raise Errno

    In6Addr::pton

    source
    fn In6Addr::pton(src : Bytes) -> In6Addr raise Errno

    In6Addr::to_bytes

    source
    fn In6Addr::to_bytes(self : In6Addr) -> Bytes

    InAddr

    source
    type InAddr

    impl ToJson for InAddr

    InAddr::new

    source
    fn InAddr::new(b0 : Byte, b1 : Byte, b2 : Byte, b3 : Byte) -> InAddr

    InAddr::ntop

    source
    fn InAddr::ntop(self : InAddr) -> Bytes raise Errno

    InAddr::pton

    source
    fn InAddr::pton(src : Bytes) -> InAddr raise Errno

    InAddr::to_bytes

    source
    fn InAddr::to_bytes(self : InAddr) -> Bytes

    InterfaceAddress

    source
    pub struct InterfaceAddress {
      name : Bytes
      phys_addr : PhysAddr
      is_internal : Bool
      address : Sockaddr
      netmask : Sockaddr
    }

    Key

    source
    type Key

    Key::get

    source
    fn[T] Key::get(self : Key) -> T?

    Key::new

    source
    fn Key::new() -> Key raise Errno

    Key::set

    source
    fn[T] Key::set(self : Key, value : T) -> Unit

    Lib

    source
    type Lib

    Lib::open

    source
    fn Lib::open(filename : Bytes) -> Lib raise DlError

    Lib::symbol

    source
    fn[T] Lib::symbol(lib : Lib, name : Bytes) -> T?

    Loop

    source
    type Loop

    Loop::alive

    source
    fn Loop::alive(uv : Loop) -> Bool

    Loop::backend_fd

    source
    fn Loop::backend_fd(uv : Loop) -> Int raise Errno

    Loop::backend_timeout

    source
    fn Loop::backend_timeout(uv : Loop) -> Int raise Errno

    Loop::close

    source
    fn Loop::close(self : Loop) -> Unit raise Errno

    Closes the event loop and releases its associated resources.

    Parameters:

    • self : The event loop to close.

    Throws an error of type Errno if the loop cannot be closed properly, such as when there are still active handles or requests associated with the loop.

    Example:

    let uv = @uv.Loop::new()
    uv.close()

    Loop::configure

    source
    fn Loop::configure(self : Loop, option : LoopOption) -> Unit raise Errno

    Loop::fork

    source
    fn Loop::fork(uv : Loop) -> Unit raise Errno

    Loop::fs_access

    source
    #as_free_fn
    fn Loop::fs_access(self : Loop, path : Bytes, mode : AccessFlags, access_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_access_sync

    source
    #as_free_fn
    fn Loop::fs_access_sync(self : Loop, path : Bytes, mode : AccessFlags) -> Unit raise Errno

    Loop::fs_chmod

    source
    #as_free_fn
    fn Loop::fs_chmod(self : Loop, path : Bytes, mode : Int, chmod_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously changes the permissions of a file.

    This function initiates a file permission change operation that will be handled asynchronously by the event loop. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • path : The file path whose permissions to change as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • mode : The new file permissions (octal notation, e.g., 0o644 for read/write for owner, read-only for group and others).
    • chmod_cb : Success callback function that receives the filesystem request handle when the permission change succeeds.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid parameters or system resource exhaustion).

    Note: On Windows, this function can only modify the write permission bit. All other permission bits are ignored.

    Example:

    let uv = @uv.Loop::new()
    let errors = []
    let path : Bytes = "test/fixtures/example-chmod.txt"
    uv.fs_chmod(
      path,
      0o644,  // rw-r--r--
      () => (),
      error => errors.push(error)
    )
    |> ignore()
    uv.run(Default)
    uv.close()
    for error in errors {
      raise error
    }

    Loop::fs_chmod_sync

    source
    #as_free_fn
    fn Loop::fs_chmod_sync(self : Loop, path : Bytes, mode : Int) -> Unit raise Errno

    Synchronously changes the permissions of a file.

    This function blocks the current thread until the file permission change operation completes. Unlike the asynchronous fs_chmod function, this operation does not require callbacks and returns immediately upon completion or failure.

    Parameters:

    • self : The event loop instance to perform the operation on.
    • path : The file path whose permissions to change as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • mode : The new file permissions (octal notation, e.g., 0o644 for read/write for owner, read-only for group and others).

    Throws an error of type Errno if the permissions cannot be changed (e.g., file does not exist, insufficient permissions, or system resource exhaustion).

    Note: On Windows, this function can only modify the write permission bit. All other permission bits are ignored.

    Example:

    let uv = @uv.Loop::new()
    let path : Bytes = "test/fixtures/example-chmod-sync.txt"
    uv.fs_chmod_sync(path, 0o644)  // rw-r--r--
    uv.close()

    Loop::fs_chown

    source
    #as_free_fn
    fn Loop::fs_chown(self : Loop, path : Bytes, uid : Uid, gid : Gid, chown_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously changes the owner and group of a file.

    This function initiates a file ownership change operation that will be handled asynchronously by the event loop. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • path : The file path whose ownership to change as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • uid : The new user ID (UID) for the file. Use -1 (or UInt::max_value) to leave the current owner unchanged.
    • gid : The new group ID (GID) for the file. Use -1 (or UInt::max_value) to leave the current group unchanged.
    • chown_cb : Success callback function that receives the filesystem request handle when the ownership change succeeds.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid parameters or system resource exhaustion).

    Note: On Windows, this function is a no-op and always succeeds since Windows doesn't use the same ownership model as Unix-like systems.

    Example:

    let uv = @uv.Loop::new()
    let errors = []
    let path : Bytes = "test/fixtures/example.txt"
    let passwd = @uv.os_get_passwd()
    uv.fs_chown(
      path,
      passwd.uid(),
      passwd.gid(),
      () => println("Ownership changed successfully"),
      error => errors.push(error)
    )
    |> ignore()
    uv.run(Default)
    uv.close()
    for error in errors {
      raise error
    }

    Loop::fs_chown_sync

    source
    #as_free_fn
    fn Loop::fs_chown_sync(self : Loop, path : Bytes, uid : Uid, gid : Gid) -> Unit raise Errno

    Synchronously changes the owner and group of a file.

    This function blocks the current thread until the file ownership change operation completes. Unlike the asynchronous fs_chown function, this operation does not require callbacks and returns immediately upon completion or failure.

    Parameters:

    • self : The event loop instance to perform the operation on.
    • path : The file path whose ownership to change as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • uid : The new user ID (UID) for the file. Use -1 (or UInt::max_value) to leave the current owner unchanged.
    • gid : The new group ID (GID) for the file. Use -1 (or UInt::max_value) to leave the current group unchanged.

    Throws an error of type Errno if the ownership cannot be changed (e.g., file does not exist, insufficient permissions, or system resource exhaustion).

    Note: On Windows, this function is a no-op and always succeeds since Windows doesn't use the same ownership model as Unix-like systems.

    Example:

    let uv = @uv.Loop::new()
    let path : Bytes = "test/fixtures/example.txt"
    let passwd = @uv.os_get_passwd()
    uv.fs_chown_sync(path, passwd.uid(), passwd.gid())
    uv.close()

    Loop::fs_close

    source
    #as_free_fn
    fn Loop::fs_close(self : Loop, file : File, close_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously closes a file descriptor.

    This function initiates a file close operation that will be handled asynchronously by the event loop. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • file : The file descriptor to close, typically obtained from fs_open or fs_open_sync.
    • close_cb : Success callback function that receives the filesystem request handle when the file is closed successfully.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid file descriptor or system resource exhaustion).

    Example:

    let uv = Loop::new()
    let errors = []
    let file = uv.fs_open_sync("README.md", OpenFlags::read_only(), 0o644)
    uv.fs_close(
      file,
      () => println("File closed successfully"),
      (error) => errors.push(error),
    )
    |> ignore()
    uv.run(Default)
    uv.close()
    for error in errors {
      raise error
    }

    Loop::fs_close_sync

    source
    #as_free_fn
    fn Loop::fs_close_sync(self : Loop, file : File) -> Unit raise Errno

    Loop::fs_closedir

    source
    #as_free_fn
    fn Loop::fs_closedir(self : Loop, dir : Dir, closedir_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_copyfile

    source
    #as_free_fn
    fn Loop::fs_copyfile(self : Loop, path : Bytes, new_path : Bytes, flags : CopyFileFlags, copy_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_copyfile_sync

    source
    #as_free_fn
    fn Loop::fs_copyfile_sync(self : Loop, path : Bytes, new_path : Bytes, flags : CopyFileFlags) -> Unit raise Errno

    Loop::fs_fchmod

    source
    #as_free_fn
    fn Loop::fs_fchmod(self : Loop, file : File, mode : Int, fchmod_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously changes the permissions of a file by file descriptor.

    This function initiates a file permission change operation using a file descriptor that will be handled asynchronously by the event loop. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • file : The file descriptor whose permissions to change, typically obtained from fs_open or fs_open_sync.
    • mode : The new file permissions (octal notation, e.g., 0o644 for read/write for owner, read-only for group and others).
    • fchmod_cb : Success callback function that receives the filesystem request handle when the permission change succeeds.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid file descriptor or system resource exhaustion).

    Note: On Windows, this function can only modify the write permission bit. All other permission bits are ignored.

    Example:

    let uv = @uv.Loop::new()
    let errors = []
    let path : Bytes = "test/fixtures/example-fchmod.txt"
    let file = uv.fs_open_sync(path, @uv.OpenFlags::read_write(), 0o644)
    uv.fs_fchmod(
      file,
      0o600,  // rw-------
      () => {
        try uv.fs_close_sync(file) catch { e => errors.push(e) }
      },
      error => {
        errors.push(error)
        try uv.fs_close_sync(file) catch { e => errors.push(e) }
      }
    )
    |> ignore()
    uv.run(Default)
    uv.close()
    for error in errors {
      raise error
    }

    Loop::fs_fchmod_sync

    source
    #as_free_fn
    fn Loop::fs_fchmod_sync(self : Loop, file : File, mode : Int) -> Unit raise Errno

    Synchronously changes the permissions of a file by file descriptor.

    This function blocks the current thread until the file permission change operation completes. Unlike the asynchronous fs_fchmod function, this operation does not require callbacks and returns immediately upon completion or failure.

    Parameters:

    • self : The event loop instance to perform the operation on.
    • file : The file descriptor whose permissions to change, typically obtained from fs_open or fs_open_sync.
    • mode : The new file permissions (octal notation, e.g., 0o644 for read/write for owner, read-only for group and others).

    Throws an error of type Errno if the permissions cannot be changed (e.g., invalid file descriptor, insufficient permissions, or system resource exhaustion).

    Note: On Windows, this function can only modify the write permission bit. All other permission bits are ignored.

    Example:

    let uv = @uv.Loop::new()
    let path : Bytes = "test/fixtures/example-fchmod-sync.txt"
    let file = uv.fs_open_sync(path, @uv.OpenFlags::read_write(), 0o644)
    uv.fs_fchmod_sync(file, 0o600)  // rw-------
    uv.fs_close_sync(file)
    uv.close()

    Loop::fs_fchown

    source
    #as_free_fn
    fn Loop::fs_fchown(self : Loop, file : File, uid : Uid, gid : Gid, fchown_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously changes the owner and group of a file by file descriptor.

    This function initiates a file ownership change operation using a file descriptor that will be handled asynchronously by the event loop. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • file : The file descriptor whose ownership to change, typically obtained from fs_open or fs_open_sync.
    • uid : The new user ID (UID) for the file. Use -1 (or UInt::max_value) to leave the current owner unchanged.
    • gid : The new group ID (GID) for the file. Use -1 (or UInt::max_value) to leave the current group unchanged.
    • fchown_cb : Success callback function that receives the filesystem request handle when the ownership change succeeds.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid file descriptor or system resource exhaustion).

    Note: On Windows, this function is a no-op and always succeeds since Windows doesn't use the same ownership model as Unix-like systems.

    Example:

    let uv = @uv.Loop::new()
    let errors = []
    let path : Bytes = "test/fixtures/example.txt"
    let passwd = @uv.os_get_passwd()
    let file = uv.fs_open_sync(path, @uv.OpenFlags::read_write(), 0o644)
    uv.fs_fchown(
      file,
      passwd.uid(),
      passwd.gid(),
      () => {
        try uv.fs_close_sync(file) catch { e => errors.push(e) }
      },
      error => {
        errors.push(error)
        try uv.fs_close_sync(file) catch { e => errors.push(e) }
      }
    )
    |> ignore()
    uv.run(Default)
    uv.close()
    for error in errors {
      raise error
    }

    Loop::fs_fchown_sync

    source
    #as_free_fn
    fn Loop::fs_fchown_sync(self : Loop, file : File, uid : Uid, gid : Gid) -> Unit raise Errno

    Synchronously changes the owner and group of a file by file descriptor.

    This function blocks the current thread until the file ownership change operation completes. Unlike the asynchronous fs_fchown function, this operation does not require callbacks and returns immediately upon completion or failure.

    Parameters:

    • self : The event loop instance to perform the operation on.
    • file : The file descriptor whose ownership to change, typically obtained from fs_open or fs_open_sync.
    • uid : The new user ID (UID) for the file. Use -1 (or UInt::max_value) to leave the current owner unchanged.
    • gid : The new group ID (GID) for the file. Use -1 (or UInt::max_value) to leave the current group unchanged.

    Throws an error of type Errno if the ownership cannot be changed (e.g., invalid file descriptor, insufficient permissions, or system resource exhaustion).

    Note: On Windows, this function is a no-op and always succeeds since Windows doesn't use the same ownership model as Unix-like systems.

    Example:

    let uv = @uv.Loop::new()
    let path : Bytes = "test/fixtures/example.txt"
    let file = uv.fs_open_sync(path, @uv.OpenFlags::read_write(), 0o644)
    let passwd = @uv.os_get_passwd()
    // Change to user ID 1000 and group ID 1000
    uv.fs_fchown_sync(file, passwd.uid(), passwd.gid())
    uv.fs_close_sync(file)
    uv.close()

    Loop::fs_fdatasync

    source
    #as_free_fn
    fn Loop::fs_fdatasync(self : Loop, file : File, sync_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously synchronizes a file's data with storage.

    This function initiates a file data sync operation that will be handled asynchronously by the event loop. The sync operation ensures that all in-memory data changes for the file are written to the underlying storage device, but does not necessarily synchronize metadata. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    This is equivalent to the fdatasync() system call, which synchronizes only the file's data but not necessarily the metadata (such as timestamps). This can be faster than fs_fsync since it doesn't need to wait for metadata writes.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • file : The file descriptor to synchronize, typically obtained from fs_open or fs_open_sync.
    • sync_cb : Success callback function that receives the filesystem request handle when the data sync operation completes successfully.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid file descriptor or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let errors = []
    let path : Bytes = "test/fixtures/datasync-test.txt"
    let file = uv.fs_open_sync(
      path,
      @uv.OpenFlags::write_only(create=true),
      0o644
    )
    let data : Bytes = "Hello, World!"
    uv.fs_write_sync(file, [data])
    uv.fs_fdatasync(
      file,
      () => println("File data synced successfully"),
      error => errors.push(error),
    )
    |> ignore()
    uv.run(Default)
    uv.fs_close_sync(file)
    uv.fs_unlink_sync(path)
    uv.close()
    for error in errors {
      raise error
    }

    Loop::fs_fdatasync_sync

    source
    #as_free_fn
    fn Loop::fs_fdatasync_sync(self : Loop, file : File) -> Unit raise Errno

    Synchronously synchronizes a file's data with storage.

    This function blocks the current thread until the file data sync operation completes. Unlike the asynchronous fs_fdatasync function, this operation does not require callbacks and returns immediately upon successful completion or failure.

    This is equivalent to the fdatasync() system call, which synchronizes only the file's data but not necessarily the metadata (such as timestamps). This can be faster than fs_fsync_sync since it doesn't need to wait for metadata writes.

    Parameters:

    • self : The event loop instance to perform the operation on.
    • file : The file descriptor to synchronize, typically obtained from fs_open or fs_open_sync.

    Throws an error of type Errno if the file data cannot be synchronized (e.g., invalid file descriptor, I/O error, or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let path : Bytes = "test/fixtures/datasync-test-sync.txt"
    let file = uv.fs_open_sync(
      path,
      @uv.OpenFlags::write_only(create=true),
      0o644
    )
    let data : Bytes = "Hello, World!"
    uv.fs_write_sync(file, [data])
    uv.fs_fdatasync_sync(file)
    uv.fs_close_sync(file)
    uv.fs_unlink_sync(path)
    uv.close()

    Loop::fs_fstat

    source
    #as_free_fn
    fn Loop::fs_fstat(self : Loop, file : File, fstat_cb : (Stat) -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_fsync

    source
    #as_free_fn
    fn Loop::fs_fsync(self : Loop, file : File, sync_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously synchronizes a file's data and metadata with storage.

    This function initiates a file sync operation that will be handled asynchronously by the event loop. The sync operation ensures that all in-memory data and metadata changes for the file are written to the underlying storage device. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    This is equivalent to the fsync() system call, which synchronizes both the file's data and metadata (such as timestamps and file size).

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • file : The file descriptor to synchronize, typically obtained from fs_open or fs_open_sync.
    • sync_cb : Success callback function that receives the filesystem request handle when the sync operation completes successfully.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid file descriptor or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let errors = []
    let path : Bytes = "test/fixtures/sync-test.txt"
    let file = uv.fs_open_sync(
      path,
      @uv.OpenFlags::write_only(create=true),
      0o644
    )
    let data : Bytes = "Hello, World!"
    uv.fs_write_sync(file, [data])
    uv.fs_fsync(
      file,
      () => println("File synced successfully"),
      error => errors.push(error),
    )
    |> ignore()
    uv.run(Default)
    uv.fs_close_sync(file)
    uv.fs_unlink_sync(path)
    uv.close()
    for error in errors {
      raise error
    }

    Loop::fs_fsync_sync

    source
    #as_free_fn
    fn Loop::fs_fsync_sync(self : Loop, file : File) -> Unit raise Errno

    Synchronously synchronizes a file's data and metadata with storage.

    This function blocks the current thread until the file sync operation completes. Unlike the asynchronous fs_fsync function, this operation does not require callbacks and returns immediately upon successful completion or failure.

    This is equivalent to the fsync() system call, which synchronizes both the file's data and metadata (such as timestamps and file size).

    Parameters:

    • self : The event loop instance to perform the operation on.
    • file : The file descriptor to synchronize, typically obtained from fs_open or fs_open_sync.

    Throws an error of type Errno if the file cannot be synchronized (e.g., invalid file descriptor, I/O error, or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let path : Bytes = "test/fixtures/sync-test-sync.txt"
    let file = uv.fs_open_sync(
      path,
      @uv.OpenFlags::write_only(create=true),
      0o644
    )
    let data : Bytes = "Hello, World!"
    uv.fs_write_sync(file, [data])
    uv.fs_fsync_sync(file)
    uv.fs_close_sync(file)
    uv.fs_unlink_sync(path)
    uv.close()

    Loop::fs_ftruncate

    source
    #as_free_fn
    fn Loop::fs_ftruncate(self : Loop, file : File, length : Int64, k : () -> Unit, e : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_futime

    source
    #as_free_fn
    fn Loop::fs_futime(self : Loop, file : Int, atime : Double, mtime : Double, success_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_futime_sync

    source
    #as_free_fn
    fn Loop::fs_futime_sync(self : Loop, file : Int, atime : Double, mtime : Double) -> Unit raise Errno

    Loop::fs_lchown

    source
    #as_free_fn
    fn Loop::fs_lchown(self : Loop, path : Bytes, uid : Uid, gid : Gid, lchown_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously changes the owner and group of a symbolic link.

    This function initiates a symbolic link ownership change operation that will be handled asynchronously by the event loop. Unlike fs_chown, this function changes the ownership of the symbolic link itself rather than the file it points to. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • path : The symbolic link path whose ownership to change as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • uid : The new user ID (UID) for the symbolic link. Use -1 (or UInt::max_value) to leave the current owner unchanged.
    • gid : The new group ID (GID) for the symbolic link. Use -1 (or UInt::max_value) to leave the current group unchanged.
    • lchown_cb : Success callback function that receives the filesystem request handle when the ownership change succeeds.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid parameters or system resource exhaustion).

    Note: On Windows, this function is a no-op and always succeeds since Windows doesn't use the same ownership model as Unix-like systems.

    Example:

    let uv = @uv.Loop::new()
    let errors = []
    let target_file : Bytes = "test/fixtures/example.txt"
    let symlink_file : Bytes = "test/fixtures/example-lchown.txt"
    let passwd = @uv.os_get_passwd()
    // First create a symlink
    uv.fs_symlink_sync(target_file, symlink_file, @uv.SymlinkFlags::new())
    uv.fs_lchown(
      symlink_file,
      passwd.uid(),
      passwd.gid(),
      () => {
        try uv.fs_unlink_sync(symlink_file) catch { e => errors.push(e) }
      },
      error => {
        errors.push(error)
        try uv.fs_unlink_sync(symlink_file) catch { e => errors.push(e) }
      }
    )
    |> ignore()
    uv.run(Default)
    uv.close()
    for error in errors {
      raise error
    }

    Loop::fs_lchown_sync

    source
    #as_free_fn
    fn Loop::fs_lchown_sync(self : Loop, path : Bytes, uid : Uid, gid : Gid) -> Unit raise Errno

    Synchronously changes the owner and group of a symbolic link.

    This function blocks the current thread until the symbolic link ownership change operation completes. Unlike the asynchronous fs_lchown function, this operation does not require callbacks and returns immediately upon completion or failure. Unlike fs_chown_sync, this function changes the ownership of the symbolic link itself rather than the file it points to.

    Parameters:

    • self : The event loop instance to perform the operation on.
    • path : The symbolic link path whose ownership to change as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • uid : The new user ID (UID) for the symbolic link. Use -1 (or UInt::max_value) to leave the current owner unchanged.
    • gid : The new group ID (GID) for the symbolic link. Use -1 (or UInt::max_value) to leave the current group unchanged.

    Throws an error of type Errno if the ownership cannot be changed (e.g., symbolic link does not exist, insufficient permissions, or system resource exhaustion).

    Note: On Windows, this function is a no-op and always succeeds since Windows doesn't use the same ownership model as Unix-like systems.

    Example:

    let uv = @uv.Loop::new()
    let target_file : Bytes = "test/fixtures/example.txt"
    let symlink_file : Bytes = "test/fixtures/example-lchown-sync.txt"
    let passwd = @uv.os_get_passwd()
    uv.fs_symlink_sync(target_file, symlink_file, @uv.SymlinkFlags::new())
    uv.fs_lchown_sync(symlink_file, passwd.uid(), passwd.gid())
    uv.fs_unlink_sync(symlink_file)
    uv.close()
    #as_free_fn
    fn Loop::fs_link(self : Loop, path : Bytes, new_path : Bytes, link_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously creates a hard link from new_path to path.

    This function initiates a hard link creation operation that will be handled asynchronously by the event loop. A hard link creates an additional directory entry that points to the same file data as the original path. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    Hard links can only be created for files (not directories) and both paths must be on the same filesystem. Unlike symbolic links, hard links point directly to the file data and remain valid even if the original path is removed.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • path : The existing file path to link to as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • new_path : The new path for the hard link as a Bytes object.
    • link_cb : Success callback function that receives the filesystem request handle when the hard link is created successfully.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid parameters or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let errors = []
    let original_file : Bytes = "test/fixtures/example.txt"
    let link_file : Bytes = "test/fixtures/example-link.txt"
    uv.fs_link(
      original_file,
      link_file,
      () => {
        println("Hard link created successfully")
        try uv.fs_unlink_sync(link_file) catch { e => errors.push(e) }
      },
      error => errors.push(error)
    )
    |> ignore()
    uv.run(Default)
    uv.close()
    for error in errors {
      raise error
    }
    #as_free_fn
    fn Loop::fs_link_sync(self : Loop, path : Bytes, new_path : Bytes) -> Unit raise Errno

    Synchronously creates a hard link from new_path to path.

    This function blocks the current thread until the hard link creation operation completes. Unlike the asynchronous fs_link function, this operation does not require callbacks and returns immediately upon completion or failure.

    Hard links can only be created for files (not directories) and both paths must be on the same filesystem. Unlike symbolic links, hard links point directly to the file data and remain valid even if the original path is removed.

    Parameters:

    • self : The event loop instance to perform the operation on.
    • path : The existing file path to link to as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • new_path : The new path for the hard link as a Bytes object.

    Throws an error of type Errno if the hard link cannot be created (e.g., file does not exist, paths on different filesystems, insufficient permissions, or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let original_file : Bytes = "test/fixtures/example.txt"
    let link_file : Bytes = "test/fixtures/example-link-sync.txt"
    uv.fs_link_sync(original_file, link_file)
    // Verify the link exists
    let stat = uv.fs_stat_sync(link_file)
    @assert.t(stat.is_file())
    // Clean up
    uv.fs_unlink_sync(link_file)
    uv.close()

    Loop::fs_lstat

    source
    #as_free_fn
    fn Loop::fs_lstat(self : Loop, path : Bytes, lstat_cb : (Stat) -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_lstat_sync

    source
    #as_free_fn
    fn Loop::fs_lstat_sync(self : Loop, path : Bytes) -> Stat raise Errno

    Synchronously gets file status information for a symbolic link.

    This function blocks the current thread until the lstat operation completes. Unlike fs_stat_sync, this function does not follow symbolic links and returns information about the link itself rather than the target.

    Parameters:

    • self : The event loop instance to perform the operation on.
    • path : The file or symbolic link path to examine as a Bytes object.

    Returns a Stat structure containing file information.

    Throws an error of type Errno if the file information cannot be obtained (e.g., file does not exist, insufficient permissions, or I/O error).

    Example:

    let uv = @uv.Loop::new()
    let target_file : Bytes = "test/fixtures/example.txt"
    let symlink_file : Bytes = "test/fixtures/example-lstat.txt"
    uv.fs_symlink_sync(target_file, symlink_file, @uv.SymlinkFlags::new())
    let stat = uv.fs_lstat_sync(symlink_file)
    @assert.t(stat.is_symlink())
    uv.fs_unlink_sync(symlink_file)
    uv.close()

    Loop::fs_lutime

    source
    #as_free_fn
    fn Loop::fs_lutime(self : Loop, path : Bytes, atime : Double, mtime : Double, success_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_lutime_sync

    source
    #as_free_fn
    fn Loop::fs_lutime_sync(self : Loop, path : Bytes, atime : Double, mtime : Double) -> Unit raise Errno

    Loop::fs_mkdir

    source
    #as_free_fn
    fn Loop::fs_mkdir(self : Loop, path : Bytes, mode : Int, mkdir_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously creates a directory at the specified path with the given permissions.

    This function initiates a directory creation operation that will be handled asynchronously by the event loop. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • path : The directory path to create as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • mode : The directory permissions to use when creating the directory (octal notation, e.g., 0o755).
    • mkdir_cb : Success callback function that receives the filesystem request handle when the directory is created successfully.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid parameters or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let es = []
    let dir : Bytes = "test/fixtures/doc-test-dir"
    uv.fs_mkdir(
      dir,
      0o755,
      () => println("Directory created successfully"),
      (e) => es.push(e)
    )
    |> ignore()
    uv.run(Default)
    uv.fs_rmdir_sync(dir)
    uv.close()
    for e in es {
      raise e
    }

    Loop::fs_mkdir_sync

    source
    #as_free_fn
    fn Loop::fs_mkdir_sync(self : Loop, path : Bytes, mode : Int) -> Unit raise Errno

    Synchronously creates a directory at the specified path with the given permissions.

    This function blocks the current thread until the directory creation operation completes. Unlike the asynchronous fs_mkdir function, this operation does not require callbacks and returns immediately upon completion or failure.

    Parameters:

    • self : The event loop instance to perform the operation on.
    • path : The directory path to create as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • mode : The directory permissions to use when creating the directory (octal notation, e.g., 0o755).

    Throws an error of type Errno if the directory cannot be created (e.g., path already exists, insufficient permissions, or invalid path).

    Example:

    let uv = @uv.Loop::new()
    try {
      uv.fs_mkdir_sync("test/fixtures", 0o755)
      fail("Directory should not exist")
    } catch {
      Errno::EEXIST => ()
      error => raise error
    }
    uv.close()

    Loop::fs_mkdtemp

    source
    #as_free_fn
    fn Loop::fs_mkdtemp(self : Loop, template : Bytes, mkdtemp_cb : (Bytes) -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_mkdtemp_sync

    source
    #as_free_fn
    fn Loop::fs_mkdtemp_sync(self : Loop, template : Bytes) -> Bytes raise Errno

    Loop::fs_mkstemp

    source
    #as_free_fn
    fn Loop::fs_mkstemp(self : Loop, template : Bytes, mkstemp_cb : (Bytes) -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_mkstemp_sync

    source
    #as_free_fn
    fn Loop::fs_mkstemp_sync(self : Loop, template : Bytes) -> Bytes raise Errno

    Loop::fs_open

    source
    #as_free_fn
    fn Loop::fs_open(self : Loop, path : Bytes, flags : OpenFlags, mode : Int, open_cb : (File) -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously opens a file at the specified path with the given flags and mode.

    This function initiates a file open operation that will be handled asynchronously by the event loop. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • path : The file path to open as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • flags : The file access mode and behavior flags. Use OpenFlags::read_only(), OpenFlags::write_only(), or OpenFlags::read_write() with optional parameters for additional behaviors like append, create, truncate, or exclusive access.
    • mode : The file permissions to use when creating a new file (octal notation, e.g., 0o644). This parameter is ignored if the file already exists.
    • open_cb : Success callback function that receives the filesystem request handle and the opened file descriptor when the operation succeeds.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid parameters or system resource exhaustion).

    Example:

    let uv = Loop::new()
    let errors = []
    uv.fs_open(
      "README.md",
      OpenFlags::read_only(),
      0o644,
      file => uv.fs_close_sync(file) catch { _ => () },
      (error) => errors.push(error),
    )
    |> ignore()
    uv.run(Default)
    uv.close()
    for error in errors {
      raise error
    }

    Loop::fs_open_sync

    source
    #as_free_fn
    fn Loop::fs_open_sync(self : Loop, path : Bytes, flags : OpenFlags, mode : Int) -> File raise Errno

    Synchronously opens a file at the specified path with the given flags and mode.

    This function blocks the current thread until the file open operation completes. Unlike the asynchronous fs_open function, this operation does not require callbacks and returns the file descriptor immediately upon successful completion.

    Parameters:

    • self : The event loop instance to perform the operation on.
    • path : The file path to open as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • flags : The file access mode and behavior flags. Use OpenFlags::read_only(), OpenFlags::write_only(), or OpenFlags::read_write() with optional parameters for additional behaviors like append, create, truncate, or exclusive access.
    • mode : The file permissions to use when creating a new file (octal notation, e.g., 0o644). This parameter is ignored if the file already exists.

    Returns a File handle that can be used for subsequent file operations like reading, writing, or closing.

    Throws an error of type Errno if the file cannot be opened (e.g., file does not exist, insufficient permissions, invalid path, or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let file = uv.fs_open_sync("README.md", @uv.OpenFlags::read_only(), 0o644)
    uv.fs_close_sync(file)
    uv.close()

    Loop::fs_opendir

    source
    #as_free_fn
    fn Loop::fs_opendir(self : Loop, path : Bytes, opendir_cb : (Dir) -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_read

    source
    #as_free_fn
    fn Loop::fs_read(self : Loop, file : File, bufs : Array[BytesView], offset? : Int64, read_cb : (Int) -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously reads data from a file into multiple buffers.

    This function initiates a read operation that will be handled asynchronously by the event loop. The data is read from the file into the provided array of byte views, which can be used for scatter-gather I/O operations. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • file : The file descriptor to read from, typically obtained from fs_open or fs_open_sync.
    • bufs : An array of byte views that will receive the data read from the file. The views define both the memory locations and the amount of data to read into each buffer.
    • offset : The file position to start reading from. If -1 (default), reads from the current file position. Otherwise, reads from the specified absolute position in the file.
    • read_cb : Success callback function that receives the filesystem request handle and the number of bytes actually read when the operation succeeds.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid file descriptor or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let errors = []
    uv.fs_read(
      @uv.stdin(),
      [Bytes::make(100, 0)],
      count => println("Read \{count} bytes"),
      error => errors.push(error),
    )
    |> ignore()
    uv.run(Default)
    uv.close()
    for error in errors {
      raise error
    }

    Loop::fs_read_sync

    source
    #as_free_fn
    fn Loop::fs_read_sync(self : Loop, file : File, bufs : Array[BytesView], offset? : Int64) -> Int raise Errno

    Loop::fs_readdir

    source
    #as_free_fn
    fn Loop::fs_readdir(self : Loop, dir : Dir, n : Int, readdir_cb : (Array[Dirent]) -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    #as_free_fn
    fn Loop::fs_readlink(self : Loop, path : Bytes, readlink_cb : (Bytes) -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously reads the target of a symbolic link.

    This function initiates a symbolic link read operation that will be handled asynchronously by the event loop. The operation reads the target path that a symbolic link points to. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • path : The symbolic link path to read as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • readlink_cb : Success callback function that receives the filesystem request handle and the target path when the operation succeeds.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid parameters or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let errors = []
    let target_file : Bytes = "test/fixtures/example.txt"
    let symlink_file : Bytes = "test/fixtures/example-symlink.txt"
    // First create a symlink
    uv.fs_symlink_sync(target_file, symlink_file, @uv.SymlinkFlags::new())
    // Then read its target
    uv.fs_readlink(
      symlink_file,
      target => {
        println("Symlink points to: \{target}")
        try {
          @assert.eq(target, target_file)
          uv.fs_unlink_sync(symlink_file)
        } catch { e => errors.push(e) }
      },
      error => errors.push(error)
    )
    |> ignore()
    uv.run(Default)
    uv.close()
    for error in errors {
      raise error
    }
    #as_free_fn
    fn Loop::fs_readlink_sync(self : Loop, path : Bytes) -> Bytes raise Errno

    Synchronously reads the target of a symbolic link.

    This function blocks the current thread until the symbolic link read operation completes. Unlike the asynchronous fs_readlink function, this operation does not require callbacks and returns the target path immediately upon successful completion.

    Parameters:

    • self : The event loop instance to perform the operation on.
    • path : The symbolic link path to read as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).

    Returns the target path that the symbolic link points to as a Bytes object.

    Throws an error of type Errno if the symbolic link cannot be read (e.g., path does not exist, path is not a symbolic link, insufficient permissions, or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let target_file : Bytes = "test/fixtures/example.txt"
    let symlink_file : Bytes = "test/fixtures/example-symlink-sync.txt"
    // First create a symlink
    uv.fs_symlink_sync(target_file, symlink_file, @uv.SymlinkFlags::new())
    // Then read its target
    let target = uv.fs_readlink_sync(symlink_file)
    @assert.eq(target, target_file)
    // Clean up
    uv.fs_unlink_sync(symlink_file)
    uv.close()

    Loop::fs_realpath

    source
    #as_free_fn
    fn Loop::fs_realpath(self : Loop, path : Bytes, path_cb : (Bytes) -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously resolves a file path to its absolute canonical form.

    This function initiates a path resolution operation that will be handled asynchronously by the event loop. The resolved path eliminates symbolic links, relative path components (like . and ..), and redundant separators to produce an absolute canonical path. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • path : The file path to resolve as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • path_cb : Success callback function that receives the filesystem request handle and the resolved absolute path when the operation succeeds.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid parameters or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let errors = []
    uv.fs_realpath(
      "test/fixtures/example.txt",
      realpath => println("Resolved: \{realpath}"),
      error => errors.push(error)
    )
    |> ignore()
    uv.run(Default)
    uv.close()
    for error in errors {
      raise error
    }

    Loop::fs_realpath_sync

    source
    #as_free_fn
    fn Loop::fs_realpath_sync(self : Loop, path : Bytes) -> Bytes raise Errno

    Loop::fs_rename

    source
    #as_free_fn
    fn Loop::fs_rename(self : Loop, path : Bytes, new_path : Bytes, rename_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_rename_sync

    source
    #as_free_fn
    fn Loop::fs_rename_sync(self : Loop, path : Bytes, new_path : Bytes) -> Unit raise Errno

    Synchronously renames a file or directory.

    This function blocks the current thread until the rename operation completes. Unlike the asynchronous fs_rename function, this operation does not require callbacks and returns immediately upon successful completion or failure.

    Parameters

    • path: The current path of the file or directory to rename
    • new_path: The new path for the file or directory

    Errors

    Raises an Errno error if the rename operation fails, such as:
    • Source path does not exist
    • Destination path already exists (for files)
    • Insufficient permissions
    • Cross-device rename not supported

    Example

    let uv = @uv.Loop::new()
    try {
      uv.fs_rename_sync("old_file.txt", "new_file.txt")
      println("File renamed successfully")
    } catch {
      error => println("Rename failed: " + error.to_string())
    }
    uv.close()

    Loop::fs_rmdir

    source
    #as_free_fn
    fn Loop::fs_rmdir(self : Loop, path : Bytes, rmdir_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_rmdir_sync

    source
    #as_free_fn
    fn Loop::fs_rmdir_sync(self : Loop, path : Bytes) -> Unit raise Errno

    Loop::fs_scandir

    source
    #as_free_fn
    fn Loop::fs_scandir(self : Loop, path : Bytes, flags : Int, scandir_cb : (Scandir) -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_scandir_sync

    source
    #as_free_fn
    fn Loop::fs_scandir_sync(self : Loop, path : Bytes, flags : Int) -> Scandir raise Errno

    Loop::fs_sendfile

    source
    #as_free_fn
    fn Loop::fs_sendfile(self : Loop, out_fd : File, in_fd : File, in_offset : Int64, length : UInt64, sendfile_cb : (Int64) -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously transfers data between file descriptors.

    This function initiates a sendfile operation that will be handled asynchronously by the event loop. The sendfile operation is an efficient way to transfer data from one file descriptor to another without copying data through userspace. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    On platforms that support it, this function uses the native sendfile() system call for optimal performance. On platforms that don't support it, it falls back to a read/write loop.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • out_fd : The destination file descriptor to write to.
    • in_fd : The source file descriptor to read from.
    • in_offset : The offset in the input file to start reading from.
    • length : The maximum number of bytes to transfer.
    • sendfile_cb : Success callback function that receives the filesystem request handle and the number of bytes transferred when the operation succeeds.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid file descriptors or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let errors = []
    let dst_path : Bytes = "test/fixtures/example-sent.txt"
    let src_file = uv.fs_open_sync("test/fixtures/example.txt", @uv.OpenFlags::read_only(), 0o644)
    let dst_file = uv.fs_open_sync(dst_path, @uv.OpenFlags::write_only(create=true), 0o644)
    uv.fs_sendfile(
      dst_file,
      src_file,
      0L,
      1024UL,
      _ => {
        try {
          uv.fs_close_sync(src_file)
          uv.fs_close_sync(dst_file)
          uv.fs_unlink_sync(dst_path)
        } catch { e => errors.push(e) }
      },
      error => {
        errors.push(error)
        try {
          uv.fs_close_sync(src_file)
          uv.fs_close_sync(dst_file)
          uv.fs_unlink_sync(dst_path)
        } catch { e => errors.push(e) }
      }
    )
    |> ignore()
    uv.run(Default)
    uv.close()
    for error in errors {
      raise error
    }

    Loop::fs_sendfile_sync

    source
    #as_free_fn
    fn Loop::fs_sendfile_sync(self : Loop, out_fd : File, in_fd : File, in_offset : Int64, length : UInt64) -> Int64 raise Errno

    Synchronously transfers data between file descriptors.

    This function blocks the current thread until the sendfile operation completes. Unlike the asynchronous fs_sendfile function, this operation does not require callbacks and returns the number of bytes transferred immediately upon successful completion.

    On platforms that support it, this function uses the native sendfile() system call for optimal performance. On platforms that don't support it, it falls back to a read/write loop.

    Parameters:

    • self : The event loop instance to perform the operation on.
    • out_fd : The destination file descriptor to write to.
    • in_fd : The source file descriptor to read from.
    • in_offset : The offset in the input file to start reading from.
    • length : The maximum number of bytes to transfer.

    Returns the number of bytes actually transferred.

    Throws an error of type Errno if the transfer cannot be completed (e.g., invalid file descriptors, I/O error, or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let dst_path : Bytes = "test/fixtures/example-sent.txt"
    let src_file = uv.fs_open_sync("test/fixtures/example.txt", @uv.OpenFlags::read_only(), 0o644)
    let dst_file = uv.fs_open_sync(dst_path, @uv.OpenFlags::write_only(create=true), 0o644)
    let _ = uv.fs_sendfile_sync(dst_file, src_file, 0L, 1024UL)
    uv.fs_close_sync(src_file)
    uv.fs_close_sync(dst_file)
    uv.fs_unlink_sync(dst_path)
    uv.close()

    Loop::fs_stat

    source
    #as_free_fn
    fn Loop::fs_stat(self : Loop, path : Bytes, stat_cb : (Stat) -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_stat_sync

    source
    #as_free_fn
    fn Loop::fs_stat_sync(self : Loop, path : Bytes) -> Stat raise Errno

    Loop::fs_statfs

    source
    #as_free_fn
    fn Loop::fs_statfs(self : Loop, path : Bytes, statfs_cb : (StatFs) -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_statfs_sync

    source
    #as_free_fn
    fn Loop::fs_statfs_sync(self : Loop, path : Bytes) -> StatFs raise Errno

    #as_free_fn
    fn Loop::fs_symlink(self : Loop, path : Bytes, new_path : Bytes, flags : SymlinkFlags, symlink_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously creates a symbolic link from new_path to path.

    This function initiates a symbolic link creation operation that will be handled asynchronously by the event loop. A symbolic link creates a file that points to another file or directory by name. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    Unlike hard links, symbolic links can point to files or directories on different filesystems and can point to non-existent targets. If the target file is moved or deleted, the symlink becomes broken.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • path : The target path that the symlink will point to as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • new_path : The path where the symbolic link will be created as a Bytes object.
    • flags : Symbolic link creation flags. Use SymlinkFlags::new() with optional parameters to specify symlink behavior on Windows.
    • symlink_cb : Success callback function that receives the filesystem request handle when the symbolic link is created successfully.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid parameters or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let errors = []
    let target_file : Bytes = "test/fixtures/example.txt"
    let symlink_file : Bytes = "test/fixtures/example-symlink.txt"
    uv.fs_symlink(
      target_file,
      symlink_file,
      @uv.SymlinkFlags::new(),
      () => {
        println("Symbolic link created successfully")
        try uv.fs_unlink_sync(symlink_file) catch { e => errors.push(e) }
      },
      error => errors.push(error)
    )
    |> ignore()
    uv.run(Default)
    uv.close()
    for error in errors {
      raise error
    }
    #as_free_fn
    fn Loop::fs_symlink_sync(self : Loop, path : Bytes, new_path : Bytes, flags : SymlinkFlags) -> Unit raise Errno

    Synchronously creates a symbolic link from new_path to path.

    This function blocks the current thread until the symbolic link creation operation completes. Unlike the asynchronous fs_symlink function, this operation does not require callbacks and returns immediately upon completion or failure.

    Unlike hard links, symbolic links can point to files or directories on different filesystems and can point to non-existent targets. If the target file is moved or deleted, the symlink becomes broken.

    Parameters:

    • self : The event loop instance to perform the operation on.
    • path : The target path that the symlink will point to as a Bytes object. If you have a String, StringView, or BytesView, convert it to Bytes first using @encoding.encode(encoding=UTF8, string_value).
    • new_path : The path where the symbolic link will be created as a Bytes object.
    • flags : Symbolic link creation flags. Use SymlinkFlags::new() with optional parameters to specify symlink behavior on Windows.

    Throws an error of type Errno if the symbolic link cannot be created (e.g., insufficient permissions, invalid path, or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let target_file : Bytes = "test/fixtures/example.txt"
    let symlink_file : Bytes = "test/fixtures/example-symlink-sync.txt"
    uv.fs_symlink_sync(target_file, symlink_file, @uv.SymlinkFlags::new())
    // Verify the symlink exists
    let stat = uv.fs_lstat_sync(symlink_file)
    @assert.t(stat.is_symlink())
    // Clean up
    uv.fs_unlink_sync(symlink_file)
    uv.close()
    #as_free_fn
    fn Loop::fs_unlink(self : Loop, path : Bytes, k : () -> Unit, e : (Errno) -> Unit) -> Fs raise Errno

    #as_free_fn
    fn Loop::fs_unlink_sync(self : Loop, path : Bytes) -> Unit raise Errno

    Loop::fs_utime

    source
    #as_free_fn
    fn Loop::fs_utime(self : Loop, path : Bytes, atime : Double, mtime : Double, success_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Loop::fs_utime_sync

    source
    #as_free_fn
    fn Loop::fs_utime_sync(self : Loop, path : Bytes, atime : Double, mtime : Double) -> Unit raise Errno

    Loop::fs_write

    source
    #as_free_fn
    fn Loop::fs_write(self : Loop, file : File, bufs : Array[BytesView], offset? : Int64, write_cb : (Int) -> Unit, error_cb : (Errno) -> Unit) -> Fs raise Errno

    Asynchronously writes data from multiple buffers to a file.

    This function initiates a write operation that will be handled asynchronously by the event loop. The data is written from the provided array of byte views to the file, which can be used for gather I/O operations. When the operation completes, either the success callback or error callback will be invoked depending on the result.

    Parameters:

    • self : The event loop instance to schedule the operation on.
    • file : The file descriptor to write to, typically obtained from fs_open or fs_open_sync.
    • bufs : An array of byte views containing the data to write to the file. The views define both the memory locations and the amount of data to write from each buffer.
    • offset : The file position to start writing to. If -1 (default), writes to the current file position. Otherwise, writes to the specified absolute position in the file.
    • write_cb : Success callback function that receives the filesystem request handle and the number of bytes actually written when the operation succeeds.
    • error_cb : Error callback function that receives the filesystem request handle and the error code when the operation fails.

    Throws an error of type Errno if the operation cannot be initiated (e.g., invalid file descriptor or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let errors = []
    let path : Bytes = "test/fixtures/doc-test.txt"
    let file = uv.fs_open_sync(
      path,
      @uv.OpenFlags::write_only(create=true),
      0o644
    )
    let data : Bytes = "Hello, World!"
    uv.fs_write(
      file,
      [data],
      written => println("Wrote \{written} bytes"),
      error => errors.push(error),
    )
    |> ignore()
    uv.run(Default)
    uv.fs_close_sync(file)
    uv.fs_unlink_sync(path)
    uv.close()
    for error in errors {
      raise error
    }

    Loop::fs_write_sync

    source
    #as_free_fn
    fn Loop::fs_write_sync(self : Loop, file : File, bufs : Array[BytesView], offset? : Int64) -> Unit raise Errno

    Synchronously writes data from multiple buffers to a file.

    This function blocks the current thread until the write operation completes. Unlike the asynchronous fs_write function, this operation does not require callbacks and returns immediately upon successful completion or failure.

    Parameters:

    • self : The event loop instance to perform the operation on.
    • file : The file descriptor to write to, typically obtained from fs_open or fs_open_sync.
    • bufs : An array of byte views containing the data to write to the file. The views define both the memory locations and the amount of data to write from each buffer.
    • offset : The file position to start writing to. If -1 (default), writes to the current file position. Otherwise, writes to the specified absolute position in the file.

    Throws an error of type Errno if the file cannot be written to (e.g., invalid file descriptor, insufficient permissions, disk full, or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let path : Bytes = "test/fixtures/doc-test-sync.txt"
    let file = uv.fs_open_sync(
      path,
      @uv.OpenFlags::write_only(create=true),
      0o644
    )
    let data : Bytes = "Hello, World!"
    uv.fs_write_sync(file, [data])
    uv.fs_close_sync(file)
    uv.fs_unlink_sync(path)
    uv.close()

    Loop::getaddrinfo

    source
    #as_free_fn
    fn Loop::getaddrinfo(self : Loop, getaddrinfo_cb : (Iter[AddrInfo]) -> Unit, error_cb : (Errno) -> Unit, node : Bytes, service : Bytes, hints? : AddrInfoHints) -> GetAddrInfo raise Errno

    Loop::getnameinfo

    source
    #as_free_fn
    fn Loop::getnameinfo(self : Loop, getnameinfo_cb : (Bytes?, Bytes?) -> Unit, error_cb : (Errno) -> Unit, addr : Sockaddr, flags? : Int) -> GetNameInfo raise Errno

    Loop::metrics_idle_time

    source
    #as_free_fn
    fn Loop::metrics_idle_time(self : Loop) -> UInt64

    Loop::metrics_info

    source
    #as_free_fn
    fn Loop::metrics_info(self : Loop) -> Metrics raise Errno

    Loop::new

    source
    fn Loop::new() -> Loop raise Errno

    Creates a new event loop instance.

    Returns a new event loop that can be used for asynchronous I/O operations.

    Throws an error of type Errno if the loop initialization fails due to system resource constraints or other platform-specific issues.

    Example:

    let uv = @uv.Loop::new()
    uv.close()

    Loop::now

    source
    fn Loop::now(self : Loop) -> UInt64

    Return the current timestamp in milliseconds. The timestamp is cached at the start of the event loop tick, see uv_update_time() for details and rationale.

    The timestamp increases monotonically from some arbitrary point in time. Don't make assumptions about the starting point, you will only get disappointed.

    Note: Use @uv.hrtime() if you need sub-millisecond granularity.

    Loop::print_all_handles

    source
    fn Loop::print_all_handles(self : Loop, file : File) -> Unit

    Loop::queue_work

    source
    fn Loop::queue_work(self : Loop, work_cb : () -> Unit, after_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Work raise Errno

    Loop::random

    source
    #as_free_fn
    fn Loop::random(self : Loop, buffer : BytesView, flags : Int, random_cb : (BytesView) -> Unit, error_cb : (Errno) -> Unit) -> Random raise Errno

    Loop::random_sync

    source
    #as_free_fn
    fn Loop::random_sync(self : Loop, buffer : BytesView, flags : Int) -> Unit raise Errno

    Synchronously generates random data.

    The synchronous version may block indefinitely when not enough entropy is available. This function blocks the current thread until the random data generation completes. Unlike the asynchronous random function, this operation does not require callbacks and returns immediately upon successful completion or failure.

    Parameters:

    • self : The event loop instance to perform the operation on.
    • buffer : A view of the buffer to fill with random data.
    • flags : Flags to control the random data generation (typically 0).

    Throws an error of type Errno if random data cannot be generated (e.g., insufficient entropy or system resource exhaustion).

    Example:

    let uv = @uv.Loop::new()
    let buffer = Bytes::make(16, 0)
    uv.random_sync(buffer[:], 0)
    // buffer now contains random data
    uv.close()

    Loop::run

    source
    fn Loop::run(self : Loop, mode : RunMode) -> Unit raise Errno

    Runs the event loop with the specified mode.

    Parameters:

    • self : The event loop to run.
    • mode : The run mode that determines how the loop executes. Can be Default (runs until no more active handles), Once (runs once and returns), or NoWait (polls for I/O once but doesn't block).

    Throws an error of type Errno if the loop fails to run properly.

    Example:

    let uv = @uv.Loop::new()
    uv.run(Default)
    uv.close()

    Loop::spawn

    source
    #as_free_fn
    fn Loop::spawn(self : Loop, options : ProcessOptions) -> Process raise Errno

    Loop::stop

    source
    fn Loop::stop(self : Loop) -> Unit

    Loop::update_time

    source
    fn Loop::update_time(self : Loop) -> Unit

    Update the event loop's concept of "now". Libuv caches the current time at the start of the event loop tick in order to reduce the number of time-related system calls.

    You won't normally need to call this function unless you have callbacks that block the event loop for longer periods of time, where "longer" is somewhat subjective but probably on the order of a millisecond or more.

    Loop::walk

    source
    fn Loop::walk(self : Loop, walk_cb : (Handle) -> Unit) -> Unit

    LoopOption

    source
    pub(all) enum LoopOption {
      BlockSignal(Signum)
      MeasureIdleTime
      UseIoUringSqPoll
    }

    Membership

    source
    pub(all) enum Membership {
      LeaveGroup
      JoinGroup
    }

    Membership::to_int

    source
    fn Membership::to_int(self : Membership) -> Int

    Metrics

    source
    type Metrics

    Metrics::events

    source
    fn Metrics::events(self : Metrics) -> UInt64

    Metrics::events_waiting

    source
    fn Metrics::events_waiting(self : Metrics) -> UInt64

    Metrics::loop_count

    source
    fn Metrics::loop_count(self : Metrics) -> UInt64

    Mutex

    source
    type Mutex

    impl Share for Mutex

    Mutex::lock

    source
    fn Mutex::lock(self : Mutex) -> Unit

    Mutex::new

    source
    fn Mutex::new() -> Mutex raise Errno

    Mutex::trylock

    source
    fn Mutex::trylock(self : Mutex) -> Unit raise Errno

    Mutex::unlock

    source
    fn Mutex::unlock(self : Mutex) -> Unit

    Once

    source
    type Once

    Once::call

    source
    fn Once::call(once : Once, cb : FuncRef[() -> Unit]) -> Unit

    Once::new

    source
    fn Once::new() -> Once

    OpenFlags

    source
    type OpenFlags

    OpenFlags::read_only

    source
    fn OpenFlags::read_only(access_hint? : AccessHint, direct? : Bool, directory? : Bool, exclusive_lock? : Bool, filemap? : Bool, noatime? : Bool, nofollow? : Bool, nonblock? : Bool, symlink? : Bool) -> OpenFlags

    Creates file open flags for read-only access.

    Returns an OpenFlags instance configured for read-only file access. Files opened with these flags can only be read from, not written to or modified.

    Example:

    let uv = @uv.Loop::new()
    let flags = @uv.OpenFlags::read_only()
    let file = uv.fs_open_sync("README.md", flags, 0o644)
    uv.fs_close_sync(file)
    uv.close()

    OpenFlags::read_write

    source
    fn OpenFlags::read_write(access_hint? : AccessHint, append? : Bool, create? : Bool, direct? : Bool, exclusive? : Bool, exclusive_lock? : Bool, filemap? : Bool, noatime? : Bool, noctty? : Bool, nofollow? : Bool, nonblock? : Bool, symlink? : Bool, sync? : Sync, temporary? : Bool, truncate? : Bool) -> OpenFlags

    Creates file open flags for read-write access with configurable behaviors.

    Parameters:

    • append : Whether to append to the file instead of overwriting. When true, writes will be positioned at the end of the file. Defaults to false.
    • create : Whether to create the file if it doesn't exist. When true, a new file will be created if the specified path doesn't exist. Defaults to false.
    • truncate : Whether to truncate the file to zero length when opening. When true, any existing content will be discarded. Defaults to false.
    • exclusive : Whether to fail if the file already exists when creating. When true and create is also true, the operation will fail if the file already exists. Defaults to false.

    Returns an OpenFlags instance configured for read-write access with the specified behaviors.

    Example:

    let uv = @uv.Loop::new()
    // Create a new file for reading and writing, fail if it exists
    let flags = @uv.OpenFlags::read_write(create=true, exclusive=true)
    let path : Bytes = "new_file.txt"
    let file = uv.fs_open_sync(path, flags, 0o644)
    uv.fs_close_sync(file)
    uv.fs_unlink_sync(path)
    uv.close()

    OpenFlags::write_only

    source
    fn OpenFlags::write_only(append? : Bool, create? : Bool, direct? : Bool, exclusive? : Bool, exclusive_lock? : Bool, filemap? : Bool, nofollow? : Bool, nonblock? : Bool, sync? : Sync, temporary? : Bool, truncate? : Bool) -> OpenFlags

    Creates file open flags for write-only access with configurable behaviors.

    Parameters:

    • append : Whether to append to the file instead of overwriting. When true, writes will be positioned at the end of the file. Defaults to false.
    • create : Whether to create the file if it doesn't exist. When true, a new file will be created if the specified path doesn't exist. Defaults to false.
    • truncate : Whether to truncate the file to zero length when opening. When true, any existing content will be discarded. Defaults to false.
    • exclusive : Whether to fail if the file already exists when creating. When true and create is also true, the operation will fail if the file already exists. Defaults to false.

    Returns an OpenFlags instance configured for write-only access with the specified behaviors.

    Example:

    let uv = @uv.Loop::new()
    // Create a new file for writing, truncate if it exists
    let flags = @uv.OpenFlags::write_only(create=true, truncate=true)
    let path : Bytes = "output.txt"
    let file = uv.fs_open_sync(path, flags, 0o644)
    uv.fs_close_sync(file)
    uv.fs_unlink_sync(path)
    uv.close()

    OsFd

    source
    type OsFd

    OsFd::to_int

    source
    fn OsFd::to_int(self : OsFd) -> Int raise Errno

    OsSock

    source
    type OsSock

    OsSock::to_int

    source
    fn OsSock::to_int(self : OsSock) -> Int

    Passwd

    source
    type Passwd

    Passwd::gid

    source
    fn Passwd::gid(passwd : Passwd) -> Gid

    Passwd::shell

    source
    fn Passwd::shell(passwd : Passwd) -> Bytes

    Passwd::uid

    source
    fn Passwd::uid(passwd : Passwd) -> Uid

    Passwd::username

    source
    fn Passwd::username(passwd : Passwd) -> Bytes

    PhysAddr

    source
    type PhysAddr

    impl Show for PhysAddr
    impl ToJson for PhysAddr

    Pid

    source
    type Pid

    impl Compare for Pid
    impl Eq for Pid
    impl Hash for Pid
    impl Show for Pid

    Pid::of_int

    source
    fn Pid::of_int(pid : Int) -> Pid

    Pid::to_int

    source
    fn Pid::to_int(self : Pid) -> Int

    Pipe

    source
    type Pipe

    impl ToHandle for Pipe
    impl ToStream for Pipe

    Pipe::bind

    source
    fn Pipe::bind(self : Pipe, name : Bytes, flags : PipeBindFlags) -> Unit raise Errno

    Pipe::chmod

    source
    fn Pipe::chmod(self : Pipe, mode : PipeMode) -> Unit raise Errno

    Alters pipe permissions, allowing it to be accessed from processes run by different users. Makes the pipe writable or readable by all users.

    Pipe::connect

    source
    fn Pipe::connect(self : Pipe, name : Bytes, connect_cb : () -> Unit, error_cb : (Errno) -> Unit, no_truncate? : Bool) -> Connect raise Errno

    Pipe::new

    source
    fn Pipe::new(self : Loop, ipc? : Bool) -> Pipe raise Errno

    Pipe::open

    source
    fn Pipe::open(self : Pipe, file : File) -> Unit raise Errno

    Pipe::pending_count

    source
    fn Pipe::pending_count(self : Pipe) -> UInt

    Pipe::pending_instances

    source
    fn Pipe::pending_instances(self : Pipe, count : Int) -> Unit

    Set the number of pending pipe instance handles when the pipe server is waiting for connections.

    NOTE: This setting applies to Windows only.

    Pipe::pending_type

    source
    fn Pipe::pending_type(self : Pipe) -> HandleType

    Pipe::to_handle

    source
    fn Pipe::to_handle(self : Pipe) -> Handle

    Pipe::to_stream

    source
    fn Pipe::to_stream(self : Pipe) -> Stream

    Pipe::try_write2

    source
    fn[Stream : ToStream + ToHandle] Pipe::try_write2(self : Pipe, bufs : Array[BytesView], send_handle : Stream, write_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Write raise Errno

    Pipe::write2

    source
    fn[Stream : ToStream + ToHandle] Pipe::write2(self : Pipe, bufs : Array[BytesView], send_handle : Stream, write_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Write raise Errno

    PipeBindFlags

    source
    type PipeBindFlags

    PipeBindFlags::new

    source
    fn PipeBindFlags::new(truncate? : Bool) -> PipeBindFlags

    PipeFlags

    source
    type PipeFlags

    PipeFlags::new

    source
    fn PipeFlags::new(non_block? : Bool) -> PipeFlags

    PipeMode

    source
    pub(all) enum PipeMode {
      Readable
      Writable
      ReadWrite
    }

    Poll

    source
    type Poll

    impl ToHandle for Poll

    Poll::file

    source
    fn Poll::file(self : Loop, fd : File) -> Poll raise Errno

    Poll::socket

    source
    fn Poll::socket(self : Loop, socket : OsSock) -> Poll raise Errno

    Poll::start

    source
    fn Poll::start(self : Poll, events : PollEvent, poll_cb : (Poll, PollEvent) -> Unit, error_cb : (Poll, Errno) -> Unit) -> Unit raise Errno

    Poll::stop

    source
    fn Poll::stop(self : Poll) -> Unit raise Errno

    PollEvent

    source
    type PollEvent

    impl BitAnd for PollEvent
    impl BitOr for PollEvent

    PollEvent::disconnect

    source
    fn PollEvent::disconnect() -> PollEvent

    PollEvent::is_disconnect

    source
    fn PollEvent::is_disconnect(self : PollEvent) -> Bool

    PollEvent::is_prioritized

    source
    fn PollEvent::is_prioritized(self : PollEvent) -> Bool

    PollEvent::is_readable

    source
    fn PollEvent::is_readable(self : PollEvent) -> Bool

    PollEvent::is_writable

    source
    fn PollEvent::is_writable(self : PollEvent) -> Bool

    PollEvent::prioritized

    source
    fn PollEvent::prioritized() -> PollEvent

    PollEvent::readable

    source
    fn PollEvent::readable() -> PollEvent

    PollEvent::writable

    source
    fn PollEvent::writable() -> PollEvent

    Prepare

    source
    type Prepare

    impl ToHandle for Prepare

    Prepare::new

    source
    fn Prepare::new(self : Loop) -> Prepare raise Errno

    Prepare::start

    source
    fn Prepare::start(self : Prepare, cb : (Prepare) -> Unit) -> Unit raise Errno

    Prepare::stop

    source
    fn Prepare::stop(self : Prepare) -> Unit raise Errno

    Process

    source
    type Process

    impl ToHandle for Process

    Process::kill

    source
    fn Process::kill(self : Process, signum : Signum) -> Unit raise Errno

    Process::pid

    source
    fn Process::pid(self : Process) -> Pid

    ProcessOptions

    source
    type ProcessOptions

    ProcessOptions::new

    source
    fn ProcessOptions::new(file : Bytes, args : Array[Bytes], env? : Array[Bytes], cwd? : Bytes, stdio? : Array[StdioContainer], uid? : Uid, gid? : Gid, exit_cb : (Process, Int64, Int) -> Unit) -> ProcessOptions

    Protocol

    source
    pub(all) enum Protocol {
      Tcp
      Udp
    }

    Protocol::tcp

    source
    fn Protocol::tcp() -> Protocol

    Protocol::udp

    source
    fn Protocol::udp() -> Protocol

    Random

    source
    type Random

    impl ToReq for Random

    Req

    source
    type Req

    Req::type_

    source
    fn Req::type_(self : Req) -> ReqType

    ReqType

    source
    pub enum ReqType {
      Unknown
      Req
      Connect
      Write
      Shutdown
      UdpSend
      Fs
      Work
      Getaddrinfo
      Getnameinfo
      Random
    }

    ReqType::name

    source
    fn ReqType::name(self : ReqType) -> Bytes

    RunMode

    source
    pub(all) enum RunMode {
      Default
      Once
      NoWait
    }

    Rusage

    source
    type Rusage

    Rusage::idrss

    source
    fn Rusage::idrss(rusage : Rusage) -> Int

    Rusage::inblock

    source
    fn Rusage::inblock(rusage : Rusage) -> Int

    Rusage::isrss

    source
    fn Rusage::isrss(rusage : Rusage) -> Int

    Rusage::ixrss

    source
    fn Rusage::ixrss(rusage : Rusage) -> Int

    Rusage::majflt

    source
    fn Rusage::majflt(rusage : Rusage) -> Int

    Rusage::maxrss

    source
    fn Rusage::maxrss(rusage : Rusage) -> Int

    Rusage::minflt

    source
    fn Rusage::minflt(rusage : Rusage) -> Int

    Rusage::msgrcv

    source
    fn Rusage::msgrcv(rusage : Rusage) -> Int

    Rusage::msgsnd

    source
    fn Rusage::msgsnd(rusage : Rusage) -> Int

    Rusage::nivcsw

    source
    fn Rusage::nivcsw(rusage : Rusage) -> Int

    Rusage::nsignals

    source
    fn Rusage::nsignals(rusage : Rusage) -> Int

    Rusage::nswap

    source
    fn Rusage::nswap(rusage : Rusage) -> Int

    Rusage::nvcsw

    source
    fn Rusage::nvcsw(rusage : Rusage) -> Int

    Rusage::oublock

    source
    fn Rusage::oublock(rusage : Rusage) -> Int

    Rusage::stime

    source
    fn Rusage::stime(rusage : Rusage) -> Timeval

    Rusage::utime

    source
    fn Rusage::utime(rusage : Rusage) -> Timeval

    RwLock

    source
    #alias(RWLock, deprecated="`RWLock` is deprecated, use `RwLock` instead")
    type RwLock

    impl Share for RwLock

    RwLock::new

    source
    fn RwLock::new() -> RwLock raise Errno

    RwLock::rdlock

    source
    fn RwLock::rdlock(self : RwLock) -> Unit

    RwLock::rdunlock

    source
    fn RwLock::rdunlock(self : RwLock) -> Unit

    RwLock::tryrdlock

    source
    fn RwLock::tryrdlock(self : RwLock) -> Unit raise Errno

    RwLock::trywrlock

    source
    fn RwLock::trywrlock(self : RwLock) -> Unit raise Errno

    RwLock::wrlock

    source
    fn RwLock::wrlock(self : RwLock) -> Unit

    RwLock::wrunlock

    source
    fn RwLock::wrunlock(self : RwLock) -> Unit

    Scandir

    source
    type Scandir

    Scandir::next

    source
    fn Scandir::next(self : Scandir) -> Dirent raise Errno

    Sem

    source
    type Sem

    impl Share for Sem

    Sem::new

    source
    fn Sem::new(value : UInt) -> Sem raise Errno

    Sem::post

    source
    fn Sem::post(self : Sem) -> Unit

    Sem::trywait

    source
    fn Sem::trywait(self : Sem) -> Unit raise Errno

    Sem::wait

    source
    fn Sem::wait(self : Sem) -> Unit

    Shutdown

    source
    type Shutdown

    impl ToReq for Shutdown

    Signal

    source
    type Signal

    Signal::new

    source
    fn Signal::new(self : Loop) -> Signal raise Errno

    Signal::start

    source
    fn Signal::start(self : Signal, cb : (Signal, Signum) -> Unit, signum : Signum, oneshot? : Bool) -> Unit raise Errno

    Signal::stop

    source
    fn Signal::stop(self : Signal) -> Unit raise Errno

    Signum

    source
    type Signum

    Signum::sigabrt

    source
    fn Signum::sigabrt() -> Signum

    Signum::sighup

    source
    fn Signum::sighup() -> Signum

    Signum::sigint

    source
    fn Signum::sigint() -> Signum

    Signum::sigpipe

    source
    fn Signum::sigpipe() -> Signum raise Errno

    Signum::sigprof

    source
    fn Signum::sigprof() -> Signum raise Errno

    Signum::sigquit

    source
    fn Signum::sigquit() -> Signum

    Signum::sigterm

    source
    fn Signum::sigterm() -> Signum

    Signum::sigtstp

    source
    fn Signum::sigtstp() -> Signum raise Errno

    Signum::sigwinch

    source
    fn Signum::sigwinch() -> Signum

    SockType

    source
    type SockType

    SockType::datagram

    source
    fn SockType::datagram() -> SockType

    SockType::dgram

    source
    #deprecated("Use SockType::datagram() instead")
    fn SockType::dgram() -> SockType

    SockType::raw

    source
    fn SockType::raw() -> SockType

    SockType::stream

    source
    fn SockType::stream() -> SockType

    Sockaddr

    source
    type Sockaddr

    impl ToJson for Sockaddr

    SockaddrIn

    source
    type SockaddrIn

    SockaddrIn::addr

    source
    fn SockaddrIn::addr(self : SockaddrIn) -> InAddr

    SockaddrIn::port

    source
    fn SockaddrIn::port(self : SockaddrIn) -> UInt16

    SockaddrIn6

    source
    type SockaddrIn6

    SockaddrIn6::addr

    source
    fn SockaddrIn6::addr(self : SockaddrIn6) -> In6Addr

    SockaddrIn6::port

    source
    fn SockaddrIn6::port(self : SockaddrIn6) -> UInt16

    SockaddrIn6::scope_id

    source
    fn SockaddrIn6::scope_id(self : SockaddrIn6) -> IfIndex

    Stat

    source
    type Stat

    Stat::atim_nsec

    source
    fn Stat::atim_nsec(self : Stat) -> Int64

    Stat::atim_sec

    source
    fn Stat::atim_sec(self : Stat) -> Int64

    Stat::birthtim_nsec

    source
    fn Stat::birthtim_nsec(self : Stat) -> Int64

    Stat::birthtim_sec

    source
    fn Stat::birthtim_sec(self : Stat) -> Int64

    Stat::blksize

    source
    fn Stat::blksize(self : Stat) -> UInt64

    Stat::blocks

    source
    fn Stat::blocks(self : Stat) -> UInt64

    Stat::ctim_nsec

    source
    fn Stat::ctim_nsec(self : Stat) -> Int64

    Stat::ctim_sec

    source
    fn Stat::ctim_sec(self : Stat) -> Int64

    Stat::dev

    source
    fn Stat::dev(self : Stat) -> UInt64

    Stat::flags

    source
    fn Stat::flags(self : Stat) -> UInt64

    Stat::gen

    source
    fn Stat::gen(self : Stat) -> UInt64

    Stat::gid

    source
    fn Stat::gid(self : Stat) -> UInt64

    Stat::ino

    source
    fn Stat::ino(self : Stat) -> UInt64

    Stat::is_block_device

    source
    fn Stat::is_block_device(self : Stat) -> Bool raise Errno

    Stat::is_character_device

    source
    fn Stat::is_character_device(self : Stat) -> Bool

    Stat::is_directory

    source
    fn Stat::is_directory(self : Stat) -> Bool

    Stat::is_fifo

    source
    fn Stat::is_fifo(self : Stat) -> Bool

    Stat::is_file

    source
    fn Stat::is_file(self : Stat) -> Bool

    Stat::is_pipe

    source
    #deprecated("Use Stat::is_fifo instead")
    fn Stat::is_pipe(self : Stat) -> Bool

    Stat::is_regular

    source
    fn Stat::is_regular(self : Stat) -> Bool

    Stat::is_socket

    source
    fn Stat::is_socket(self : Stat) -> Bool raise Errno

    fn Stat::is_symlink(self : Stat) -> Bool

    Stat::mode

    source
    fn Stat::mode(self : Stat) -> UInt64

    Stat::mtim_nsec

    source
    fn Stat::mtim_nsec(self : Stat) -> Int64

    Stat::mtim_sec

    source
    fn Stat::mtim_sec(self : Stat) -> Int64

    fn Stat::nlink(self : Stat) -> UInt64

    Stat::rdev

    source
    fn Stat::rdev(self : Stat) -> UInt64

    Stat::size

    source
    fn Stat::size(self : Stat) -> UInt64

    Stat::type_

    source
    fn Stat::type_(self : Stat) -> DirentType

    Stat::uid

    source
    fn Stat::uid(self : Stat) -> UInt64

    StatFs

    source
    type StatFs

    StatFs::get_bavail

    source
    fn StatFs::get_bavail(self : StatFs) -> UInt64

    StatFs::get_bfree

    source
    fn StatFs::get_bfree(self : StatFs) -> UInt64

    StatFs::get_blocks

    source
    fn StatFs::get_blocks(self : StatFs) -> UInt64

    StatFs::get_bsize

    source
    fn StatFs::get_bsize(self : StatFs) -> UInt64

    StatFs::get_ffree

    source
    fn StatFs::get_ffree(self : StatFs) -> UInt64

    StatFs::get_files

    source
    fn StatFs::get_files(self : StatFs) -> UInt64

    StatFs::get_type

    source
    fn StatFs::get_type(self : StatFs) -> UInt64

    StdioContainer

    source
    type StdioContainer

    StdioContainer::create_pipe

    source
    fn[Stream : ToStream + ToHandle] StdioContainer::create_pipe(stream : Stream, readable? : Bool, writable? : Bool, non_block? : Bool) -> StdioContainer

    StdioContainer::ignore

    source

    StdioContainer::inherit_file

    source
    fn StdioContainer::inherit_file(file : File) -> StdioContainer

    StdioContainer::inherit_stream

    source
    fn StdioContainer::inherit_stream(stream : Stream) -> StdioContainer

    Stream

    source
    type Stream

    impl ToHandle for Stream
    impl ToStream for Stream

    Stream::is_readable

    source
    fn Stream::is_readable(self : Stream) -> Bool

    Stream::is_writable

    source
    fn Stream::is_writable(self : Stream) -> Bool

    Stream::read_start

    source
    fn Stream::read_start(self : Stream, alloc_cb : (Handle, Int) -> BytesView, read_cb : (Stream, Int, BytesView) -> Unit, error_cb : (Stream, Errno) -> Unit) -> Unit raise Errno

    Stream::read_stop

    source
    fn Stream::read_stop(self : Stream) -> Unit raise Errno

    Stream::shutdown

    source
    fn Stream::shutdown(self : Stream, shutdown_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Shutdown raise Errno

    Stream::to_handle

    source
    fn Stream::to_handle(self : Stream) -> Handle

    Stream::try_write

    source
    fn Stream::try_write(self : Stream, bufs : Array[BytesView], write_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Write raise Errno

    Stream::try_write2

    source
    fn Stream::try_write2(self : Stream, bufs : Array[BytesView], send_handle : Stream, write_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Write raise Errno

    Stream::write

    source
    fn Stream::write(self : Stream, bufs : Array[BytesView], write_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Write raise Errno

    Stream::write2

    source
    fn Stream::write2(self : Stream, bufs : Array[BytesView], send_handle : Stream, write_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Write raise Errno

    SymlinkFlags

    source
    type SymlinkFlags

    SymlinkFlags::new

    source
    fn SymlinkFlags::new(dir? : Bool, junction? : Bool) -> SymlinkFlags

    Creates symbolic link flags for different types of symbolic links.

    Parameters:

    • dir : Whether the symlink points to a directory (Windows only). When true, creates a directory symlink on Windows. This flag is ignored on Unix-like systems where symlink type is determined automatically. Defaults to false.
    • junction : Whether to create a junction point (Windows only). When true, creates a junction point instead of a regular symlink on Windows. Junction points have different permissions and behavior than regular symlinks. This flag is ignored on Unix-like systems. Defaults to false.

    Returns a SymlinkFlags instance configured with the specified behaviors.

    Example:

    // Regular file symlink (works on all platforms)
    ignore(@uv.SymlinkFlags::new())

    // Directory symlink (needed on Windows for directories)
    ignore(@uv.SymlinkFlags::new(dir=true))

    // Junction point (Windows-specific)
    ignore(@uv.SymlinkFlags::new(junction=true))

    Sync

    source
    pub(all) enum Sync {
      Data
      Full
    }

    Tcp

    source
    type Tcp

    impl ToHandle for Tcp
    impl ToStream for Tcp

    Tcp::bind

    source
    fn[Sockaddr : ToSockaddr + ToJson] Tcp::bind(self : Tcp, addr : Sockaddr, flags : TcpBindFlags) -> Unit raise Errno

    Bind the handle to an address and port.

    When the port is already taken, you can expect to see an UV_EADDRINUSE error from uv_listen() or uv_tcp_connect() unless you specify UV_TCP_REUSEPORT in flags for all the binding sockets. That is, a successful call to this function does not guarantee that the call to uv_listen() or uv_tcp_connect() will succeed as well.

    PARAMETERS:

    • handle – TCP handle. It should have been initialized with uv_tcp_init().
    • addr – Address to bind to. It should point to an initialized SockaddrIn or SockaddrIn6.
    • flags – Flags that control the behavior of binding the socket. UV_TCP_IPV6ONLY can be contained in flags to disable dual-stack support and only use IPv6. UV_TCP_REUSEPORT can be contained in flags to enable the socket option SO_REUSEPORT with the capability of load balancing that distribute incoming connections across all listening sockets in multiple processes or threads.

    RETURNS:

    0 on success, or an error code < 0 on failure.

    Changed in version 1.49.0: added the UV_TCP_REUSEPORT flag.

    Tcp::close_reset

    source
    fn Tcp::close_reset(self : Tcp, close_cb : () -> Unit) -> Unit raise Errno

    Resets a TCP connection by sending a RST packet. This is accomplished by setting the SO_LINGER socket option with a linger interval of zero and then calling uv_close(). Due to some platform inconsistencies, mixing of uv_shutdown() and uv_tcp_close_reset() calls is not allowed.

    New in version 1.32.0.

    Tcp::connect

    source
    fn[Sockaddr : ToSockaddr + ToJson] Tcp::connect(self : Tcp, addr : Sockaddr, connect_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Connect raise Errno

    Tcp::getpeername

    source
    fn Tcp::getpeername(self : Tcp) -> Sockaddr raise Errno

    Get the address of the peer connected to the handle. struct sockaddr_storage is used for IPv4 and IPv6 support.

    Tcp::getsockname

    source
    fn Tcp::getsockname(self : Tcp) -> Sockaddr raise Errno

    Get the current address to which the handle is bound. struct sockaddr_storage is used for IPv4 and IPv6 support.

    Tcp::keepalive

    source
    fn Tcp::keepalive(self : Tcp, enable : Bool, delay? : UInt) -> Unit raise Errno

    Enable / disable TCP keep-alive. delay is the initial delay in seconds, ignored when enable is zero.

    After delay has been reached, 10 successive probes, each spaced 1 second from the previous one, will still happen. If the connection is still lost at the end of this procedure, then the handle is destroyed with a UV_ETIMEDOUT error passed to the corresponding callback.

    If delay is less than 1 then UV_EINVAL is returned.

    Changed in version 1.49.0: If delay is less than 1 then UV_EINVAL is returned.

    Tcp::keepalive_ex

    source
    fn Tcp::keepalive_ex(self : Tcp, on : Bool, idle~ : UInt, interval~ : UInt, count~ : UInt) -> Unit raise Errno

    Enable / disable TCP keep-alive with all socket options: TCP_KEEPIDLE, TCP_KEEPINTVL and TCP_KEEPCNT. idle is the value for TCP_KEEPIDLE, intvl is the value for TCP_KEEPINTVL, cnt is the value for TCP_KEEPCNT, ignored when on is zero.

    With TCP keep-alive enabled, idle is the time (in seconds) the connection needs to remain idle before TCP starts sending keep-alive probes. intvl is the time (in seconds) between individual keep-alive probes. TCP will drop the connection after sending cnt probes without getting any replies from the peer, then the handle is destroyed with a UV_ETIMEDOUT error passed to the corresponding callback.

    If one of idle, intvl, or cnt is less than 1, UV_EINVAL is returned.

    Tcp::new

    source
    fn Tcp::new(uv : Loop) -> Tcp raise Errno

    Tcp::new_ex

    source
    fn Tcp::new_ex(uv : Loop, domain : AddressFamily) -> Tcp raise Errno

    Tcp::nodelay

    source
    fn Tcp::nodelay(self : Tcp, enable : Bool) -> Unit raise Errno

    Enable TCP_NODELAY, which disables Nagle’s algorithm.

    Tcp::open

    source
    fn Tcp::open(self : Tcp, os_sock : OsSock) -> Unit raise Errno

    Tcp::simultaneous_accepts

    source
    fn Tcp::simultaneous_accepts(self : Tcp, enable : Bool) -> Unit raise Errno

    Enable / disable simultaneous asynchronous accept requests that are queued by the operating system when listening for new TCP connections.

    This setting is used to tune a TCP server for the desired performance. Having simultaneous accepts can significantly improve the rate of accepting connections (which is why it is enabled by default) but may lead to uneven load distribution in multi-process setups.

    Tcp::try_write2

    source
    fn[Stream : ToStream + ToHandle] Tcp::try_write2(self : Tcp, bufs : Array[BytesView], send_handle : Stream, write_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Write raise Errno

    Tcp::write2

    source
    fn[Stream : ToStream + ToHandle] Tcp::write2(self : Tcp, bufs : Array[BytesView], send_handle : Stream, write_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Write raise Errno

    TcpBindFlags

    source
    type TcpBindFlags

    TcpBindFlags::new

    source
    fn TcpBindFlags::new(ipv6_only? : Bool, reuse_port? : Bool) -> TcpBindFlags

    Thread

    source
    type Thread

    impl Eq for Thread
    impl Share for Thread

    Thread::detach

    source
    fn Thread::detach(self : Thread) -> Unit raise Errno

    Thread::equal

    source
    fn Thread::equal(self : Thread, other : Thread) -> Bool

    Thread::get_affinity

    source
    fn Thread::get_affinity(self : Thread) -> CpuSet raise Errno

    Thread::get_name

    source
    fn Thread::get_name(self : Thread) -> Bytes raise Errno

    Thread::get_priority

    source
    fn Thread::get_priority(self : Thread) -> ThreadPriority raise Errno

    Thread::join

    source
    fn Thread::join(self : Thread) -> Unit raise Errno

    Thread::new

    source
    fn Thread::new(cb : () -> Unit, stack_size? : UInt64) -> Thread raise Errno

    Thread::self

    source
    fn Thread::self() -> Thread raise Errno

    Thread::set_affinity

    source
    fn Thread::set_affinity(self : Thread, cpu_set : CpuSet) -> Unit raise Errno

    Thread::set_name

    source
    fn Thread::set_name(name : Bytes) -> Unit raise Errno

    Thread::set_priority

    source
    fn Thread::set_priority(self : Thread, priority : ThreadPriority) -> Unit raise Errno

    ThreadPriority

    source
    pub enum ThreadPriority {
      Highest
      AboveNormal
      Normal
      BelowNormal
      Lowest
    }

    Timer

    source
    type Timer

    impl ToHandle for Timer

    Timer::get_due_in

    source
    fn Timer::get_due_in(self : Timer) -> UInt64

    Timer::get_repeat

    source
    fn Timer::get_repeat(self : Timer) -> UInt64

    Timer::new

    source
    fn Timer::new(self : Loop) -> Timer raise Errno

    Timer::set_repeat

    source
    fn Timer::set_repeat(self : Timer, repeat : UInt64) -> Unit

    Timer::start

    source
    fn Timer::start(self : Timer, timeout~ : UInt64, repeat~ : UInt64, cb : (Timer) -> Unit) -> Unit raise Errno

    Timer::stop

    source
    fn Timer::stop(self : Timer) -> Unit raise Errno

    Timespec64

    source
    pub type Timespec64 FixedArray[Int64]

    Timespec64::inner

    source
    #deprecated("Use `struct T(A)` to declare a newtype and use `.0` access the underlying type instead.")
    fn Timespec64::inner(self : Timespec64) -> FixedArray[Int64]
    Convert newtype to its underlying type, automatically derived.

    Timespec64::nsec

    source
    fn Timespec64::nsec(self : Timespec64) -> Int

    Timespec64::sec

    source
    fn Timespec64::sec(self : Timespec64) -> Int64

    Timeval

    source
    pub struct Timeval {
      sec : Int64
      usec : Int64
    }

    Timeval64

    source
    pub type Timeval64 FixedArray[Int64]

    Timeval64::inner

    source
    #deprecated("Use `struct T(A)` to declare a newtype and use `.0` access the underlying type instead.")
    fn Timeval64::inner(self : Timeval64) -> FixedArray[Int64]
    Convert newtype to its underlying type, automatically derived.

    Timeval64::sec

    source
    fn Timeval64::sec(self : Timeval64) -> Int64

    Timeval64::usec

    source
    fn Timeval64::usec(self : Timeval64) -> Int

    Tty

    source
    type Tty

    impl ToHandle for Tty
    impl ToStream for Tty

    Tty::get_vterm_state

    source
    fn Tty::get_vterm_state() -> Unit raise Errno

    Tty::get_winsize

    source
    fn Tty::get_winsize(self : Tty) -> (Int, Int) raise Errno

    Tty::new

    source
    fn Tty::new(self : Loop, file : File) -> Tty raise Errno

    Tty::reset_mode

    source
    fn Tty::reset_mode() -> Unit raise Errno

    Tty::set_mode

    source
    fn Tty::set_mode(self : Tty, mode : TtyMode) -> Unit raise Errno

    Tty::set_vterm_state

    source
    fn Tty::set_vterm_state(state : TtyVtermState) -> Unit

    TtyMode

    source
    type TtyMode

    TtyMode::io

    source
    fn TtyMode::io() -> TtyMode

    TtyMode::normal

    source
    fn TtyMode::normal() -> TtyMode

    TtyMode::raw

    source
    fn TtyMode::raw() -> TtyMode

    TtyMode::raw_vt

    source
    fn TtyMode::raw_vt() -> TtyMode

    TtyVtermState

    source
    pub enum TtyVtermState {
      Supported
      Unsupported
    }

    TtyVtermState::supported

    source
    fn TtyVtermState::supported() -> TtyVtermState

    TtyVtermState::unsupported

    source
    fn TtyVtermState::unsupported() -> TtyVtermState

    Udp

    source
    type Udp

    impl ToHandle for Udp

    Udp::bind

    source
    fn[Sockaddr : ToSockaddr + ToJson] Udp::bind(self : Udp, addr : Sockaddr, flags : UdpFlags) -> Unit raise Errno

    Udp::connect

    source
    fn[Sockaddr : ToSockaddr + ToJson] Udp::connect(self : Udp, addr : Sockaddr) -> Unit raise Errno

    Udp::get_send_queue_count

    source
    fn Udp::get_send_queue_count(self : Udp) -> UInt64

    Get the count of items in the send queue

    Udp::get_send_queue_size

    source
    fn Udp::get_send_queue_size(self : Udp) -> UInt64

    Get the size of the send queue

    Udp::getpeername

    source
    fn Udp::getpeername(self : Udp) -> Sockaddr raise Errno

    Get the address of the peer connected to the UDP handle

    Udp::getsockname

    source
    fn Udp::getsockname(self : Udp) -> Sockaddr raise Errno

    Get the current address to which the UDP handle is bound

    Udp::new

    source
    fn Udp::new(uv : Loop) -> Udp raise Errno

    Udp::new_ex

    source
    fn Udp::new_ex(uv : Loop, domain : AddressFamily, flags : UdpFlags) -> Udp raise Errno

    Extended UDP initialization with flags

    Udp::open

    source
    fn Udp::open(self : Udp, os_sock : OsSock) -> Unit raise Errno

    Open UDP handle from existing socket

    Udp::recv_start

    source
    fn Udp::recv_start(self : Udp, alloc_cb : (Handle, Int) -> BytesView, read_cb : (Udp, Int, BytesView, Sockaddr, UdpFlags) -> Unit, error_cb : (Udp, Errno) -> Unit) -> Unit raise Errno

    Udp::recv_stop

    source
    fn Udp::recv_stop(self : Udp) -> Unit raise Errno

    Udp::send

    source
    fn[Sockaddr : ToSockaddr + ToJson] Udp::send(self : Udp, data : Array[BytesView], send_cb : () -> Unit, error_cb : (Errno) -> Unit, addr? : Sockaddr) -> UdpSend raise Errno

    Udp::set_broadcast

    source
    fn Udp::set_broadcast(self : Udp, on : Bool) -> Unit raise Errno

    Enable or disable broadcast mode

    Udp::set_membership

    source
    fn Udp::set_membership(self : Udp, multicast_addr : Bytes, interface_addr : Bytes, membership : Membership) -> Unit raise Errno

    Set UDP multicast group membership

    Udp::set_multicast_interface

    source
    fn Udp::set_multicast_interface(self : Udp, interface_addr : Bytes) -> Unit raise Errno

    Set the multicast interface to use

    Udp::set_multicast_loop

    source
    fn Udp::set_multicast_loop(self : Udp, on : Bool) -> Unit raise Errno

    Enable or disable multicast loopback

    Udp::set_multicast_ttl

    source
    fn Udp::set_multicast_ttl(self : Udp, ttl : Int) -> Unit raise Errno

    Set the multicast Time To Live (TTL)

    Udp::set_source_membership

    source
    fn Udp::set_source_membership(self : Udp, multicast_addr : Bytes, interface_addr : Bytes, source_addr : Bytes, membership : Membership) -> Unit raise Errno

    Set UDP source-specific multicast group membership

    Udp::set_ttl

    source
    fn Udp::set_ttl(self : Udp, ttl : Int) -> Unit raise Errno

    Set the Time To Live (TTL) for UDP packets

    Udp::try_send

    source
    fn[Sockaddr : ToSockaddr + ToJson] Udp::try_send(self : Udp, data : Array[BytesView], addr? : Sockaddr) -> Int raise Errno

    Try to send data synchronously (non-blocking) Returns the number of bytes written or a negative error code

    Udp::try_send2

    source
    fn[T : ToSockaddr + ToJson] Udp::try_send2(self : Udp, data : Array[(Array[BytesView], T?)], flags : UdpFlags) -> Int raise Errno

    Udp::using_recvmmsg

    source
    fn Udp::using_recvmmsg(self : Udp) -> Bool

    Check if the UDP handle is using recvmmsg for receiving data

    UdpFlags

    source
    type UdpFlags

    UdpFlags::new

    source
    fn UdpFlags::new(ipv6_only? : Bool, partial? : Bool, reuse_addr? : Bool, mmsg_chunk? : Bool, mmsg_free? : Bool, linux_recv_err? : Bool, reuse_port? : Bool, recvmmsg? : Bool) -> UdpFlags

    UdpSend

    source
    type UdpSend

    impl ToReq for UdpSend

    Uid

    source
    pub(all) type Uid UInt64

    Uid::inner

    source
    #deprecated("Use `struct T(A)` to declare a newtype and use `.0` access the underlying type instead.")
    fn Uid::inner(self : Uid) -> UInt64
    Convert newtype to its underlying type, automatically derived.

    Utsname

    source
    type Utsname

    Utsname::machine

    source
    fn Utsname::machine(self : Utsname) -> BytesView

    Utsname::release

    source
    fn Utsname::release(self : Utsname) -> BytesView

    Utsname::sysname

    source
    fn Utsname::sysname(self : Utsname) -> BytesView

    Utsname::version

    source
    fn Utsname::version(self : Utsname) -> BytesView

    Version

    source
    type Version

    Version::major

    source
    fn Version::major(self : Version) -> Int

    Version::minor

    source
    fn Version::minor(self : Version) -> Int

    Version::patch

    source
    fn Version::patch(self : Version) -> Int

    Version::suffix

    source
    fn Version::suffix(self : Version) -> Bytes

    Version::to_bytes

    source
    fn Version::to_bytes(_ : Version) -> Bytes

    Work

    source
    type Work

    impl Cancelable for Work
    impl ToReq for Work

    Write

    source
    type Write

    impl ToReq for Write

    PriorityAboveNormal

    source
    let PriorityAboveNormal : Int

    PriorityBelowNormal

    source
    let PriorityBelowNormal : Int

    PriorityHigh

    source
    let PriorityHigh : Int

    PriorityHighest

    source
    let PriorityHighest : Int

    PriorityLow

    source
    let PriorityLow : Int

    PriorityNormal

    source
    let PriorityNormal : Int

    accept

    source
    fn[Server : ToStream + ToHandle, Client : ToStream + ToHandle] accept(server : Server, client : Client) -> Unit raise Errno

    args

    source
    fn args() -> FixedArray[Bytes]

    Returns a copy of command-line arguments passed to the program.

    The arguments are copied to prevent accidental/intentional modification to the original command-line arguments.

    Example:

    println(@uv.args())

    available_parallelism

    source
    fn available_parallelism() -> Int

    chdir

    source
    fn chdir(path : Bytes) -> Unit raise Errno

    clock_gettime

    source
    fn clock_gettime(clock_id : ClockId) -> Timespec64 raise Errno

    close

    source
    #deprecated("Use Handle::close() instead")
    fn[Handle : ToHandle] close(handle : Handle, cb : () -> Unit) -> Unit

    cpu_info

    source
    fn cpu_info() -> Array[CpuInfo] raise Errno

    Returns current CPU information.

    Example:

    let cpu_infos = @uv.cpu_info()
    for cpu_info in cpu_infos {
      println(cpu_info.model())
    }

    cwd

    source
    fn cwd() -> Bytes raise Errno

    disable_stdio_inheritance

    source
    fn disable_stdio_inheritance() -> Unit

    exepath

    source
    fn exepath() -> Bytes raise Errno

    get_available_memory

    source
    fn get_available_memory() -> UInt64

    get_constrained_memory

    source
    fn get_constrained_memory() -> UInt64

    get_free_memory

    source
    fn get_free_memory() -> UInt64

    get_process_title

    source
    fn get_process_title() -> Bytes raise

    get_total_memory

    source
    fn get_total_memory() -> UInt64

    getcpu

    source
    fn getcpu() -> Int raise Errno

    getrusage

    source
    fn getrusage() -> Rusage raise Errno

    getrusage_thread

    source
    fn getrusage_thread() -> Rusage raise Errno

    gettimeofday

    source
    fn gettimeofday() -> Timeval64 raise Errno

    guess_handle

    source
    fn guess_handle(file : File) -> HandleType

    hrtime

    source
    fn hrtime() -> UInt64

    Returns the current high-resolution timestamp. This is expressed in nanoseconds. It is relative to an arbitrary time in the past. It is not related to the time of day and therefore not subject to clock drift. The primary use is for measuring performance between intervals.

    Note: Not every platform can support nanosecond resolution; however, this value will always be in nanoseconds.

    interface_addresses

    source
    fn interface_addresses() -> FixedArray[InterfaceAddress] raise

    ip4_addr

    source
    fn ip4_addr(ip : Bytes, port : Int) -> SockaddrIn raise Errno

    Creates an IPv4 socket address structure from an IP address and port number.

    Parameters:

    • ip : The IPv4 address as a null-terminated byte string (e.g., "127.0.0.1").
    • port : The port number for the socket address.

    Returns a SockaddrIn structure representing the IPv4 socket address that can be used with TCP operations like binding or connecting.

    Example:

    let addr = @uv.ip4_addr("127.0.0.1", 8080)
    println(addr.ip_name())

    ip6_addr

    source
    fn ip6_addr(ip : Bytes, port : Int) -> SockaddrIn6 raise Errno

    is_closing

    source
    #deprecated("Use Handle::is_closing() instead")
    fn[Handle : ToHandle] is_closing(handle : Handle) -> Bool

    is_readable

    source
    #deprecated("Use Stream::is_readable() instead")
    fn[Stream : ToStream + ToHandle] is_readable(stream : Stream) -> Bool

    is_writable

    source
    #deprecated("Use Stream::is_writable() instead")
    fn[Stream : ToStream + ToHandle] is_writable(stream : Stream) -> Bool

    kill

    source
    fn kill(pid : Pid, signum : Signum) -> Unit raise Errno

    library_shutdown

    source
    fn library_shutdown() -> Unit

    listen

    source
    fn[Stream : ToStream + ToHandle] listen(stream : Stream, backlog : Int, connection_cb : (Stream) -> Unit, error_cb : (Stream, Errno) -> Unit) -> Unit raise Errno

    loadavg

    source
    fn loadavg() -> (Double, Double, Double)

    os_environ

    source
    fn os_environ() -> Environ raise Errno

    os_get_group

    source
    fn os_get_group(gid : Gid) -> Group raise Errno

    os_get_passwd

    source
    fn os_get_passwd() -> Passwd raise Errno

    let passwd = @uv.os_get_passwd()
println(passwd.username())
println(passwd.uid().0)
println(passwd.gid().0)
println(passwd.shell())

    os_get_passwd2

    source
    fn os_get_passwd2(uid : Uid) -> Passwd raise Errno

    os_getenv

    source
    fn os_getenv(name : Bytes) -> Bytes? raise Errno

    os_gethostname

    source
    fn os_gethostname() -> Bytes raise Errno

    os_getpid

    source
    fn os_getpid() -> Pid

    os_getppid

    source
    fn os_getppid() -> Pid

    os_getpriority

    source
    fn os_getpriority(pid : Pid) -> Int raise Errno

    Retrieves the scheduling priority of the process specified by pid. The returned value of priority is between -20 (high priority) and 19 (low priority).

    Note: On Windows, the returned priority will equal one of the Priority constants.

    os_homedir

    source
    fn os_homedir() -> Bytes raise Errno

    os_setenv

    source
    fn os_setenv(name : Bytes, value : Bytes) -> Unit raise Errno

    os_setpriority

    source
    fn os_setpriority(pid : Pid, priority : Int) -> Unit raise Errno

    Sets the scheduling priority of the process specified by pid. The priority value range is between -20 (high priority) and 19 (low priority).

    Note: On Windows, this function utilizes SetPriorityClass(). The priority argument is mapped to a Windows priority class. When retrieving the process priority, the result will equal one of the @uv.Priorityconstants, and not necessarily the exact value of priority`.

    Note: On Windows, setting @uv.PriorityHighest will only work for elevated user, for others it will be silently reduced to @uv.PriorityHigh.

    os_tmpdir

    source
    fn os_tmpdir() -> Bytes raise Errno

    Retrieves the path to the system's temporary directory.

    Returns a String containing the path to the temporary directory where temporary files can be created.

    Throws an error of type Errno if the underlying system call fails or if there are insufficient resources to complete the operation.

    Example:

    println(@uv.os_tmpdir())

    os_uname

    source
    fn os_uname() -> Utsname raise Errno

    Retrieves system information including the system name, release, version, and machine architecture.

    Returns a Utsname structure containing system identification information.

    Throws an error of type Errno if the underlying system call fails.

    Example:

    let info = @uv.os_uname()
    println(info.sysname())
    println(info.release())
    println(info.machine())

    os_unsetenv

    source
    fn os_unsetenv(name : Bytes) -> Unit raise Errno

    pipe

    source
    fn pipe(read_flags? : PipeFlags, write_flags? : PipeFlags) -> (File, File) raise Errno

    read_start

    source
    #deprecated("Use Stream::read_start() instead")
    fn[Stream : ToStream + ToHandle] read_start(stream : Stream, alloc_cb : (Stream, Int) -> BytesView, read_cb : (Stream, Int, BytesView) -> Unit, error_cb : (Stream, Errno) -> Unit) -> Unit raise Errno

    Starts reading from a stream with custom allocation and data handling callbacks.

    Parameters:

    • stream : The stream to read from.
    • alloc_cb : Callback function to allocate buffer space for incoming data. Takes the stream and suggested buffer size, returns a bytes view.
    • read_cb : Callback function to handle successfully read data. Takes the stream, number of bytes read, and the data as a bytes view.
    • error_cb : Callback function to handle read errors. Takes the stream and the error code.

    Throws an error of type Errno if the operation fails to start.

    read_stop

    source
    #deprecated("Use Stream::read_stop() instead")
    fn[Stream : ToStream + ToHandle] read_stop(stream : Stream) -> Unit raise Errno

    resident_set_memory

    source
    fn resident_set_memory() -> UInt64 raise Errno

    set_process_title

    source
    fn set_process_title(title : Bytes) -> Unit raise Errno

    shutdown

    source
    #deprecated("Use Stream::shutdown() instead")
    fn[Stream : ToStream + ToHandle] shutdown(stream : Stream, shutdown_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Shutdown raise Errno

    sleep

    source
    fn sleep(milliseconds : UInt) -> Unit

    socketpair

    source
    fn socketpair(type_ : SockType, protocol? : Protocol, flags : (PipeFlags, PipeFlags)) -> (OsSock, OsSock) raise Errno

    stderr

    source
    fn stderr() -> File

    stdin

    source
    fn stdin() -> File

    stdout

    source
    fn stdout() -> File

    string_to_wtf8

    source
    fn string_to_wtf8(utf16 : String) -> Bytes

    uptime

    source
    fn uptime() -> Double raise Errno

    version

    source
    fn version() -> Version

    write

    source
    #deprecated("Use Stream::write() instead")
    fn[Stream : ToStream + ToHandle] write(stream : Stream, bufs : Array[BytesView], write_cb : () -> Unit, error_cb : (Errno) -> Unit) -> Write raise Errno

    wtf8_to_string

    source
    fn wtf8_to_string(wtf8 : Bytes) -> String

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io