@futpib/parser 1.0.1 → 1.0.2

package/src/parser.ts

@@ -1,14 +1,17 @@
-import invariant from 'invariant';
+import { Class } from 'type-fest';
 import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { InputReaderImplementation } from './inputReader.js';
 import { type ParserContext, ParserContextImplementation } from './parserContext.js';
 import { type DeriveSequenceElement } from './sequence.js';
+import { ParserError, ParserUnexpectedRemainingInputError } from './parserError.js';
+import { toAsyncIterator } from './toAsyncIterator.js';
+import { inputReaderStateCompanion } from './inputReaderState.js';
 
 export type Parser<
 	Output,
 	Sequence,
 	Element = DeriveSequenceElement<Sequence>,
-> = (parserContext: ParserContext<Sequence, Element>) => Promise<Output>;
+> = (parserContext: ParserContext<Sequence, Element>) => Output | Promise<Output>;
 
 export function getParserName(parser: Parser<any, any, any>, default_ = 'anonymous'): string {
 	return parser.name || default_;
@@ -26,59 +29,152 @@ export function setParserName<
 	return parser;
 }
 
+const originalParserByClone = new WeakMap<Parser<any, any, any>, Parser<any, any, any>>();
+
+export function cloneParser<
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+>(
+	parser: Parser<Output, Sequence, Element>,
+): Parser<Output, Sequence, Element> {
+	const originalParser = originalParserByClone.get(parser) ?? parser;
+
+	const clone: Parser<Output, Sequence, Element> = (parserContext) => {
+		return originalParser(parserContext);
+	};
+
+	setParserName(clone, getParserName(parser));
+
+	originalParserByClone.set(clone, originalParser);
+
+	return clone;
+}
+
 export type RunParserOptions<
 	Output,
 	Sequence,
 	Element = DeriveSequenceElement<Sequence>,
 > = {
 	errorJoinMode?: 'none' | 'deepest' | 'furthest' | 'all';
+	parserContextClass?: Class<ParserContext<Sequence, Element>>;
 };
 
-function isAsyncIterable<T>(value: any): value is AsyncIterable<T> {
-	return value && typeof value[Symbol.asyncIterator] === 'function';
-}
+export type RunParserWithRemainingInputResult<
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+> = {
+	output: Output;
+	position: number;
+	remainingInput: undefined | AsyncIterable<Sequence>;
+};
 
-function isIterable<T>(value: any): value is Iterable<T> {
-	return value && typeof value[Symbol.iterator] === 'function';
+async function withEnrichedParserError<
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+>(
+	parserContext: ParserContext<Sequence, Element>,
+	inputReader: InputReaderImplementation<Sequence, Element>,
+	f: () => Promise<Output>,
+): Promise<Output> {
+	try {
+		return await f();
+	} catch (error) {
+		if (error instanceof ParserError) {
+			if (error.position === undefined) {
+				error.position = parserContext.position;
+			}
+
+			if (error.inputReaderSate === undefined) {
+				error.inputReaderSate = inputReader.toInputReaderState();
+			}
+		}
+
+		throw error;
+	}
 }
 
-function isIterator<T>(value: any): value is Iterator<T> {
-	return value && typeof value.next === 'function';
-}
+type RunParserInternalResult<
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+> = {
+	outputPromise: Promise<Output>;
+	parserContext: ParserContext<Sequence, Element>;
+	inputReader: InputReaderImplementation<Sequence, Element>;
+};
 
-function iteratorToAsyncIterator<T>(iterator: Iterator<T>): AsyncIterator<T> {
-	return {
-		next: async () => iterator.next(),
-	};
-}
+function runParserInternal<
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+>(
+	parser: Parser<Output, Sequence, Element>,
+	input: AsyncIterator<Sequence> | AsyncIterable<Sequence> | Iterable<Sequence> | Sequence,
+	parserInputCompanion: ParserInputCompanion<Sequence, Element>,
+	options: RunParserOptions<Output, Sequence, Element> = {},
+): RunParserInternalResult<Output, Sequence, Element> {
+	const inputAsyncIterator = toAsyncIterator(input);
 
-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;
-		})();
-	}
+	const inputReader = new InputReaderImplementation<Sequence, Element>(parserInputCompanion, inputAsyncIterator);
 
-	if (isAsyncIterable(value)) {
-		return value[Symbol.asyncIterator]();
-	}
+	const ParserContext = options.parserContextClass ?? ParserContextImplementation;
 
-	if (isIterable(value)) {
-		return iteratorToAsyncIterator(value[Symbol.iterator]());
-	}
+	const parserContext = new ParserContext<Sequence, Element>(parserInputCompanion, inputReader, undefined, {
+		...options,
+		debugName: 'root',
+	});
 
-	if (isIterator<T>(value)) {
-		return iteratorToAsyncIterator(value);
-	}
+	const outputPromise = (async () => {
+		try {
+			return await parser(parserContext);
+		} finally {
+			await parserContext.peek(0);
+		}
+	})();
+
+	return {
+		outputPromise,
+		parserContext,
+		inputReader,
+	};
+}
 
-	invariant(
-		false,
-		'Value must be an async iterator, async iterable, iterable or iterator got %s.',
-		value,
-	);
+export async function runParserWithRemainingInput<
+	Output,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+>(
+	parser: Parser<Output, Sequence, Element>,
+	input: AsyncIterator<Sequence> | AsyncIterable<Sequence> | Iterable<Sequence> | Sequence,
+	parserInputCompanion: ParserInputCompanion<Sequence, Element>,
+	options: RunParserOptions<Output, Sequence, Element> = {},
+): Promise<RunParserWithRemainingInputResult<Output, Sequence, Element>> {
+	const {
+		outputPromise,
+		parserContext,
+		inputReader,
+	} = runParserInternal(parser, input, parserInputCompanion, options);
+
+	return await withEnrichedParserError(parserContext, inputReader, async () => {
+		const output = await outputPromise;
+
+		const inputReaderState = inputReader.toInputReaderState();
+
+		const remainingInput = (
+			inputReaderStateCompanion.isDone(inputReaderState)
+				? undefined
+				: inputReaderStateCompanion.toRemainingInputAsyncIterator(inputReaderState)
+		);
+
+		return {
+			output,
+			position: parserContext.position,
+			remainingInput,
+		};
+	});
 }
 
 export async function runParser<
@@ -91,13 +187,21 @@ export async function runParser<
 	parserInputCompanion: ParserInputCompanion<Sequence, Element>,
 	options: RunParserOptions<Output, Sequence, Element> = {},
 ): Promise<Output> {
-	const inputAsyncIterator = toAsyncIterator(input);
+	const {
+		outputPromise,
+		parserContext,
+		inputReader,
+	} = runParserInternal(parser, input, parserInputCompanion, options);
 
-	const inputReader = new InputReaderImplementation<Sequence, Element>(parserInputCompanion, inputAsyncIterator);
-	const parserContext = new ParserContextImplementation<Sequence, Element>(parserInputCompanion, inputReader, undefined, {
-		...options,
-		debugName: 'root',
-	});
+	return await withEnrichedParserError(parserContext, inputReader, async () => {
+		const output = await outputPromise;
+
+		const inputReaderState = inputReader.toInputReaderState();
 
-	return parser(parserContext);
+		if (!inputReaderStateCompanion.isDone(inputReaderState)) {
+			throw new ParserUnexpectedRemainingInputError('Unexpected remaining input', 0, parserContext.position);
+		}
+
+		return output;
+	});
 }

package/src/parserAccessorParser.ts

@@ -1,3 +1,13 @@
-import { type Parser } from './parser.js';
+import { getParserName, setParserName, type Parser } from './parser.js';
 
-export const createParserAccessorParser = <Output, Sequence>(parserAccessor: () => Parser<Output, Sequence>): Parser<Output, Sequence> => async parserContext => parserAccessor()(parserContext);
+export const createParserAccessorParser = <Output, Sequence>(parserAccessor: () => Parser<Output, Sequence>): Parser<Output, Sequence> => {
+	const parserAccessorParser: Parser<Output, Sequence> = async parserContext => {
+		const parser = parserAccessor();
+
+		setParserName(parserAccessorParser, `parserAccessorParser(${getParserName(parser, 'anonymousParserAccessor')})`);
+
+		return parser(parserContext);
+	};
+
+	return parserAccessorParser;
+}

package/src/parserConsumedSequenceParser.ts

@@ -1,20 +1,29 @@
 import { createFixedLengthSequenceParser } from "./fixedLengthSequenceParser.js";
-import { Parser } from "./parser.js";
+import { getParserName, Parser, setParserName } from "./parser.js";
 
 export const createParserConsumedSequenceParser = <Output, Sequence>(
 	childParser: Parser<Output, Sequence>,
-): Parser<[Output, Sequence], Sequence> => async parserContext => {
-	const initialPosition = parserContext.position;
-	const childParserContext = parserContext.lookahead();
-	let value: Output;
-	let consumedLength: number;
-	try {
-		value = await childParser(childParserContext);
-		consumedLength = childParserContext.position - initialPosition;
-	} finally {
-		childParserContext.dispose();
-	}
-	const consumedSequenceParser = createFixedLengthSequenceParser<Sequence>(consumedLength);
-	const consumedSequence = await consumedSequenceParser(parserContext);
-	return [value, consumedSequence];
-}
+): Parser<[Output, Sequence], Sequence> => {
+	const parserConsumedSequenceParser: Parser<[Output, Sequence], Sequence> = async parserContext => {
+		const initialPosition = parserContext.position;
+		const childParserContext = parserContext.lookahead();
+
+		let value: Output;
+		let consumedLength: number;
+		try {
+			value = await childParser(childParserContext);
+			consumedLength = childParserContext.position - initialPosition;
+		} finally {
+			childParserContext.dispose();
+		}
+
+		const consumedSequenceParser = createFixedLengthSequenceParser<Sequence>(consumedLength);
+		const consumedSequence = await consumedSequenceParser(parserContext);
+
+		return [value, consumedSequence];
+	};
+
+	setParserName(parserConsumedSequenceParser, `parserConsumedSequenceParser(${getParserName(childParser, 'anonymousParserConsumedSequenceParserChild')})`);
+
+	return parserConsumedSequenceParser;
+};

package/src/parserContext.test.ts

@@ -30,6 +30,29 @@ test('parserContext.read', async t => {
 	});
 });
 
+test('parserContext.readSequence', async t => {
+	const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function * () {
+		yield '';
+		yield 'abc';
+		yield 'def';
+		yield '';
+		yield 'gh';
+	})()), ...commonParserContextArguments);
+
+	t.is(await parserContext.readSequence(0, 0), '');
+	t.is(await parserContext.readSequence(0, 1), 'a');
+	t.is(await parserContext.readSequence(1, 4), 'cde');
+	t.is(await parserContext.readSequence(0, 1), 'f');
+	t.is(await parserContext.readSequence(0, 0), '');
+	t.is(await parserContext.readSequence(0, 1), 'g');
+	t.is(await parserContext.readSequence(1, 1), '');
+	t.is(await parserContext.readSequence(0, 0), '');
+
+	await t.throwsAsync(async () => parserContext.readSequence(0, 1), {
+		instanceOf: ParserUnexpectedEndOfInputError,
+	});
+});
+
 test('parserContext.lookahead', async t => {
 	const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function * () {
 		yield * 'abcdefgh';
@@ -42,11 +65,15 @@ test('parserContext.lookahead', async t => {
 	});
 
 	t.is(await lookaheadContext3.peek(2), 'c');
+	t.is(await lookaheadContext3.peekSequence(2, 3), 'c');
 	t.is(await lookaheadContext3.peek(3), undefined);
+	t.is(await lookaheadContext3.peekSequence(3, 4), undefined);
 	t.is(await lookaheadContext3.read(0), 'a');
 	t.is(await lookaheadContext3.read(0), 'b');
 	t.is(await lookaheadContext3.read(0), 'c');
 	t.is(await lookaheadContext3.peek(0), undefined);
+	t.is(await lookaheadContext3.peekSequence(0, 1), undefined);
+	t.is(await lookaheadContext3.peekSequence(0, 0), '');
 
 	t.is(await parserContext.peek(0), 'a');
 	t.is(await lookaheadContext1.peek(0), 'a');
@@ -63,6 +90,10 @@ test('parserContext.lookahead', async t => {
 	t.is(lookaheadContext1.position, 1);
 	t.is(lookaheadContext2.position, 0);
 	t.is(lookaheadContext3.position, 3);
+
+	lookaheadContext3.skip(1);
+	t.is(await lookaheadContext3.peekSequence(0, 0), undefined);
+	t.is(lookaheadContext3.position, 4);
 });
 
 test('parserContext.unlookahead', async t => {

package/src/parserContext.ts

@@ -1,6 +1,5 @@
 /* eslint-disable prefer-arrow-callback */
 
-import invariant from 'invariant';
 import { type ParserInputCompanion } from './parserInputCompanion.js';
 import { type InputReader } from './inputReader.js';
 import {
@@ -8,6 +7,7 @@ import {
 } from './parserError.js';
 import { type RunParserOptions } from './parser.js';
 import { type Falsy, customInvariant, type ValueOrAccessor } from './customInvariant.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 
 type LookaheadOptions = {
 	debugName?: string;
@@ -21,14 +21,21 @@ type ParserContextOptions<Sequence, Element> =
 
 export type ParserContext<Sequence, Element> = {
 	from(elements: Element[]): Sequence;
+	concat(sequences: Sequence[]): Sequence;
 	length(sequence: Sequence): number;
 	at(sequence: Sequence, index: number): Element | undefined;
+	subsequence(sequence: Sequence, start: number, end: number): Sequence;
+	indexOf(sequence: Sequence, element: Element, fromIndex?: number): number;
+	indexOfSubsequence(sequence: Sequence, subsequence: Sequence, fromIndex?: number): number;
+	equals(sequenceA: Sequence, sequenceB: Sequence): boolean;
 
 	get position(): number;
 	peek(offset: number): Promise<Element | undefined>;
+	peekSequence(start: number, end: number): Promise<Sequence | undefined>;
 	skip(offset: number): void;
 
 	read(offset: number): Promise<Element>;
+	readSequence(start: number, end: number): Promise<Sequence>;
 
 	lookahead(options?: LookaheadOptions): ParserContext<Sequence, Element>;
 	unlookahead(): void;
@@ -72,6 +79,10 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		return this._parserInputCompanion.from(elements);
 	}
 
+	concat(sequences: Sequence[]): Sequence {
+		return this._parserInputCompanion.concat(sequences);
+	}
+
 	length(sequence: Sequence): number {
 		return this._parserInputCompanion.length(sequence);
 	}
@@ -80,6 +91,22 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		return this._parserInputCompanion.at(sequence, index);
 	}
 
+	subsequence(sequence: Sequence, start: number, end: number): Sequence {
+		return this._parserInputCompanion.subsequence(sequence, start, end);
+	}
+
+	indexOf(sequence: Sequence, element: Element, fromIndex?: number): number {
+		return this._parserInputCompanion.indexOf(sequence, element, fromIndex);
+	}
+
+	indexOfSubsequence(sequence: Sequence, subsequence: Sequence, fromIndex?: number): number {
+		return this._parserInputCompanion.indexOfSubsequence(sequence, subsequence, fromIndex);
+	}
+
+	equals(sequenceA: Sequence, sequenceB: Sequence): boolean {
+		return this._parserInputCompanion.equals(sequenceA, sequenceB);
+	}
+
 	get position() {
 		return this._inputReader.position;
 	}
@@ -95,6 +122,39 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		return this._inputReader.peek(offset);
 	}
 
+	async peekSequence(start: number, end: number): Promise<Sequence | undefined> {
+		if (
+			this._options.sliceEnd !== undefined
+				&& (this.position + end - 1) >= this._options.sliceEnd
+		) {
+			return undefined;
+		}
+
+		parserImplementationInvariant(
+			start >= 0,
+			'start (%s) >= 0',
+			start,
+		);
+		parserImplementationInvariant(
+			end >= start,
+			'end (%s) >= start (%s)',
+			start,
+			end,
+		);
+		parserImplementationInvariant(
+			Number.isSafeInteger(start),
+			'start (%d) is not a safe integer',
+			start,
+		);
+		parserImplementationInvariant(
+			Number.isSafeInteger(end),
+			'end (%d) is not a safe integer',
+			end,
+		);
+
+		return this._inputReader.peekSequence(start, end);
+	}
+
 	skip(offset: number) {
 		this._inputReader.skip(offset);
 	}
@@ -111,21 +171,31 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 		return element;
 	}
 
-	lookahead(options: LookaheadOptions = {}): ParserContext<Sequence, Element> {
-		const lookaheadInputReader = this._inputReader.lookahead();
+	async readSequence(start: number, end: number): Promise<Sequence> {
+		const sequence = await this.peekSequence(start, end);
 
-		if (this.position !== lookaheadInputReader.position) {
-			debugger;
+		if (sequence === undefined) {
+			throw new ParserUnexpectedEndOfInputError('', this._depth, this.position);
 		}
 
-		invariant(
+		this.skip(end);
+
+		return sequence;
+	}
+
+	lookahead(options: LookaheadOptions = {}): ParserContext<Sequence, Element> {
+		const lookaheadInputReader = this._inputReader.lookahead();
+
+		parserImplementationInvariant(
 			this.position === lookaheadInputReader.position,
 			'lookahead this.position (%s) === lookaheadInputReader.position (%s)',
 			this.position,
 			lookaheadInputReader.position,
 		);
 
-		const lookaheadParserContext = new ParserContextImplementation(
+		const ParserContext = this._options.parserContextClass ?? ParserContextImplementation;
+
+		const lookaheadParserContext = new ParserContext<Sequence, Element>(
 			this._parserInputCompanion,
 			lookaheadInputReader,
 			this,
@@ -143,11 +213,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 			},
 		);
 
-		if (this.position !== lookaheadParserContext.position) {
-			debugger;
-		}
-
-		invariant(
+		parserImplementationInvariant(
 			this.position === lookaheadParserContext.position,
 			'lookahead this.position (%s) === lookaheadParserContext.position (%s)',
 			this.position,
@@ -158,11 +224,14 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 	}
 
 	unlookahead() {
-		invariant(this._parentParserContext !== undefined, 'this._parentParserContext !== undefined');
-		invariant(
+		const parentParserContext = parserImplementationInvariant(
+			this._parentParserContext,
+			'this._parentParserContext !== undefined',
+		);
+		parserImplementationInvariant(
 			(
-				this._parentParserContext._exclusiveChildParserContext === undefined
-				|| this._parentParserContext._exclusiveChildParserContext === this
+				parentParserContext._exclusiveChildParserContext === undefined
+				|| parentParserContext._exclusiveChildParserContext === this
 			),
 			[
 				'Parent\'s exclusive child must be undefined or this',
@@ -171,29 +240,29 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 				'parent.exclusiveChild: %s',
 			].join('\n'),
 			this.toString(),
-			this._parentParserContext.toString(),
-			this._parentParserContext._exclusiveChildParserContext?.toString(),
+			parentParserContext.toString(),
+			parentParserContext._exclusiveChildParserContext?.toString(),
 		);
-		invariant(
-			this._parentParserContext.position <= this.position,
+		parserImplementationInvariant(
+			parentParserContext.position <= this.position,
 			'unlookahead this._parentParserContext.position (%s) <= this.position (%s)',
-			this._parentParserContext.position,
+			parentParserContext.position,
 			this.position,
 		);
 
-		const offset = this._inputReader.position - this._parentParserContext._inputReader.position;
+		const offset = this._inputReader.position - parentParserContext._inputReader.position;
 
-		this._parentParserContext.skip(offset);
+		parentParserContext.skip(offset);
 
-		invariant(
-			this._parentParserContext.position === this.position,
+		parserImplementationInvariant(
+			parentParserContext.position === this.position,
 			'unlookahead this._parentParserContext.position (%s) === this.position (%s)',
-			this._parentParserContext.position,
+			parentParserContext.position,
 			this.position,
 		);
 
-		this._inputReader = this._parentParserContext._inputReader;
-		this._parentParserContext._exclusiveChildParserContext = this;
+		this._inputReader = parentParserContext._inputReader;
+		parentParserContext._exclusiveChildParserContext = this;
 
 		if (this._exclusiveChildParserContext) {
 			this._exclusiveChildParserContext.unlookahead();
@@ -201,11 +270,14 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 	}
 
 	dispose() {
-		invariant(this._parentParserContext !== undefined, 'this._parentParserContext !== undefined');
-		invariant(
+		const parentParserContext = parserImplementationInvariant(
+			this._parentParserContext,
+			'this._parentParserContext !== undefined',
+		);
+		parserImplementationInvariant(
 			(
-				this._parentParserContext._exclusiveChildParserContext === undefined
-				|| this._parentParserContext._exclusiveChildParserContext === this
+				parentParserContext._exclusiveChildParserContext === undefined
+				|| parentParserContext._exclusiveChildParserContext === this
 			),
 			[
 				'Parent\'s exclusive child must be undefined or this',
@@ -214,11 +286,11 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 				'parent.exclusiveChild: %s',
 			].join('\n'),
 			this.toString(),
-			this._parentParserContext.toString(),
-			this._parentParserContext._exclusiveChildParserContext?.toString(),
+			parentParserContext.toString(),
+			parentParserContext._exclusiveChildParserContext?.toString(),
 		);
 
-		this._parentParserContext._exclusiveChildParserContext = undefined;
+		parentParserContext._exclusiveChildParserContext = undefined;
 		this._parentParserContext = undefined;
 	}
 
@@ -231,7 +303,7 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 	}
 
 	invariantJoin<T>(value: T, childErrors: ParserParsingFailedError[], format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy> {
-		invariant(childErrors.length > 0, 'childErrors.length > 0');
+		parserImplementationInvariant(childErrors.length > 0, 'childErrors.length > 0');
 
 		const errorJoinMode = this._options.errorJoinMode ?? 'none';
 		const parserContext = this;
@@ -315,6 +387,6 @@ export class ParserContextImplementation<Sequence, Element> implements ParserCon
 			}, value, format, ...formatArguments);
 		}
 
-		invariant(false, 'Unsupported errorJoinMode: %s', errorJoinMode);
+		return parserImplementationInvariant(false, 'Unsupported errorJoinMode: %s', errorJoinMode);
 	}
 }

package/src/parserCreatorCompose.ts

@@ -1,3 +1,4 @@
+import mem from 'mem';
 import { type Parser } from './parser.js';
 import { type DeriveSequenceElement } from './sequence.js';
 
@@ -11,13 +12,30 @@ export function parserCreatorCompose<
 	f1: (...arguments_: Arguments) => Parser<OutputA, Sequence, Element>,
 	f2: (outputA: OutputA) => Parser<OutputB, Sequence, Element>,
 ): (...arguments_: Arguments) => Parser<OutputB, Sequence, Element> {
-	return (...arguments_) => {
+	const parserCreatorComposedOuter: (...arguments_: Arguments) => Parser<OutputB, Sequence, Element> = (...arguments_) => {
 		const parserA = f1(...arguments_);
 
-		return async parserContext => {
+		const parserCreatorComposedInner: Parser<OutputB, Sequence, Element> = async parserContext => {
 			const outputA = await parserA(parserContext);
 			const parserB = f2(outputA);
 			return parserB(parserContext);
 		};
+
+		return parserCreatorComposedInner;
 	};
+
+	return parserCreatorComposedOuter;
+}
+
+export function parserCreatorComposeMem<
+	Arguments extends unknown[],
+	OutputA,
+	OutputB,
+	Sequence,
+	Element = DeriveSequenceElement<Sequence>,
+>(
+	f1: (...arguments_: Arguments) => Parser<OutputA, Sequence, Element>,
+	f2: (outputA: OutputA) => Parser<OutputB, Sequence, Element>,
+): (...arguments_: Arguments) => Parser<OutputB, Sequence, Element> {
+	return parserCreatorCompose(mem(f1), mem(f2));
 }