Interface WritableChannel<T>

Closes the channel. Closed channels cannot be written to. They can still be read from if there are values left in the buffer

More precisely, after close:

• Blocked calls to WritableChannel.write will unblock by throwing CannotWriteIntoClosedChannel

• Future calls to WritableChannel.write will throw CannotWriteIntoClosedChannel immediately

• Calls to ReadableChannel.read will consume the values left in the buffer before returning undefined

Unlike in Go, this method is safe to call multiple times (idempotent)

Writes value to the channel. If there is no free space in the channel, blocks until there is. This gives backpressure: if writer is faster than reader, the channel buffer will eventually fill up and the writer will start to block

If channel is buffered, tries to write value in the buffer, and blocks if the buffer is full. If channel is unbuffered, waits for ReadableChannel.read call (resolved immediately if there is a blocked ReadableChannel.read call already)

If the channel was closed before the call, or became closed while the call was blocked, throws CannotWriteIntoClosedChannel

Order of values is guaranteed for sequential writes: after await ch.write(1); await ch.write(2), 1 is guaranteed to be read before 2. Order is not guaranteed for concurrent writes: after await Promise.race([ch.write(1), ch.write(2)]), 1 and 2 can appear in any order when reading

Note: in current implementation, order of values is the same as order of calls to write(), so example above will always give 1, 2. This will change in future if worker_threads support will be implemented. It is not advisable to rely on this