@thomasfosterau/effect-parse 0.4.1 → 0.5.0

package/src/Expression.ts

@@ -38,7 +38,10 @@ import * as Predicate from "effect/Predicate"
 import type { Input, State } from "./Input.js"
 import { Fail } from "./Input.js"
 import type { Parser } from "./Parser.js"
-import { make as makeParser } from "./Parser.js"
+import { combinator } from "./Parser.js"
+
+/** A parser's step, interpreted or compiled. */
+type Step = (state: State<any>) => unknown
 import { TiedFailures } from "./internal/ties.js"
 
 /**
@@ -154,101 +157,111 @@ export const make = <A, E, R, I extends Input, const Ops extends ReadonlyArray<O
   readonly operand: Parser<A, E, R, I>
   readonly operators: Ops
 }): Parser<A, E | OpError<Ops[number]>, R | OpServices<Ops[number]>, I & OpInput<Ops[number]>> => {
-  const operand = options.operand.step
   const prefixes = options.operators.filter((o): o is Prefix<A, any, any, any> => Predicate.isTagged(o, "Prefix"))
   const postfixes = options.operators.filter((o): o is Postfix<A, any, any, any> => Predicate.isTagged(o, "Postfix"))
   const infixes = options.operators.filter((o): o is Infix<A, any, any, any> => Predicate.isTagged(o, "Infix"))
+  const operators = [...prefixes, ...postfixes, ...infixes]
+  const parsers = [options.operand, ...operators.map((o) => o.parser)]
+  // Builds the step from the operand's and the operators' steps, in that
+  // order: their own steps when interpreted, compiled ones when compiled
+  const build = (steps: ReadonlyArray<Step>) => {
+    const operand = steps[0]
+    const prefixSteps = steps.slice(1, 1 + prefixes.length)
+    const postfixSteps = steps.slice(1 + prefixes.length, 1 + prefixes.length + postfixes.length)
+    const infixSteps = steps.slice(1 + prefixes.length + postfixes.length)
 
-  // Attempts each operator in turn. Returns the index of the first match
-  // (with its output in `matched`), -1 if none matched, or -2 on a fatal
-  // failure. Failed attempts are folded into `failures`, merged only when
-  // read (#44): a round in which an operator matches discards them unmerged.
-  // Like `matched`, it is shared by nested expressions, which clear it.
-  let matched: unknown
-  const failures = new TiedFailures()
-  const tryOps = (state: State<any>, ops: ReadonlyArray<OperatorBase<any, any, any>>, mustConsume: boolean): number => {
-    const start = state.pos
-    for (let i = 0; i < ops.length; i++) {
-      const out = ops[i].parser.step(state)
-      if (out !== Fail) {
-        // A prefix or postfix operator matching nothing would apply forever
-        if (mustConsume && state.pos === start) {
-          state.failMessage("Cut", "Assert", "prefix and postfix operators must always consume")
-          return -2
+    // Attempts each operator in turn. Returns the index of the first match
+    // (with its output in `matched`), -1 if none matched, or -2 on a fatal
+    // failure. Failed attempts are folded into `failures`, merged only when
+    // read (#44): a round in which an operator matches discards them unmerged.
+    // Like `matched`, it is shared by nested expressions, which clear it.
+    let matched: unknown
+    const failures = new TiedFailures()
+    const tryOps = (state: State<any>, ops: ReadonlyArray<Step>, mustConsume: boolean): number => {
+      const start = state.pos
+      for (let i = 0; i < ops.length; i++) {
+        const out = ops[i](state)
+        if (out !== Fail) {
+          // A prefix or postfix operator matching nothing would apply forever
+          if (mustConsume && state.pos === start) {
+            state.failMessage("Cut", "Assert", "prefix and postfix operators must always consume")
+            return -2
+          }
+          matched = out
+          return i
         }
-        matched = out
-        return i
+        if (state.mode !== "Backtrack") return -2
+        state.rewind(start)
+        failures.add(state)
       }
-      if (state.mode !== "Backtrack") return -2
-      state.rewind(start)
-      failures.add(state)
+      return -1
     }
-    return -1
-  }
 
-  const expr = (state: State<any>, minPower: number): A | Fail => {
-    let lhs: A | Fail
-    failures.clear()
-    const p = tryOps(state, prefixes, true)
-    if (p === -2) return Fail
-    if (p >= 0) {
-      const op = prefixes[p]
-      const opOut = matched
-      const operandValue = expr(state, op.precedence * 2)
-      if (operandValue === Fail) return Fail
-      lhs = op.fold(opOut, operandValue)
-    } else {
-      const prefixFailure = failures.failure
-      const prefixTie1 = failures.tie1
-      const prefixTie2 = failures.tie2
-      lhs = operand(state)
-      if (lhs === Fail) {
-        if (prefixFailure !== undefined && state.mode === "Backtrack") {
-          // The operand may have parsed nested expressions, which reuse `failures`
-          failures.failure = prefixFailure
-          failures.tie1 = prefixTie1
-          failures.tie2 = prefixTie2
-          failures.add(state)
-          failures.fail(state)
+    const expr = (state: State<any>, minPower: number): A | Fail => {
+      let lhs: A | Fail
+      failures.clear()
+      const p = tryOps(state, prefixSteps, true)
+      if (p === -2) return Fail
+      if (p >= 0) {
+        const op = prefixes[p]
+        const opOut = matched
+        const operandValue = expr(state, op.precedence * 2)
+        if (operandValue === Fail) return Fail
+        lhs = op.fold(opOut, operandValue)
+      } else {
+        const prefixFailure = failures.failure
+        const prefixTie1 = failures.tie1
+        const prefixTie2 = failures.tie2
+        // SAFETY: the operand's step, interpreted or compiled, returns its output (an `A`) or `Fail`
+        lhs = operand(state) as A | Fail
+        if (lhs === Fail) {
+          if (prefixFailure !== undefined && state.mode === "Backtrack") {
+            // The operand may have parsed nested expressions, which reuse `failures`
+            failures.failure = prefixFailure
+            failures.tie1 = prefixTie1
+            failures.tie2 = prefixTie2
+            failures.add(state)
+            failures.fail(state)
+          }
+          return Fail
         }
-        return Fail
       }
-    }
 
-    while (true) {
-      const start = state.pos
-      failures.clear()
-      const q = tryOps(state, postfixes, true)
-      if (q === -2) return Fail
-      if (q >= 0) {
-        const op = postfixes[q]
-        if (op.precedence * 2 < minPower) {
+      while (true) {
+        const start = state.pos
+        failures.clear()
+        const q = tryOps(state, postfixSteps, true)
+        if (q === -2) return Fail
+        if (q >= 0) {
+          const op = postfixes[q]
+          if (op.precedence * 2 < minPower) {
+            state.rewind(start)
+            break
+          }
+          lhs = op.fold(lhs, matched)
+          continue
+        }
+        // The infix attempts are folded on top of the postfix ones
+        const i = tryOps(state, infixSteps, false)
+        if (i === -2) return Fail
+        if (i < 0) {
+          failures.hint(state)
+          break
+        }
+        const op = infixes[i]
+        const leftPower = op.precedence * 2
+        if (leftPower < minPower) {
           state.rewind(start)
           break
         }
-        lhs = op.fold(lhs, matched)
-        continue
-      }
-      // The infix attempts are folded on top of the postfix ones
-      const i = tryOps(state, infixes, false)
-      if (i === -2) return Fail
-      if (i < 0) {
-        failures.hint(state)
-        break
+        const opOut = matched
+        const rhs = expr(state, op.associativity === "left" ? leftPower + 1 : leftPower)
+        if (rhs === Fail) return Fail
+        lhs = op.fold(lhs, opOut, rhs)
       }
-      const op = infixes[i]
-      const leftPower = op.precedence * 2
-      if (leftPower < minPower) {
-        state.rewind(start)
-        break
-      }
-      const opOut = matched
-      const rhs = expr(state, op.associativity === "left" ? leftPower + 1 : leftPower)
-      if (rhs === Fail) return Fail
-      lhs = op.fold(lhs, opOut, rhs)
+      return lhs
     }
-    return lhs
+    return (state: State<any>) => expr(state, 0)
   }
-
-  return makeParser((state: State<any>) => expr(state, 0), "expression")
+  return combinator(parsers, build, "expression")
 }

package/src/Input.ts

@@ -19,6 +19,7 @@ import * as Context from "effect/Context"
 import type { Encoding } from "./Encoding.js"
 import type { ErrorKind } from "./ParseError.js"
 import type { Builder as SyntaxBuilder } from "./internal/syntax.js"
+import type { AsciiRun } from "./internal/text.js"
 
 /**
  * The kinds of input a parser can consume.
@@ -56,6 +57,17 @@ export type BinaryInput = ArrayBufferLike | ArrayBufferView
  */
 export type Source<I> = I | ([I] extends [Uint8Array] ? BinaryInput : never)
 
+/**
+ * The overloads of {@link fromSource}.
+ *
+ * @since 0.5.0
+ * @category constructors
+ */
+export interface FromSourceFn {
+  (source: BinaryInput): Uint8Array
+  <I extends Input>(source: Source<I>): I
+}
+
 /**
  * Converts a {@link Source} to the input parsers read: binary data becomes a
  * `Uint8Array` view of the same memory, everything else is returned as is.
@@ -70,10 +82,7 @@ export type Source<I> = I | ([I] extends [Uint8Array] ? BinaryInput : never)
  * @since 0.1.0
  * @category constructors
  */
-export const fromSource: {
-  (source: BinaryInput): Uint8Array
-  <I extends Input>(source: Source<I>): I
-} = (source: Input | BinaryInput): any => {
+export const fromSource: FromSourceFn = (source: Input | BinaryInput): any => {
   if (Predicate.isString(source) || source instanceof Uint8Array || Array.isArray(source)) return source
   if (ArrayBuffer.isView(source)) return new Uint8Array(source.buffer, source.byteOffset, source.byteLength)
   // An explicit length fixes the view's size even for a resizable buffer
@@ -292,6 +301,31 @@ export class State<I extends Input = Input> {
    * @internal
    */
   syntax: SyntaxBuilder | undefined = undefined
+  /**
+   * 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.
+   *
+   * @internal
+   */
+  searches: Map<object, Array<number>> | undefined = undefined
+  /**
+   * A run of ASCII bytes of this state's UTF-8 input, decoded once, from
+   * which `Text.utf8` slices the long strings it decodes (see
+   * `internal/text.ts`); `reset` clears it with the other per-run fields.
+   *
+   * @internal
+   */
+  asciiRun: AsciiRun | undefined = undefined
+  /**
+   * A `DataView` of this state's byte input, for the `Binary` parsers;
+   * created on first use. It lives as long as the state, whose input never
+   * changes: one per read cost most of a number's time.
+   *
+   * @internal
+   */
+  view: DataView | undefined = undefined
 
   constructor(
     source: I | Source<I>,
@@ -301,7 +335,7 @@ export class State<I extends Input = Input> {
       readonly offset?: number | undefined
     }
   ) {
-    const input = fromSource(source as Input) as I
+    const input = fromSource<I>(source)
     this.input = input
     this.end = input.length
     this.pos = options?.offset ?? 0
@@ -393,6 +427,8 @@ export class State<I extends Input = Input> {
     this.depth = 0
     this.encoding = undefined
     this.resume = undefined
+    this.searches = undefined
+    this.asciiRun = undefined
     return this
   }
 
@@ -445,7 +481,14 @@ export class State<I extends Input = Input> {
    * Extracts the slice `[start, end)` of the input.
    */
   slice(start: number, end: number): Slice<I> {
-    const input = this.input as any
+    // SAFETY: `inputKind` 1 is a `Uint8Array`, whose `subarray` returns a
+    // `Uint8Array` view (its `Slice`); 0 and 2 are a string and an array, whose
+    // `slice` returns a string and an array of the same elements (their
+    // `Slice`). `subarray` is only called for kind 1
+    const input = this.input as {
+      slice(start: number, end: number): Slice<I>
+      subarray(start: number, end: number): Slice<I>
+    } & I
     switch (this.inputKind) {
       case 0:
         return input.slice(start, end)
@@ -598,14 +641,30 @@ export class State<I extends Input = Input> {
   }
 }
 
+/**
+ * The last merges {@link mergeExpected} made, as `[a, b, merged]` triples. A
+ * parse merges the same few pairs of expectation arrays over and over (a
+ * whitespace skipper's hint with a repetition's, then with the failure of
+ * the token after them), and expectation arrays are never mutated, so a
+ * merge seen recently returns its earlier result, which in turn keeps the
+ * next merge's input the same array.
+ */
+const merges: Array<ReadonlyArray<string>> = /*#__PURE__*/ new Array(12).fill(empty)
+let mergeSlot = 0
+
 /** @internal */
 export const mergeExpected = (a: ReadonlyArray<string>, b: ReadonlyArray<string>): ReadonlyArray<string> => {
   if (Arr.isReadonlyArrayEmpty(a)) return b
   if (Arr.isReadonlyArrayEmpty(b)) return a
+  for (let i = 0; i < 12; i += 3) if (merges[i] === a && merges[i + 1] === b) return merges[i + 2]
   const out = a.slice()
   for (const e of b) {
     if (!out.includes(e)) out.push(e)
   }
+  merges[mergeSlot] = a
+  merges[mergeSlot + 1] = b
+  merges[mergeSlot + 2] = out
+  mergeSlot = mergeSlot === 9 ? 0 : mergeSlot + 3
   return out
 }
 

package/src/Nom.ts

@@ -132,7 +132,9 @@ export const take = Token.take
  */
 export const takeWhile = <I extends Input = string>(
   predicate: (token: TokenOf<I>) => boolean
-): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeWhile<I>(predicate as any)
+): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>
+  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind
+  Token.takeWhile<I>(predicate as Token.TokenSet<I>)
 
 /**
  * @since 0.1.0
@@ -140,7 +142,9 @@ export const takeWhile = <I extends Input = string>(
  */
 export const takeWhile1 = <I extends Input = string>(
   predicate: (token: TokenOf<I>) => boolean
-): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeWhile<I>(predicate as any, { min: 1 })
+): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>
+  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind
+  Token.takeWhile<I>(predicate as Token.TokenSet<I>, { min: 1 })
 
 /**
  * @since 0.1.0
@@ -150,7 +154,9 @@ export const takeWhileMN = <I extends Input = string>(
   m: number,
   n: number,
   predicate: (token: TokenOf<I>) => boolean
-): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeWhile<I>(predicate as any, { min: m, max: n })
+): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>
+  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind
+  Token.takeWhile<I>(predicate as Token.TokenSet<I>, { min: m, max: n })
 
 /**
  * @since 0.1.0
@@ -158,7 +164,9 @@ export const takeWhileMN = <I extends Input = string>(
  */
 export const takeTill = <I extends Input = string>(
   predicate: (token: TokenOf<I>) => boolean
-): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeTill<I>(predicate as any)
+): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>
+  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind
+  Token.takeTill<I>(predicate as Token.TokenSet<I>)
 
 /**
  * @since 0.1.0
@@ -166,7 +174,9 @@ export const takeTill = <I extends Input = string>(
  */
 export const takeTill1 = <I extends Input = string>(
   predicate: (token: TokenOf<I>) => boolean
-): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeTill<I>(predicate as any, { min: 1 })
+): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>
+  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind
+  Token.takeTill<I>(predicate as Token.TokenSet<I>, { min: 1 })
 
 /**
  * @since 0.1.0

package/src/ParseError.ts

@@ -167,6 +167,9 @@ export const fromFailure = <E = never>(
     mode,
     expected: failure.expected,
     context: failure.context,
+    // SAFETY: `E` is the user error type of the parser whose run recorded
+    // `failure`; a failure with `hasCause` carries a cause raised by that
+    // parser's `fail` / `mapError`
     cause: failure.hasCause ? (failure.cause as E) : undefined,
     description: failure.message,
     encoding: input instanceof Uint8Array ? encoding : undefined