@thomasfosterau/effect-parse 0.2.0 → 0.4.0

package/src/ParserStream.ts

@@ -36,6 +36,7 @@ import * as Registry from "./internal/compiler/registry.js"
 import type * as Resume from "./internal/resume.js"
 import * as Run from "./internal/run.js"
 import * as Stack from "./internal/stack.js"
+import { isEmptyUnits } from "./internal/text.js"
 import type { Parser } from "./Parser.js"
 
 /**
@@ -49,7 +50,7 @@ export type Chunkable = string | Uint8Array | ReadonlyArray<unknown>
 const concat = <I extends Chunkable>(a: I, b: I): I => {
   if (Predicate.isString(a)) return (a + (b as string)) as I
   if (a instanceof Uint8Array) {
-    if (a.length === 0) return b
+    if (a.byteLength === 0) return b
     const out = new Uint8Array(a.length + (b as Uint8Array).length)
     out.set(a)
     out.set(b as Uint8Array, a.length)
@@ -174,6 +175,7 @@ class Incremental<A, E, I extends Chunkable> {
   /** The input length at the last attempt, and where that attempt ran out of input. */
   private attempted = 0
   private restart = 0
+  private pushed = 0
   /** Set once an attempt settles: a success (with its end offset) or a definite failure. */
   private settled: { readonly value: A; readonly pos: number } | "failed" | undefined
 
@@ -221,9 +223,14 @@ class Incremental<A, E, I extends Chunkable> {
   }
 
   push(chunk: I): void {
-    if (chunk.length === 0) return
+    if (isEmptyUnits(chunk)) return
     this.append(chunk)
     if (this.settled !== undefined) return
+    // The first attempt waits for a second chunk: an input that arrives in
+    // one chunk (most small responses) is parsed once, by `finish`, instead
+    // of once in partial mode and again in complete mode, since a repetition
+    // that completes without resuming keeps no checkpoint
+    if (++this.pushed === 1) return
     // An attempt re-reads what the last one could not finish, from `restart`;
     // waiting until at least half as much new input has arrived keeps the
     // total work linear in the input. Strings are also copied when they are
@@ -234,9 +241,12 @@ class Incremental<A, E, I extends Chunkable> {
     this.attempt()
   }
 
-  /** The step attempts run: the parser's resumable compiled code if it was compiled, else the interpreter. */
-  private step(state: State<I>): unknown {
-    return Stack.run(Registry.stepFor(this.parser, state, true) ?? this.parser.step, state)
+  /**
+   * The step attempts run: the parser's compiled code if it was compiled
+   * (the resumable build, unless `resumable` is false), else the interpreter.
+   */
+  private step(state: State<I>, resumable = true): unknown {
+    return Stack.run(Registry.stepFor(this.parser, state, resumable) ?? this.parser.step, state)
   }
 
   private attempt(): void {
@@ -258,10 +268,12 @@ class Incremental<A, E, I extends Chunkable> {
     if (settled !== undefined && settled !== "failed") {
       if (settled.pos === this.length) return Effect.succeed(settled.value)
     } else if (settled === undefined) {
-      // The last attempt, in complete mode, resumes from the checkpoints too
+      // The last attempt, in complete mode, resumes from the checkpoints too;
+      // with no attempt before it, it is an ordinary parse
       const state = new State(this.input(), { context: this.context })
-      state.resume = this.resume
-      const a = this.step(state)
+      const resumable = this.attempted > 0
+      if (resumable) state.resume = this.resume
+      const a = this.step(state, resumable)
       if (a !== Fail && state.pos === state.end) return Effect.succeed(a as A)
     }
     // The error comes from an ordinary parse of the whole input, so it is the

package/src/Syntax.ts

@@ -46,17 +46,19 @@
  *
  * @since 0.2.0
  */
+import * as Str from "effect/String"
 import * as Predicate from "effect/Predicate"
 import type * as Context from "effect/Context"
 import { dual } from "effect/Function"
 import * as Option from "effect/Option"
 import type { Input, Slice, Source } from "./Input.js"
-import { Fail, fromSource } from "./Input.js"
+import { Fail, fromSource, State } from "./Input.js"
 import * as ParseError from "./ParseError.js"
 import { nodeOf } from "./internal/node.js"
+import { Key } from "./internal/key.js"
 import * as Stack from "./internal/stack.js"
 import type { ErrorInfo, Green, Previous, Segment } from "./internal/syntax.js"
-import { absolute, errorKind, SyntaxState } from "./internal/syntax.js"
+import { absolute, errorKind, SyntaxBuilder } from "./internal/syntax.js"
 import type { Parser } from "./Parser.js"
 import { described, isParser } from "./Parser.js"
 
@@ -67,7 +69,7 @@ import { described, isParser } from "./Parser.js"
 const syntaxNode = (self: Parser.Any, kind: string, named: boolean): Parser.Any => {
   const step = self.step
   // Identifies the nodes this parser builds, so a reparse can reuse them
-  const key = {}
+  const key = new Key()
   return described<unknown, unknown, unknown, Input>(
     (state) => {
       const builder = state.syntax
@@ -133,7 +135,7 @@ export const token: {
 
 const defaultTokenKind = (self: Parser.Any): string => {
   const n = nodeOf(self)
-  if (n._tag === "Literal" && Predicate.isString(n.literal) && !n.caseless) return n.literal
+  if (Predicate.isTagged(n, "Literal") && Predicate.isString(n.literal) && !n.caseless) return n.literal
   return self.name ?? "token"
 }
 
@@ -577,7 +579,7 @@ export class SyntaxNode<I extends Input = string> {
     let out = ""
     const visit = (green: Green, field: string | undefined) => {
       if (green.named || green === this.green) {
-        if (out.length > 0) out += " "
+        if (Str.isNonEmpty(out)) out += " "
         if (field !== undefined) out += `${field}: `
         out += `(${green.kind}`
         for (let i = 0; i < green.children.length; i++) visit(green.children[i], green.fields?.[i])
@@ -708,7 +710,8 @@ export class TreeCursor<I extends Input = string> {
 const expectedEof = ["end of input"]
 
 const run = <A, E, I extends Input>(config: Config, input: I, previous: Previous | undefined): Tree<A, E, I> => {
-  const state = new SyntaxState<I>(input, { context: config.context }, previous)
+  const state = new State<I>(input, { context: config.context })
+  const builder = new SyntaxBuilder(state, previous)
   const a = Stack.run(config.inner.step, state)
   // Text parsers record the encoding when they fail, which they may have done inside reused nodes
   if (state.encoding === undefined && previous !== undefined) state.encoding = previous.encoding
@@ -722,8 +725,8 @@ const run = <A, E, I extends Input>(config: Config, input: I, previous: Previous
   } else {
     value = Option.some(a as A)
   }
-  const green = state.finish(config.kind, Option.getOrUndefined(value), fatal, state.pos)
-  return new Tree<A, E, I>(input, value, state.reused, green, config, state.encoding)
+  const green = builder.finish(config.kind, Option.getOrUndefined(value), fatal, state.pos)
+  return new Tree<A, E, I>(input, value, builder.reused, green, config, state.encoding)
 }
 
 /**
@@ -756,7 +759,7 @@ export const parse: {
   options?: ParseOptions & { readonly context?: Context.Context<R> }
 ): Tree<A, E, I> => {
   const n = nodeOf(grammar)
-  const isRoot = n._tag === "Syntax" && n.kind !== undefined && n.named
+  const isRoot = Predicate.isTagged(n, "Syntax") && n.kind !== undefined && n.named
   const config: Config = {
     kind: isRoot ? n.kind : (options?.kind ?? "document"),
     inner: isRoot ? (n.self as Parser.Any) : grammar,

package/src/internal/compiler/closure.ts

@@ -12,20 +12,21 @@ import type { Encoding } from "../../Encoding.js"
 import type { ErrMode, State } from "../../Input.js"
 import { Fail } from "../../Input.js"
 import * as Option from "effect/Option"
+import * as Result from "effect/Result"
 import type { Node, NodeOf, ParserLike } from "../node.js"
 import { addEntry, flushEntries, fromEntries, isPlainKey } from "../entries.js"
-import { nodeOf } from "../node.js"
+import { nodeOf, scansFloat } from "../node.js"
 import { floatScan, floatTexts, scanFloatBytes, scanFloatString, toFloat } from "../numbers.js"
-import { charOf, fastLimit, firstCodePoint, fold, validate } from "../text.js"
+import { charOf, fastLimit, firstCodePoint, fold, utf16be, utf16le, validate } from "../text.js"
 import { countTokens, indexOf } from "../tokens.js"
 import type { AltPlan } from "./first.js"
+import { Key } from "../key.js"
 import * as Resume from "../resume.js"
 import type { Backend } from "./registry.js"
 import type { EntryPair } from "./entries.js"
 import { buildsEntries, pairOf } from "./entries.js"
 import { FirstSets, planAlt } from "./first.js"
-import type { CharSet } from "./sets.js"
-import { kindOfEncoding, TableSize, textSet, tokenSet } from "./sets.js"
+import { acceptTable, kindOfEncoding, TableSize, textSet, tokenSet } from "./sets.js"
 
 export type Step = (state: State<any>) => any
 
@@ -53,9 +54,6 @@ const Margin = 4
 
 const lowerAscii = (c: number): number => (c >= 65 && c <= 90 ? c + 32 : c)
 
-const isSuccess = (r: any): boolean => r._tag === "Success"
-const isSome = (o: any): boolean => o._tag === "Some"
-
 interface Slot {
   fn: Step | undefined
 }
@@ -183,7 +181,9 @@ class Compiler {
         return this.partialSafe(
           p,
           node.encoding === undefined ? this.token(p, node, used) : this.text(p, node, node.encoding, used),
-          node._tag === "Literal" || node._tag === "TakeUntil" ? node.literal.length * 4 : Margin
+          Predicate.isTagged(node, "Literal") || Predicate.isTagged(node, "TakeUntil")
+            ? node.literal.length * 4
+            : Margin
         )
       case "TillLineEnding":
       case "Identifier":
@@ -228,8 +228,8 @@ class Compiler {
         return (s) => {
           const a = c(s)
           if (a === Fail) return Fail
-          const r = f(a) as any
-          if (isSuccess(r)) return r.success
+          const r = f(a)
+          if (Result.isSuccess(r)) return r.success
           s.mode = BT
           return Fail
         }
@@ -240,8 +240,8 @@ class Compiler {
         return (s) => {
           const a = c(s)
           if (a === Fail) return Fail
-          const o = f(a) as any
-          if (isSome(o)) return o.value
+          const o = f(a)
+          if (Option.isSome(o)) return o.value
           s.mode = BT
           return Fail
         }
@@ -326,8 +326,8 @@ class Compiler {
       case "Opt":
       case "OrElseSucceed": {
         const c = this.compile(node.self, used)
-        const orElse = !used ? undefined : node._tag === "Opt" ? Option.none : node.value
-        const some = used && node._tag === "Opt"
+        const orElse = !used ? undefined : Predicate.isTagged(node, "Opt") ? Option.none : node.value
+        const some = used && Predicate.isTagged(node, "Opt")
         return (s) => {
           const start = s.pos
           const a = c(s)
@@ -558,9 +558,9 @@ class Compiler {
     }
     // Switch on the next unit when the selector is `any` or `peek(any)`
     let sel = nodeOf(node.selector)
-    const peek = sel._tag === "Peek"
+    const peek = Predicate.isTagged(sel, "Peek")
     if (peek) sel = nodeOf((sel as NodeOf<"Peek">).self)
-    if (sel._tag !== "Any" || !this.native(sel.encoding)) return general
+    if (!Predicate.isTagged(sel, "Any") || !this.native(sel.encoding)) return general
     const enc = sel.encoding
     // Units below `limit` are whole tokens, so the key is known in advance
     const limit = enc === undefined ? (this.kind === 0 ? 0xd800 : TableSize) : Math.min(fastLimit(enc), 0xd800)
@@ -596,11 +596,11 @@ class Compiler {
   repeat(node: NodeOf<"Repeat"> | NodeOf<"Fold">, used: boolean): Step {
     const { max, min } = node
     const checkLoop = max === Infinity
-    const isFold = node._tag === "Fold"
+    const isFold = Predicate.isTagged(node, "Fold")
     const cond = isFold ? (node as NodeOf<"Fold">).while : undefined
     const c = this.compile(node.self, used)
     const resumable = this.resumable
-    const key = {}
+    const key = new Key()
     // The accumulator: an array, the fold's value, or nothing when unused (and unneeded by `while`)
     const tracked = used || cond !== undefined
     const init: () => unknown = !tracked ? () => undefined : isFold ? (node as NodeOf<"Fold">).init : () => []
@@ -715,7 +715,7 @@ class Compiler {
     }
     const { max, min } = node
     const checkLoop = max === Infinity
-    if (node._tag === "Repeat") {
+    if (Predicate.isTagged(node, "Repeat")) {
       return (s) => {
         const acc = new EntriesAcc()
         for (let count = 0; count < max; count++) {
@@ -812,7 +812,7 @@ class Compiler {
     const c = this.compile(node.self, used)
     const sep = this.compile(node.separator, false)
     const resumable = this.resumable
-    const key = {}
+    const key = new Key()
     return (s) => {
       const entry = s.pos
       let acc: Array<unknown> | undefined
@@ -878,7 +878,7 @@ class Compiler {
     const sep = this.compile(node.separator, true)
     const op = node.op
     const resumable = this.resumable
-    const key = {}
+    const key = new Key()
     if (!node.right) {
       return (s) => {
         const entry = s.pos
@@ -1169,22 +1169,19 @@ class Compiler {
   // ---------------------------------------------------------------------------
 
   text(p: ParserLike, node: TokenNode, enc: Encoding<any>, used: boolean): Step {
-    const kind = this.kind as 0 | 1
-    const fast = fastLimit(enc)
+    const { fast, unitAt, width: unitWidth } = unitReader(this.kind, enc)
     const decode = enc.decode
     const width = enc.width
     const toText = enc.text
-    const unitAt: (input: any, i: number) => number =
-      kind === 0 ? (input: string, i) => input.charCodeAt(i) : (input: Uint8Array, i) => input[i]
     switch (node._tag) {
       case "Any":
         return (s) => {
           const pos = s.pos
           const end = s.end
           if (pos >= end) return fail(s)
-          const c = unitAt(s.input, pos)
+          const c = unitAt(s.input, pos, end)
           if (c < fast) {
-            s.pos = pos + 1
+            s.pos = pos + unitWidth
             return used ? charOf(c) : undefined
           }
           const cp = decode(s.input, pos, end)
@@ -1204,11 +1201,11 @@ class Compiler {
             let pos = start
             for (let i = 0; i < n; i++) {
               if (pos >= end) return failAt(s, pos)
-              const c = unitAt(input, pos)
+              const c = unitAt(input, pos, end)
               let cp: number
               if (c < fast) {
                 cp = c
-                pos++
+                pos += unitWidth
               } else {
                 cp = decode(input, pos, end)
                 if (cp < 0) return failAt(s, pos)
@@ -1253,15 +1250,15 @@ class Compiler {
           const pos = s.pos
           const end = s.end
           if (pos >= end) return fail(s)
-          const c = unitAt(s.input, pos)
+          const c = unitAt(s.input, pos, end)
           if (c < fast && c < TableSize) {
             if (accept[c] === 0) return fail(s)
-            s.pos = pos + 1
+            s.pos = pos + unitWidth
             return used ? charOf(c) : undefined
           }
           const cp = c < fast ? c : decode(s.input, pos, end)
           if (cp < 0 || test(cp) === negate) return fail(s)
-          s.pos = pos + (c < fast ? 1 : width(cp))
+          s.pos = pos + (c < fast ? unitWidth : width(cp))
           return used ? charOf(cp) : undefined
         }
       }
@@ -1274,8 +1271,8 @@ class Compiler {
           let pos = start
           for (let got = 0; got < count; got++) {
             if (pos >= end) return failAt(s, pos)
-            const c = unitAt(input, pos)
-            if (c < fast) pos++
+            const c = unitAt(input, pos, end)
+            if (c < fast) pos += unitWidth
             else {
               const cp = decode(input, pos, end)
               if (cp < 0) return failAt(s, pos)
@@ -1291,32 +1288,12 @@ class Compiler {
         const set = textSet(node.set)
         const accept = acceptTable(set, negate)
         const test = set.test
-        const small = Math.min(fast, TableSize)
-        return (s) => {
-          const input = s.input
-          const start = s.pos
-          const end = s.end
-          let i = start
-          let count = 0
-          while (count < max && i < end) {
-            const c = unitAt(input, i)
-            if (c < small) {
-              if (accept[c] === 0) break
-              i++
-            } else if (c < fast) {
-              if (test(c) === negate) break
-              i++
-            } else {
-              const cp = decode(input, i, end)
-              if (cp < 0 || test(cp) === negate) break
-              i += width(cp)
-            }
-            count++
-          }
-          if (count < min) return failAt(s, i)
-          s.pos = i
-          return used ? toText(input, start, i) : undefined
-        }
+        const loop: TextLoop = { max, min, negate, accept, test, small: Math.min(fast, TableSize), fast, used }
+        // One function per kind of unit read, from its own source: a loop
+        // shared by every encoding sees several readers once a program
+        // parses more than one, and stops inlining them
+        if (unitWidth === 2) return takeWhileUtf16(loop, enc === utf16le ? 0 : 1, enc)
+        return this.kind === 0 ? takeWhileString(loop, enc) : takeWhileBytes(loop, enc)
       }
       case "TakeUntil":
       case "Rest":
@@ -1341,17 +1318,15 @@ class Compiler {
       }
     }
     // `Text.taken` checks that the text is well formed, then decodes it
-    const fast = fastLimit(enc)
+    const { fast, unitAt, width } = unitReader(this.kind, enc)
     const toText = enc.text
-    const unitAt: (input: any, i: number) => number =
-      this.kind === 0 ? (input: string, i) => input.charCodeAt(i) : (input: Uint8Array, i) => input[i]
     return (s) => {
       const start = s.pos
       if (c(s) === Fail) return Fail
       const end = s.pos
       const input = s.input
       let i = start
-      while (i < end && unitAt(input, i) < fast) i++
+      while (i < end && unitAt(input, i, end) < fast) i += width
       if (i < end && validate(enc, s, i, end) < 0) return fail(s)
       return used ? toText(input, start, end) : undefined
     }
@@ -1364,11 +1339,7 @@ class Compiler {
    */
   private float(node: NodeOf<"Map">): Step | undefined {
     if (!floatTexts.has(node.self) || this.kind === 2) return undefined
-    let taken = nodeOf(node.self)
-    while (taken._tag === "Expected") taken = nodeOf(taken.self)
-    if (taken._tag !== "Taken") return undefined
-    const enc = taken.encoding
-    if (enc !== undefined && !(this.native(enc) && enc.unit === 1 && enc.asciiCompatible)) return undefined
+    if (!scansFloat(node.self, (enc) => this.native(enc))) return undefined
     const c = this.compile(node.self, true)
     const scan = (this.kind === 0 ? scanFloatString : scanFloatBytes) as (
       input: unknown,
@@ -1415,6 +1386,15 @@ class Compiler {
               }
               return false
             }
+    } else if (ctrl < unitReader(kind, enc).fast) {
+      const { unitAt, width } = unitReader(kind, enc)
+      control = (s) => {
+        if (s.pos < s.end && unitAt(s.input, s.pos, s.end) === ctrl) {
+          s.pos += width
+          return true
+        }
+        return false
+      }
     } else {
       control = (s) => {
         if (s.pos >= s.end) return false
@@ -1425,7 +1405,7 @@ class Compiler {
       }
     }
     const resumable = this.resumable
-    const key = {}
+    const key = new Key()
     /** Fails as incomplete, keeping a checkpoint in a streaming parse. */
     const incomplete = (s: State<any>, start: number, checkpoint: unknown): typeof Fail => {
       if (s.resume !== undefined) Resume.save(s, key, start, checkpoint)
@@ -1522,19 +1502,149 @@ const fail = (s: State<any>): typeof Fail => {
 }
 
 /** Fails, leaving the cursor at `pos`: how far a token parser read (see `partialSafe`). */
+/** The settings of a compiled `Text` `takeWhile` loop. */
+interface TextLoop {
+  readonly max: number
+  readonly min: number
+  readonly negate: boolean
+  /** 1 where a code below `small` is accepted (see `acceptTable`). */
+  readonly accept: Uint8Array
+  readonly test: (code: number) => boolean
+  readonly small: number
+  /** Units below it are whole code points. */
+  readonly fast: number
+  readonly used: boolean
+}
+
+// `takeWhile` for each kind of unit read. The three loops differ only in
+// how they read a unit; they are written out because a single loop calling
+// a reader, or branching on one, measured slower (see `text`).
+
+const takeWhileString = (loop: TextLoop, enc: Encoding<string>): Step => {
+  const { accept, fast, max, min, negate, small, test, used } = loop
+  const { decode, text, width } = enc
+  return (s) => {
+    const input: string = s.input
+    const start = s.pos
+    const end = s.end
+    let i = start
+    let count = 0
+    while (count < max && i < end) {
+      const c = input.charCodeAt(i)
+      if (c < small) {
+        if (accept[c] === 0) break
+        i++
+      } else if (c < fast) {
+        if (test(c) === negate) break
+        i++
+      } else {
+        const cp = decode(input, i, end)
+        if (cp < 0 || test(cp) === negate) break
+        i += width(cp)
+      }
+      count++
+    }
+    if (count < min) return failAt(s, i)
+    s.pos = i
+    return used ? text(input, start, i) : undefined
+  }
+}
+
+const takeWhileBytes = (loop: TextLoop, enc: Encoding<Uint8Array>): Step => {
+  const { accept, max, min, negate, small, test, used } = loop
+  const { decode, text, width } = enc
+  return (s) => {
+    const input: Uint8Array = s.input
+    const start = s.pos
+    const end = s.end
+    let i = start
+    let count = 0
+    while (count < max && i < end) {
+      const c = input[i]
+      // A byte below `fast` is below `small` too, as `small` is `fast` or the table size
+      if (c < small) {
+        if (accept[c] === 0) break
+        i++
+      } else {
+        const cp = decode(input, i, end)
+        if (cp < 0 || test(cp) === negate) break
+        i += width(cp)
+      }
+      count++
+    }
+    if (count < min) return failAt(s, i)
+    s.pos = i
+    return used ? text(input, start, i) : undefined
+  }
+}
+
+/** For UTF-16 bytes; `lo` is the offset of a unit's low byte (0 for little endian). */
+const takeWhileUtf16 = (loop: TextLoop, lo: 0 | 1, enc: Encoding<Uint8Array>): Step => {
+  const { accept, fast, max, min, negate, small, test, used } = loop
+  const { decode, text, width } = enc
+  const hi = 1 - lo
+  return (s) => {
+    const input: Uint8Array = s.input
+    const start = s.pos
+    const end = s.end
+    let i = start
+    let count = 0
+    while (count < max && i < end) {
+      // A unit cut off by `end` reads as 0xFFFF, so `decode` reports it
+      const c = i + 1 < end ? input[i + lo] | (input[i + hi] << 8) : 0xffff
+      if (c < fast ? (c < small ? accept[c] === 0 : test(c) === negate) : false) break
+      if (c < fast) i += 2
+      else {
+        const cp = decode(input, i, end)
+        if (cp < 0 || test(cp) === negate) break
+        i += width(cp)
+      }
+      count++
+    }
+    if (count < min) return failAt(s, i)
+    s.pos = i
+    return used ? text(input, start, i) : undefined
+  }
+}
+
+/**
+ * How a `Text` parser reads its encoding's code units: a unit below `fast`
+ * is a whole code point, `width` input units long. UTF-16 bytes get a unit
+ * reader, as in the JIT; a unit cut off by `end` reads as 0xFFFF, so it
+ * takes the `decode` path, which reports it truncated.
+ */
+interface UnitReader {
+  readonly width: 1 | 2
+  readonly fast: number
+  readonly unitAt: (input: any, i: number, end: number) => number
+}
+
+const unitReader = (kind: 0 | 1 | 2, enc: Encoding<any>): UnitReader => {
+  if (kind === 1 && (enc === utf16le || enc === utf16be)) {
+    return {
+      width: 2,
+      fast: 0xd800,
+      unitAt:
+        enc === utf16le
+          ? (input: Uint8Array, i, end) => (i + 1 < end ? input[i] | (input[i + 1] << 8) : 0xffff)
+          : (input: Uint8Array, i, end) => (i + 1 < end ? (input[i] << 8) | input[i + 1] : 0xffff)
+    }
+  }
+  // `end` is declared though unused: calls with more arguments than
+  // parameters measured 1-2% slower on the JSON benchmark
+  return {
+    width: 1,
+    fast: fastLimit(enc),
+    unitAt: kind === 0 ? (input: string, i, _end) => input.charCodeAt(i) : (input: Uint8Array, i, _end) => input[i]
+  }
+}
+
 const failAt = (s: State<any>, pos: number): typeof Fail => {
   s.pos = pos
   s.mode = BT
   return Fail
 }
 
-/** 1 where a small code is accepted (taking `negate` into account). */
-const acceptTable = (set: CharSet, negate: boolean): Uint8Array => {
-  const t = new Uint8Array(TableSize)
-  for (let c = 0; c < TableSize; c++) t[c] = (set.table[c] === 1) !== negate ? 1 : 0
-  return t
-}
-
 /** A literal matched against a string input, returning `value`. */
 const stringLiteral = (str: string, value: unknown): Step => {
   const len = str.length
@@ -1592,12 +1702,14 @@ export const createClosureCompiler = (kind: 0 | 1 | 2, resumable = false): Closu
   }
 }
 
+/** A compiled root parser, with the parts of it that run interpreted. */
+export interface CompiledRoot {
+  readonly step: Step
+  readonly fallbacks: ReadonlyArray<Fallback>
+}
+
 /** Compiles a root parser for one input kind. */
-const compileClosure = (
-  root: ParserLike,
-  kind: 0 | 1 | 2,
-  resumable = false
-): { readonly step: Step; readonly fallbacks: ReadonlyArray<Fallback> } => {
+const compileClosure = (root: ParserLike, kind: 0 | 1 | 2, resumable = false): CompiledRoot => {
   const compiler = new Compiler(kind, resumable)
   const step = compiler.compile(root, true)
   return { step, fallbacks: compiler.fallbacks }
@@ -1605,12 +1717,12 @@ const compileClosure = (
 
 /** The closure compiler as a backend. */
 export const backend: Backend = {
-  build: (p, kind, resumable) => {
-    try {
-      const { fallbacks, step } = compileClosure(p, kind, resumable)
-      return { backend: "closure", step, fallbacks, error: undefined }
-    } catch (error) {
-      return { backend: undefined, step: undefined, fallbacks: [], error }
-    }
-  }
+  build: (p, kind, resumable) =>
+    Result.match(
+      Result.try(() => compileClosure(p, kind, resumable)),
+      {
+        onSuccess: ({ fallbacks, step }) => ({ backend: "closure" as const, step, fallbacks, error: undefined }),
+        onFailure: (error) => ({ backend: undefined, step: undefined, fallbacks: [], error })
+      }
+    )
 }