@thomasfosterau/effect-parse 0.5.0 → 0.6.0

package/dist/internal/tuple.js

@@ -0,0 +1,170 @@
+import { Fail } from "../Input.js";
+// src/internal/tuple.ts
+/**
+* Tuple steps: run steps in sequence and collect their outputs in an array.
+*
+* V8 pretenures by allocation site, and only array and object literals have
+* one: an array from `new Array(n)` starts young, so tuples that a parse keeps
+* (a `repeat(seq(...))`, a tree) are copied by a scavenge or two before they
+* are promoted. A literal's site learns that its arrays survive, and V8 then
+* allocates them straight into the old generation. So arities up to
+* {@link maxLiteral} build their tuple with a literal of that arity, each its
+* own site; longer tuples fall back to `new Array(n)` (#86).
+*/
+/** The longest tuple built with a literal. */
+const maxLiteral = 8;
+/** A step that runs `steps` in order and returns their outputs as an array, or {@link Fail}. */
+const tupleStep = (steps) => {
+	const n = steps.length;
+	if (n <= maxLiteral) return literals[n](steps);
+	return (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;
+	};
+};
+const literals = [
+	() => () => [],
+	([s0]) => (state) => {
+		const a0 = s0(state);
+		if (a0 === Fail) return Fail;
+		return [a0];
+	},
+	([s0, s1]) => (state) => {
+		const a0 = s0(state);
+		if (a0 === Fail) return Fail;
+		const a1 = s1(state);
+		if (a1 === Fail) return Fail;
+		return [a0, a1];
+	},
+	([s0, s1, s2]) => (state) => {
+		const a0 = s0(state);
+		if (a0 === Fail) return Fail;
+		const a1 = s1(state);
+		if (a1 === Fail) return Fail;
+		const a2 = s2(state);
+		if (a2 === Fail) return Fail;
+		return [
+			a0,
+			a1,
+			a2
+		];
+	},
+	([s0, s1, s2, s3]) => (state) => {
+		const a0 = s0(state);
+		if (a0 === Fail) return Fail;
+		const a1 = s1(state);
+		if (a1 === Fail) return Fail;
+		const a2 = s2(state);
+		if (a2 === Fail) return Fail;
+		const a3 = s3(state);
+		if (a3 === Fail) return Fail;
+		return [
+			a0,
+			a1,
+			a2,
+			a3
+		];
+	},
+	([s0, s1, s2, s3, s4]) => (state) => {
+		const a0 = s0(state);
+		if (a0 === Fail) return Fail;
+		const a1 = s1(state);
+		if (a1 === Fail) return Fail;
+		const a2 = s2(state);
+		if (a2 === Fail) return Fail;
+		const a3 = s3(state);
+		if (a3 === Fail) return Fail;
+		const a4 = s4(state);
+		if (a4 === Fail) return Fail;
+		return [
+			a0,
+			a1,
+			a2,
+			a3,
+			a4
+		];
+	},
+	([s0, s1, s2, s3, s4, s5]) => (state) => {
+		const a0 = s0(state);
+		if (a0 === Fail) return Fail;
+		const a1 = s1(state);
+		if (a1 === Fail) return Fail;
+		const a2 = s2(state);
+		if (a2 === Fail) return Fail;
+		const a3 = s3(state);
+		if (a3 === Fail) return Fail;
+		const a4 = s4(state);
+		if (a4 === Fail) return Fail;
+		const a5 = s5(state);
+		if (a5 === Fail) return Fail;
+		return [
+			a0,
+			a1,
+			a2,
+			a3,
+			a4,
+			a5
+		];
+	},
+	([s0, s1, s2, s3, s4, s5, s6]) => (state) => {
+		const a0 = s0(state);
+		if (a0 === Fail) return Fail;
+		const a1 = s1(state);
+		if (a1 === Fail) return Fail;
+		const a2 = s2(state);
+		if (a2 === Fail) return Fail;
+		const a3 = s3(state);
+		if (a3 === Fail) return Fail;
+		const a4 = s4(state);
+		if (a4 === Fail) return Fail;
+		const a5 = s5(state);
+		if (a5 === Fail) return Fail;
+		const a6 = s6(state);
+		if (a6 === Fail) return Fail;
+		return [
+			a0,
+			a1,
+			a2,
+			a3,
+			a4,
+			a5,
+			a6
+		];
+	},
+	([s0, s1, s2, s3, s4, s5, s6, s7]) => (state) => {
+		const a0 = s0(state);
+		if (a0 === Fail) return Fail;
+		const a1 = s1(state);
+		if (a1 === Fail) return Fail;
+		const a2 = s2(state);
+		if (a2 === Fail) return Fail;
+		const a3 = s3(state);
+		if (a3 === Fail) return Fail;
+		const a4 = s4(state);
+		if (a4 === Fail) return Fail;
+		const a5 = s5(state);
+		if (a5 === Fail) return Fail;
+		const a6 = s6(state);
+		if (a6 === Fail) return Fail;
+		const a7 = s7(state);
+		if (a7 === Fail) return Fail;
+		return [
+			a0,
+			a1,
+			a2,
+			a3,
+			a4,
+			a5,
+			a6,
+			a7
+		];
+	}
+];
+export { tupleStep };
+
+//# sourceMappingURL=tuple.js.map

package/dist/internal/tuple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple.js","names":[],"sources":["../../src/internal/tuple.ts"],"sourcesContent":["/**\n * Tuple steps: run steps in sequence and collect their outputs in an array.\n *\n * V8 pretenures by allocation site, and only array and object literals have\n * one: an array from `new Array(n)` starts young, so tuples that a parse keeps\n * (a `repeat(seq(...))`, a tree) are copied by a scavenge or two before they\n * are promoted. A literal's site learns that its arrays survive, and V8 then\n * allocates them straight into the old generation. So arities up to\n * {@link maxLiteral} build their tuple with a literal of that arity, each its\n * own site; longer tuples fall back to `new Array(n)` (#86).\n */\nimport { Fail } from \"../Input.js\"\nimport type { State } from \"../Input.js\"\n\ntype Step = (state: State<any>) => unknown\n\n/** The longest tuple built with a literal. */\nconst maxLiteral = 8\n\n/** A step that runs `steps` in order and returns their outputs as an array, or {@link Fail}. */\nexport const tupleStep = (steps: ReadonlyArray<Step>): ((state: State<any>) => Array<unknown> | Fail) => {\n  const n = steps.length\n  if (n <= maxLiteral) return literals[n](steps)\n  return (state) => {\n    const out = new Array<unknown>(n)\n    for (let i = 0; i < n; i++) {\n      const a = steps[i](state)\n      if (a === Fail) return Fail\n      out[i] = a\n    }\n    return out\n  }\n}\n\nconst literals: ReadonlyArray<(steps: ReadonlyArray<Step>) => (state: State<any>) => Array<unknown> | Fail> = [\n  () => () => [],\n  ([s0]) =>\n    (state) => {\n      const a0 = s0(state)\n      if (a0 === Fail) return Fail\n      return [a0]\n    },\n  ([s0, s1]) =>\n    (state) => {\n      const a0 = s0(state)\n      if (a0 === Fail) return Fail\n      const a1 = s1(state)\n      if (a1 === Fail) return Fail\n      return [a0, a1]\n    },\n  ([s0, s1, s2]) =>\n    (state) => {\n      const a0 = s0(state)\n      if (a0 === Fail) return Fail\n      const a1 = s1(state)\n      if (a1 === Fail) return Fail\n      const a2 = s2(state)\n      if (a2 === Fail) return Fail\n      return [a0, a1, a2]\n    },\n  ([s0, s1, s2, s3]) =>\n    (state) => {\n      const a0 = s0(state)\n      if (a0 === Fail) return Fail\n      const a1 = s1(state)\n      if (a1 === Fail) return Fail\n      const a2 = s2(state)\n      if (a2 === Fail) return Fail\n      const a3 = s3(state)\n      if (a3 === Fail) return Fail\n      return [a0, a1, a2, a3]\n    },\n  ([s0, s1, s2, s3, s4]) =>\n    (state) => {\n      const a0 = s0(state)\n      if (a0 === Fail) return Fail\n      const a1 = s1(state)\n      if (a1 === Fail) return Fail\n      const a2 = s2(state)\n      if (a2 === Fail) return Fail\n      const a3 = s3(state)\n      if (a3 === Fail) return Fail\n      const a4 = s4(state)\n      if (a4 === Fail) return Fail\n      return [a0, a1, a2, a3, a4]\n    },\n  ([s0, s1, s2, s3, s4, s5]) =>\n    (state) => {\n      const a0 = s0(state)\n      if (a0 === Fail) return Fail\n      const a1 = s1(state)\n      if (a1 === Fail) return Fail\n      const a2 = s2(state)\n      if (a2 === Fail) return Fail\n      const a3 = s3(state)\n      if (a3 === Fail) return Fail\n      const a4 = s4(state)\n      if (a4 === Fail) return Fail\n      const a5 = s5(state)\n      if (a5 === Fail) return Fail\n      return [a0, a1, a2, a3, a4, a5]\n    },\n  ([s0, s1, s2, s3, s4, s5, s6]) =>\n    (state) => {\n      const a0 = s0(state)\n      if (a0 === Fail) return Fail\n      const a1 = s1(state)\n      if (a1 === Fail) return Fail\n      const a2 = s2(state)\n      if (a2 === Fail) return Fail\n      const a3 = s3(state)\n      if (a3 === Fail) return Fail\n      const a4 = s4(state)\n      if (a4 === Fail) return Fail\n      const a5 = s5(state)\n      if (a5 === Fail) return Fail\n      const a6 = s6(state)\n      if (a6 === Fail) return Fail\n      return [a0, a1, a2, a3, a4, a5, a6]\n    },\n  ([s0, s1, s2, s3, s4, s5, s6, s7]) =>\n    (state) => {\n      const a0 = s0(state)\n      if (a0 === Fail) return Fail\n      const a1 = s1(state)\n      if (a1 === Fail) return Fail\n      const a2 = s2(state)\n      if (a2 === Fail) return Fail\n      const a3 = s3(state)\n      if (a3 === Fail) return Fail\n      const a4 = s4(state)\n      if (a4 === Fail) return Fail\n      const a5 = s5(state)\n      if (a5 === Fail) return Fail\n      const a6 = s6(state)\n      if (a6 === Fail) return Fail\n      const a7 = s7(state)\n      if (a7 === Fail) return Fail\n      return [a0, a1, a2, a3, a4, a5, a6, a7]\n    }\n]\n"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://www.schemastore.org/package",
   "name": "@thomasfosterau/effect-parse",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Parser combinators for Effect, ported from Rust's nom and winnow: text, bytes, bits and token streams, streaming input, compiled parsers and Schema integration",
   "keywords": [
     "effect",
@@ -24,7 +24,8 @@
   "files": [
     "dist",
     "src",
-    "!dist/**/*.tsbuildinfo"
+    "!dist/**/*.tsbuildinfo",
+    "CHANGELOG.md"
   ],
   "type": "module",
   "sideEffects": false,
@@ -102,19 +103,25 @@
     "@changesets/changelog-github": "^1.0.1",
     "@changesets/cli": "^3.0.3",
     "@effect/language-service": "^0.87.5",
-    "@effect/platform-node-shared": "4.1.1",
-    "@effect/tsgo": "0.63.0",
+    "@effect/platform-node-shared": "4.1.4",
+    "@effect/tsgo": "0.67.7",
     "@enfect/oxlint": "^0.10.0",
+    "@thomasfosterau/effect-bib": "0.1.0",
+    "@thomasfosterau/effect-ext": "0.2.0",
+    "@thomasfosterau/effect-ical": "0.1.0",
+    "@thomasfosterau/effect-parse": "0.6.0",
+    "@thomasfosterau/effect-rdf": "0.2.0",
+    "@thomasfosterau/effect-xml": "0.1.0",
     "@types/node": "^26.6.5",
     "@typescript/native": "npm:typescript@7.0.2",
-    "@vitest/coverage-istanbul": "5.0.5",
-    "effect": "4.1.1",
-    "fallow": "3.40.0",
+    "@vitest/coverage-istanbul": "5.1.0",
+    "effect": "4.1.4",
+    "fallow": "3.42.0",
     "rolldown": "^1.2.14",
     "typescript": "npm:@typescript/typescript6@6.0.2",
-    "vite": "npm:@voidzero-dev/vite-plus-core@1.4.0",
-    "vite-plus": "1.4.0",
-    "vitest": "5.0.5"
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.6.0",
+    "vite-plus": "1.6.0",
+    "vitest": "5.1.0"
   },
   "peerDependencies": {
     "effect": "^4.0.0"

package/src/Ascii.ts

@@ -31,6 +31,7 @@ import type { Parser } from "./Parser.js"
 import * as P from "./Parser.js"
 import * as numbers from "./internal/numbers.js"
 import { Key } from "./internal/key.js"
+import { controlCode } from "./internal/node.js"
 import * as Resume from "./internal/resume.js"
 import { codePointPredicate } from "./internal/tokens.js"
 import { literalImpl, range, takeWhileImpl } from "./Token.js"
@@ -533,7 +534,8 @@ export const caseless: CaselessFn = (lit: string | Uint8Array): any => literalIm
 // Escapes
 // -----------------------------------------------------------------------------
 
-const controlCode = (c: string | number): number => (Predicate.isNumber(c) ? c : c.charCodeAt(0))
+/** The first UTF-16 unit of a control character: what `atControl` compares with a string's units. */
+const firstUnit = (s: string): number => s.charCodeAt(0)
 
 const atControl = (state: State<Input>, control: number): boolean => {
   if (state.pos >= state.end) return false
@@ -567,7 +569,7 @@ export const takeEscaped = <A, E, R, I extends Input, B, E2, R2, I2 extends Inpu
   control: string | number,
   escapable: Parser<B, E2, R2, I2>
 ): Parser<Slice<I & I2>, E | E2, R | R2, I & I2> => {
-  const ctrl = controlCode(control)
+  const ctrl = controlCode(control, firstUnit)
   return takeEscapedImpl(
     normal,
     (state) => {
@@ -684,7 +686,7 @@ export const escaped = <E, R, I extends Input, E2, R2, I2 extends Input>(
   control: string | number,
   escape: Parser<string, E2, R2, I2>
 ): Parser<string, E | E2, R | R2, I & I2> => {
-  const ctrl = controlCode(control)
+  const ctrl = controlCode(control, firstUnit)
   return escapedImpl(
     normal,
     (state) => {

package/src/Binary.ts

@@ -334,6 +334,18 @@ export const f64: (endian: Endianness) => Parser<number, never, never, Uint8Arra
   leF64
 )
 
+const MaxCount = /*#__PURE__*/ BigInt(Number.MAX_SAFE_INTEGER)
+
+/**
+ * Whether a length read from the input is a count: a non-negative integer
+ * of at most `Number.MAX_SAFE_INTEGER`. A signed, fractional or `NaN`
+ * length is the input's to choose, so it fails the parse where it was read
+ * (as `Parser.filter` does) and never reaches `Token.take` or
+ * `Parser.repeat`, which throw on one.
+ */
+const isCount = (n: number | bigint): boolean =>
+  Predicate.isBigInt(n) ? n >= 0n && n <= MaxCount : Number.isSafeInteger(n) && n >= 0
+
 const toCount = (n: number | bigint): number => (Predicate.isBigInt(n) ? Number(n) : n)
 
 /** How many counts {@link byCount} keeps the parsers of. */
@@ -359,7 +371,9 @@ const byCount = <A>(build: (n: number) => A): ((n: number | bigint) => A) => {
 
 /**
  * Parses a length with `count`, then takes that many tokens (winnow's
- * `length_take`, nom's `length_data`).
+ * `length_take`, nom's `length_data`). A length that is not a non-negative
+ * integer (a negative `i8`, a fractional float) fails the parse at the
+ * length.
  *
  * @since 0.1.0
  * @category length-prefixed
@@ -373,9 +387,15 @@ export const lengthTake = <E, R, I extends Input = Uint8Array>(
     [count],
     ([countStep]) =>
       (state: State<I>) => {
+        const start = state.pos
         // SAFETY: the count parser's step, interpreted or compiled, returns its output (a number or bigint) or `Fail`
         const n = countStep(state) as number | bigint | Fail
         if (n === Fail) return Fail
+        // As `Parser.filter` fails: at the length, backtracking
+        if (!isCount(n)) {
+          state.rewind(start)
+          return state.backtrack("Verify")
+        }
         return take(n)(state)
       },
     "lengthTake"
@@ -384,7 +404,8 @@ export const lengthTake = <E, R, I extends Input = Uint8Array>(
 
 /**
  * Parses a length with `count`, then applies `parser` that many times
- * (winnow's `length_repeat`, nom's `length_count`).
+ * (winnow's `length_repeat`, nom's `length_count`). A length that is not a
+ * non-negative integer fails the parse at the length.
  *
  * @since 0.1.0
  * @category length-prefixed
@@ -394,7 +415,7 @@ export const lengthRepeat = <E, R, I extends Input, A, E2, R2, I2 extends Input>
   parser: Parser<A, E2, R2, I2>
 ): Parser<Array<A>, E | E2, R | R2, I & I2> =>
   P.flatMap(
-    count,
+    P.filter(count, isCount),
     byCount((n) => P.repeat(parser, n))
   )
 

package/src/Bits.ts

@@ -24,6 +24,7 @@ import type { State } from "./Input.js"
 import { Fail, Failure } from "./Input.js"
 import type { Parser } from "./Parser.js"
 import { make } from "./Parser.js"
+import { checkCount } from "./internal/node.js"
 
 declare const BitInputBrand: unique symbol
 
@@ -136,6 +137,7 @@ const readBits = (state: State<any>, count: number): number => {
  * @category parsers
  */
 export const take = (count: number): Parser<number, never, never, BitInput> => {
+  checkCount(count)
   if (count > 53) throw new RangeError("Bits.take: use Bits.takeBig for more than 53 bits")
   const expected = [`${count} bits`]
   return make((state: State<any>) => {
@@ -152,6 +154,7 @@ export const take = (count: number): Parser<number, never, never, BitInput> => {
  * @category parsers
  */
 export const takeBig = (count: number): Parser<bigint, never, never, BitInput> => {
+  checkCount(count)
   const expected = [`${count} bits`]
   return make((state: State<any>) => {
     const avail = state.end - state.pos
@@ -175,6 +178,7 @@ export const takeBig = (count: number): Parser<bigint, never, never, BitInput> =
  * @category parsers
  */
 export const pattern = (pattern: number, count: number): Parser<number, never, never, BitInput> => {
+  checkCount(count)
   const expected = [`bit pattern ${pattern.toString(2).padStart(count, "0")}`]
   return make((state: State<any>) => {
     const start = state.pos

package/src/Input.ts

@@ -276,6 +276,18 @@ export class State<I extends Input = Input> {
     this.deepestIsLatest = false
     this.deepestFailure = failure
   }
+  /**
+   * Whether compiled code is running on this state. A compiled run that fails
+   * is thrown away (the interpreter runs again to build the error) and one
+   * that succeeds records no diagnostics, so interpreted steps called from it
+   * (an opaque `Parser.make`, a leaf near the end of a partial input) record
+   * a `Backtrack` or `Cut` failure's mode only, without building its
+   * {@link Failure} (#82). `Incomplete` failures are still built: a compiled
+   * run's `Incomplete` is reported as it stands.
+   *
+   * @internal
+   */
+  compiledRun = false
   /** When defined, `Parser.resumeAfter`/`retryAfter` record failures here. */
   recovered: Array<Failure> | undefined = undefined
   /** When defined, `Parser.trace` reports events here. */
@@ -304,8 +316,10 @@ export class State<I extends Input = Input> {
   /**
    * Where the stop characters of compiled `takeTill`s next occur in this
    * state's input, by search site; created on first use. It lives as long
-   * as the state (whose input never changes), and `reset` clears it with
-   * the other per-run fields.
+   * as the state. `reset` keeps it for string input (a string never
+   * changes, and the positions are absolute, so they hold wherever the next
+   * run starts) and drops it for bytes and arrays, which a caller may
+   * refill in place between runs.
    *
    * @internal
    */
@@ -383,7 +397,11 @@ export class State<I extends Input = Input> {
    *
    * Every per-run field is reset: the cursor and end, the latest failure,
    * hints and furthest failure, recorded recoveries, the tracer and tracing
-   * depth, the recorded encoding and streaming checkpoints. Like the
+   * depth, the recorded encoding and streaming checkpoints. For string
+   * input, what the state has learnt about the string (where the stop
+   * characters of `takeTill` and the literals of `takeUntilAny` occur) is
+   * kept, as a string cannot change; for bytes and arrays it is dropped, so
+   * a buffer refilled in place between runs is searched afresh. Like the
    * constructor, `partial` defaults to `false` and `context` to the empty
    * context, so pass them again on every reset.
    *
@@ -422,12 +440,19 @@ export class State<I extends Input = Input> {
     this.hintExpected = empty
     this.deepestFailure = undefined
     this.deepestIsLatest = false
+    this.compiledRun = false
     this.recovered = undefined
     this.tracer = undefined
     this.depth = 0
     this.encoding = undefined
     this.resume = undefined
-    this.searches = undefined
+    // For a string, `searches` is kept: it remembers where stop characters
+    // and literals occur by absolute position, and a string never changes,
+    // so it holds at any offset. A lexer that resets before each token
+    // otherwise searched to the end of the buffer again for every token
+    // (#126). Bytes and arrays can be refilled in place between runs (a
+    // `Uint8Array` source is viewed, not copied), so theirs is dropped.
+    if (this.inputKind !== 0) this.searches = undefined
     this.asciiRun = undefined
     return this
   }
@@ -503,6 +528,10 @@ export class State<I extends Input = Input> {
    * Records a recoverable failure at the current offset and returns {@link Fail}.
    */
   backtrack(kind: ErrorKind, expected: ReadonlyArray<string> = empty, offset: number = this.pos): Fail {
+    if (this.compiledRun) {
+      this.mode = "Backtrack"
+      return Fail
+    }
     return this.failWith("Backtrack", this.makeFailure(offset, kind, expected))
   }
 
@@ -510,6 +539,10 @@ export class State<I extends Input = Input> {
    * Records an unrecoverable failure at the current offset and returns {@link Fail}.
    */
   cut(kind: ErrorKind, expected: ReadonlyArray<string> = empty, offset: number = this.pos): Fail {
+    if (this.compiledRun) {
+      this.mode = "Cut"
+      return Fail
+    }
     return this.failWith("Cut", this.makeFailure(offset, kind, expected))
   }