README
Tr
Copy
Tr
ToHandle
Tr
ToNtbs
Tr
ToReq
Tr
ToSockaddr
Tr
ToStream
T
AddrInfo
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
T
FsEventFlags
- ::newFsEventType::new
T
GetAddrInfo
T
GetNameInfo
T
Gid
- ::closeHandle::close
- ::get_loopHandle::get_loop
- ::is_closingHandle::is_closing
- ::newIdle::new
- ::startIdle::start
- ::stopIdle::stop
- ::aliveLoop::alive
- ::closeLoop::close
- ::fs_closeLoop::fs_close
- ::fs_copyfileLoop::fs_copyfile
- ::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_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
- ::killProcess::kill
- ::pidProcess::pid
- ::newProcessOptions::new
T
Random
T
Req
T
RunMode
T
Shutdown
- ::newSignal::new
- ::startSignal::start
- ::stopSignal::stop
T
Signum
T
Sockaddr
T
SockaddrIn
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
- ::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
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_mkdir
V
fs_open
V
fs_read
V
fs_realpath
V
fs_rename
V
fs_rmdir
V
fs_scandir
V
fs_unlink
V
fs_write
V
getaddrinfo
V
hrtime
V
ip4_addr
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.1.19

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

trait ToNtbs

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

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) -> @moonbitlang/core/string.StringView
StringView

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

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

FsEventType

source

pub enum FsEventType {
  Rename
  Change
}

FsEventType::new

source

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

GetAddrInfo

source

type GetAddrInfo

GetNameInfo

source

type GetNameInfo

Gid

source

type Gid

Handle

source

type Handle

Handle::close

source

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

Handle::get_loop

source

fn Handle::get_loop(self : Handle) -> Loop

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_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, @moonbitlang/core/string.StringView
StringView) -> 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, Dirent) -> 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(self : Loop, req : GetAddrInfo, getaddrinfo_cb : (GetAddrInfo, AddrInfo) -> Unit, error_cb : (GetAddrInfo, Errno) -> Unit, node : Bytes, service : Bytes, hints : FixedArray[AddrInfo]) -> 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() -> OpenFlags

OpenFlags::read_write

source

fn OpenFlags::read_write() -> OpenFlags

OpenFlags::write

source

fn OpenFlags::write() -> 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 : Int) -> 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

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

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

pub enum Signum {
  SIGHUP
  SIGINT
  SIGQUIT
  SIGABRT
  SIGTERM
  SIGWINCH
}

impl Eq for Signum

impl Hash for Signum

Sockaddr

source

type Sockaddr

SockaddrIn

source

type SockaddrIn

impl ToSockaddr for SockaddrIn

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 : Int) -> 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

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

Uid

source

type Uid

Utsname

source

type Utsname

Utsname::machine

source

fn Utsname::machine(self : Utsname) -> @moonbitlang/core/string.StringView
StringView

Utsname::release

source

fn Utsname::release(self : Utsname) -> @moonbitlang/core/string.StringView
StringView

Utsname::sysname

source

fn Utsname::sysname(self : Utsname) -> @moonbitlang/core/string.StringView
StringView

Utsname::version

source

fn Utsname::version(self : Utsname) -> @moonbitlang/core/string.StringView
StringView

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[@moonbitlang/core/string.StringView
StringView]!Error

argv

source

fn argv() -> Array[Bytes]

close

source

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

cwd

source

fn cwd() -> @moonbitlang/core/string.StringView
StringView!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_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, @moonbitlang/core/string.StringView
StringView) -> 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, Dirent) -> 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(self : Loop, req : GetAddrInfo, getaddrinfo_cb : (GetAddrInfo, AddrInfo) -> Unit, error_cb : (GetAddrInfo, Errno) -> Unit, node : Bytes, service : Bytes, hints : FixedArray[AddrInfo]) -> Unit!Errno

hrtime

source

fn hrtime() -> UInt64

ip4_addr

source

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

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 : UInt64) -> 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

Source Files

Site source Report issue Packages Build queue Skills Statistics

uv

#tonyfettes/uv

#Quickstart

#Copy

#ToHandle

#ToNtbs

#ToReq

#ToSockaddr

#ToStream

#AddrInfo

#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

#FsEventType

#FsEventType::new

#GetAddrInfo

#GetNameInfo

#Gid

#Handle

#Handle::close

#Handle::get_loop

#Handle::is_closing

#Idle

#Idle::new

#Idle::start

#Idle::stop

#Loop

#Loop::alive

#Loop::close

#Loop::fs_close

#Loop::fs_copyfile

#Loop::fs_mkdir

#Loop::fs_open

#Loop::fs_read

#Loop::fs_realpath

#Loop::fs_rename

#Loop::fs_rmdir

#Loop::fs_scandir

#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

#Pipe

#Pipe::bind

#Pipe::new

#Pipe::to_handle

#Pipe::to_stream

#Process

#Process::kill

#Process::pid

#ProcessOptions

#ProcessOptions::new

Copy

ToHandle

ToNtbs

ToReq

ToSockaddr

ToStream

AddrInfo

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

FsEventType

FsEventType::new

GetAddrInfo

GetNameInfo

Gid

Handle

Handle::close

Handle::get_loop

Handle::is_closing

Idle

Idle::new

Idle::start

Idle::stop

Loop

Loop::alive

Loop::close

Loop::fs_close

Loop::fs_copyfile

Loop::fs_mkdir

Loop::fs_open

Loop::fs_read

Loop::fs_realpath

Loop::fs_rename

Loop::fs_rmdir

Loop::fs_scandir

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

Pipe

Pipe::bind

Pipe::new

Pipe::to_handle

Pipe::to_stream

Process

Process::kill

Process::pid

ProcessOptions

ProcessOptions::new

Random

Req

RunMode