@thomasfosterau/effect-parse 0.1.0 → 0.3.0

package/src/Binary.ts

@@ -17,6 +17,7 @@
  *
  * @since 0.1.0
  */
+import * as Predicate from "effect/Predicate"
 import type { Input, Slice, State } from "./Input.js"
 import { Fail } from "./Input.js"
 import type { Parser } from "./Parser.js"
@@ -41,9 +42,13 @@ export {
  */
 export type Endianness = "big" | "little" | "native"
 
-const nativeLittle = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1
+const nativeLittle = /*#__PURE__*/ new Uint8Array(/*#__PURE__*/ new Uint16Array([1]).buffer)[0] === 1
 
-const fixed = <A>(size: number, name: string, read: (view: DataView, offset: number) => A): Parser<A, never, never, Uint8Array> => {
+const fixed = <A>(
+  size: number,
+  name: string,
+  read: (view: DataView, offset: number) => A
+): Parser<A, never, never, Uint8Array> => {
   const expected = [`${size} byte${size === 1 ? "" : "s"}`]
   return P.make((state: State<Uint8Array>) => {
     const pos = state.pos
@@ -86,7 +91,7 @@ const readI128 = (little: boolean) => {
  * @since 0.1.0
  * @category integers
  */
-export const u8: Parser<number, never, never, Uint8Array> = fixed(1, "u8", (v, o) => v.getUint8(o))
+export const u8: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(1, "u8", (v, o) => v.getUint8(o))
 
 /**
  * A signed byte.
@@ -94,60 +99,126 @@ export const u8: Parser<number, never, never, Uint8Array> = fixed(1, "u8", (v, o
  * @since 0.1.0
  * @category integers
  */
-export const i8: Parser<number, never, never, Uint8Array> = fixed(1, "i8", (v, o) => v.getInt8(o))
+export const i8: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(1, "i8", (v, o) => v.getInt8(o))
 
 /** @since 0.1.0 @category integers */
-export const beU16: Parser<number, never, never, Uint8Array> = fixed(2, "beU16", (v, o) => v.getUint16(o, false))
+export const beU16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(2, "beU16", (v, o) =>
+  v.getUint16(o, false)
+)
 /** @since 0.1.0 @category integers */
-export const leU16: Parser<number, never, never, Uint8Array> = fixed(2, "leU16", (v, o) => v.getUint16(o, true))
+export const leU16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(2, "leU16", (v, o) =>
+  v.getUint16(o, true)
+)
 /** @since 0.1.0 @category integers */
-export const beI16: Parser<number, never, never, Uint8Array> = fixed(2, "beI16", (v, o) => v.getInt16(o, false))
+export const beI16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(2, "beI16", (v, o) =>
+  v.getInt16(o, false)
+)
 /** @since 0.1.0 @category integers */
-export const leI16: Parser<number, never, never, Uint8Array> = fixed(2, "leI16", (v, o) => v.getInt16(o, true))
+export const leI16: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(2, "leI16", (v, o) =>
+  v.getInt16(o, true)
+)
 /** @since 0.1.0 @category integers */
-export const beU24: Parser<number, never, never, Uint8Array> = fixed(3, "beU24", readU24(false))
+export const beU24: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  3,
+  "beU24",
+  /*#__PURE__*/ readU24(false)
+)
 /** @since 0.1.0 @category integers */
-export const leU24: Parser<number, never, never, Uint8Array> = fixed(3, "leU24", readU24(true))
+export const leU24: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  3,
+  "leU24",
+  /*#__PURE__*/ readU24(true)
+)
 /** @since 0.1.0 @category integers */
-export const beI24: Parser<number, never, never, Uint8Array> = fixed(3, "beI24", readI24(false))
+export const beI24: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  3,
+  "beI24",
+  /*#__PURE__*/ readI24(false)
+)
 /** @since 0.1.0 @category integers */
-export const leI24: Parser<number, never, never, Uint8Array> = fixed(3, "leI24", readI24(true))
+export const leI24: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  3,
+  "leI24",
+  /*#__PURE__*/ readI24(true)
+)
 /** @since 0.1.0 @category integers */
-export const beU32: Parser<number, never, never, Uint8Array> = fixed(4, "beU32", (v, o) => v.getUint32(o, false))
+export const beU32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, "beU32", (v, o) =>
+  v.getUint32(o, false)
+)
 /** @since 0.1.0 @category integers */
-export const leU32: Parser<number, never, never, Uint8Array> = fixed(4, "leU32", (v, o) => v.getUint32(o, true))
+export const leU32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, "leU32", (v, o) =>
+  v.getUint32(o, true)
+)
 /** @since 0.1.0 @category integers */
-export const beI32: Parser<number, never, never, Uint8Array> = fixed(4, "beI32", (v, o) => v.getInt32(o, false))
+export const beI32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, "beI32", (v, o) =>
+  v.getInt32(o, false)
+)
 /** @since 0.1.0 @category integers */
-export const leI32: Parser<number, never, never, Uint8Array> = fixed(4, "leI32", (v, o) => v.getInt32(o, true))
+export const leI32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, "leI32", (v, o) =>
+  v.getInt32(o, true)
+)
 /** @since 0.1.0 @category integers */
-export const beU64: Parser<bigint, never, never, Uint8Array> = fixed(8, "beU64", (v, o) => v.getBigUint64(o, false))
+export const beU64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, "beU64", (v, o) =>
+  v.getBigUint64(o, false)
+)
 /** @since 0.1.0 @category integers */
-export const leU64: Parser<bigint, never, never, Uint8Array> = fixed(8, "leU64", (v, o) => v.getBigUint64(o, true))
+export const leU64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, "leU64", (v, o) =>
+  v.getBigUint64(o, true)
+)
 /** @since 0.1.0 @category integers */
-export const beI64: Parser<bigint, never, never, Uint8Array> = fixed(8, "beI64", (v, o) => v.getBigInt64(o, false))
+export const beI64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, "beI64", (v, o) =>
+  v.getBigInt64(o, false)
+)
 /** @since 0.1.0 @category integers */
-export const leI64: Parser<bigint, never, never, Uint8Array> = fixed(8, "leI64", (v, o) => v.getBigInt64(o, true))
+export const leI64: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, "leI64", (v, o) =>
+  v.getBigInt64(o, true)
+)
 /** @since 0.1.0 @category integers */
-export const beU128: Parser<bigint, never, never, Uint8Array> = fixed(16, "beU128", readU128(false))
+export const beU128: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  16,
+  "beU128",
+  /*#__PURE__*/ readU128(false)
+)
 /** @since 0.1.0 @category integers */
-export const leU128: Parser<bigint, never, never, Uint8Array> = fixed(16, "leU128", readU128(true))
+export const leU128: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  16,
+  "leU128",
+  /*#__PURE__*/ readU128(true)
+)
 /** @since 0.1.0 @category integers */
-export const beI128: Parser<bigint, never, never, Uint8Array> = fixed(16, "beI128", readI128(false))
+export const beI128: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  16,
+  "beI128",
+  /*#__PURE__*/ readI128(false)
+)
 /** @since 0.1.0 @category integers */
-export const leI128: Parser<bigint, never, never, Uint8Array> = fixed(16, "leI128", readI128(true))
+export const leI128: Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ fixed(
+  16,
+  "leI128",
+  /*#__PURE__*/ readI128(true)
+)
 
 /** @since 0.1.0 @category floats */
-export const beF32: Parser<number, never, never, Uint8Array> = fixed(4, "beF32", (v, o) => v.getFloat32(o, false))
+export const beF32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, "beF32", (v, o) =>
+  v.getFloat32(o, false)
+)
 /** @since 0.1.0 @category floats */
-export const leF32: Parser<number, never, never, Uint8Array> = fixed(4, "leF32", (v, o) => v.getFloat32(o, true))
+export const leF32: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(4, "leF32", (v, o) =>
+  v.getFloat32(o, true)
+)
 /** @since 0.1.0 @category floats */
-export const beF64: Parser<number, never, never, Uint8Array> = fixed(8, "beF64", (v, o) => v.getFloat64(o, false))
+export const beF64: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, "beF64", (v, o) =>
+  v.getFloat64(o, false)
+)
 /** @since 0.1.0 @category floats */
-export const leF64: Parser<number, never, never, Uint8Array> = fixed(8, "leF64", (v, o) => v.getFloat64(o, true))
+export const leF64: Parser<number, never, never, Uint8Array> = /*#__PURE__*/ fixed(8, "leF64", (v, o) =>
+  v.getFloat64(o, true)
+)
 
-const byEndian = <A>(big: A, little: A) => (endian: Endianness): A =>
-  endian === "big" ? big : endian === "little" ? little : nativeLittle ? little : big
+const byEndian =
+  <A>(big: A, little: A) =>
+  (endian: Endianness): A =>
+    endian === "big" ? big : endian === "little" ? little : nativeLittle ? little : big
 
 /**
  * An unsigned 16-bit integer in the given byte order (winnow's `u16`).
@@ -155,32 +226,67 @@ const byEndian = <A>(big: A, little: A) => (endian: Endianness): A =>
  * @since 0.1.0
  * @category integers
  */
-export const u16: (endian: Endianness) => Parser<number, never, never, Uint8Array> = byEndian(beU16, leU16)
+export const u16: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(
+  beU16,
+  leU16
+)
 /** @since 0.1.0 @category integers */
-export const i16: (endian: Endianness) => Parser<number, never, never, Uint8Array> = byEndian(beI16, leI16)
+export const i16: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(
+  beI16,
+  leI16
+)
 /** @since 0.1.0 @category integers */
-export const u24: (endian: Endianness) => Parser<number, never, never, Uint8Array> = byEndian(beU24, leU24)
+export const u24: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(
+  beU24,
+  leU24
+)
 /** @since 0.1.0 @category integers */
-export const i24: (endian: Endianness) => Parser<number, never, never, Uint8Array> = byEndian(beI24, leI24)
+export const i24: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(
+  beI24,
+  leI24
+)
 /** @since 0.1.0 @category integers */
-export const u32: (endian: Endianness) => Parser<number, never, never, Uint8Array> = byEndian(beU32, leU32)
+export const u32: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(
+  beU32,
+  leU32
+)
 /** @since 0.1.0 @category integers */
-export const i32: (endian: Endianness) => Parser<number, never, never, Uint8Array> = byEndian(beI32, leI32)
+export const i32: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(
+  beI32,
+  leI32
+)
 /** @since 0.1.0 @category integers */
-export const u64: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = byEndian(beU64, leU64)
+export const u64: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ byEndian(
+  beU64,
+  leU64
+)
 /** @since 0.1.0 @category integers */
-export const i64: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = byEndian(beI64, leI64)
+export const i64: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ byEndian(
+  beI64,
+  leI64
+)
 /** @since 0.1.0 @category integers */
-export const u128: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = byEndian(beU128, leU128)
+export const u128: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ byEndian(
+  beU128,
+  leU128
+)
 /** @since 0.1.0 @category integers */
-export const i128: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = byEndian(beI128, leI128)
+export const i128: (endian: Endianness) => Parser<bigint, never, never, Uint8Array> = /*#__PURE__*/ byEndian(
+  beI128,
+  leI128
+)
 /** @since 0.1.0 @category floats */
-export const f32: (endian: Endianness) => Parser<number, never, never, Uint8Array> = byEndian(beF32, leF32)
+export const f32: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(
+  beF32,
+  leF32
+)
 /** @since 0.1.0 @category floats */
-export const f64: (endian: Endianness) => Parser<number, never, never, Uint8Array> = byEndian(beF64, leF64)
+export const f64: (endian: Endianness) => Parser<number, never, never, Uint8Array> = /*#__PURE__*/ byEndian(
+  beF64,
+  leF64
+)
 
-
-const toCount = (n: number | bigint): number => typeof n === "bigint" ? Number(n) : n
+const toCount = (n: number | bigint): number => (Predicate.isBigInt(n) ? Number(n) : n)
 
 /**
  * Parses a length with `count`, then takes that many tokens (winnow's

package/src/Bits.ts

@@ -68,9 +68,12 @@ const inUnits = <A>(state: State<any>, factor: number, step: (state: State<any>)
     state.pos = factor > 1 ? Math.floor(state.pos / factor) : state.pos / factor
     const f = state.failure
     state.failure = scale(f, 1 / factor)
+    // A committed failure keeps only the failures recorded after the commit
+    // (see `Parser.cut`), so none from before these units
+    if (state.mode === "Cut") state.deepest = undefined
     if (inner !== undefined) {
       const d = inner === f ? state.failure : scale(inner, 1 / factor)
-      if (deepest === undefined || d.offset >= deepest.offset) state.deepest = d
+      if (state.deepest === undefined || d.offset >= state.deepest.offset) state.deepest = d
     }
     return Fail
   }
@@ -111,7 +114,7 @@ const readBits = (state: State<any>, count: number): number => {
   let pos = state.pos
   let value = 0
   for (let i = 0; i < count; i++) {
-    const byte = input[pos >>> 3]!
+    const byte = input[pos >>> 3]
     value = value * 2 + ((byte >>> (7 - (pos & 7))) & 1)
     pos++
   }
@@ -186,7 +189,7 @@ export const pattern = (pattern: number, count: number): Parser<number, never, n
  * @since 0.1.0
  * @category parsers
  */
-export const bool: Parser<boolean, never, never, BitInput> = make((state: State<any>) => {
+export const bool: Parser<boolean, never, never, BitInput> = /*#__PURE__*/ make((state: State<any>) => {
   if (state.pos >= state.end) return state.eoi("Bits", ["1 bit"], 1)
   return readBits(state, 1) === 1
 }, "bool")

package/src/Compiler.ts

@@ -0,0 +1,98 @@
+/**
+ * Compiles parsers into fused, specialized code. Grammars are written as
+ * usual; compiling the root of a grammar only makes `Parser.parse`,
+ * `Parser.parseSync`, `Parser.parsePeek`, `Parser.parsePartial` and
+ * `Parser.parseEffect` faster, from any `offset`.
+ *
+ * There are two compilers, one function each, so a program bundles only the
+ * one it uses, and a program that compiles nothing bundles neither:
+ *
+ * - {@link jit} generates code with `new Function` where it is allowed, and
+ *   otherwise uses the closure compiler. It is the fastest.
+ * - {@link closure} builds specialized closures only. It never generates
+ *   code, and a bundle that uses only it contains no `new Function`, so it
+ *   is the choice under a Content Security Policy, where even probing for
+ *   `new Function` is reported as a violation.
+ *
+ * ```ts
+ * import { Ascii, Compiler, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * export const list = Compiler.jit(
+ *   Parser.separated(Ascii.decInt, Token.literal(","))
+ * )
+ * Parser.parse(list, "1,2,3") // Result.succeed([1, 2, 3]), compiled
+ * ```
+ *
+ * Both return the same parser, so they also work in a pipe:
+ * `p.pipe(Compiler.closure)`. The code is built lazily on the first run, for
+ * each kind of input (string, bytes or array), and cached with the parser.
+ * Compiling a parser again, with either function, replaces its compiled
+ * form.
+ *
+ * **Results and errors are unchanged.** Compiled code records no
+ * diagnostics. When it fails, the parser runs again, interpreted, from the
+ * same offset, so every `ParseError` (offset, expected, context, cause and
+ * message) is exactly the one the interpreter reports.
+ *
+ * **Callbacks should be pure.** On an input that fails, the callbacks given
+ * to `map`, `filter`, `tryMap`, `tap`, `fold`, ... may run twice, once
+ * compiled and once interpreted. Callbacks whose results are discarded
+ * (a `map` inside `taken` or `preceded`, for example) may not run at all,
+ * nor those of a branch that is certain to fail, and token-set predicates
+ * may be called once per character code and cached.
+ *
+ * `Parser.parsePartial` and `ParserStream.parseAll` run a build that
+ * handles partial input. `ParserStream.parseMany`, `Parser.parseRecoverable`
+ * and runs with the `trace` option are always interpreted. Parsers that
+ * can't be described, such as `Parser.make` and `Parser.gen`, run
+ * interpreted inside compiled code.
+ *
+ * @since 0.2.0
+ */
+import type { Input } from "./Input.js"
+import type { Parser } from "./Parser.js"
+import { backend as closureBackend } from "./internal/compiler/closure.js"
+import { backend as jitBackend } from "./internal/compiler/jit.js"
+import { register } from "./internal/compiler/registry.js"
+
+/**
+ * Compiles a parser with the JIT: generated code where `new Function` is
+ * allowed, otherwise specialized closures (see {@link closure}). Returns the
+ * same parser.
+ *
+ * @example
+ * ```ts
+ * import { Ascii, Compiler, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * const list = Compiler.jit(Parser.separated(Ascii.decInt, Token.literal(",")))
+ * Parser.parse(list, "1,2,3") // Result.succeed([1, 2, 3])
+ * ```
+ *
+ * @since 0.2.0
+ * @category compilation
+ */
+export const jit = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<A, E, R, I> => {
+  register(self, jitBackend)
+  return self
+}
+
+/**
+ * Compiles a parser into specialized closures. Returns the same parser.
+ * Nothing is generated, so it works under a Content Security Policy, and a
+ * bundle that compiles only with `closure` contains no `new Function`.
+ *
+ * @example
+ * ```ts
+ * import { Ascii, Compiler, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * const list = Compiler.closure(Parser.separated(Ascii.decInt, Token.literal(",")))
+ * Parser.parse(list, "1,2,3") // Result.succeed([1, 2, 3])
+ * ```
+ *
+ * @since 0.2.0
+ * @category compilation
+ */
+export const closure = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<A, E, R, I> => {
+  register(self, closureBackend)
+  return self
+}

package/src/Expression.ts

@@ -35,10 +35,10 @@
  * @since 0.1.0
  */
 import type { Input, State } from "./Input.js"
-import { Fail, mergeFailures } from "./Input.js"
-import type { Failure } from "./Input.js"
+import { Fail } from "./Input.js"
 import type { Parser } from "./Parser.js"
 import { make as makeParser } from "./Parser.js"
+import { TiedFailures } from "./internal/ties.js"
 
 /**
  * An operator in an expression grammar.
@@ -160,13 +160,15 @@ export const make = <A, E, R, I extends Input, const Ops extends ReadonlyArray<O
 
   // 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. Expectations of failed attempts are accumulated in `failure`.
+  // 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
-  let failure: Failure | undefined
+  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)
+      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) {
@@ -177,29 +179,36 @@ export const make = <A, E, R, I extends Input, const Ops extends ReadonlyArray<O
         return i
       }
       if (state.mode !== "Backtrack") return -2
-      failure = failure === undefined ? state.failure : mergeFailures(failure, state.failure)
       state.pos = start
+      failures.add(state)
     }
     return -1
   }
 
   const expr = (state: State<any>, minPower: number): A | Fail => {
     let lhs: A | Fail
-    failure = undefined
+    failures.clear()
     const p = tryOps(state, prefixes, true)
     if (p === -2) return Fail
     if (p >= 0) {
-      const op = prefixes[p]!
+      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 = failure
+      const prefixFailure = failures.failure
+      const prefixTie1 = failures.tie1
+      const prefixTie2 = failures.tie2
       lhs = operand(state)
       if (lhs === Fail) {
         if (prefixFailure !== undefined && state.mode === "Backtrack") {
-          state.failWith("Backtrack", mergeFailures(prefixFailure, state.failure))
+          // 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
       }
@@ -207,11 +216,11 @@ export const make = <A, E, R, I extends Input, const Ops extends ReadonlyArray<O
 
     while (true) {
       const start = state.pos
-      failure = undefined
+      failures.clear()
       const q = tryOps(state, postfixes, true)
       if (q === -2) return Fail
       if (q >= 0) {
-        const op = postfixes[q]!
+        const op = postfixes[q]
         if (op.precedence * 2 < minPower) {
           state.pos = start
           break
@@ -219,15 +228,14 @@ export const make = <A, E, R, I extends Input, const Ops extends ReadonlyArray<O
         lhs = op.fold(lhs, matched)
         continue
       }
-      const postfixFailure = failure
+      // 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) {
-        const f = postfixFailure === undefined ? failure : failure === undefined ? postfixFailure : mergeFailures(postfixFailure, failure)
-        if (f !== undefined && f.offset === state.pos) state.setHint(f.offset, f.expected)
+        failures.hint(state)
         break
       }
-      const op = infixes[i]!
+      const op = infixes[i]
       const leftPower = op.precedence * 2
       if (leftPower < minPower) {
         state.pos = start