Module async/channel

Attach the consumer to ch. Internal: Channel.receiver and Channel.pair are the only callers.

Send a value, suspending while the buffer is full. .Err(value) once the channel is closed or the Receiver is gone (Rust's SendError(T)).

Send without suspending: .Err(value) if the buffer is full, the channel is closed, or the Receiver is gone.

True once the channel is closed — including by the last Sender being dropped. Buffered values may still be waiting; try_recv answering Disconnected is the closed-AND-drained test.

Number of values currently buffered.

Stop accepting values now. Buffered values still come out of recv, then it reports Disconnected.

Create an independent clone of self.

Release the resources self owns — a file descriptor, a socket, a lock, a buffer the allocator handed out. Called automatically when the last reference to the value goes away, so an implementor never calls it directly and must tolerate being the only one who ever does.

It must be safe to run exactly once: the runtime calls it at refcount zero, and a type that also exposes an explicit close/release is responsible for making the second call a no-op.

Attach the consumer to ch. Internal: Channel.receiver and Channel.pair are the only callers.

Mint a producer for this channel, counted like every other Sender.

This is how the first sender is created after Channel(T).receiver(...) and how a fan-in of producer tasks is set up. A sender minted after the channel has already closed does not reopen it — its sends fail.

Receive the oldest value, suspending while the channel is empty.

.Err(TryRecvError.Disconnected) once the channel is closed AND drained — which happens on its own when the last Sender is dropped. Same TryRecvError as try_recv rather than a second error type, and Empty is impossible here: a suspending receive that found the channel empty and open would have kept waiting.

Values already buffered when the last sender went away are still handed out, one per call, BEFORE the disconnect is reported.

Receive without suspending: .Ok(value), Empty while the channel is open but has nothing buffered, Disconnected once it is closed and drained.

True once the channel is closed — including by the last Sender being dropped. Buffered values may still be waiting; try_recv answering Disconnected is the closed-AND-drained test.

Number of values currently buffered.

Stop accepting values now. Buffered values still come out of recv, then it reports Disconnected.

Release the resources self owns — a file descriptor, a socket, a lock, a buffer the allocator handed out. Called automatically when the last reference to the value goes away, so an implementor never calls it directly and must tolerate being the only one who ever does.

It must be safe to run exactly once: the runtime calls it at refcount zero, and a type that also exposes an explicit close/release is responsible for making the second call a no-op.

A channel holding at most capacity buffered values (must be > 0).

Send a value, suspending while the buffer is full. .Err(value) once the channel is closed or the Receiver is gone (Rust's SendError(T)).

Receive the oldest value, suspending while the channel is empty.

.Err(TryRecvError.Disconnected) once the channel is closed AND drained — which happens on its own when the last Sender is dropped. Same TryRecvError as try_recv rather than a second error type, and Empty is impossible here: a suspending receive that found the channel empty and open would have kept waiting.

Values already buffered when the last sender went away are still handed out, one per call, BEFORE the disconnect is reported.

Send without suspending: .Err(value) if the buffer is full, the channel is closed, or the Receiver is gone.

Receive without suspending: .Ok(value), Empty while the channel is open but has nothing buffered, Disconnected once it is closed and drained.

Stop accepting values now. Buffered values still come out of recv, then it reports Disconnected.

Record that this channel's Receiver handle is gone: every further send fails, and a task suspended on a full buffer finds out on its next tick. Internal — Receiver's dispose is the only caller.

Wake the longest-waiting receiver, if any. Called wherever a value becomes available.

Wake the longest-waiting sender, if any. Called wherever a slot frees up.

Wake every suspended sender and drop the queue.

Wake every suspended task on both sides.

True once the channel is closed — including by the last Sender being dropped. Buffered values may still be waiting; try_recv answering Disconnected is the closed-AND-drained test.

Number of values currently buffered.

Create a channel and its single consumer — the tuple-free half of the Sender/Receiver split. Mint producers with Receiver.sender() and Sender.clone().

rx := Channel(i32).receiver(usize(4));
tx := rx.sender();
_s := io.await(tx.send(i32(1), io), io);
v := io.await(rx.recv(io), io).unwrap();

This is the form to use when the end of the stream matters: each handle is its own binding and therefore has its own lifetime, so dropping the last Sender closes the channel while the Receiver is still alive to notice. pair cannot do that — see its note.

A Receiver with no Sender yet is not closed, so recv on it suspends; mint the senders before receiving.

Create a channel and hand back both halves at once — the shape of Rust's mpsc::sync_channel(capacity) (this channel is bounded, like the blocking one).

The tuple keeps both handles alive for as long as the tuple binding lives (measured 2026-09-10): Yo has no destructuring binding, so tx := pair.0 copies a handle out rather than moving it, and the tuple holds its own reference to each half. Dropping tx early therefore does NOT drop the last sender, and the auto-close fires only when the whole scope — Receiver included — goes away. Use this form when the producer tasks and the consumer share a scope, or call close() explicitly; use receiver() + sender() when the receiver must learn that the producers are finished.

Yield the next item, or .None once the stream is finished.

Render self under spec. An unrecognised spec degrades to the plain to_string() rendering rather than failing.

Render self as the text a USER should read — Rust's Display::fmt, not its Debug. Hand-written (or generated by derive(Error) from a per-variant format string) whenever the structural form would be wrong.