@thomasfosterau/effect-parse 0.5.0 → 0.6.0

package/src/internal/node.ts

@@ -197,13 +197,59 @@ export const describedNode = (p: ParserLike): Node | undefined =>
 /** The description of a parser: `Opaque` when it has none. */
 export const nodeOf = (p: ParserLike): Node => describedNode(p) ?? { _tag: "Opaque", step: p.step }
 
-/** Normalizes a range, as `repeat`, `takeWhile`, ... do. */
+/** How a rejected argument reads in an error: never the argument's own text. */
+const describeArgument = (u: unknown): string =>
+  Predicate.isNumber(u) || Predicate.isBigInt(u) || u === undefined || u === null
+    ? String(u)
+    : Predicate.isString(u)
+      ? "a string"
+      : "a value that is not a number"
+
+/**
+ * `count` as given, which must be a non-negative safe integer, else a
+ * `RangeError`. A count is a `number` only in the types, and each backend
+ * read a negative, fractional, `NaN` or non-number count its own way: the
+ * interpreter moved the cursor backwards, and the JIT wrote the value into
+ * the source it compiles.
+ */
+export const checkCount = (count: number, what: string = "count"): number => {
+  if (!Number.isSafeInteger(count) || count < 0)
+    throw new RangeError(`invalid ${what}: expected a non-negative integer, got ${describeArgument(count)}`)
+  return count
+}
+
+/**
+ * Normalizes a range, as `repeat`, `takeWhile`, ... do. Throws a
+ * `RangeError` unless both bounds are non-negative integers (`max` may be
+ * `Infinity`) with `min <= max` (see {@link checkCount}).
+ */
 export const bounds = (
   range: number | { readonly min?: number | undefined; readonly max?: number | undefined } | undefined
 ): Bounds => {
   if (range === undefined) return { min: 0, max: Infinity }
-  if (Predicate.isNumber(range)) return { min: range, max: range }
-  return { min: range.min ?? 0, max: range.max ?? Infinity }
+  if (!Predicate.isObject(range)) {
+    const count = checkCount(range)
+    return { min: count, max: count }
+  }
+  const min = checkCount(range.min ?? 0, "range: min")
+  const max = range.max ?? Infinity
+  if (max !== Infinity) checkCount(max, "range: max")
+  if (min > max) throw new RangeError(`invalid range: min (${min}) > max (${max})`)
+  return { min, max }
+}
+
+/**
+ * The code of a control character given as a one-character string or a
+ * code: a non-negative integer, else a `RangeError` (it is compared with
+ * input units, and the JIT writes it into the source it compiles).
+ */
+export const controlCode = (control: string | number, read: (s: string) => number): number => {
+  const code = Predicate.isString(control) ? read(control) : control
+  if (!Number.isSafeInteger(code) || code < 0)
+    throw new RangeError(
+      `invalid control character: expected a character or its code, got ${describeArgument(control)}`
+    )
+  return code
 }
 
 /**

package/src/internal/run.ts

@@ -33,10 +33,12 @@ export const runOn = <A>(
 
 /**
  * Runs a compiled step on `state`: directly when it guards against
- * call-stack overflows itself (the JIT's), else under `Stack.run`.
+ * call-stack overflows itself (the JIT's), else under `Stack.run`. While it
+ * runs, `state.compiledRun` is set, so the interpreted steps it calls skip
+ * building the failures it throws away (#82).
  */
 export const runCompiled = <A>(step: (state: State<any>) => A, guarded: boolean, state: State<any>): A | Fail =>
-  guarded ? step(state) : Stack.run(step, state)
+  Stack.runCompiled(step, guarded, state)
 
 /**
  * Runs the compiled step of `compiled` (or, if compiling failed, the

package/src/internal/stack.ts

@@ -40,6 +40,23 @@ export const run = <S extends State<any>, A>(step: (state: S) => A, state: S): A
   }
 }
 
+/**
+ * Runs a compiled step with `state.compiledRun` set, so that the
+ * interpreted steps it calls skip building the failures it throws away
+ * (#82): directly when the step guards against call-stack overflows itself
+ * (the JIT's), else under {@link run}. The flag is restored however the
+ * step ends, a throw included, since the state may be the caller's.
+ */
+export const runCompiled = <S extends State<any>, A>(step: (state: S) => A, guarded: boolean, state: S): A | Fail => {
+  const outer = state.compiledRun
+  state.compiledRun = true
+  try {
+    return guarded ? step(state) : run(step, state)
+  } finally {
+    state.compiledRun = outer
+  }
+}
+
 /**
  * Records the `TooDeep` failure of a call-stack overflow. The JIT's
  * generated entry catches overflows itself, with this, so that the runners

package/src/internal/tokens.ts

@@ -417,27 +417,37 @@ export const countTokens = (state: State<Input>, start: number, end: number): nu
 /**
  * The first index at or after `from` of any of `needles` within
  * `[from, state.end)`, or -1. The state remembers, under `needles`, where
- * each one next occurs (`[from, at]` at `2 * i`), so successive searches
- * forwards over one input search each needle once per occurrence rather
- * than once per call (as `nextStop` does for `takeTill`).
+ * each one next occurs (`[from, at, end]` at `3 * i`), so successive
+ * searches forwards over one input search each needle once per occurrence
+ * rather than once per call (as `nextStop` does for `takeTill`).
+ *
+ * A remembered answer is used only where it still holds: an occurrence, when
+ * the search starts between where it was searched from and where it was
+ * found, and it still fits before the end; "not found", when the search
+ * starts no earlier and the end is no further than the end that search ran
+ * to (a parser may narrow `state.end` for a while, and `reset` widens it
+ * again, so a miss within a narrower end says nothing about a wider one).
  */
 export const indexOfAny = (state: State<Input>, needles: ReadonlyArray<Input>, from: number): number => {
   const searches = (state.searches ??= new Map())
   let memo = searches.get(needles)
   if (memo === undefined) {
-    memo = needles.flatMap(() => [-1, -1])
+    memo = needles.flatMap(() => [-1, -1, -1])
     searches.set(needles, memo)
   }
   let best = -1
   for (let i = 0; i < needles.length; i++) {
-    const known = memo[2 * i] ?? -1
-    let at = memo[2 * i + 1] ?? -1
+    const known = memo[3 * i] ?? -1
+    let at = memo[3 * i + 1] ?? -1
+    const searchedTo = memo[3 * i + 2] ?? -1
     const needle = needles[i] ?? ""
-    // Searched again when the input's end moved before a remembered occurrence
-    if (known < 0 || from < known || (at >= 0 && (at < from || at > state.end - needle.length))) {
+    const stale =
+      known < 0 || from < known || (at >= 0 ? at < from || at > state.end - needle.length : state.end > searchedTo)
+    if (stale) {
       at = indexOf(state, needle, from)
-      memo[2 * i] = from
-      memo[2 * i + 1] = at
+      memo[3 * i] = from
+      memo[3 * i + 1] = at
+      memo[3 * i + 2] = state.end
     }
     if (at >= 0 && (best < 0 || at < best)) best = at
   }

package/src/internal/tuple.ts

@@ -0,0 +1,141 @@
+/**
+ * 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).
+ */
+import { Fail } from "../Input.js"
+import type { State } from "../Input.js"
+
+type Step = (state: State<any>) => unknown
+
+/** 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}. */
+export const tupleStep = (steps: ReadonlyArray<Step>): ((state: State<any>) => Array<unknown> | Fail) => {
+  const n = steps.length
+  if (n <= maxLiteral) return literals[n](steps)
+  return (state) => {
+    const out = new Array<unknown>(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: ReadonlyArray<(steps: ReadonlyArray<Step>) => (state: State<any>) => Array<unknown> | Fail> = [
+  () => () => [],
+  ([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]
+    }
+]