api

channel.ch

Declarations in channel.ch

1 declarationsasync

Declarations

Public only
async#
Publicnamespace
namespace async
a composite generic (`FutureTable>`) is unsupported (B20).
ChannelNode#
Publicstruct
struct ChannelNode<T> { var value : T var next : *ChannelNode<T> }
ChannelShared#
Publicstruct
struct ChannelShared<T> { var m : mutex var head : *ChannelNode<T> var tail : *ChannelNode<T> var closed : bool var senders : int var receivers : int var waker : Waker }
delete#
function
func delete(self : *ChannelShared) : void
channel_node_take#
Publicfunction
func channel_node_take<T>(n : *ChannelNode<T>) : T
Move a `T` out of a heap node without running a destructor. The node is then
option_take#
Publicfunction
func option_take<T>(o : *Option<T>) : T
Move the payload out of an `Option` through a pointer, leaving `None`.
channel_wake_locked#
Publicfunction
func channel_wake_locked<T>(s : *ChannelShared<T>) : void
channel_release_shared#
Publicfunction
func channel_release_shared<T>(s : *ChannelShared<T>) : void
channel_push#
Publicfunction
func channel_push<T>(s : *ChannelShared<T>, value : T) : bool
channel_pop_opt#
Publicfunction
func channel_pop_opt<T>(s : *ChannelShared<T>) : Option<T>
Sender#
Publicstruct
struct Sender<T> { var shared : *ChannelShared<T> }
---- sender ----------------------------------------------------------------
send#
Publicfunction
func send(self : &Sender, value : T) : bool
clone_sender#
Publicfunction
func clone_sender(self : &Sender) : Sender<T>
A new handle to the same channel. The channel closes once every handle
close#
Publicfunction
func close(self : &Sender) : void
delete#
Publicfunction
func delete(self : &Sender) : void
Receiver#
Publicstruct
struct Receiver<T> { var shared : *ChannelShared<T> }
---- receiver --------------------------------------------------------------
try_recv#
Publicfunction
func try_recv(self : &Receiver) : Option<T>
Non-blocking receive. Returns `None` when nothing is queued (the channel
is_closed#
Publicfunction
func is_closed(self : &Receiver) : bool
close#
Publicfunction
func close(self : &Receiver) : void
recv_or#
Publicfunction
func recv_or(self : &Receiver, fallback : T) : FutureHandle<T>
Await the next value; when every sender is gone (and the queue is empty)
delete#
Publicfunction
func delete(self : &Receiver) : void
RecvState#
Publicstruct
struct RecvState<T> { var shared : *ChannelShared<T> var fallback : Option<T> var vtbl : *FutureTable<T> }
recv_poll#
Publicfunction
func recv_poll<T>(frame : *void, cx : *Context) : Poll<T>
recv_drop#
Publicfunction
func recv_drop<T>(frame : *void) : void
Channel#
Publicstruct
struct Channel<T> { var sender : Sender<T> var receiver : Receiver<T> }
---- channel ---------------------------------------------------------------
delete#
function
func delete(self : *Channel) : void
---- channel ---------------------------------------------------------------
channel#
Publicfunction
func channel<T>() : Channel<T>
clone_sender#
Publicfunction
func clone_sender<T>(s : *ChannelShared<T>) : Sender<T>
Clone the sender into a value the caller owns (e.g. to capture in a lambda).
Chemical API Referencechemicallang.com  ·  GitHub