uv
MoonBit binding to libuv
moon add tonyfettes/uv@0.12.12
Download zipAuthor
Version
0.12.12
License
Apache-2.0
Repository
Last updated
6 months ago
Downloads
1K
Dependencies
- tonyfettes/c0.7.4
README#tonyfettes/uv
This is a MoonBit binding to the libuv library.
#Quickstart
- Add this module as a dependency to your MoonBit project.moon update moon add tonyfettes/uv
- Import tonyfettes/uv package where you need it.{ "import": [ "tonyfettes/uv" ] }
- 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
#Share
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
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
}#ToSockaddr
#ToStream
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
}#Errno
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
}
#AccessFlags
type AccessFlags#AccessFlags::new
#AddrInfo
type AddrInfo#AddrInfoFlags
type AddrInfoFlags#AddrInfoFlags::new
fn AddrInfoFlags::new(passive? : Bool, canonname? : Bool, numeric_host? : Bool, numeric_serv? : Bool, all? : Bool, addrconfig? : Bool, v4mapped? : Bool) -> AddrInfoFlags#AddrInfoHints
type AddrInfoHints#AddrInfoHints::new
fn AddrInfoHints::new(flags? : AddrInfoFlags, family? : AddressFamily, socktype? : SockType, protocol? : Protocol) -> AddrInfoHints#AddressFamily
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)#Async
type AsyncWake 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.
#Async::new
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
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
type Barrier#Check
type CheckHandle 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
}#Cond
type CondCondition 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:
- Lock the mutex
- Check the condition in a loop
- If condition not met, wait on the condition variable
- When signaled, the loop continues and rechecks the condition
- Unlock the mutex when done
#Cond::broadcast
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::signal
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
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
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.
#CopyFileFlags
type CopyFileFlags#CopyFileFlags::new
#CpuInfo
type CpuInfo#CpuSet
type CpuSet#CpuTimes
type CpuTimes#Dirent
type Dirent#DirentType
pub enum DirentType {
Unknown
File
Dir
Link
Fifo
Socket
Char
Block
}Type of directory entry, indicating the file system object kind.
#Environ
type Environ#File
type File#FsEvent
type FsEvent#FsEvent::start
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#FsEventFlags
type FsEventFlags#FsPoll
type FsPoll#FsPoll::start
#Gid
pub(all) type Gid UInt64#Group
type Group#Handle
type Handle#HandleType
pub enum HandleType {
Unknown
Async
Check
FsEvent
FsPoll
Handle
Idle
Pipe
Poll
Prepare
Process
Stream
Tcp
Timer
Tty
Udp
Signal
File
}#Idle
type IdleHandle 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
}#IfIndex
type IfIndex#In6Addr
type In6Addr#In6Addr::new
#InAddr
type InAddr#Key
type Key#Lib
type Lib#Loop
type Loop#Loop::close
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::fs_access
#Loop::fs_access_sync
#as_free_fn
fn Loop::fs_access_sync(self : Loop, path : Bytes, mode : AccessFlags) -> Unit raise Errno#Loop::fs_chmod
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
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
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
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
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
#Loop::fs_closedir
#Loop::fs_copyfile
#Loop::fs_copyfile_sync
#as_free_fn
fn Loop::fs_copyfile_sync(self : Loop, path : Bytes, new_path : Bytes, flags : CopyFileFlags) -> Unit raise Errno#Loop::fs_fchmod
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
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
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
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
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
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
#Loop::fs_fsync
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
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
#Loop::fs_futime
#Loop::fs_futime_sync
#Loop::fs_lchown
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
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()#Loop::fs_link
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
}#Loop::fs_link_sync
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
#Loop::fs_lstat_sync
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
#Loop::fs_lutime_sync
#Loop::fs_mkdir
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
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
#Loop::fs_mkdtemp_sync
#Loop::fs_mkstemp
#Loop::fs_mkstemp_sync
#Loop::fs_open
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
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
#Loop::fs_read
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
#Loop::fs_readdir
#Loop::fs_readlink
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
}#Loop::fs_readlink_sync
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
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
#Loop::fs_rename
#Loop::fs_rename_sync
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
#Loop::fs_rmdir_sync
#Loop::fs_scandir
#Loop::fs_scandir_sync
#Loop::fs_sendfile
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
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
#Loop::fs_stat_sync
#Loop::fs_statfs
#Loop::fs_statfs_sync
#Loop::fs_symlink
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
}#Loop::fs_symlink_sync
#as_free_fn
fn Loop::fs_symlink_sync(self : Loop, path : Bytes, new_path : Bytes, flags : SymlinkFlags) -> Unit raise ErrnoSynchronously 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()#Loop::fs_unlink
#Loop::fs_unlink_sync
#Loop::fs_utime
#Loop::fs_utime_sync
#Loop::fs_write
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
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
#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
#Loop::new
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
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::queue_work
#Loop::random
#Loop::random_sync
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
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
#Loop::update_time
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.
#Membership
pub(all) enum Membership {
LeaveGroup
JoinGroup
}#Metrics
type Metrics#Mutex
type Mutex#Once
type Once#OpenFlags
type OpenFlags#OpenFlags::read_only
fn OpenFlags::read_only(access_hint? : AccessHint, direct? : Bool, directory? : Bool, exclusive_lock? : Bool, filemap? : Bool, noatime? : Bool, nofollow? : Bool, nonblock? : Bool, symlink? : Bool) -> OpenFlagsCreates 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
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) -> OpenFlagsCreates 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
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()#Passwd
type Passwd#PhysAddr
type PhysAddr#Pid
type Pid#Pipe
type Pipe#Pipe::bind
#Pipe::chmod
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
#Pipe::pending_instances
Set the number of pending pipe instance handles when the pipe server is waiting for connections.
NOTE: This setting applies to Windows only.
#Pipe::try_write2
#PipeBindFlags
type PipeBindFlags#PipeFlags
type PipeFlags#Poll
type Poll#Poll::start
#PollEvent
type PollEvent#Prepare
type Prepare#Process
type Process#ProcessOptions
type ProcessOptions#ProcessOptions::new
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
pub(all) enum Protocol {
Tcp
Udp
}#ReqType
pub enum ReqType {
Unknown
Req
Connect
Write
Shutdown
UdpSend
Fs
Work
Getaddrinfo
Getnameinfo
Random
}#Rusage
type Rusage#RwLock
#alias(RWLock, deprecated="`RWLock` is deprecated, use `RwLock` instead")
type RwLock#Scandir
type Scandir#Sem
type Sem#Signal
type Signal#Signum
type Signum#SockType
type SockType#Sockaddr
type Sockaddr#Stat
type Stat#StatFs
type StatFs#StdioContainer
type StdioContainer#StdioContainer::create_pipe
fn[Stream : ToStream + ToHandle] StdioContainer::create_pipe(stream : Stream, readable? : Bool, writable? : Bool, non_block? : Bool) -> StdioContainer#StdioContainer::inherit_stream
#Stream
type Stream#Stream::read_start
#Stream::shutdown
#Stream::try_write
#Stream::try_write2
#Stream::write
#SymlinkFlags
type SymlinkFlags#SymlinkFlags::new
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))#Tcp
type Tcp#Tcp::bind
fn[Sockaddr : ToSockaddr + ToJson] Tcp::bind(self : Tcp, addr : Sockaddr, flags : TcpBindFlags) -> Unit raise ErrnoBind 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
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
#Tcp::getpeername
Get the address of the peer connected to the handle.
struct sockaddr_storage is used for IPv4 and IPv6 support.
#Tcp::getsockname
Get the current address to which the handle is bound.
struct sockaddr_storage is used for IPv4 and IPv6 support.
#Tcp::keepalive
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
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::nodelay
Enable TCP_NODELAY, which disables Nagle’s algorithm.
#Tcp::simultaneous_accepts
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
#TcpBindFlags
type TcpBindFlags#Thread
type Thread#Thread::set_affinity
#Thread::set_priority
#Timer
type Timer#Timer::start
#Timespec64
pub type Timespec64 FixedArray[Int64]#Timespec64::inner
#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.
#Timeval64
pub type Timeval64 FixedArray[Int64]#Timeval64::inner
Convert newtype to its underlying type, automatically derived.
#Tty
type Tty#TtyMode
type TtyMode#TtyVtermState
pub enum TtyVtermState {
Supported
Unsupported
}#Udp
type Udp#Udp::bind
#Udp::connect
#Udp::get_send_queue_count
Get the count of items in the send queue
#Udp::get_send_queue_size
Get the size of the send queue
#Udp::getpeername
Get the address of the peer connected to the UDP handle
#Udp::getsockname
Get the current address to which the UDP handle is bound
#Udp::new_ex
Extended UDP initialization with flags
#Udp::open
Open UDP handle from existing socket
#Udp::recv_start
#Udp::send
#Udp::set_broadcast
Enable or disable broadcast mode
#Udp::set_membership
fn Udp::set_membership(self : Udp, multicast_addr : Bytes, interface_addr : Bytes, membership : Membership) -> Unit raise ErrnoSet UDP multicast group membership
#Udp::set_multicast_interface
Set the multicast interface to use
#Udp::set_multicast_loop
Enable or disable multicast loopback
#Udp::set_multicast_ttl
Set the multicast Time To Live (TTL)
#Udp::set_source_membership
fn Udp::set_source_membership(self : Udp, multicast_addr : Bytes, interface_addr : Bytes, source_addr : Bytes, membership : Membership) -> Unit raise ErrnoSet UDP source-specific multicast group membership
#Udp::set_ttl
Set the Time To Live (TTL) for UDP packets
#Udp::try_send
Try to send data synchronously (non-blocking)
Returns the number of bytes written or a negative error code
#Udp::try_send2
#UdpFlags
type UdpFlags#Uid
pub(all) type Uid UInt64#Utsname
type Utsname#Version
type Version#accept
#args
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())#close
#deprecated("Use Handle::close() instead")
fn[Handle : ToHandle] close(handle : Handle, cb : () -> Unit) -> Unit#cpu_info
Returns current CPU information.
Example:
let cpu_infos = @uv.cpu_info()
for cpu_info in cpu_infos {
println(cpu_info.model())
}#hrtime
fn hrtime() -> UInt64Returns 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.
#ip4_addr
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())#is_closing
#deprecated("Use Handle::is_closing() instead")
fn[Handle : ToHandle] is_closing(handle : Handle) -> Bool#is_readable
#is_writable
#listen
#os_get_passwd
let passwd = @uv.os_get_passwd()
println(passwd.username())
println(passwd.uid().0)
println(passwd.gid().0)
println(passwd.shell())#os_getpriority
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_setpriority
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
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
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())#read_start
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
#shutdown
#socketpair
#write
Source Files
- args.mbt
- async.mbt
- barrier.mbt
- bytes.mbt
- check.mbt
- cond.mbt
- debug.mbt
- dl.mbt
- dns.mbt
- env.mbt
- error.mbt
- fs.mbt
- fs_event.mbt
- fs_poll.mbt
- handle.mbt
- idle.mbt
- if.mbt
- ip.mbt
- key.mbt
- loop.mbt
- metrics.mbt
- mutex.mbt
- once.mbt
- os.mbt
- passwd.mbt
- pipe.mbt
- poll.mbt
- prepare.mbt
- process.mbt
- random.mbt
- req.mbt
- rusage.mbt
- rwlock.mbt
- sem.mbt
- signal.mbt
- socket.mbt
- stream.mbt
- string.mbt
- tcp.mbt
- thread.mbt
- time.mbt
- timer.mbt
- tty.mbt
- udp.mbt
- uv.mbt
- version.mbt
- work.mbt
MoonBit binding to libuv
0.12.12
Apache-2.0
Updated 6 months ago
1K downloadsDependencies
- tonyfettes/c0.7.4