Channel Buffering in TypeScript

In TypeScript, we don’t have built-in channels like in Go. However, we can simulate a similar behavior using a class with a queue and promises. Here’s an example that demonstrates a concept similar to buffered channels:

class BufferedChannel<T> {
    private queue: T[] = [];
    private capacity: number;

    constructor(capacity: number) {
        this.capacity = capacity;
    }

    async send(value: T): Promise<void> {
        while (this.queue.length >= this.capacity) {
            await new Promise(resolve => setTimeout(resolve, 0));
        }
        this.queue.push(value);
    }

    async receive(): Promise<T> {
        while (this.queue.length === 0) {
            await new Promise(resolve => setTimeout(resolve, 0));
        }
        return this.queue.shift()!;
    }
}

async function main() {
    // Here we create a BufferedChannel of strings with a capacity of 2
    const messages = new BufferedChannel<string>(2);

    // Because this channel is buffered, we can send these
    // values into the channel without a corresponding
    // concurrent receive.
    await messages.send("buffered");
    await messages.send("channel");

    // Later we can receive these two values as usual.
    console.log(await messages.receive());
    console.log(await messages.receive());
}

main().catch(console.error);

This TypeScript code demonstrates a concept similar to buffered channels. Here’s what’s happening:

1. We define a BufferedChannel class that simulates a buffered channel. It has a capacity and uses a queue to store values.

2. The send method adds items to the queue if there’s capacity. If the queue is full, it waits using a Promise.

3. The receive method retrieves items from the queue. If the queue is empty, it waits using a Promise.

4. In the main function, we create a BufferedChannel of strings with a capacity of 2.

5. We then send two values into the channel without immediately receiving them.

6. Finally, we receive and print the two values.

To run this TypeScript code, you would typically compile it to JavaScript and then run it with Node.js. The output would be:

buffered
channel

This example demonstrates how we can implement a concept similar to Go’s buffered channels in TypeScript, using asynchronous programming and Promises.