Module async/channel

Attach a new producer to ch and count it. Internal: Channel.receiver, Channel.pair, Receiver.sender and clone are the 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 — by an explicit close(), or by the last Sender being dropped.

Number of values currently buffered.

Close the channel now, without waiting for the other senders to go.

Create an independent clone of self.

One ArcWeak fewer; the cell is freed when its payload is gone and this was the last handle. A zeroed handle names no cell.

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.

The future holds its own copy of the channel handle, so it borrows nothing from the Receiver.

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.

One ArcWeak fewer; the cell is freed when its payload is gone and this was the last handle. A zeroed handle names no cell.

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

Send a value, suspending while the buffer is full. Resolves to .Ok(()) once buffered, or .Err(value) if the channel is (or becomes) closed, or its Receiver has been dropped — the failed value is handed back.

Receive the oldest value, suspending while the channel is empty. Resolves to .None once the channel is closed AND drained.

Try to send without suspending: .Ok(()) if buffered, .Err(value) if the channel is full, closed, or has no Receiver any more.

Try to receive without suspending — .Ok(value), or the reason there is none.

This used to answer Option(T), which collapsed the two answers a polling caller must act on differently: .None meant both "nothing buffered yet, retry" and "closed and drained, no value will ever arrive". TryRecvError is the SAME type std/sync/channel.try_recv returns, so the two channels now report the same distinction with the same vocabulary.

A closed channel with buffered values still yields them: Disconnected means closed AND drained.

Close the channel: pending and future sends fail with .Err; recv keeps draining buffered values, then resolves .None.

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 close() has been called.

Number of values currently buffered.

Buffer value (moved in). Internal: the callers check the capacity.

Count one more Sender. Internal: Sender._attach and Sender.clone.

Count one Sender fewer, and answer how many are left. Internal: Sender.drop.

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).

Both halves are move-only, so the tuple is taken apart by a consuming match, which moves each half into its own binding:

match(
  Channel(i32).pair(usize(2)),
  (tx, rx) => {
    _s := io.await(tx.send(i32(1), io), io);
    v := io.await(rx.recv(io), io);
  }
);

Each binding then has its own lifetime, as with receiver() + sender(): dropping tx drops the last sender and closes the channel.

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

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.