@thomasfosterau/effect-parse 0.2.0 → 0.3.0

package/src/Input.ts

@@ -213,8 +213,31 @@ export class State<I extends Input = Input> {
   context: Context.Context<never>
   /** Mode of the latest failure. Only meaningful after a step returned {@link Fail}. */
   mode: ErrMode = "Backtrack"
-  /** Details of the latest failure. Only meaningful after a step returned {@link Fail}. */
-  failure: Failure
+  /**
+   * The latest failure, kept unmerged: the failure is `failureHead` merged
+   * (as `mergeFailures` does) with `failureTie1` and then `failureTie2`, all
+   * at the same offset. `Parser.alt` records its tied branch failures here
+   * with {@link failTies} instead of merging them, so that an enclosing `alt`
+   * whose next branch succeeds never pays for the merge. Reading
+   * {@link failure} performs the merge, once.
+   *
+   * @internal
+   */
+  failureHead: Failure
+  /** @internal */
+  failureTie1: Failure | undefined = undefined
+  /** @internal */
+  failureTie2: Failure | undefined = undefined
+  /** Backs {@link deepest}. @internal */
+  deepestFailure: Failure | undefined = undefined
+  /**
+   * Whether the furthest failure is the latest failure, still unmerged, so
+   * that {@link deepest} is that failure once merged. Only set while
+   * `failureTie1` is.
+   *
+   * @internal
+   */
+  deepestIsLatest = false
   /**
    * The offset of a recoverable failure that occurred without consuming
    * input (for example the last attempt of a `repeat`). Its
@@ -233,7 +256,14 @@ export class State<I extends Input = Input> {
    * recorded inside it when it commits, and `Parser.peek` and `Parser.not`
    * forget the failures of a lookahead that succeeded.
    */
-  deepest: Failure | undefined = undefined
+  get deepest(): Failure | undefined {
+    if (this.deepestIsLatest) this.settleFailure()
+    return this.deepestFailure
+  }
+  set deepest(failure: Failure | undefined) {
+    this.deepestIsLatest = false
+    this.deepestFailure = failure
+  }
   /** When defined, `Parser.resumeAfter`/`retryAfter` record failures here. */
   recovered: Array<Failure> | undefined = undefined
   /** When defined, `Parser.trace` reports events here. */
@@ -274,7 +304,37 @@ export class State<I extends Input = Input> {
     this.partial = options?.partial ?? false
     this.context = options?.context ?? Context.empty()
     this.inputKind = Predicate.isString(input) ? 0 : input instanceof Uint8Array ? 1 : 2
-    this.failure = initialFailure
+    this.failureHead = initialFailure
+  }
+
+  /** Details of the latest failure. Only meaningful after a step returned {@link Fail}. */
+  get failure(): Failure {
+    if (this.failureTie1 !== undefined) this.settleFailure()
+    return this.failureHead
+  }
+  set failure(failure: Failure) {
+    if (this.deepestIsLatest) this.settleFailure()
+    this.failureHead = failure
+    this.failureTie1 = undefined
+    this.failureTie2 = undefined
+  }
+
+  /** Merges the latest failure's ties into it (see {@link failureHead}). */
+  private settleFailure(): void {
+    let failure = this.failureHead
+    const tie1 = this.failureTie1
+    if (tie1 !== undefined) {
+      failure = mergeTiedFailures(failure, tie1, mergeExpected(failure.expected, tie1.expected))
+      const tie2 = this.failureTie2
+      if (tie2 !== undefined) failure = mergeTiedFailures(failure, tie2, mergeExpected(failure.expected, tie2.expected))
+      this.failureHead = failure
+      this.failureTie1 = undefined
+      this.failureTie2 = undefined
+    }
+    if (this.deepestIsLatest) {
+      this.deepestFailure = failure
+      this.deepestIsLatest = false
+    }
   }
 
   /**
@@ -317,10 +377,13 @@ export class State<I extends Input = Input> {
     this.partial = options?.partial ?? false
     this.context = options?.context ?? Context.empty()
     this.mode = "Backtrack"
-    this.failure = initialFailure
+    this.failureHead = initialFailure
+    this.failureTie1 = undefined
+    this.failureTie2 = undefined
     this.hintOffset = -1
     this.hintExpected = empty
-    this.deepest = undefined
+    this.deepestFailure = undefined
+    this.deepestIsLatest = false
     this.recovered = undefined
     this.tracer = undefined
     this.depth = 0
@@ -410,10 +473,34 @@ export class State<I extends Input = Input> {
    */
   failWith(mode: ErrMode, failure: Failure): Fail {
     this.mode = mode
-    this.failure = failure
-    if (mode === "Backtrack" && (this.deepest === undefined || failure.offset >= this.deepest.offset)) {
-      this.deepest = failure
+    if (this.deepestIsLatest) {
+      // The furthest failure is the latest one: it is replaced below, unmerged, if `failure` is as far
+      if (mode === "Backtrack" && failure.offset >= this.failureHead.offset) this.deepestIsLatest = false
+      else this.settleFailure()
     }
+    this.failureHead = failure
+    this.failureTie1 = undefined
+    this.failureTie2 = undefined
+    if (mode === "Backtrack" && (this.deepestFailure === undefined || failure.offset >= this.deepestFailure.offset)) {
+      this.deepestFailure = failure
+    }
+    return Fail
+  }
+
+  /**
+   * Records a recoverable failure made of tied failures, merged only when
+   * read: `failWith("Backtrack", f)` where `f` merges `head` with `tie1`
+   * and then `tie2` (all at the same offset), as `mergeFailures` would.
+   *
+   * @internal
+   */
+  failTies(head: Failure, tie1: Failure, tie2: Failure | undefined): Fail {
+    this.mode = "Backtrack"
+    if (this.deepestIsLatest && head.offset < this.failureHead.offset) this.settleFailure()
+    this.failureHead = head
+    this.failureTie1 = tie1
+    this.failureTie2 = tie2
+    this.deepestIsLatest = this.deepestFailure === undefined || head.offset >= this.deepestFailure.offset
     return Fail
   }
 
@@ -492,7 +579,17 @@ export const mergeExpected = (a: ReadonlyArray<string>, b: ReadonlyArray<string>
 export const mergeFailures = (a: Failure, b: Failure): Failure => {
   if (a.offset > b.offset) return a
   if (b.offset > a.offset) return b
-  const expected = mergeExpected(a.expected, b.expected)
+  return mergeTiedFailures(a, b, mergeExpected(a.expected, b.expected))
+}
+
+/**
+ * {@link mergeFailures} for two failures at the same offset, given their
+ * merged expectations (`mergeExpected(a.expected, b.expected)`, possibly
+ * memoised by the caller).
+ *
+ * @internal
+ */
+export const mergeTiedFailures = (a: Failure, b: Failure, expected: ReadonlyArray<string>): Failure => {
   if (expected === b.expected) return b
   return new Failure(
     b.offset,

package/src/ParseError.ts

@@ -289,7 +289,7 @@ export const inspectToken = (u: unknown): string => {
 const causeMessage = (cause: unknown): string | undefined => {
   if (cause === undefined) return undefined
   if (Predicate.isString(cause)) return cause
-  if (cause instanceof Error) return cause.message
+  // An `Error`'s message, or any other object's string `message`
   if (Predicate.isObjectOrArray(cause) && "message" in cause && Predicate.isString(cause.message)) {
     return cause.message
   }

package/src/Parser.ts

@@ -40,7 +40,7 @@ import { pipeArguments } from "effect/Pipeable"
 import * as Result from "effect/Result"
 import type { Contravariant, Covariant, Simplify } from "effect/Types"
 import type { ErrMode, Input, Slice, Source, TraceEvent } from "./Input.js"
-import { Fail, Failure, mergeExpected, mergeFailures, State } from "./Input.js"
+import { Fail, Failure, mergeExpected, mergeFailures, mergeTiedFailures, State } from "./Input.js"
 import type { ErrorKind } from "./ParseError.js"
 import * as ParseError from "./ParseError.js"
 import * as Registry from "./internal/compiler/registry.js"
@@ -48,6 +48,7 @@ import * as Entries from "./internal/entries.js"
 import * as Resume from "./internal/resume.js"
 import * as Run from "./internal/run.js"
 import * as Stack from "./internal/stack.js"
+import { TiedFailures } from "./internal/ties.js"
 import type { Node } from "./internal/node.js"
 import { bounds, NodeId } from "./internal/node.js"
 
@@ -1785,19 +1786,48 @@ export const alt = <const Ps extends ReadonlyArray<Parser.Any>>(
   return described(
     (state: State<any>) => {
       const start = state.pos
+      // The branches' failures merged left to right, as `mergeFailures` would,
+      // except that the last two failures tied with `failure` wait in `tie1`
+      // and `tie2` and are merged only when needed: when a third tie arrives,
+      // when a succeeding branch stops where they failed (for the hint), or
+      // when the merge is read from the state after `failTies`. An `alt` whose
+      // later branch consumes input discards them unmerged.
       let failure: Failure | undefined
+      let tie1: Failure | undefined
+      let tie2: Failure | undefined
       for (let i = 0; i < n; i++) {
         const a = steps[i](state)
         if (a !== Fail) {
-          if (failure !== undefined && failure.offset === state.pos) state.setHint(failure.offset, failure.expected)
+          if (failure !== undefined && failure.offset === state.pos) {
+            let expected = failure.expected
+            if (tie1 !== undefined) expected = mergeExpected(expected, tie1.expected)
+            if (tie2 !== undefined) expected = mergeExpected(expected, tie2.expected)
+            state.setHint(failure.offset, expected)
+          }
           return a
         }
         if (state.mode !== "Backtrack") return Fail
-        failure = failure === undefined ? state.failure : mergeFailures(failure, state.failure)
         state.pos = start
+        // The branch's failure, whose own ties (from a nested `alt`) can be taken over unmerged
+        const head = state.failureHead
+        if (failure === undefined || head.offset > failure.offset) {
+          failure = head
+          tie1 = state.failureTie1
+          tie2 = state.failureTie2
+        } else if (head.offset === failure.offset) {
+          const f = state.failure
+          if (tie1 === undefined) tie1 = f
+          else if (tie2 === undefined) tie2 = f
+          else {
+            failure = mergeTiedFailures(failure, tie1, mergeExpected(failure.expected, tie1.expected))
+            tie1 = tie2
+            tie2 = f
+          }
+        }
       }
       // `failure` is set: there are at least two alternatives, and each one that fails sets it
-      return state.failWith("Backtrack", failure ?? state.failure)
+      if (failure === undefined) return state.failWith("Backtrack", state.failure)
+      return tie1 === undefined ? state.failWith("Backtrack", failure) : state.failTies(failure, tie1, tie2)
     },
     "alt",
     { _tag: "Alt", parsers }
@@ -1911,11 +1941,13 @@ export const permutation = <const Ps extends ReadonlyArray<Parser.Any>>(
   const steps = parsers.map((p) => p.step)
   const n = steps.length
   return make((state: State<any>) => {
-    const out = new Array(n)
+    // A round's failures, merged only if no parser matches in it (#44)
+    const ties = new TiedFailures()
     const done = new Array<boolean>(n).fill(false)
+    const out = new Array(n)
     let remaining = n
     while (remaining > 0) {
-      let failure: Failure | undefined
+      ties.clear()
       let matched = false
       for (let i = 0; i < n; i++) {
         if (done[i]) continue
@@ -1929,11 +1961,11 @@ export const permutation = <const Ps extends ReadonlyArray<Parser.Any>>(
           break
         }
         if (state.mode !== "Backtrack") return Fail
-        failure = failure === undefined ? state.failure : mergeFailures(failure, state.failure)
         state.pos = start
+        ties.add(state)
       }
-      // `failure` is set: some parser is not done yet, and each one that fails sets it
-      if (!matched) return state.failWith("Backtrack", failure ?? state.failure)
+      // Some parser is not done yet, and each one that fails is folded in
+      if (!matched) return ties.fail(state)
     }
     return out as any
   }, "permutation")