Struct Producer 

pub struct Producer<T, D> { /* private fields */ }

r[impl jetstream.subscription.surface.producer] The producer’s end. It can send, and it can learn — which is the half a bare Sender cannot do, and the reason a producer loop written against one compiles, runs, and keeps inferring long after the subscriber has gone.

Cancellation is offered all three ways the rule allows: a signal to await, a flag to test, and a send that fails once cancelled. A loop that checks none of them still stops at its next send.

Implementations

impl<T, D> Producer<T, D>

pub async fn send(&self, item: T) -> Result<(), Cancelled>

Emit one item. Fails once the subscriber has gone, so a loop that watches nothing else still terminates.

pub async fn finish(self, done: D)

r[impl jetstream.subscription.termination] End the subscription, carrying the result. Consuming self is the point: a producer that has finished cannot emit again.

pub async fn fail(self, error: Error)

r[impl jetstream.subscription.surface.termination] End the subscription because the work failed.

Without this a producer had no way to say so. Returning early — the ? in any ordinary producer loop — drops the Producer, which closes the channel, which the dispatcher reads as a subscription that simply stopped: it then supplies the terminator the caller is owed, and the subscriber receives a normal typed ending carrying a fabricated result. A failure reported as success is the one outcome the surface must never produce, so the channel carries failures and this is how one is sent.

Dropping without calling either this or finish remains the cancelled case, which is what the dispatcher’s synthetic terminator is for.

pub fn is_cancelled(&self) -> bool

pub async fn cancelled(&self)

Resolves when the subscriber goes away — the shape a producer that is waiting on something else selects over.

pub fn cancellation(&self) -> CancellationToken

The token itself, for a producer that hands cancellation onward to the work rather than watching it here.