README
Tr
Copy
Tr
ToHandle
Tr
ToNtbs
Tr
ToReq
Tr
ToSockaddr
Tr
ToStream
- ::addrAddrInfo::addr
- ::canonnameAddrInfo::canonname
- ::familyAddrInfo::family
- ::protocolAddrInfo::protocol
- ::socktypeAddrInfo::socktype
- ::newAddrInfoFlags::new
- ::newAddrInfoHints::new
- ::inetAddressFamily::inet
- ::inet6AddressFamily::inet6
T
Connect
- ::newCopyFileFlags::new
T
CopyOnWrite
- ::nameDirent::name
- ::type_Dirent::type_
T
DirentType
T
Errno
T
File
T
Fs
- ::get_pathFsEvent::get_path
- ::newFsEvent::new
- ::startFsEvent::start
- ::stopFsEvent::stop
- ::newFsEventFlags::new
T
FsEventType
T
GetAddrInfo
T
Gid
- ::closeHandle::close
- ::is_closingHandle::is_closing
- ::newIdle::new
- ::startIdle::start
- ::stopIdle::stop
- ::aliveLoop::alive
- ::closeLoop::close
- ::fs_closeLoop::fs_close
- ::fs_copyfileLoop::fs_copyfile
- ::fs_fstatLoop::fs_fstat
- ::fs_lstatLoop::fs_lstat
- ::fs_mkdirLoop::fs_mkdir
- ::fs_openLoop::fs_open
- ::fs_readLoop::fs_read
- ::fs_realpathLoop::fs_realpath
- ::fs_renameLoop::fs_rename
- ::fs_rmdirLoop::fs_rmdir
- ::fs_scandirLoop::fs_scandir
- ::fs_statLoop::fs_stat
- ::fs_unlinkLoop::fs_unlink
- ::fs_writeLoop::fs_write
- ::getaddrinfoLoop::getaddrinfo
- ::newLoop::new
- ::queue_workLoop::queue_work
- ::randomLoop::random
- ::runLoop::run
- ::spawnLoop::spawn
- ::stopLoop::stop
- ::lockMutex::lock
- ::newMutex::new
- ::trylockMutex::trylock
- ::unlockMutex::unlock
- ::readOpenFlags::read
- ::read_writeOpenFlags::read_write
- ::writeOpenFlags::write
- ::bindPipe::bind
- ::newPipe::new
- ::to_handlePipe::to_handle
- ::to_streamPipe::to_stream
- ::newPipeBindFlags::new
- ::killProcess::kill
- ::pidProcess::pid
- ::newProcessOptions::new
- ::tcpProtocol::tcp
- ::udpProtocol::udp
T
Random
T
Req
T
RunMode
T
Shutdown
- ::newSignal::new
- ::startSignal::start
- ::stopSignal::stop
- ::sigabrtSignum::sigabrt
- ::sighupSignum::sighup
- ::sigintSignum::sigint
- ::sigpipeSignum::sigpipe
- ::sigquitSignum::sigquit
- ::sigtermSignum::sigterm
- ::sigwinchSignum::sigwinch
- ::dgramSockType::dgram
- ::rawSockType::raw
- ::streamSockType::stream
- ::ip_nameSockaddr::ip_name
T
SockaddrIn
- ::atim_nsecStat::atim_nsec
- ::atim_secStat::atim_sec
- ::birthtim_nsecStat::birthtim_nsec
- ::birthtim_secStat::birthtim_sec
- ::blksizeStat::blksize
- ::blocksStat::blocks
- ::ctim_nsecStat::ctim_nsec
- ::ctim_secStat::ctim_sec
- ::devStat::dev
- ::flagsStat::flags
- ::genStat::gen
- ::gidStat::gid
- ::inoStat::ino
- ::is_block_deviceStat::is_block_device
- ::is_character_deviceStat::is_character_device
- ::is_directoryStat::is_directory
- ::is_fileStat::is_file
- ::is_pipeStat::is_pipe
- ::is_socketStat::is_socket
- ::is_symlinkStat::is_symlink
- ::modeStat::mode
- ::mtim_nsecStat::mtim_nsec
- ::mtim_secStat::mtim_sec
- ::nlinkStat::nlink
- ::rdevStat::rdev
- ::sizeStat::size
- ::uidStat::uid
T
Status
- ::create_pipeStdioContainer::create_pipe
- ::ignoreStdioContainer::ignore
- ::inherit_fileStdioContainer::inherit_file
- ::inherit_streamStdioContainer::inherit_stream
- ::is_readableStream::is_readable
- ::is_writableStream::is_writable
- ::read_startStream::read_start
- ::read_stopStream::read_stop
- ::shutdownStream::shutdown
- ::to_handleStream::to_handle
- ::writeStream::write
- ::bindTcp::bind
- ::connectTcp::connect
- ::newTcp::new
- ::newTcpBindFlags::new
- ::currentThread::current
- ::equalThread::equal
- ::joinThread::join
- ::newThread::new
- ::get_due_inTimer::get_due_in
- ::get_repeatTimer::get_repeat
- ::newTimer::new
- ::set_repeatTimer::set_repeat
- ::startTimer::start
- ::stopTimer::stop
- ::newTty::new
- ::reset_modeTty::reset_mode
- ::set_modeTty::set_mode
- ::ioTtyMode::io
- ::normalTtyMode::normal
- ::rawTtyMode::raw
- ::raw_vtTtyMode::raw_vt
- ::bindUdp::bind
- ::connectUdp::connect
- ::newUdp::new
- ::recv_startUdp::recv_start
- ::recv_stopUdp::recv_stop
- ::sendUdp::send
- ::newUdpFlags::new
T
UdpSend
T
Uid
- ::machineUtsname::machine
- ::releaseUtsname::release
- ::sysnameUtsname::sysname
- ::versionUtsname::version
T
Work
T
Write
V
accept
V
args
V
argv
V
close
V
cwd
V
disable_stdio_inheritance
V
errno
V
fs_close
V
fs_copyfile
V
fs_fstat
V
fs_lstat
V
fs_mkdir
V
fs_open
V
fs_read
V
fs_realpath
V
fs_rename
V
fs_rmdir
V
fs_scandir
V
fs_scandir_next
V
fs_stat
V
fs_unlink
V
fs_write
V
getaddrinfo
V
hrtime
V
ip4_addr
V
ip_name
V
is_closing
V
is_readable
V
is_writable
V
listen
V
os_uname
V
pipe
V
queue_work
V
random
V
read_start
V
read_stop
V
run
V
shutdown
V
sleep
V
spawn
V
stderr
V
stdin
V
stdout
V
stop
V
write

uv

MoonBit binding to libuv

Download zip

Author

tonyfettes

Version

0.4.0

License

Apache-2.0

Repository

github.com/tonyfettes/uv.mbt

Last updated

last year

Downloads

#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(
      "mkdir",
      ["mkdir", "test-dir"],
      fn(process, exit_status, term_signal) {
        println(
          "Process exited with status \{exit_status} and signal \{term_signal}",
        )
        process.close(fn(_) {  })
      },
    )
    let process = uv.spawn!(options)
    println("Launched process with ID \{(process).pid()}")
    uv.run!(Default)
    uv.stop()
    uv.close!()
  } catch {
    error => println("Error: \{error}")
  }
}

Copy

source

pub trait Copy {
  copy(Self) -> Self
}

ToHandle

source

pub trait ToHandle {
  to_handle(Self) -> Handle
  of_handle(Handle) -> Self
  close(Self, (Self) -> Unit) -> Unit
  is_closing(Self) -> Bool
}

ToNtbs

source

pub(open) trait ToNtbs {
  to_ntbs(Self) -> Bytes
}

impl ToNtbs for String

impl ToNtbs for Bytes

impl ToNtbs for View

impl ToNtbs for StringView

ToReq

source

pub trait ToReq {
  to_req(Self) -> Req
}

ToSockaddr

source

trait ToSockaddr

ToStream

source

pub trait ToStream : ToHandle {
  to_stream(Self) -> Stream
  of_stream(Stream) -> Self
  read_start(Self, (Self, Int) -> @moonbitlang/core/bytes.View
View, (Self, Int, @moonbitlang/core/bytes.View
View) -> Unit, (Self, Errno) -> Unit) -> Unit!Errno
  read_stop(Self) -> Unit!Errno
  write(Self, Array[@moonbitlang/core/bytes.View
View], (Write) -> Unit, (Write, Errno) -> Unit) -> Unit!Errno
  listen(Self, Int, (Self) -> Unit, (Self, Errno) -> Unit) -> Unit!Errno
  is_readable(Self) -> Bool
  is_writable(Self) -> Bool
  shutdown(Self, (Shutdown) -> Unit, (Shutdown, Errno) -> Unit) -> Unit!Errno
}

AddrInfo

source

type AddrInfo

AddrInfo::addr

source

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

AddrInfo::canonname

source

fn AddrInfo::canonname(self : AddrInfo) -> String?

AddrInfo::family

source

fn AddrInfo::family(self : AddrInfo) -> AddressFamily!Errno

AddrInfo::protocol

source

fn AddrInfo::protocol(self : AddrInfo) -> Protocol!Errno

AddrInfo::socktype

source

fn AddrInfo::socktype(self : AddrInfo) -> SockType!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 enum AddressFamily {
  INET
  INET6
}

impl Show for AddressFamily

AddressFamily::inet

source

fn AddressFamily::inet() -> AddressFamily

AddressFamily::inet6

source

fn AddressFamily::inet6() -> AddressFamily

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
}

Dirent

source

type Dirent

Dirent::name

source

fn Dirent::name(self : Dirent) -> String

Dirent::type_

source

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

DirentType

source

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

impl Show for DirentType

impl ToJson for DirentType

Errno

source

pub type! Errno Status

impl Eq for Errno

impl Hash for Errno

impl Show for Errno

File

source

type File

Fs

source

type Fs

impl ToReq for Fs

FsEvent

source

type FsEvent

impl ToHandle for FsEvent

FsEvent::get_path

source

fn FsEvent::get_path(self : FsEvent) -> String!Errno

FsEvent::new

source

fn FsEvent::new(self : Loop) -> FsEvent!Errno

FsEvent::start

source

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

FsEvent::stop

source

fn FsEvent::stop(self : FsEvent) -> Unit!Errno

FsEventFlags

source

type FsEventFlags

FsEventFlags::new

source

fn FsEventFlags::new(recursive~ : Bool = ..) -> FsEventFlags

FsEventType

source

pub enum FsEventType {
  Rename
  Change
}

impl Show for FsEventType

impl ToJson for FsEventType

GetAddrInfo

source

type GetAddrInfo

Gid

source

type Gid

Handle

source

type Handle

Handle::close

source

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

Handle::is_closing

source

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

Idle

source

type Idle

impl ToHandle for Idle

Idle::new

source

fn Idle::new(self : Loop) -> Idle!Errno

Idle::start

source

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

Idle::stop

source

fn Idle::stop(self : Idle) -> Unit!Errno

Loop

source

type Loop

Loop::alive

source

fn Loop::alive(loop_ : Loop) -> Bool

Loop::close

source

fn Loop::close(loop_ : Loop) -> Unit!Errno

Loop::fs_close

source

fn Loop::fs_close(self : Loop, file : File, cb : (Fs) -> Unit) -> Unit!Errno

Loop::fs_copyfile

source

fn Loop::fs_copyfile[Ntbs : ToNtbs](self : Loop, path : Ntbs, new_path : Ntbs, flags : CopyFileFlags, k : (Fs) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

Loop::fs_fstat

source

fn Loop::fs_fstat(self : Loop, file : File, k : (Fs, Stat) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

Loop::fs_lstat

source

fn Loop::fs_lstat[Ntbs : ToNtbs](self : Loop, path : Ntbs, k : (Fs, Stat) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

Loop::fs_mkdir

source

fn Loop::fs_mkdir[Ntbs : ToNtbs](self : Loop, path : Ntbs, mode : Int, k : (Fs) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

Loop::fs_open

source

fn Loop::fs_open[Ntbs : ToNtbs](self : Loop, path : Ntbs, flags : OpenFlags, mode : Int, open_cb : (Fs, File) -> Unit, error_cb : (Fs, Errno) -> Unit) -> Unit!Errno

Loop::fs_read

source

fn Loop::fs_read(self : Loop, file : File, bufs : Array[@moonbitlang/core/bytes.View
View], offset~ : Int64 = .., read_cb : (Fs, Int) -> Unit, error_cb : (Fs, Errno) -> Unit) -> Unit!Errno

Loop::fs_realpath

source

fn Loop::fs_realpath[Ntbs : ToNtbs](self : Loop, path : Ntbs, k : (Fs, String) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

Loop::fs_rename

source

fn Loop::fs_rename[Ntbs : ToNtbs](self : Loop, path : Ntbs, new_path : Ntbs, k : (Fs) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

Loop::fs_rmdir

source

fn Loop::fs_rmdir[Ntbs : ToNtbs](self : Loop, path : Ntbs, k : (Fs) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

Loop::fs_scandir

source

fn Loop::fs_scandir[Ntbs : ToNtbs](self : Loop, path : Ntbs, flags : Int, k : (Fs) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

Loop::fs_stat

source

fn Loop::fs_stat[Ntbs : ToNtbs](self : Loop, path : Ntbs, k : (Fs, Stat) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

Loop::fs_unlink

source

fn Loop::fs_unlink[Ntbs : ToNtbs](self : Loop, path : Ntbs, k : (Fs) -> Unit, e : (Fs, Error) -> Unit) -> Unit!Errno

Loop::fs_write

source

fn Loop::fs_write(self : Loop, file : File, bufs : Array[@moonbitlang/core/bytes.View
View], offset~ : Int64 = .., write_cb : (Fs, Int) -> Unit, error_cb : (Fs, Errno) -> Unit) -> Unit!Errno

Loop::getaddrinfo

source

fn Loop::getaddrinfo[Node : ToNtbs, Service : ToNtbs](self : Loop, getaddrinfo_cb : (GetAddrInfo, Iter[AddrInfo]) -> Unit, error_cb : (GetAddrInfo, Errno) -> Unit, node : Node, service : Service, hints? : AddrInfoHints) -> Unit!Errno

Loop::new

source

fn Loop::new() -> Loop!Errno

Loop::queue_work

source

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

Loop::random

source

fn Loop::random(self : Loop, buffer : @moonbitlang/core/bytes.View
View, flags : Int, random_cb : (Random, @moonbitlang/core/bytes.View
View) -> Unit, error_cb : (Random, Errno) -> Unit) -> Unit!Errno

Loop::run

source

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

Loop::spawn

source

fn Loop::spawn(self : Loop, options : ProcessOptions) -> Process!Errno

Loop::stop

source

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

Mutex

source

type Mutex

impl Copy for Mutex

Mutex::lock

source

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

Mutex::new

source

fn Mutex::new() -> Mutex!Errno

Mutex::trylock

source

fn Mutex::trylock(self : Mutex) -> Unit!Errno

Mutex::unlock

source

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

OpenFlags

source

type OpenFlags

OpenFlags::read

source

fn OpenFlags::read(create~ : Bool = ..) -> OpenFlags

OpenFlags::read_write

source

fn OpenFlags::read_write(create~ : Bool = ..) -> OpenFlags

OpenFlags::write

source

fn OpenFlags::write(create~ : Bool = ..) -> OpenFlags

Pipe

source

type Pipe

impl ToHandle for Pipe

impl ToStream for Pipe

Pipe::bind

source

fn Pipe::bind[Ntbs : ToNtbs](self : Pipe, name : Ntbs, flags : PipeBindFlags) -> Unit!Errno

Pipe::new

source

fn Pipe::new(self : Loop, ipc~ : Bool = ..) -> Pipe!Errno

Pipe::to_handle

source

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

Pipe::to_stream

source

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

PipeBindFlags

source

type PipeBindFlags

PipeBindFlags::new

source

fn PipeBindFlags::new(truncate~ : Bool = ..) -> PipeBindFlags

Process

source

type Process

impl ToHandle for Process

Process::kill

source

fn Process::kill(self : Process, signum : Int) -> Unit!Errno

Process::pid

source

fn Process::pid(self : Process) -> Int

ProcessOptions

source

type ProcessOptions

ProcessOptions::new

source

fn ProcessOptions::new[Ntbs : ToNtbs](file : Ntbs, args : Array[@moonbitlang/core/string.StringView
StringView], env? : Array[@moonbitlang/core/string.StringView
StringView], cwd? : @moonbitlang/core/string.StringView
StringView, stdio? : Array[StdioContainer], uid? : Uid, gid? : Gid, exit_cb : (Process, Int64, Int) -> Unit) -> ProcessOptions

Protocol

source

pub enum Protocol {
  TCP
  UDP
}

impl Show for Protocol

Protocol::tcp

source

fn Protocol::tcp() -> Protocol

Protocol::udp

source

fn Protocol::udp() -> Protocol

Random

source

type Random

Req

source

type Req

RunMode

source

pub(all) enum RunMode {
  Default
  Once
  NoWait
}

Shutdown

source

type Shutdown

impl ToReq for Shutdown

Signal

source

type Signal

Signal::new

source

fn Signal::new(self : Loop) -> Signal!Errno

Signal::start

source

fn Signal::start(self : Signal, cb : (Signal, Signum) -> Unit, signum : Signum) -> Unit!Errno

Signal::stop

source

fn Signal::stop(self : Signal) -> Unit!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?

Signum::sigquit

source

fn Signum::sigquit() -> Signum

Signum::sigterm

source

fn Signum::sigterm() -> Signum

Signum::sigwinch

source

fn Signum::sigwinch() -> Signum

SockType

source

type SockType

impl Show for SockType

SockType::dgram

source

fn SockType::dgram() -> SockType

SockType::raw

source

fn SockType::raw() -> SockType

SockType::stream

source

fn SockType::stream() -> SockType

Sockaddr

source

type Sockaddr

impl ToSockaddr for Sockaddr

Sockaddr::ip_name

source

fn Sockaddr::ip_name(self : Sockaddr) -> String!Errno

SockaddrIn

source

type SockaddrIn

impl ToSockaddr for SockaddrIn

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

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_file

source

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

Stat::is_pipe

source

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

Stat::is_socket

source

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

Stat::is_symlink

source

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

Stat::nlink

source

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::uid

source

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

Status

source

pub enum Status {
  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 Status

impl Hash for Status

StdioContainer

source

type StdioContainer

StdioContainer::create_pipe

source

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

StdioContainer::ignore

source

fn StdioContainer::ignore() -> StdioContainer

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) -> @moonbitlang/core/bytes.View
View, read_cb : (Stream, Int, @moonbitlang/core/bytes.View
View) -> Unit, error_cb : (Stream, Errno) -> Unit) -> Unit!Errno

Stream::read_stop

source

fn Stream::read_stop(self : Stream) -> Unit!Errno

Stream::shutdown

source

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

Stream::to_handle

source

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

Stream::write

source

fn Stream::write(self : Stream, bufs : Array[@moonbitlang/core/bytes.View
View], write_cb : (Write) -> Unit, error_cb : (Write, Errno) -> Unit) -> Unit!Errno

Tcp

source

type Tcp

impl ToHandle for Tcp

impl ToStream for Tcp

Tcp::bind

source

fn Tcp::bind[Sockaddr : ToSockaddr](self : Tcp, addr : Sockaddr, flags : TcpBindFlags) -> Unit!Errno

Tcp::connect

source

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

Tcp::new

source

fn Tcp::new(loop_ : Loop) -> Tcp!Errno

TcpBindFlags

source

type TcpBindFlags

TcpBindFlags::new

source

fn TcpBindFlags::new(ipv6_only~ : Bool = .., reuse_port~ : Bool = ..) -> TcpBindFlags

Thread

source

type Thread

impl Copy for Thread

Thread::current

source

fn Thread::current() -> Thread

Thread::equal

source

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

Thread::join

source

fn Thread::join(self : Thread) -> Unit!Errno

Thread::new

source

fn Thread::new(callback : () -> Unit) -> Thread!Errno

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!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!Errno

Timer::stop

source

fn Timer::stop(self : Timer) -> Unit!Errno

Tty

source

type Tty

impl ToHandle for Tty

impl ToStream for Tty

Tty::new

source

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

Tty::reset_mode

source

fn Tty::reset_mode() -> Unit!Errno

Tty::set_mode

source

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

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

Udp

source

type Udp

impl ToHandle for Udp

Udp::bind

source

fn Udp::bind[Sockaddr : ToSockaddr](self : Udp, addr : Sockaddr, flags : UdpFlags) -> Unit!Errno

Udp::connect

source

fn Udp::connect[Sockaddr : ToSockaddr](self : Udp, addr : Sockaddr) -> Unit!Errno

Udp::new

source

fn Udp::new(loop_ : Loop) -> Udp!Errno

Udp::recv_start

source

fn Udp::recv_start(self : Udp, alloc_cb : (Handle, Int) -> @moonbitlang/core/bytes.View
View, read_cb : (Udp, Int, @moonbitlang/core/bytes.View
View, Sockaddr, UdpFlags) -> Unit, error_cb : (Udp, Errno) -> Unit) -> Unit!Errno

Udp::recv_stop

source

fn Udp::recv_stop(self : Udp) -> Unit!Errno

Udp::send

source

fn Udp::send[Sockaddr : ToSockaddr](self : Udp, data : Array[@moonbitlang/core/bytes.View
View], send_cb : (UdpSend) -> Unit, error_cb : (UdpSend, Errno) -> Unit, addr? : Sockaddr) -> Unit!Errno

UdpFlags

source

type UdpFlags

UdpFlags::new

source

fn UdpFlags::new() -> UdpFlags

UdpSend

source

type UdpSend

impl ToReq for UdpSend

Uid

source

type Uid

Utsname

source

type Utsname

Utsname::machine

source

fn Utsname::machine(self : Utsname) -> String

Utsname::release

source

fn Utsname::release(self : Utsname) -> String

Utsname::sysname

source

fn Utsname::sysname(self : Utsname) -> String

Utsname::version

source

fn Utsname::version(self : Utsname) -> String

Work

source

type Work

Write

source

type Write

impl ToReq for Write

accept

source

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

args

source

fn args() -> Array[String]

argv

source

fn argv() -> Array[Bytes]

close

source

fn close[Handle : ToHandle](handle : Handle, cb : (Handle) -> Unit) -> Unit

cwd

source

fn cwd() -> String!Errno

disable_stdio_inheritance

source

fn disable_stdio_inheritance() -> Unit

errno

source

fn errno(errno : Int) -> Errno

fs_close

source

fn fs_close(self : Loop, file : File, cb : (Fs) -> Unit) -> Unit!Errno

fs_copyfile

source

fn fs_copyfile[Ntbs : ToNtbs](self : Loop, path : Ntbs, new_path : Ntbs, flags : CopyFileFlags, k : (Fs) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

fs_fstat

source

fn fs_fstat(self : Loop, file : File, k : (Fs, Stat) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

fs_lstat

source

fn fs_lstat[Ntbs : ToNtbs](self : Loop, path : Ntbs, k : (Fs, Stat) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

fs_mkdir

source

fn fs_mkdir[Ntbs : ToNtbs](self : Loop, path : Ntbs, mode : Int, k : (Fs) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

fs_open

source

fn fs_open[Ntbs : ToNtbs](self : Loop, path : Ntbs, flags : OpenFlags, mode : Int, open_cb : (Fs, File) -> Unit, error_cb : (Fs, Errno) -> Unit) -> Unit!Errno

fs_read

source

fn fs_read(self : Loop, file : File, bufs : Array[@moonbitlang/core/bytes.View
View], offset~ : Int64 = .., read_cb : (Fs, Int) -> Unit, error_cb : (Fs, Errno) -> Unit) -> Unit!Errno

fs_realpath

source

fn fs_realpath[Ntbs : ToNtbs](self : Loop, path : Ntbs, k : (Fs, String) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

fs_rename

source

fn fs_rename[Ntbs : ToNtbs](self : Loop, path : Ntbs, new_path : Ntbs, k : (Fs) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

fs_rmdir

source

fn fs_rmdir[Ntbs : ToNtbs](self : Loop, path : Ntbs, k : (Fs) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

fs_scandir

source

fn fs_scandir[Ntbs : ToNtbs](self : Loop, path : Ntbs, flags : Int, k : (Fs) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

fs_scandir_next

source

fn fs_scandir_next(req : Fs) -> Dirent!Errno

fs_stat

source

fn fs_stat[Ntbs : ToNtbs](self : Loop, path : Ntbs, k : (Fs, Stat) -> Unit, e : (Fs, Errno) -> Unit) -> Unit!Errno

fs_unlink

source

fn fs_unlink[Ntbs : ToNtbs](self : Loop, path : Ntbs, k : (Fs) -> Unit, e : (Fs, Error) -> Unit) -> Unit!Errno

fs_write

source

fn fs_write(self : Loop, file : File, bufs : Array[@moonbitlang/core/bytes.View
View], offset~ : Int64 = .., write_cb : (Fs, Int) -> Unit, error_cb : (Fs, Errno) -> Unit) -> Unit!Errno

getaddrinfo

source

fn getaddrinfo[Node : ToNtbs, Service : ToNtbs](self : Loop, getaddrinfo_cb : (GetAddrInfo, Iter[AddrInfo]) -> Unit, error_cb : (GetAddrInfo, Errno) -> Unit, node : Node, service : Service, hints? : AddrInfoHints) -> Unit!Errno

hrtime

source

fn hrtime() -> UInt64

ip4_addr

source

fn ip4_addr[Ntbs : ToNtbs](ip : Ntbs, port : Int) -> SockaddrIn

ip_name

source

fn ip_name(self : Sockaddr) -> String!Errno

is_closing

source

fn is_closing[Handle : ToHandle](handle : Handle) -> Bool

is_readable

source

fn is_readable[Stream : ToStream + ToHandle](stream : Stream) -> Bool

is_writable

source

fn is_writable[Stream : ToStream + ToHandle](stream : Stream) -> Bool

listen

source

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

os_uname

source

fn os_uname() -> Utsname!Errno

pipe

source

fn pipe(read_flags : Int, write_flags : Int) -> (File, File)!Errno

queue_work

source

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

random

source

fn random(self : Loop, buffer : @moonbitlang/core/bytes.View
View, flags : Int, random_cb : (Random, @moonbitlang/core/bytes.View
View) -> Unit, error_cb : (Random, Errno) -> Unit) -> Unit!Errno

read_start

source

fn read_start[Stream : ToStream + ToHandle](stream : Stream, alloc_cb : (Stream, Int) -> @moonbitlang/core/bytes.View
View, read_cb : (Stream, Int, @moonbitlang/core/bytes.View
View) -> Unit, error_cb : (Stream, Errno) -> Unit) -> Unit!Errno

read_stop

source

fn read_stop[Stream : ToStream + ToHandle](stream : Stream) -> Unit!Errno

run

source

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

shutdown

source

fn shutdown[Stream : ToStream + ToHandle](stream : Stream, shutdown_cb : (Shutdown) -> Unit, error_cb : (Shutdown, Errno) -> Unit) -> Unit!Errno

sleep

source

fn sleep(milliseconds : UInt) -> Unit

spawn

source

fn spawn(self : Loop, options : ProcessOptions) -> Process!Errno

stderr

source

fn stderr() -> File

stdin

source

fn stdin() -> File

stdout

source

fn stdout() -> File

stop

source

fn stop(self : Loop) -> Unit

write

source

fn write[Stream : ToStream + ToHandle](stream : Stream, bufs : Array[@moonbitlang/core/bytes.View
View], write_cb : (Write) -> Unit, error_cb : (Write, Errno) -> Unit) -> Unit!Errno

Site source Report issue Packages Build queue Skills Statistics

uv

#tonyfettes/uv

#Quickstart

#Copy

#ToHandle

#ToNtbs

#ToReq

#ToSockaddr

#ToStream

#AddrInfo

#AddrInfo::addr

#AddrInfo::canonname

#AddrInfo::family

#AddrInfo::protocol

#AddrInfo::socktype

#AddrInfoFlags

#AddrInfoFlags::new

#AddrInfoHints

#AddrInfoHints::new

#AddressFamily

#AddressFamily::inet

#AddressFamily::inet6

#Connect

#CopyFileFlags

#CopyFileFlags::new

#CopyOnWrite

#Dirent

#Dirent::name

#Dirent::type_

#DirentType

#Errno

#File

#Fs

#FsEvent

#FsEvent::get_path

#FsEvent::new

#FsEvent::start

#FsEvent::stop

#FsEventFlags

#FsEventFlags::new

#FsEventType

#GetAddrInfo

#Gid

#Handle

#Handle::close

#Handle::is_closing

#Idle

#Idle::new

#Idle::start

#Idle::stop

#Loop

#Loop::alive

#Loop::close

#Loop::fs_close

#Loop::fs_copyfile

#Loop::fs_fstat

#Loop::fs_lstat

#Loop::fs_mkdir

#Loop::fs_open

#Loop::fs_read

#Loop::fs_realpath

#Loop::fs_rename

#Loop::fs_rmdir

#Loop::fs_scandir

#Loop::fs_stat

#Loop::fs_unlink

#Loop::fs_write

#Loop::getaddrinfo

#Loop::new

#Loop::queue_work

#Loop::random

#Loop::run

#Loop::spawn

#Loop::stop

#Mutex

#Mutex::lock

#Mutex::new

#Mutex::trylock

#Mutex::unlock

#OpenFlags

Copy

ToHandle

ToNtbs

ToReq

ToSockaddr

ToStream

AddrInfo

AddrInfo::addr

AddrInfo::canonname

AddrInfo::family

AddrInfo::protocol

AddrInfo::socktype

AddrInfoFlags

AddrInfoFlags::new

AddrInfoHints

AddrInfoHints::new

AddressFamily

AddressFamily::inet

AddressFamily::inet6

Connect

CopyFileFlags

CopyFileFlags::new

CopyOnWrite

Dirent

Dirent::name

Dirent::type_

DirentType

Errno

File

Fs

FsEvent

FsEvent::get_path

FsEvent::new

FsEvent::start

FsEvent::stop

FsEventFlags

FsEventFlags::new

FsEventType

GetAddrInfo

Gid

Handle

Handle::close

Handle::is_closing

Idle

Idle::new

Idle::start

Idle::stop

Loop

Loop::alive

Loop::close

Loop::fs_close

Loop::fs_copyfile

Loop::fs_fstat

Loop::fs_lstat

Loop::fs_mkdir

Loop::fs_open

Loop::fs_read

Loop::fs_realpath

Loop::fs_rename

Loop::fs_rmdir

Loop::fs_scandir

Loop::fs_stat

Loop::fs_unlink

Loop::fs_write

Loop::getaddrinfo

Loop::new

Loop::queue_work

Loop::random

Loop::run

Loop::spawn

Loop::stop

Mutex

Mutex::lock

Mutex::new

Mutex::trylock

Mutex::unlock

OpenFlags

OpenFlags::read

OpenFlags::read_write

OpenFlags::write