Skip to content

channel ​

channel crea un canal tipado y retorna sus dos extremos propios (owned) como una tupla.

Firmachannel<T>(capacity?: usize): [Sender<T>, Receiver<T>]

capacity es opcional: omítelo para un canal ilimitado, o pasa un usize para acotar cuántos valores quedan en buffer, Sender<T>.send/trySend esperan por (o rechazan por falta de) espacio cuando un canal acotado está lleno. Sender<T>.send(value: T): Promise<void> espera por espacio y entrega value, rechazando con channel is closed en cuanto todo Receiver<T> sea descartado; Sender<T>.trySend(value: T): boolean nunca espera, retornando true cuando se acepta o false si el canal está lleno o cerrado. Receiver<T>.recv(): Promise<T?> espera el siguiente mensaje, resolviéndose a None en cuanto todo Sender<T> fue descartado y no queda nada en buffer; Receiver<T>.tryRecv(): T? nunca espera, retornando el siguiente mensaje en buffer o None si todavía no hay uno. Receiver<T>.close(): void cierra el canal, send/trySend empiezan a fallar, mientras recv/tryRecv todavía drenan lo que ya estaba en buffer antes de asentarse en None. Al igual que Promise<T> y JoinHandle<T>, Sender<T>/Receiver<T> son tipos nativos y nunca necesitan importarse.

Los payloads de canal quedan restringidos al mismo subconjunto que la propia Promise<T> soporta: string, arrays de elementos Copy y escalares Copy, no interfaces arbitrarias.

Un Sender<T>/Receiver<T> movido dentro de una tarea spawn se consume ahí, igual que cualquier otro valor propio (owned), capturarlo dos veces, digamos, en dos tareas separadas, es un error de move en tiempo de compilación, así que un único productor o consumidor por extremo es la forma a buscar. El ejemplo de abajo mueve tx dentro de un worker generado (spawned) que devuelve un resultado por host apenas se resuelve, dejando que main procese los resultados a medida que llegan en vez de esperar a que toda búsqueda termine, como haría Promise.all, mira la página de Playground en Tooling para entender por qué este ejemplo no corre ahí:

tyrus
import { NetError, resolve } from "tyrus:net";
import { Sender, channel, spawn } from "tyrus:task";

async function lookupAllInto(tx: Sender<string>, hosts: string[]): Promise<void> {
    for (let i: usize = 0; i < hosts.length; i = i + 1) {
        try {
            const addresses: string[] = await resolve(hosts[i], 2_000);
            await tx.send(`${hosts[i]}: ${addresses.length} address(es)`);
        } catch (error: NetError) {
            await tx.send(`${hosts[i]}: lookup failed`);
        }
    }
}

async function main(): Promise<void> {
    const [tx, rx] = channel<string>();
    // The worker streams each host's result back through the channel as
    // soon as it resolves, instead of making the caller wait for every
    // lookup to finish the way `Promise.all` would.
    const worker = spawn(async (): Promise<void> => await lookupAllInto(tx, ["example.com", "localhost"]));

    for (let i = 0; i < 2; i = i + 1) {
        const result = await rx.recv();
        print(result ?? "no result");
    }
    rx.close();
    await worker.join();
}

Una capacidad de 0 es un error de compilación (E3035): un canal sin espacio no guarda nada, así que todo send esperaría por un recv que no tiene de dónde tomar el valor. Omite el argumento para usar la capacidad predeterminada.