@thomasfosterau/effect-parse 0.2.0 → 0.4.0

package/src/Input.ts

@@ -13,6 +13,7 @@
  *
  * @since 0.1.0
  */
+import * as Arr from "effect/Array"
 import * as Predicate from "effect/Predicate"
 import * as Context from "effect/Context"
 import type { Encoding } from "./Encoding.js"
@@ -80,7 +81,7 @@ export const fromSource: {
   return source
 }
 
-const isArrayBufferLike = (u: unknown): u is ArrayBufferLike =>
+const isArrayBufferLike = (u: Input | BinaryInput): u is ArrayBufferLike =>
   u instanceof ArrayBuffer || (globalThis.SharedArrayBuffer !== undefined && u instanceof SharedArrayBuffer)
 
 /**
@@ -200,9 +201,11 @@ export interface TraceEvent {
 export class State<I extends Input = Input> {
   /** The full input being parsed. */
   readonly input: I
-  /** The current offset. Advanced by parsers, rewound on backtracking. */
-  // Declared, not defined, so that a subclass can make it an accessor
-  declare pos: number
+  /**
+   * The current offset. Parsers advance it by assigning it; moving it back
+   * (backtracking, or after a lookahead) goes through {@link rewind}.
+   */
+  pos: number
   /** The end offset (the input's length; in bits inside `Bits.bits`). */
   end: number
   /** 0 = string, 1 = Uint8Array, 2 = array. */
@@ -213,8 +216,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 +259,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. */
@@ -253,7 +286,8 @@ export class State<I extends Input = Input> {
    */
   resume: Map<object, Map<number, unknown>> | undefined = undefined
   /**
-   * The tree builder of a `Syntax` parse; `undefined` otherwise.
+   * The tree builder of a `Syntax` parse; `undefined` otherwise. A builder
+   * rather than a subclass of `State`, so that every state has one shape.
    *
    * @internal
    */
@@ -274,7 +308,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 +381,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
@@ -329,6 +396,37 @@ export class State<I extends Input = Input> {
     return this
   }
 
+  /**
+   * Moves the cursor back to `offset`, abandoning what was parsed after it:
+   * how a parser backtracks, or returns to where a lookahead started. A step
+   * that moves the cursor backwards must use this rather than assigning
+   * {@link pos}, so that a `Syntax` parse drops the nodes the abandoned
+   * attempt built. Moving forward is an assignment.
+   *
+   * @example
+   * ```ts
+   * import { Input, Parser } from "@thomasfosterau/effect-parse"
+   *
+   * // Like `Parser.opt`, for one parser
+   * const optional = <A>(p: Parser.Parser<A>) =>
+   *   Parser.make<A | undefined>((state) => {
+   *     const start = state.pos
+   *     const a = p.step(state)
+   *     if (a !== Input.Fail) return a
+   *     if (state.mode !== "Backtrack") return Input.Fail
+   *     state.rewind(start)
+   *     return undefined
+   *   })
+   * ```
+   *
+   * @since 0.4.0
+   */
+  rewind(offset: number): void {
+    const syntax = this.syntax
+    if (syntax !== undefined && offset < this.pos) syntax.rewound(this.pos, offset)
+    this.pos = offset
+  }
+
   /**
    * The number of input units (code units, bytes or elements) remaining.
    */
@@ -410,10 +508,36 @@ 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
+    }
+    if (this.syntax !== undefined) this.syntax.reach(failure.offset)
+    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
+    if (this.syntax !== undefined) this.syntax.reach(head.offset)
     return Fail
   }
 
@@ -444,8 +568,9 @@ export class State<I extends Input = Input> {
     ) {
       return f
     }
-    const context =
-      d.context.length === 0 ? f.context : [...d.context, ...f.context.filter((l) => !d.context.includes(l))]
+    const context = Arr.isReadonlyArrayEmpty(d.context)
+      ? f.context
+      : [...d.context, ...f.context.filter((l) => !d.context.includes(l))]
     return new Failure(d.offset, d.kind, d.expected, context, d.hasCause, d.cause, d.message, d.needed)
   }
 
@@ -455,6 +580,7 @@ export class State<I extends Input = Input> {
    * `repeat` and `Ascii.digit1`.
    */
   setHint(offset: number, expected: ReadonlyArray<string>): void {
+    if (this.syntax !== undefined) this.syntax.reach(offset)
     if (this.hintOffset === offset) {
       this.hintExpected = mergeExpected(this.hintExpected, expected)
     } else {
@@ -465,7 +591,7 @@ export class State<I extends Input = Input> {
 
   /** @internal */
   makeFailure(offset: number, kind: ErrorKind, expected: ReadonlyArray<string>): Failure {
-    if (this.hintOffset === offset && this.hintExpected.length > 0) {
+    if (this.hintOffset === offset && Arr.isReadonlyArrayNonEmpty(this.hintExpected)) {
       expected = mergeExpected(this.hintExpected, expected)
     }
     return new Failure(offset, kind, expected, empty, false, undefined, undefined, 0)
@@ -474,8 +600,8 @@ export class State<I extends Input = Input> {
 
 /** @internal */
 export const mergeExpected = (a: ReadonlyArray<string>, b: ReadonlyArray<string>): ReadonlyArray<string> => {
-  if (a.length === 0) return b
-  if (b.length === 0) return a
+  if (Arr.isReadonlyArrayEmpty(a)) return b
+  if (Arr.isReadonlyArrayEmpty(b)) return a
   const out = a.slice()
   for (const e of b) {
     if (!out.includes(e)) out.push(e)
@@ -492,13 +618,23 @@ 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,
     b.kind,
     expected,
-    b.context.length > 0 ? b.context : a.context,
+    Arr.isReadonlyArrayNonEmpty(b.context) ? b.context : a.context,
     b.hasCause || a.hasCause,
     b.hasCause ? b.cause : a.cause,
     b.message ?? a.message,

package/src/ParseError.ts

@@ -19,9 +19,11 @@
  *
  * @since 0.1.0
  */
+import * as Arr from "effect/Array"
 import * as Predicate from "effect/Predicate"
 import * as Data from "effect/Data"
 import * as Option from "effect/Option"
+import * as Result from "effect/Result"
 import type { Encoding } from "./Encoding.js"
 import type { ErrMode, Failure, Input } from "./Input.js"
 import * as text from "./internal/text.js"
@@ -245,7 +247,7 @@ const codePointCount = (s: string, start: number, end: number): number => {
  * @category utils
  */
 export const formatExpected = (expected: ReadonlyArray<string>): string => {
-  if (expected.length === 0) return ""
+  if (Arr.isReadonlyArrayEmpty(expected)) return ""
   if (expected.length === 1) return expected[0]
   return `${expected.slice(0, -1).join(", ")} or ${expected[expected.length - 1]}`
 }
@@ -277,11 +279,11 @@ const describeFound = (input: Input, offset: number, encoding: Encoding<any> | u
 export const inspectToken = (u: unknown): string => {
   if (Predicate.isString(u)) return JSON.stringify(u)
   if (Predicate.isObjectOrArray(u)) {
-    try {
-      return JSON.stringify(u)
-    } catch {
-      return String(u)
-    }
+    // `JSON.stringify` throws on cycles and `BigInt`s
+    return Result.getOrElse(
+      Result.try(() => JSON.stringify(u)),
+      () => String(u)
+    )
   }
   return String(u)
 }
@@ -289,7 +291,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
   }
@@ -366,7 +368,7 @@ const render = (error: ParseError<unknown>): string => {
   if (error.description !== undefined) lines.push(error.description)
   if (error.mode === "Incomplete") {
     lines.push("unexpected end of input (incomplete)")
-  } else if (error.expected.length > 0) {
+  } else if (Arr.isReadonlyArrayNonEmpty(error.expected)) {
     lines.push(`expected ${formatExpected(error.expected)}, found ${describeFound(input, offset, encoding)}`)
   } else if (cause === undefined && error.description === undefined) {
     lines.push(`unexpected ${describeFound(input, offset, encoding)} (${error.kind})`)

package/src/Parser.ts

@@ -40,14 +40,16 @@ 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"
 import * as Entries from "./internal/entries.js"
+import { Key } from "./internal/key.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"
 
@@ -272,6 +274,8 @@ const isTwoParserArgs = (args: IArguments) => isParser(args[0]) && isParser(args
  * The step function must either return the parsed value, having advanced
  * `state.pos` past the consumed input, or return the result of one of
  * `state.backtrack`, `state.cut`, `state.incomplete`, ... to signal failure.
+ * A step that moves the cursor backwards (to retry, or after a lookahead)
+ * calls `state.rewind(offset)` rather than assigning `state.pos`.
  *
  * @example
  * ```ts
@@ -722,7 +726,7 @@ export const tryMap: {
         if (a === Fail) return Fail
         const r = f(a)
         if (Result.isSuccess(r)) return r.success
-        state.pos = start
+        state.rewind(start)
         return state.failCause("Backtrack", "Verify", r.failure)
       },
       self.name,
@@ -776,7 +780,7 @@ export const filterMap: {
         if (a === Fail) return Fail
         const o = f(a)
         if (Option.isSome(o)) return o.value
-        state.pos = start
+        state.rewind(start)
         return state.backtrack("Verify")
       },
       self.name,
@@ -807,7 +811,7 @@ export const filter: {
       const a = step(state)
       if (a === Fail) return Fail
       if (predicate(a)) return a
-      state.pos = start
+      state.rewind(start)
       return state.backtrack("Verify")
     },
     self.name,
@@ -851,7 +855,7 @@ export const filterOrFail: {
         const a = step(state)
         if (a === Fail) return Fail
         if (predicate(a)) return a
-        state.pos = start
+        state.rewind(start)
         return state.failCause("Backtrack", "Verify", orFailWith(a))
       },
       self.name,
@@ -1031,7 +1035,7 @@ export const complete = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Pa
       const start = state.pos
       const a = step(state)
       if (a === Fail && state.mode === "Incomplete") {
-        state.pos = start
+        state.rewind(start)
         return state.backtrack("Complete")
       }
       return a
@@ -1222,7 +1226,7 @@ export const orElseSucceed: {
 
 /** Rewinds after a recoverable failure, remembering it as a hint. */
 const recover = (state: State<any>, start: number): void => {
-  state.pos = start
+  state.rewind(start)
   const f = state.failure
   if (f.offset === start) {
     state.hintOffset = start
@@ -1296,7 +1300,7 @@ export const peek = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser
       if (a !== Fail) {
         // Failures inside a lookahead that succeeded are about input that was
         // never consumed, so they are not reported as the furthest failure
-        state.pos = start
+        state.rewind(start)
         state.hintOffset = hintOffset
         state.hintExpected = hintExpected
         state.deepest = deepest
@@ -1326,12 +1330,12 @@ export const not = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<
       const a = step(state)
       if (a !== Fail) {
         // The failures inside `self` are not this parser's failure
-        state.pos = start
+        state.rewind(start)
         state.deepest = deepest
         return state.backtrack("Not")
       }
       if (state.mode !== "Backtrack") return Fail
-      state.pos = start
+      state.rewind(start)
       state.hintOffset = hintOffset
       state.hintExpected = hintExpected
       state.deepest = deepest
@@ -1785,19 +1789,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
+        state.rewind(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 }
@@ -1876,7 +1909,7 @@ export const dispatch: {
       if (key === Fail) return Fail
       const parser = choose(key)
       if (parser === undefined) {
-        state.pos = start
+        state.rewind(start)
         return state.backtrack("Dispatch")
       }
       return parser.step(state)
@@ -1911,11 +1944,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 +1964,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
+        state.rewind(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")
@@ -1963,7 +1998,7 @@ interface FoldCheckpoint<B> {
   readonly pos: number
 }
 
-const saveFold = <B>(state: State<any>, key: object, entry: number, acc: B, pos: number): void =>
+const saveFold = <B>(state: State<any>, key: Key, entry: number, acc: B, pos: number): void =>
   Resume.save(state, key, entry, { acc, count: 0, pos } satisfies FoldCheckpoint<B>)
 
 const foldImpl = <A, B, E, R, I extends Input>(
@@ -1978,7 +2013,7 @@ const foldImpl = <A, B, E, R, I extends Input>(
   const [min, max] = normalizeRange(range)
   const step = self.step
   const checkLoop = max === Infinity
-  const key = {}
+  const key = new Key()
   return described(
     (state) => {
       const entry = state.pos
@@ -2157,7 +2192,7 @@ export const repeatTill: {
             if (b !== Fail) return [acc, b]
             if (state.mode !== "Backtrack") return Fail
             endFailure = state.failure
-            state.pos = start
+            state.rewind(start)
             if (acc.length >= max) return Fail
           }
           const a = step(state)
@@ -2220,7 +2255,7 @@ export const separated: {
     const step = self.step
     const sepStep = separator.step
     const checkLoop = max === Infinity
-    const key = {}
+    const key = new Key()
     return described(
       (state) => {
         const entry = state.pos
@@ -2263,7 +2298,7 @@ export const separated: {
               Resume.save(state, key, entry, { acc, pos: start } satisfies SeparatedCheckpoint<A>)
             }
             if (state.mode !== "Backtrack" || acc.length < min) return Fail
-            state.pos = start
+            state.rewind(start)
             return Resume.done(state, key, entry, resumed !== undefined, acc)
           }
           acc.push(a)
@@ -2304,7 +2339,7 @@ export const separatedFoldl1 = <A, E, R, I extends Input, S, E2, R2, I2 extends
 ): Parser<A, E | E2, R | R2, I & I2> => {
   const step = self.step
   const sepStep = separator.step
-  const key = {}
+  const key = new Key()
   return described(
     (state) => {
       const entry = state.pos
@@ -2335,7 +2370,7 @@ export const separatedFoldl1 = <A, E, R, I extends Input, S, E2, R2, I2 extends
         if (a === Fail) {
           if (state.mode === "Incomplete" && state.resume !== undefined) saveFold(state, key, entry, acc, start)
           if (state.mode !== "Backtrack") return Fail
-          state.pos = start
+          state.rewind(start)
           return Resume.done(state, key, entry, resumed !== undefined, acc as A)
         }
         acc = op(acc, s, a)
@@ -2380,7 +2415,7 @@ export const separatedFoldr1 = <A, E, R, I extends Input, S, E2, R2, I2 extends
         const a = step(state)
         if (a === Fail) {
           if (state.mode !== "Backtrack") return Fail
-          state.pos = start
+          state.rewind(start)
           break
         }
         seps.push(s)
@@ -2552,7 +2587,7 @@ export const resumeAfter: {
         if (state.recovered === undefined || state.mode === "Incomplete") return Fail
         const failure = state.failure
         const mode = state.mode
-        state.pos = start
+        state.rewind(start)
         if (recoverStep(state) === Fail) return state.failWith(mode, failure)
         state.recovered.push(failure)
         state.syntax?.skipped(start, failure, mode)
@@ -2599,7 +2634,7 @@ export const retryAfter: {
           if (state.recovered === undefined || state.mode === "Incomplete") return Fail
           const failure = state.failure
           const mode = state.mode
-          state.pos = start
+          state.rewind(start)
           if (recoverStep(state) === Fail || state.pos === start) return state.failWith(mode, failure)
           state.recovered.push(failure)
           state.syntax?.skipped(start, failure, mode)
@@ -2676,7 +2711,7 @@ const preview = (state: State<any>, offset: number): string => {
  */
 export const consoleTracer = (event: TraceEvent): void => {
   const indent = "  ".repeat(event.depth)
-  if (event._tag === "Enter") {
+  if (Predicate.isTagged(event, "Enter")) {
     console.log(`${indent}> ${event.name} @${event.offset} | ${preview(event.state, event.offset)}`)
   } else {
     const consumed = (event.endOffset ?? event.offset) - event.offset