Improve transform speed

[ehmicky]

This improves the speed of transforms when the transform function is synchronous, which I am assuming should be the vast majority of the cases.

The performance improvement is quite big. On my machine, using a child process with some big output (1MB), the transform runs 4x faster.

[ehmicky]

Duplicating the code is unfortunate. All of the following lines are just copies of the lines above, but without async/await. Since we're iterating over possibly millions of chunks, unnecessarily waiting for millions of ticks ends up being very slow for synchronous functions.

I tried to think of a smart way to get the same benefit without duplicating the code, but could not find one. For example, I've tried the following instead:

const transformChunk = async function * (chunk, generators, index) {
	if (index === generators.length) {
		yield chunk;
		return;
	}

	const {transform, transformAsync} = generators[index];
	if (transformAsync) {
		for await (const transformedChunk of transform(chunk)) {
			yield * transformChunk(transformedChunk, generators, index + 1);
		}
	} else {
		for (const transformedChunk of transform(chunk)) {
			yield * transformChunk(transformedChunk, generators, index + 1);
		}
	}
};

But this does not give much performance benefits. This is because transformChunk still needs to be async, therefore the yield * statement iterates asynchronously, even when the for loop is synchronous.

So the only way to get the performance benefit is to make that function not async, which ends up requiring duplicating all the code.

The performance benefit is quite big, so I thought it was worth considering.

It turns out Node.js core team might actually have come to the same conclusion when implementing Readable.from(), which also involves bridging iterators and streams. They go even one step further and end up duplicating their code in 3 instances.

// There are a lot of duplication here, it's done on purpose for performance
// reasons - avoid await when not needed.

I wish JavaScript had a version of the await keyword that does not wait for one tick when the argument is not a promise, as a performance optimization (at the expense of not knowing whether a tick has passed or not).