@futpib/parser 1.0.1 → 1.0.2

package/src/terminatedArrayParser.test.ts

@@ -0,0 +1,258 @@
+import test from 'ava';
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { createTerminatedArrayParser, createTerminatedArrayParserNaive, createTerminatedArrayParserUnsafe } from './terminatedArrayParser.js';
+import { Parser, runParser } from './parser.js';
+import { stringParserInputCompanion, uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { HighResolutionTotalTimer } from './highResolutionTimer.js';
+import { createElementParser } from './elementParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createTupleParser } from './tupleParser.js';
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createUnionParser } from './unionParser.js';
+import { createExactElementParser } from './exactElementParser.js';
+
+test('terminatedArrayParser of union parsers', async t => {
+	const parser: Parser<[ number[], number ], Uint8Array> = createTerminatedArrayParser(
+		createUnionParser([
+			createExactElementParser(1),
+			createExactElementParser(2),
+		]),
+		createExactElementParser(0),
+	);
+
+	const input = new Uint8Array([ 0 ]);
+
+	const result = await runParser(parser, input, uint8ArrayParserInputCompanion);
+
+	t.deepEqual(result, [ [], 0 ]);
+});
+
+testProp(
+	'terminatedArrayParser both terminator and element matching',
+	[
+		fc.string(),
+	],
+	async (t, string) => {
+		const terminatedArrayParserNaive = createTerminatedArrayParserNaive(
+			createExactSequenceParser(string),
+			createExactSequenceParser(string),
+		);
+		const terminatedArrayParser = createTerminatedArrayParser(
+			createExactSequenceParser(string),
+			createExactSequenceParser(string),
+		);
+
+		const [
+			naiveResult,
+			result,
+		] = await Promise.allSettled([
+			runParser(
+				terminatedArrayParserNaive,
+				string,
+				stringParserInputCompanion,
+			),
+			runParser(
+				terminatedArrayParser,
+				string,
+				stringParserInputCompanion,
+			),
+		]);
+
+		t.is(naiveResult.status, 'rejected');
+
+		if (
+			result.status === 'rejected'
+				&& naiveResult.status === 'rejected'
+		) {
+			result.reason.message = 'REDACTED';
+			naiveResult.reason.message = 'REDACTED';
+		}
+
+		t.deepEqual(result, naiveResult);
+	},
+	{
+		verbose: true,
+	},
+);
+
+const naiveTotalTimer = new HighResolutionTotalTimer();
+const optimizedTotalTimer = new HighResolutionTotalTimer();
+const unsafeTotalTimer = new HighResolutionTotalTimer();
+
+testProp.serial(
+	'terminatedArrayParser',
+	[
+		fc
+			.integer({
+				min: 1,
+				max: 2 ** 8,
+			})
+			.chain(terminatorLength => (
+				fc
+					.string({
+						minLength: terminatorLength,
+					})
+					.map(string => ({
+						string,
+						terminator: string.slice(0 - terminatorLength)
+					}))
+					.filter(({ string, terminator }) => string.split(terminator).length === 2)
+			))
+	],
+	async (t, { string, terminator }) => {
+		const terminatedArrayParserNaive = createTerminatedArrayParserNaive(
+			promiseCompose(
+				createTupleParser([
+					createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+					createElementParser<string>(),
+				]),
+				([ _, element ]) => element,
+			),
+			createExactSequenceParser(terminator),
+		);
+		const terminatedArrayParser = createTerminatedArrayParser(
+			promiseCompose(
+				createTupleParser([
+					createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+					createElementParser<string>(),
+				]),
+				([ _, element ]) => element,
+			),
+			createExactSequenceParser(terminator),
+		);
+
+		const createTestWrapperParser = (innerParser: typeof terminatedArrayParser): Parser<{
+			string: string;
+			terminator: string;
+			position: number;
+		}, string> => async parserContext => {
+			const [ characters, terminator ] = await innerParser(parserContext);
+
+			return {
+				string: characters.join(''),
+				terminator,
+				nextPeek: await parserContext.peek(0),
+				position: parserContext.position,
+			};
+		};
+
+		const actualNaive = await naiveTotalTimer.measureAsync(() => runParser(
+			createTestWrapperParser(terminatedArrayParserNaive),
+			string,
+			stringParserInputCompanion,
+		));
+
+		t.is(actualNaive.string.length + actualNaive.terminator.length, string.length);
+
+		const actual = await optimizedTotalTimer.measureAsync(() => runParser(
+			createTestWrapperParser(terminatedArrayParser),
+			string,
+			stringParserInputCompanion,
+		));
+
+		t.deepEqual(actual, actualNaive);
+	},
+	{
+		verbose: true,
+	},
+);
+
+test.serial(
+	'terminatedArrayParser performance',
+	t => {
+		t.true(
+			optimizedTotalTimer.time * 1n < naiveTotalTimer.time,
+			`Naive: ${naiveTotalTimer.time / 1000000n}ms, Optimized: ${optimizedTotalTimer.time / 1000000n}ms`,
+		);
+	},
+);
+
+testProp.serial(
+	'terminatedArrayParserUnsafe',
+	[
+		fc
+			.integer({
+				min: 1,
+				max: 2 ** 8,
+			})
+			.chain(terminatorLength => (
+				fc
+					.string({
+						minLength: terminatorLength,
+					})
+					.map(string => ({
+						string,
+						terminator: string.slice(0 - terminatorLength)
+					}))
+					.filter(({ string, terminator }) => string.split(terminator).length === 2)
+			))
+	],
+	async (t, { string, terminator }) => {
+		const terminatedArrayParserNaive = createTerminatedArrayParserNaive(
+			promiseCompose(
+				createTupleParser([
+					createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+					createElementParser<string>(),
+				]),
+				([ _, element ]) => element,
+			),
+			createExactSequenceParser(terminator),
+		);
+		const terminatedArrayParserUnsafe = createTerminatedArrayParserUnsafe(
+			promiseCompose(
+				createTupleParser([
+					createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+					createElementParser<string>(),
+				]),
+				([ _, element ]) => element,
+			),
+			createExactSequenceParser(terminator),
+		);
+
+		const createTestWrapperParser = (innerParser: typeof terminatedArrayParserUnsafe): Parser<{
+			string: string;
+			terminator: string;
+			position: number;
+		}, string> => async parserContext => {
+			const [ characters, terminator ] = await innerParser(parserContext);
+
+			return {
+				string: characters.join(''),
+				terminator,
+				nextPeek: await parserContext.peek(0),
+				position: parserContext.position,
+			};
+		};
+
+		const actualNaive = await runParser(
+			createTestWrapperParser(terminatedArrayParserNaive),
+			string,
+			stringParserInputCompanion,
+		);
+
+		t.is(actualNaive.string.length + actualNaive.terminator.length, string.length);
+
+		const actual = await unsafeTotalTimer.measureAsync(() => runParser(
+			createTestWrapperParser(terminatedArrayParserUnsafe),
+			string,
+			stringParserInputCompanion,
+		));
+
+		t.deepEqual(actual, actualNaive);
+	},
+	{
+		verbose: true,
+	},
+);
+
+test.serial(
+	'terminatedArrayParserUnsafe performance',
+	t => {
+		t.true(
+			unsafeTotalTimer.time * 1n < naiveTotalTimer.time,
+			`Naive: ${naiveTotalTimer.time / 1000000n}ms, Unsafe: ${unsafeTotalTimer.time / 1000000n}ms`,
+		);
+	},
+);

package/src/terminatedArrayParser.ts

@@ -1,4 +1,6 @@
 import { getParserName, type Parser, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createUnionParser } from './unionParser.js';
 
@@ -8,9 +10,9 @@ class Terminated<T> {
 	) {}
 }
 
-export const createTerminatedArrayParser = <ElementOutput, TerminatorOutput, Sequence>(
+export const createTerminatedArrayParserNaive = <ElementOutput, TerminatorOutput, Sequence>(
 	elementParser: Parser<ElementOutput, Sequence>,
-	terminatorParser: Parser<unknown, Sequence>,
+	terminatorParser: Parser<TerminatorOutput, Sequence>,
 ): Parser<[ElementOutput[], TerminatorOutput], Sequence> => {
 	const wrappedTerminatorParser = promiseCompose(terminatorParser, terminatorValue => new Terminated(terminatorValue));
 
@@ -24,7 +26,7 @@ export const createTerminatedArrayParser = <ElementOutput, TerminatorOutput, Seq
 		promiseCompose(terminatorParser, terminatorValue => new Terminated(terminatorValue)),
 	]);
 
-	return async parserContext => {
+	const terminatedArrayParserNaive: Parser<[ElementOutput[], TerminatorOutput], Sequence> = async parserContext => {
 		const elements: ElementOutput[] = [];
 
 		while (true) {
@@ -37,4 +39,107 @@ export const createTerminatedArrayParser = <ElementOutput, TerminatorOutput, Seq
 			elements.push(elementOrTerminator);
 		}
 	};
+
+	setParserName(terminatedArrayParserNaive, `${getParserName(elementParser, 'anonymousElement')}*?${getParserName(terminatorParser, 'anonymousTerminator')}`);
+
+	return terminatedArrayParserNaive;
+};
+
+export const createTerminatedArrayParser = <ElementOutput, TerminatorOutput, Sequence>(
+	elementParser: Parser<ElementOutput, Sequence>,
+	terminatorParser: Parser<TerminatorOutput, Sequence>,
+): Parser<[ElementOutput[], TerminatorOutput], Sequence> => {
+	const terminatedArrayParser: Parser<[ElementOutput[], TerminatorOutput], Sequence> = async parserContext => {
+		const elements: ElementOutput[] = [];
+
+		while (true) {
+			const terminatorParserContext = parserContext.lookahead({
+				debugName: getParserName(terminatorParser, 'anonymousTerminator'),
+			});
+
+			try {
+				const terminatorValue = await terminatorParser(terminatorParserContext);
+
+				const elementParserContext = parserContext.lookahead({
+					debugName: getParserName(elementParser, 'anonymousElement'),
+				});
+
+				try {
+					await elementParser(elementParserContext);
+
+					parserImplementationInvariant(
+						false,
+						[
+							'Both element and terminator parsers matched.',
+							'Element parser: %s',
+							'Terminator parser: %s',
+						],
+						getParserName(elementParser, 'anonymousElement'),
+						getParserName(terminatorParser, 'anonymousTerminator'),
+					);
+				} catch (error) {
+					if (!(error instanceof ParserParsingFailedError)) {
+						throw error;
+					}
+				} finally {
+					elementParserContext.dispose();
+				}
+
+				terminatorParserContext.unlookahead();
+
+				return [ elements, terminatorValue ];
+			} catch (error) {
+				if (!(error instanceof ParserParsingFailedError)) {
+					throw error;
+				}
+			} finally {
+				terminatorParserContext.dispose();
+			}
+
+			const element = await elementParser(parserContext);
+
+			elements.push(element);
+		}
+	};
+
+	setParserName(terminatedArrayParser, `${getParserName(elementParser, 'anonymousElement')}*?${getParserName(terminatorParser, 'anonymousTerminator')}`);
+
+	return terminatedArrayParser;
+};
+
+export const createTerminatedArrayParserUnsafe = <ElementOutput, TerminatorOutput, Sequence>(
+	elementParser: Parser<ElementOutput, Sequence>,
+	terminatorParser: Parser<TerminatorOutput, Sequence>,
+): Parser<[ElementOutput[], TerminatorOutput], Sequence> => {
+	const terminatedArrayParserUnsafe: Parser<[ElementOutput[], TerminatorOutput], Sequence> = async parserContext => {
+		const elements: ElementOutput[] = [];
+
+		while (true) {
+			const terminatorParserContext = parserContext.lookahead({
+				debugName: getParserName(terminatorParser, 'anonymousTerminator'),
+			});
+
+			try {
+				const terminatorValue = await terminatorParser(terminatorParserContext);
+
+				terminatorParserContext.unlookahead();
+
+				return [ elements, terminatorValue ];
+			} catch (error) {
+				if (!(error instanceof ParserParsingFailedError)) {
+					throw error;
+				}
+			} finally {
+				terminatorParserContext.dispose();
+			}
+
+			const element = await elementParser(parserContext);
+
+			elements.push(element);
+		}
+	};
+
+	setParserName(terminatedArrayParserUnsafe, `${getParserName(elementParser, 'anonymousElement')}*?${getParserName(terminatorParser, 'anonymousTerminator')}`);
+
+	return terminatedArrayParserUnsafe;
 };

package/src/toAsyncIterable.ts

@@ -0,0 +1,7 @@
+export function toAsyncIterable<T>(value: AsyncIterator<T>): AsyncIterable<T> {
+	return {
+		[Symbol.asyncIterator]() {
+			return value;
+		},
+	};
+}

package/src/toAsyncIterator.ts

@@ -0,0 +1,48 @@
+import invariant from "invariant";
+
+function isAsyncIterable<T>(value: any): value is AsyncIterable<T> {
+	return value && typeof value[Symbol.asyncIterator] === 'function';
+}
+
+function isIterable<T>(value: any): value is Iterable<T> {
+	return value && typeof value[Symbol.iterator] === 'function';
+}
+
+function isIterator<T>(value: any): value is Iterator<T> {
+	return value && typeof value.next === 'function';
+}
+
+function iteratorToAsyncIterator<T>(iterator: Iterator<T>): AsyncIterator<T> {
+	return {
+		next: async () => iterator.next(),
+	};
+}
+
+export function toAsyncIterator<T>(value: AsyncIterator<T> | AsyncIterable<T> | Iterable<T> | T): AsyncIterator<T> {
+	if (
+		typeof value === 'string'
+		|| value instanceof Uint8Array
+	) {
+		return (async function * () {
+			yield value as any;
+		})();
+	}
+
+	if (isAsyncIterable(value)) {
+		return value[Symbol.asyncIterator]();
+	}
+
+	if (isIterable(value)) {
+		return iteratorToAsyncIterator(value[Symbol.iterator]());
+	}
+
+	if (isIterator<T>(value)) {
+		return iteratorToAsyncIterator(value);
+	}
+
+	invariant(
+		false,
+		'Value must be an async iterator, async iterable, iterable or iterator got %s.',
+		value,
+	);
+}

package/src/tupleParser.ts

@@ -10,6 +10,10 @@ export function createTupleParser<A, B, C, D, E, F, G, H, Sequence>([ parserA, p
 export function createTupleParser<A, B, C, D, E, F, G, H, I, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I], Sequence>;
 export function createTupleParser<A, B, C, D, E, F, G, H, I, J, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J], Sequence>;
 export function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K], Sequence>;
+export function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L], Sequence>;
+export function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, M, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL, parserM ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>, Parser<M, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M], Sequence>;
+export function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, M, N, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL, parserM, parserN ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>, Parser<M, Sequence>, Parser<N, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M, N], Sequence>;
+export function createTupleParser<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Sequence>([ parserA, parserB, parserC, parserD, parserE, parserF, parserG, parserH, parserI, parserJ, parserK, parserL, parserM, parserN, parserO ]: [Parser<A, Sequence>, Parser<B, Sequence>, Parser<C, Sequence>, Parser<D, Sequence>, Parser<E, Sequence>, Parser<F, Sequence>, Parser<G, Sequence>, Parser<H, Sequence>, Parser<I, Sequence>, Parser<J, Sequence>, Parser<K, Sequence>, Parser<L, Sequence>, Parser<M, Sequence>, Parser<N, Sequence>, Parser<O, Sequence>]): Parser<[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O], Sequence>;
 export function createTupleParser<Sequence>(parsers: Array<Parser<unknown, Sequence>>): Parser<unknown[], Sequence> {
 	const tupleParser: Parser<unknown[], Sequence> = async parserContext => {
 		const values: unknown[] = [];
@@ -23,11 +27,10 @@ export function createTupleParser<Sequence>(parsers: Array<Parser<unknown, Seque
 		return values;
 	};
 
-	setParserName(tupleParser, [
-		'[',
-		parsers.map(parser => getParserName(parser, 'anonymousTupleChild')).join(','),
-		']',
-	].join(''));
+	setParserName(
+		tupleParser,
+		parsers.map(parser => '(' + getParserName(parser, 'anonymousTupleChild') + ')').join(''),
+	);
 
 	return tupleParser;
 }

package/src/unionParser.test.ts

@@ -0,0 +1,79 @@
+import test from 'ava';
+import { createUnionParser } from './unionParser.js';
+import { Parser, runParser, setParserName } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createArrayParser } from './arrayParser.js';
+import { createExactElementParser } from './exactElementParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { ParserError } from './parserError.js';
+
+test('union of union of union', async t => {
+	const parser: Parser<string, string> = createUnionParser([
+		createExactElementParser('a'),
+		createUnionParser([
+			createExactElementParser('b'),
+			createUnionParser([
+				createExactElementParser('c'),
+				createExactElementParser('d'),
+			]),
+			createExactElementParser('e'),
+		]),
+		createExactElementParser('f'),
+		createUnionParser([
+			createExactElementParser('g'),
+			createExactElementParser('h'),
+		]),
+	]);
+
+	for (const character of 'abcdefgh') {
+		t.deepEqual(await runParser(parser, character, stringParserInputCompanion), character);
+	}
+});
+
+test('sync and async child parsers', async t => {
+	const parser = createArrayParser(
+		createUnionParser<string, string>([
+			async parserContext => {
+				parserContext.invariant(
+					parserContext.position % 2 === 0,
+					'Expected an even position.',
+				);
+
+				return parserContext.read(0);
+			},
+			parserContext => {
+				parserContext.invariant(
+					parserContext.position % 2 === 1,
+					'Expected an odd position.',
+				);
+
+				parserContext.skip(1);
+
+				return String.fromCodePoint('A'.codePointAt(0)! + parserContext.position - 1);
+			},
+		]),
+	);
+
+	const result = await runParser(parser, 'a?c?', stringParserInputCompanion, {
+		errorJoinMode: 'all',
+	});
+
+	t.deepEqual(result, 'aBcD'.split(''));
+});
+
+test('multiple parsers succeeded error', async t => {
+	const parser = createUnionParser([
+		setParserName(createExactSequenceParser('foo'), 'foo1'),
+		setParserName(createExactSequenceParser('foo'), 'foo2'),
+	]);
+
+	const error = await t.throwsAsync(runParser(parser, 'foo', stringParserInputCompanion, {
+		errorJoinMode: 'all',
+	}), {
+		instanceOf: ParserError,
+	});
+
+	t.true(error.message.includes('foo'));
+	t.true(error.message.includes('foo1'));
+	t.true(error.message.includes('foo2'));
+});

package/src/unionParser.ts

@@ -3,36 +3,60 @@ import { getParserName, setParserName, type Parser } from './parser.js';
 import { type ParserContext } from './parserContext.js';
 import { ParserParsingFailedError } from './parserError.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+import { DeriveSequenceElement } from './sequence.js';
+
+const bigintReplacer = (_key: string, value: unknown) => {
+	if (typeof value === 'bigint') {
+		return `${value}n`;
+	}
+
+	return value;
+};
 
 export const createUnionParser = <
 	Output,
 	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
 >(
-	childParsers: Array<Parser<any, Sequence, any>>,
-): Parser<Output, Sequence, unknown> => {
+	childParsers: Array<Parser<unknown, Sequence, Element>>,
+): Parser<Output, Sequence, Element> => {
 	parserImplementationInvariant(childParsers.length > 0, 'Union parser must have at least one child parser.');
 
-	const unionParser: Parser<Output, Sequence, unknown> = async parserContext => {
-		let runningChildParserContexts: Array<ParserContext<unknown, unknown>> = [];
+	type TaskContext = {
+		childParser: Parser<unknown, Sequence, Element>,
+		childParserContext: ParserContext<Sequence, Element>,
+	};
+
+	const unionParser: Parser<Output, Sequence, Element> = async parserContext => {
+		let runningChildParserContexts: TaskContext[] = [];
 
-		const childParserResults = allSettledStream(childParsers.map(childParser => {
+		const createChildParserTask = (childParser: Parser<unknown, Sequence, Element>) => {
 			const childParserContext = parserContext.lookahead({
 				debugName: getParserName(childParser, 'anonymousUnionChild'),
 			});
 
-			runningChildParserContexts.push(childParserContext);
+			const context: TaskContext = {
+				childParser,
+				childParserContext,
+			};
+
+			runningChildParserContexts.push(context);
+
+			const getChildParserPromise = (async () => childParser(childParserContext) as Promise<Output>);
 
-			const promise = childParser(childParserContext);
+			const promise = getChildParserPromise();
 
 			return {
 				promise,
-				context: childParserContext,
+				context,
 			};
-		}));
+		};
+
+		const childParserResults = allSettledStream<Output, TaskContext>(childParsers.map(createChildParserTask));
 
 		const parserParsingFailedErrors: ParserParsingFailedError[] = [];
 		const successfulParserOutputs: Output[] = [];
-		const successfulParserContexts: Array<ParserContext<unknown, unknown>> = [];
+		const successfulTaskContexts: TaskContext[] = [];
 		let didUnlookahead = false;
 
 		for await (const childParserResult of childParserResults) {
@@ -42,7 +66,7 @@ export const createUnionParser = <
 
 			if (childParserResult.status === 'fulfilled') {
 				successfulParserOutputs.push(childParserResult.value);
-				successfulParserContexts.push(childParserResult.context);
+				successfulTaskContexts.push(childParserResult.context);
 			} else {
 				const error = childParserResult.reason;
 
@@ -60,7 +84,7 @@ export const createUnionParser = <
 				parserImplementationInvariant(!didUnlookahead, 'Union parser unlookaheaded multiple times.');
 				didUnlookahead = true;
 				const [ runningChildParserContext ] = runningChildParserContexts;
-				runningChildParserContext.unlookahead();
+				runningChildParserContext.childParserContext.unlookahead();
 			}
 		}
 
@@ -71,8 +95,12 @@ export const createUnionParser = <
 				'Successful parser outputs, indented, separated by newlines:',
 				'%s',
 				'End of successful parser outputs.',
+				'Successful parser names, indented, separated by newlines:',
+				'%s',
+				'End of successful parser names.',
 			],
-			() => successfulParserOutputs.map(output => '  ' + JSON.stringify(output)).join('\n'),
+			() => successfulParserOutputs.map(output => '  ' + JSON.stringify(output, bigintReplacer)).join('\n'),
+			() => successfulTaskContexts.map(taskContext => '  ' + getParserName(taskContext.childParser, 'anonymousUnionChild')).join('\n'),
 		);
 
 		parserContext.invariantJoin(
@@ -81,13 +109,13 @@ export const createUnionParser = <
 			'No union child parser succeeded.',
 		);
 
-		const [ successfulParserContext ] = successfulParserContexts;
+		const [ successfulParserContext ] = successfulTaskContexts;
 
 		if (!didUnlookahead) {
-			successfulParserContext.unlookahead();
+			successfulParserContext.childParserContext.unlookahead();
 		}
 
-		successfulParserContext.dispose();
+		successfulParserContext.childParserContext.dispose();
 
 		const [ successfulParserOutput ] = successfulParserOutputs;