@thomasfosterau/effect-parse 0.3.0 → 0.4.0

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 })
+      }
+    )
 }

package/src/internal/compiler/entries.ts

@@ -17,7 +17,7 @@ export interface EntryPair {
 export const pairOf = (p: ParserLike): EntryPair | undefined => {
   let node = nodeOf(p)
   while (isDiagnostic(node)) node = nodeOf(node.self)
-  if (node._tag !== "Seq") return undefined
+  if (!Predicate.isTagged(node, "Seq")) return undefined
   const output = node.output
   if (output === "tuple") return node.parsers.length === 2 ? { parsers: node.parsers, key: 0, value: 1 } : undefined
   if (Predicate.isNumber(output) || output[0] === output[1]) return undefined
@@ -27,13 +27,13 @@ export const pairOf = (p: ParserLike): EntryPair | undefined => {
 const isDiagnostic = (
   node: Node
 ): node is NodeOf<"Context" | "Expected" | "MapError" | "OrFail" | "Trace" | "Syntax" | "RetryAfter"> =>
-  node._tag === "Context" ||
-  node._tag === "Expected" ||
-  node._tag === "MapError" ||
-  node._tag === "OrFail" ||
-  node._tag === "Trace" ||
-  node._tag === "Syntax" ||
-  node._tag === "RetryAfter"
+  Predicate.isTagged(node, "Context") ||
+  Predicate.isTagged(node, "Expected") ||
+  Predicate.isTagged(node, "MapError") ||
+  Predicate.isTagged(node, "OrFail") ||
+  Predicate.isTagged(node, "Trace") ||
+  Predicate.isTagged(node, "Syntax") ||
+  Predicate.isTagged(node, "RetryAfter")
 
 /**
  * Whether `map(p, Object.fromEntries)` can build its object directly: `p`
@@ -43,7 +43,10 @@ const isDiagnostic = (
  */
 export const buildsEntries = (p: ParserLike): boolean => {
   const node = nodeOf(p)
-  if (isDiagnostic(node) || node._tag === "Mode") return buildsEntries(node.self)
-  if (node._tag === "Seq") return Predicate.isNumber(node.output) && buildsEntries(node.parsers[node.output])
-  return (node._tag === "Repeat" || node._tag === "Separated") && pairOf(node.self) !== undefined
+  if (isDiagnostic(node) || Predicate.isTagged(node, "Mode")) return buildsEntries(node.self)
+  if (Predicate.isTagged(node, "Seq"))
+    return Predicate.isNumber(node.output) && buildsEntries(node.parsers[node.output])
+  return (
+    (Predicate.isTagged(node, "Repeat") || Predicate.isTagged(node, "Separated")) && pairOf(node.self) !== undefined
+  )
 }

package/src/internal/compiler/first.ts

@@ -15,11 +15,12 @@
  * Skipping a parser that is certain to fail also skips the callbacks it
  * would have run before failing, which is why callbacks must be pure.
  */
+import * as Arr from "effect/Array"
 import * as Predicate from "effect/Predicate"
 import type { Encoding } from "../../Encoding.js"
 import type { Node, ParserLike } from "../node.js"
 import { nodeOf } from "../node.js"
-import { fastLimit } from "../text.js"
+import { fastLimit, isEmptyUnits } from "../text.js"
 import type { CharSet } from "./sets.js"
 import { kindOfEncoding, reachesAbove, TableSize, textSet, tokenSet } from "./sets.js"
 
@@ -109,12 +110,12 @@ export class FirstSets {
         const lit = node.literal
         if (node.encoding !== undefined) {
           if (kindOfEncoding(node.encoding) !== kind) return unknown
-          if (node.caseless) return lit.length === 0 ? unknown : anyUnit
+          if (node.caseless) return isEmptyUnits(lit) ? unknown : anyUnit
           const encoded = node.encoding.encode(lit as string)
-          if (encoded.length === 0) return emptyOptional
+          if (isEmptyUnits(encoded)) return emptyOptional
           return ofUnits([Predicate.isString(encoded) ? encoded.charCodeAt(0) : encoded[0]])
         }
-        if (lit.length === 0) return emptyOptional
+        if (isEmptyUnits(lit)) return emptyOptional
         let first: number
         if (Predicate.isString(lit)) {
           first = kind === 0 ? lit.charCodeAt(0) : new TextEncoder().encode(lit)[0]
@@ -128,8 +129,8 @@ export class FirstSets {
       case "OneOf":
       case "TakeWhile": {
         if (node.encoding !== undefined && kindOfEncoding(node.encoding) !== kind) return unknown
-        const min = node._tag === "OneOf" ? 1 : node.min
-        if (node._tag === "TakeWhile" && node.max === 0) return emptyOptional
+        const min = Predicate.isTagged(node, "OneOf") ? 1 : node.min
+        if (Predicate.isTagged(node, "TakeWhile") && node.max === 0) return emptyOptional
         const mode = min > 0 ? Strict : Optional
         if (node.negate) return mode === Strict ? anyUnit : withMode(anyUnit, Optional)
         const set = node.encoding === undefined ? tokenSet(node.set, kind) : textSet(node.set)
@@ -158,7 +159,7 @@ export class FirstSets {
       case "FlatMap":
       case "SeparatedFold":
       case "Dispatch": {
-        const f = this.of(node._tag === "Dispatch" ? node.selector : node.self)
+        const f = this.of(Predicate.isTagged(node, "Dispatch") ? node.selector : node.self)
         return f.mode === Strict ? f : unknown
       }
       case "Mode": {
@@ -176,7 +177,7 @@ export class FirstSets {
       case "ZipWith":
         return this.sequence([node.self, node.that])
       case "Alt": {
-        if (node.parsers.length === 0) return failing
+        if (Arr.isReadonlyArrayEmpty(node.parsers)) return failing
         let acc: First | undefined
         let mode: 0 | 1 | 2 = Strict
         for (const p of node.parsers) {