Module sync/channel

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.

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

Send a value, blocking while the buffer is full.

.Err(value) — Rust's SendError(T) — once the channel is closed or the Receiver has been dropped; the value that could not be sent comes back rather than being dropped on the floor.

Send without blocking: .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 (a snapshot, like Channel.len).

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 queue, counted like every other Sender.

This is how the first sender is created after Channel(T).receiver(...), and how a fan-in is set up: one sender() per producer, or one plus clone()s. Each of them keeps the channel open until it is dropped.

A sender minted after the channel has already closed does NOT reopen it — _closed is one-way — so its sends fail; mint the producers while the previous ones are still alive.

Receive the oldest value, blocking 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. It is the same TryRecvError try_recv reports rather than a second error type, and Empty is impossible here: a blocking receive that found the channel empty and open would have kept waiting.

Values already queued when the last sender went away are still handed out, one per call, BEFORE the disconnect is reported — closing a channel must not lose what it already accepted (Rust guarantees the same).

Receive without blocking: .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 (a snapshot, like Channel.len).

True while nothing is buffered (a snapshot).

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.

Create a bounded channel with the given capacity. Capacity must be > 0.

Send a value, blocking while the buffer is full.

.Err(value) — Rust's SendError(T) — once the channel is closed or the Receiver has been dropped; the value that could not be sent comes back rather than being dropped on the floor.

Receive the oldest value, blocking 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. It is the same TryRecvError try_recv reports rather than a second error type, and Empty is impossible here: a blocking receive that found the channel empty and open would have kept waiting.

Values already queued when the last sender went away are still handed out, one per call, BEFORE the disconnect is reported — closing a channel must not lose what it already accepted (Rust guarantees the same).

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

Receive without blocking: .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 queue's Receiver handle is gone: every further send fails, and senders parked on a full buffer wake up to find out.

Internal — Receiver's dispose is the only caller. The flag is set and the waiters are woken with the mutex HELD, for the same reason close does it: a sender that has evaluated its wait predicate but not yet parked still holds the mutex, so a broadcast issued outside it could land before the park and be lost.

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 (a snapshot, like Channel.len).

True while nothing is buffered (a snapshot).

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.

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

{ Channel } :: import "std/sync/channel";
rx := Channel(i32).receiver(usize(4));
tx := rx.sender();
tx.send(i32(1));
v := rx.recv().unwrap();

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

Exactly one Receiver exists per queue by construction, which is what makes "the receiver is gone" a fact a sender can act on.

A Receiver that has no Sender yet is not closed — nothing has been dropped — so recv on it blocks, exactly as Channel.recv on a queue nobody sends to does. Mint the senders before receiving.

Create a bounded queue and hand back both halves at once — the shape of Rust's mpsc::sync_channel(capacity).

pair := Channel(i32).pair(usize(4));
tx := pair.0;
rx := pair.1;

The tuple keeps both handles alive for as long as the tuple binding lives (measured 2026-09-10). Yo has no destructuring binding, so pair stays in scope beside tx and rx and holds its own reference to each half; tx := pair.0 copies a handle rather than moving it out. The consequence is specific: dropping tx early does NOT drop the last sender, so the auto-close does not fire until the whole scope — the Receiver included — goes away. Use this form when the producers and the consumer share a scope and the count of values is known, or call close() explicitly; use receiver() + sender() when the receiver needs to learn that the producers are finished.