happy-rusty
    Preparing search index...

    Interface Receiver<T>

    A receiver view of a channel that can only receive values.

    Obtained from the receiver property of a Channel. Shares state with the parent channel. Implements AsyncIterable for use with for await...of.

    https://doc.rust-lang.org/std/sync/mpmc/struct.Receiver.html

    1.8.0

    interface Receiver<T> {
        "[toStringTag]": "Receiver";
        capacity: number;
        isClosed: boolean;
        isEmpty: boolean;
        isFull: boolean;
        length: number;
        "[asyncIterator]"(): AsyncIterableIterator<T>;
        receive(): AsyncOption<T>;
        receiveTimeout(ms: number): AsyncOption<T>;
        toString(): string;
        tryReceive(): Option<T>;
    }

    Type Parameters

    • T

      The type of values that can be received.

    Index
    [toStringTag] capacity isClosed isEmpty isFull length
    [asyncIterator] receive receiveTimeout toString tryReceive
    "[toStringTag]": "Receiver"

    The well-known symbol Symbol.toStringTag used by Object.prototype.toString(). Returns 'Receiver' so that Object.prototype.toString.call(receiver) produces '[object Receiver]'.

    capacity: number

    The maximum number of values that can be buffered. 0 for rendezvous channels, Infinity for unbounded channels.

    Channel.capacity

    isClosed: boolean

    Returns true if the channel has been closed.

    isEmpty: boolean

    Returns true if the channel buffer is empty. Note: A rendezvous channel (capacity=0) is always empty.

    Channel.isEmpty

    isFull: boolean

    Returns true if the channel buffer is full. Note: A rendezvous channel (capacity=0) is always full.

    Channel.isFull

    length: number

    The current number of values in the buffer.

    Note: This does not count waiting senders/receivers; it only counts buffered items.

    Channel.length

    • Returns an async iterator that yields values until the channel is closed.

      The returned iterator is itself async-iterable and implements the full iterator protocol, including return(): leaving early — a break, an error raised in the loop body, or an explicit iterator.return() — cancels any in-flight next() so it no longer holds a spot in the receive queue and cannot swallow a message intended for another consumer.

      Note that a bare receive()/send() returns an ordinary promise that cannot be cancelled. If such a promise is abandoned while pending, it still occupies the queue and will consume the next message — prefer for await (or an explicit iterator.return()) when you may stop early.

      Returns AsyncIterableIterator<T>

      for await (const msg of receiver) {
          console.log('Message:', msg);
      }
      console.log('Channel closed');

    • Receives a value from the channel, waiting if necessary.

      • If the buffer has values, returns Some(value) immediately.
      • If senders are waiting (rendezvous), receives directly from one.
      • If the buffer is empty and not closed, waits for a value.
      • If the channel is closed and empty, returns None.

      Returns AsyncOption<T>

      A promise that resolves to Some(value) or None if closed and empty.

      Channel.receive

      const result = await receiver.receive();
      if (result.isSome()) {
          console.log('Received:', result.unwrap());
      } else {
          console.log('Channel closed');
      }

    • Receives a value from the channel with a timeout.

      Like receive(), but returns None if the operation cannot complete within the specified timeout.

      Parameters

      • ms: number

        Timeout in milliseconds.

      Returns AsyncOption<T>

      A promise that resolves to Some(value) or None if timed out, empty, or closed.

      Channel.receiveTimeout

      const result = await receiver.receiveTimeout(1000);
      if (result.isNone()) {
          console.log('Receive timed out or channel closed');
      }

    • Custom toString implementation.

      Returns string

      const receiver = Channel<number>(10).receiver;
      console.log(receiver.toString()); // 'Receiver(0/10)'

    • Attempts to receive a value without waiting.

      • If the buffer has values, returns Some(value).
      • If senders are waiting (rendezvous), receives directly from one.
      • Otherwise returns None.

      Returns Option<T>

      Some(value) if available, None if empty.

      Channel.tryReceive

      const result = receiver.tryReceive();
      result.inspect((v) => console.log('Got:', v));

    Settings
    Member Visibility

    On This Page
    Properties
    Methods