Without using the Streams API, is it possible to wrap a setInterval in an async generator function, to simulate a never-ending stream?
I know how to do it using setTimeout to supply the delay.
Using setTimeout:
const wait = (delay = 500) => new Promise((resolve) => setTimeout(resolve, delay))
async function * countUp(count = 0) {
while(1) (await wait(), yield count++)
}
(async ()=> {
for await(let el of countUp())
console.log(el)
})()No. Or: not easily. Async generator functions are promise based, and promises don't deal well with repetitive callbacks. Also setInterval does not support any form of backpressure.
Of course you can implement the streams API yourself, which comes down to making a queue of promises. You can take the code from that answer and write
function countUp(count = 0) {
const q = new AsyncBlockingQueue()
setInterval(() => {
q.enqueue(count++)
}, 500)
return q // has a Symbol.asyncIterator method
}
(async() => {
for await (const el of countUp())
console.log(el)
})()
Here is an implementation without dependencies. Using Promise.withResolvers() (ECMAScript 2024), we can maintain a queue of deferred objects. This overcomes the problem of resolving a promise that was created in one callback execution in another:
async function* countUp(count = 0) {
const deferreds = [Promise.withResolvers()];
setInterval(() => {
deferreds.at(-1).resolve(count++);
deferreds.push(Promise.withResolvers());
}, 500);
while (true) {
yield await deferreds[0].promise;
deferreds.shift();
}
}
(async () => {
for await (const el of countUp()) {
console.log(el);
}
})();If the consumption of the async iterator happens without other "awaits", the queue will have at most two elements.
