@thomasfosterau/effect-parse 0.5.0 → 0.6.0

package/dist/Parser.js

@@ -2,6 +2,7 @@ import * as Predicate from "effect/Predicate";
 import * as Result from "effect/Result";
 import { Fail, Failure, State, mergeExpected, mergeFailures, mergeTiedFailures } from "./Input.js";
 import { Key } from "./internal/key.js";
+import { Defer as Defer$1, NodeId, bounds, describedNode } from "./internal/node.js";
 import * as Resume from "./internal/resume.js";
 import * as Registry from "./internal/compiler/registry.js";
 import * as Run from "./internal/run.js";
@@ -17,7 +18,7 @@ import { pipeArguments } from "effect/Pipeable";
 import * as ParseError from "./ParseError.js";
 import * as Entries from "./internal/entries.js";
 import * as Stack from "./internal/stack.js";
-import { Defer as Defer$1, NodeId, bounds, describedNode } from "./internal/node.js";
+import { tupleStep } from "./internal/tuple.js";
 // src/Parser.ts
 /**
 * The `Parser` data type and its general-purpose combinators.
@@ -1282,17 +1283,8 @@ const allConsuming = (self) => terminated(self, eof);
 * @category sequencing
 */
 const seq = (...parsers) => {
-	const steps = parsers.map((p) => p.step);
-	const n = steps.length;
-	return described((state) => {
-		const out = new Array(n);
-		for (let i = 0; i < n; i++) {
-			const a = steps[i](state);
-			if (a === Fail) return Fail;
-			out[i] = a;
-		}
-		return out;
-	}, "seq", {
+	const step = tupleStep(parsers.map((p) => p.step));
+	return described(step, "seq", {
 		_tag: "Seq",
 		parsers,
 		output: "tuple"
@@ -1735,11 +1727,7 @@ const permutation = (...parsers) => {
 	}, "permutation");
 };
 const normalizeRange = (range) => {
-	if (range === void 0) return [0, Infinity];
-	if (Predicate.isNumber(range)) return [range, range];
-	const min = range.min ?? 0;
-	const max = range.max ?? Infinity;
-	if (min > max) throw new RangeError(`invalid range: min (${min}) > max (${max})`);
+	const { max, min } = bounds(range);
 	return [min, max];
 };
 const assertConsumes = (state, name) => state.failMessage("Cut", "Assert", `\`${name}\` parsers must always consume`);
@@ -1751,7 +1739,6 @@ const saveFold = (state, key, entry, acc, pos) => Resume.save(state, key, entry,
 const foldImpl = (self, range, init, f, name, node, cond) => {
 	const [min, max] = normalizeRange(range);
 	const step = self.step;
-	const checkLoop = max === Infinity;
 	const key = new Key();
 	return described((state) => {
 		const entry = state.pos;
@@ -1781,7 +1768,7 @@ const foldImpl = (self, range, init, f, name, node, cond) => {
 				recover(state, start);
 				return Resume.done(state, key, entry, resumed !== void 0, acc);
 			}
-			if (checkLoop && state.pos === start) return assertConsumes(state, name);
+			if (state.pos === start) return assertConsumes(state, name);
 			acc = f(acc, a);
 		}
 		return Resume.done(state, key, entry, resumed !== void 0, acc);
@@ -1803,9 +1790,9 @@ const foldImpl = (self, range, init, f, name, node, cond) => {
 * exactly that many times. With a literal positive `min`, the output is
 * typed as a non-empty array.
 *
-* As in winnow, an unbounded repetition of a parser that succeeds without
-* consuming input fails with an unrecoverable assertion instead of looping
-* forever.
+* A parser that succeeds without consuming input fails the repetition with
+* an unrecoverable `Assert` failure, whatever the range (winnow checks only
+* unbounded ones): a bound can come from the input (`Binary.lengthRepeat`).
 *
 * @example
 * ```ts
@@ -1913,7 +1900,6 @@ const separated = /*#__PURE__*/ dual(isTwoParserArgs, (self, separator, range) =
 	const [min, max] = normalizeRange(range);
 	const step = self.step;
 	const sepStep = separator.step;
-	const checkLoop = max === Infinity;
 	const key = new Key();
 	return described((state) => {
 		const entry = state.pos;
@@ -1949,7 +1935,7 @@ const separated = /*#__PURE__*/ dual(isTwoParserArgs, (self, separator, range) =
 				recover(state, start);
 				return Resume.done(state, key, entry, resumed !== void 0, acc);
 			}
-			if (checkLoop && state.pos === start) return assertConsumes(state, "separated");
+			if (state.pos === start) return assertConsumes(state, "separated");
 			const a = step(state);
 			if (a === Fail) {
 				if (state.mode === "Incomplete" && state.resume !== void 0) Resume.save(state, key, entry, {