@thomasfosterau/effect-parse 0.4.1 → 0.6.0

package/src/Compiler.ts

@@ -4,11 +4,15 @@
  * `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:
+ * There are three compilers, one function each, so a program bundles only
+ * the ones it uses, and a program that compiles nothing bundles none:
  *
+ * - {@link wasm} scans the input in WebAssembly and builds the value with
+ *   generated JavaScript. It is the fastest on strings and bytes, and uses
+ *   the JIT for array input and streaming, and where WebAssembly or
+ *   `new Function` is unavailable.
  * - {@link jit} generates code with `new Function` where it is allowed, and
- *   otherwise uses the closure compiler. It is the fastest.
+ *   otherwise uses the closure compiler.
  * - {@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
@@ -32,7 +36,9 @@
  * **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.
+ * message) is exactly the one the interpreter reports. Running out of
+ * partial input is not a failure that needs it: compiled code reports
+ * `Incomplete` where the interpreter does, with the same `needed`.
  *
  * **Callbacks should be pure.** On an input that fails, the callbacks given
  * to `map`, `filter`, `tryMap`, `tap`, `fold`, ... may run twice, once
@@ -41,19 +47,57 @@
  * 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
+ * `Parser.parsePartial`, `ParserStream.parseAll` and
+ * `ParserStream.parseMany` run a build that handles partial input;
+ * `parseMany` runs it once per value and parses a value again, interpreted,
+ * only when it fails. `Parser.parseRecoverable`, `Syntax`
+ * parses 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.
+ * interpreted inside compiled code; the parsers given to a
+ * `Parser.combinator` compile, and its step is built from theirs.
  *
  * @since 0.2.0
  */
-import type { Input } from "./Input.js"
-import type { Parser } from "./Parser.js"
+import type { Fail, Input, State } from "./Input.js"
+import type { Parser, RunOptions } 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"
+import { backend as wasmBackend } from "./internal/compiler/wasm.js"
+import { prepare } from "./internal/run.js"
+
+/**
+ * Compiles a parser with the WebAssembly compiler. Returns the same parser.
+ *
+ * The input is copied into WebAssembly memory and scanned there, by code
+ * generated from the grammar; a JavaScript function generated with
+ * `new Function` then builds the value from what the scan recorded, with
+ * the same callbacks and the same objects as the JIT. Parts of the grammar
+ * with no WebAssembly form (such as `Parser.make`, `flatMap`, or `filter`
+ * on a value) run their JIT-compiled code from inside the scan.
+ *
+ * It uses the JIT (see {@link jit}) for array input, for the streaming build
+ * of `Parser.parsePartial` and `ParserStream`, and where `WebAssembly` or
+ * `new Function` is unavailable: a Content Security Policy needs both
+ * `'wasm-unsafe-eval'` and `'unsafe-eval'` for it. Short strings with the
+ * same characters may be returned as one string, which no program can tell
+ * apart from two.
+ *
+ * @example
+ * ```ts
+ * import { Ascii, Compiler, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * const list = Compiler.wasm(Parser.separated(Ascii.decInt, Token.literal(",")))
+ * Parser.parse(list, "1,2,3") // Result.succeed([1, 2, 3])
+ * ```
+ *
+ * @since 0.5.0
+ * @category compilation
+ */
+export const wasm = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<A, E, R, I> => {
+  register(self, wasmBackend)
+  return self
+}
 
 /**
  * Compiles a parser with the JIT: generated code where `new Function` is
@@ -96,3 +140,50 @@ export const closure = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Par
   register(self, closureBackend)
   return self
 }
+
+/**
+ * Prepares a parser for running many times on states you own, as
+ * `Parser.run` does: for drivers that make one small run per token, such as
+ * a lexer over a buffer. `Parser.run` looks the parser's compiled form up
+ * on every run, which costs about a quarter of a small token's time; the
+ * function returned here looks it up once (again only when the input kind
+ * changes, or between complete and partial states) and calls the compiled
+ * code directly.
+ *
+ * It returns exactly what `Parser.run(self, state, options)` returns, and
+ * leaves the state as it would: the output with the cursor where the
+ * parser stopped, or `Fail` with the interpreter's failure (or, with
+ * `diagnostics: false`, only the mode). Compile the parser first with
+ * {@link jit} or {@link closure}; a parser that isn't compiled runs
+ * interpreted. The compiled form is looked up on the first run, so compile
+ * the parser before using the runner: compiling it again later doesn't
+ * reach a runner that has already run.
+ *
+ * @example
+ * ```ts
+ * import { Ascii, Compiler, Input, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * const token = Compiler.jit(Parser.preceded(Ascii.space0, Parser.alt(Ascii.alpha1, Token.oneOf("+-"))))
+ * const next = Compiler.runner(token)
+ *
+ * const tokens = (text: string): Array<string> => {
+ *   const state = new Input.State(text)
+ *   const out: Array<string> = []
+ *   while (state.pos < state.end) {
+ *     const t = next(state.reset(state.pos))
+ *     if (t === Input.Fail) break
+ *     out.push(t)
+ *   }
+ *   return out
+ * }
+ *
+ * tokens("a + b") // ["a", "+", "b"]
+ * ```
+ *
+ * @since 0.5.0
+ * @category running
+ */
+export const runner = <A, E, R, I extends Input>(
+  self: Parser<A, E, R, I>,
+  options?: RunOptions
+): ((state: State<I>) => A | Fail) => prepare(self, self.step, options?.diagnostics !== false)

package/src/Expression.ts

@@ -38,7 +38,10 @@ import * as Predicate from "effect/Predicate"
 import type { Input, State } from "./Input.js"
 import { Fail } from "./Input.js"
 import type { Parser } from "./Parser.js"
-import { make as makeParser } from "./Parser.js"
+import { combinator } from "./Parser.js"
+
+/** A parser's step, interpreted or compiled. */
+type Step = (state: State<any>) => unknown
 import { TiedFailures } from "./internal/ties.js"
 
 /**
@@ -154,101 +157,111 @@ export const make = <A, E, R, I extends Input, const Ops extends ReadonlyArray<O
   readonly operand: Parser<A, E, R, I>
   readonly operators: Ops
 }): Parser<A, E | OpError<Ops[number]>, R | OpServices<Ops[number]>, I & OpInput<Ops[number]>> => {
-  const operand = options.operand.step
   const prefixes = options.operators.filter((o): o is Prefix<A, any, any, any> => Predicate.isTagged(o, "Prefix"))
   const postfixes = options.operators.filter((o): o is Postfix<A, any, any, any> => Predicate.isTagged(o, "Postfix"))
   const infixes = options.operators.filter((o): o is Infix<A, any, any, any> => Predicate.isTagged(o, "Infix"))
+  const operators = [...prefixes, ...postfixes, ...infixes]
+  const parsers = [options.operand, ...operators.map((o) => o.parser)]
+  // Builds the step from the operand's and the operators' steps, in that
+  // order: their own steps when interpreted, compiled ones when compiled
+  const build = (steps: ReadonlyArray<Step>) => {
+    const operand = steps[0]
+    const prefixSteps = steps.slice(1, 1 + prefixes.length)
+    const postfixSteps = steps.slice(1 + prefixes.length, 1 + prefixes.length + postfixes.length)
+    const infixSteps = steps.slice(1 + prefixes.length + postfixes.length)
 
-  // 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. 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
-  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)
-      if (out !== Fail) {
-        // A prefix or postfix operator matching nothing would apply forever
-        if (mustConsume && state.pos === start) {
-          state.failMessage("Cut", "Assert", "prefix and postfix operators must always consume")
-          return -2
+    // 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. 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
+    const failures = new TiedFailures()
+    const tryOps = (state: State<any>, ops: ReadonlyArray<Step>, mustConsume: boolean): number => {
+      const start = state.pos
+      for (let i = 0; i < ops.length; i++) {
+        const out = ops[i](state)
+        if (out !== Fail) {
+          // A prefix or postfix operator matching nothing would apply forever
+          if (mustConsume && state.pos === start) {
+            state.failMessage("Cut", "Assert", "prefix and postfix operators must always consume")
+            return -2
+          }
+          matched = out
+          return i
         }
-        matched = out
-        return i
+        if (state.mode !== "Backtrack") return -2
+        state.rewind(start)
+        failures.add(state)
       }
-      if (state.mode !== "Backtrack") return -2
-      state.rewind(start)
-      failures.add(state)
+      return -1
     }
-    return -1
-  }
 
-  const expr = (state: State<any>, minPower: number): A | Fail => {
-    let lhs: A | Fail
-    failures.clear()
-    const p = tryOps(state, prefixes, true)
-    if (p === -2) return Fail
-    if (p >= 0) {
-      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 = failures.failure
-      const prefixTie1 = failures.tie1
-      const prefixTie2 = failures.tie2
-      lhs = operand(state)
-      if (lhs === Fail) {
-        if (prefixFailure !== undefined && state.mode === "Backtrack") {
-          // 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)
+    const expr = (state: State<any>, minPower: number): A | Fail => {
+      let lhs: A | Fail
+      failures.clear()
+      const p = tryOps(state, prefixSteps, true)
+      if (p === -2) return Fail
+      if (p >= 0) {
+        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 = failures.failure
+        const prefixTie1 = failures.tie1
+        const prefixTie2 = failures.tie2
+        // SAFETY: the operand's step, interpreted or compiled, returns its output (an `A`) or `Fail`
+        lhs = operand(state) as A | Fail
+        if (lhs === Fail) {
+          if (prefixFailure !== undefined && state.mode === "Backtrack") {
+            // 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
         }
-        return Fail
       }
-    }
 
-    while (true) {
-      const start = state.pos
-      failures.clear()
-      const q = tryOps(state, postfixes, true)
-      if (q === -2) return Fail
-      if (q >= 0) {
-        const op = postfixes[q]
-        if (op.precedence * 2 < minPower) {
+      while (true) {
+        const start = state.pos
+        failures.clear()
+        const q = tryOps(state, postfixSteps, true)
+        if (q === -2) return Fail
+        if (q >= 0) {
+          const op = postfixes[q]
+          if (op.precedence * 2 < minPower) {
+            state.rewind(start)
+            break
+          }
+          lhs = op.fold(lhs, matched)
+          continue
+        }
+        // The infix attempts are folded on top of the postfix ones
+        const i = tryOps(state, infixSteps, false)
+        if (i === -2) return Fail
+        if (i < 0) {
+          failures.hint(state)
+          break
+        }
+        const op = infixes[i]
+        const leftPower = op.precedence * 2
+        if (leftPower < minPower) {
           state.rewind(start)
           break
         }
-        lhs = op.fold(lhs, matched)
-        continue
-      }
-      // 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) {
-        failures.hint(state)
-        break
+        const opOut = matched
+        const rhs = expr(state, op.associativity === "left" ? leftPower + 1 : leftPower)
+        if (rhs === Fail) return Fail
+        lhs = op.fold(lhs, opOut, rhs)
       }
-      const op = infixes[i]
-      const leftPower = op.precedence * 2
-      if (leftPower < minPower) {
-        state.rewind(start)
-        break
-      }
-      const opOut = matched
-      const rhs = expr(state, op.associativity === "left" ? leftPower + 1 : leftPower)
-      if (rhs === Fail) return Fail
-      lhs = op.fold(lhs, opOut, rhs)
+      return lhs
     }
-    return lhs
+    return (state: State<any>) => expr(state, 0)
   }
-
-  return makeParser((state: State<any>) => expr(state, 0), "expression")
+  return combinator(parsers, build, "expression")
 }

package/src/Input.ts

@@ -19,6 +19,7 @@ import * as Context from "effect/Context"
 import type { Encoding } from "./Encoding.js"
 import type { ErrorKind } from "./ParseError.js"
 import type { Builder as SyntaxBuilder } from "./internal/syntax.js"
+import type { AsciiRun } from "./internal/text.js"
 
 /**
  * The kinds of input a parser can consume.
@@ -56,6 +57,17 @@ export type BinaryInput = ArrayBufferLike | ArrayBufferView
  */
 export type Source<I> = I | ([I] extends [Uint8Array] ? BinaryInput : never)
 
+/**
+ * The overloads of {@link fromSource}.
+ *
+ * @since 0.5.0
+ * @category constructors
+ */
+export interface FromSourceFn {
+  (source: BinaryInput): Uint8Array
+  <I extends Input>(source: Source<I>): I
+}
+
 /**
  * Converts a {@link Source} to the input parsers read: binary data becomes a
  * `Uint8Array` view of the same memory, everything else is returned as is.
@@ -70,10 +82,7 @@ export type Source<I> = I | ([I] extends [Uint8Array] ? BinaryInput : never)
  * @since 0.1.0
  * @category constructors
  */
-export const fromSource: {
-  (source: BinaryInput): Uint8Array
-  <I extends Input>(source: Source<I>): I
-} = (source: Input | BinaryInput): any => {
+export const fromSource: FromSourceFn = (source: Input | BinaryInput): any => {
   if (Predicate.isString(source) || source instanceof Uint8Array || Array.isArray(source)) return source
   if (ArrayBuffer.isView(source)) return new Uint8Array(source.buffer, source.byteOffset, source.byteLength)
   // An explicit length fixes the view's size even for a resizable buffer
@@ -267,6 +276,18 @@ export class State<I extends Input = Input> {
     this.deepestIsLatest = false
     this.deepestFailure = failure
   }
+  /**
+   * Whether compiled code is running on this state. A compiled run that fails
+   * is thrown away (the interpreter runs again to build the error) and one
+   * that succeeds records no diagnostics, so interpreted steps called from it
+   * (an opaque `Parser.make`, a leaf near the end of a partial input) record
+   * a `Backtrack` or `Cut` failure's mode only, without building its
+   * {@link Failure} (#82). `Incomplete` failures are still built: a compiled
+   * run's `Incomplete` is reported as it stands.
+   *
+   * @internal
+   */
+  compiledRun = false
   /** When defined, `Parser.resumeAfter`/`retryAfter` record failures here. */
   recovered: Array<Failure> | undefined = undefined
   /** When defined, `Parser.trace` reports events here. */
@@ -292,6 +313,33 @@ export class State<I extends Input = Input> {
    * @internal
    */
   syntax: SyntaxBuilder | undefined = undefined
+  /**
+   * Where the stop characters of compiled `takeTill`s next occur in this
+   * state's input, by search site; created on first use. It lives as long
+   * as the state. `reset` keeps it for string input (a string never
+   * changes, and the positions are absolute, so they hold wherever the next
+   * run starts) and drops it for bytes and arrays, which a caller may
+   * refill in place between runs.
+   *
+   * @internal
+   */
+  searches: Map<object, Array<number>> | undefined = undefined
+  /**
+   * A run of ASCII bytes of this state's UTF-8 input, decoded once, from
+   * which `Text.utf8` slices the long strings it decodes (see
+   * `internal/text.ts`); `reset` clears it with the other per-run fields.
+   *
+   * @internal
+   */
+  asciiRun: AsciiRun | undefined = undefined
+  /**
+   * A `DataView` of this state's byte input, for the `Binary` parsers;
+   * created on first use. It lives as long as the state, whose input never
+   * changes: one per read cost most of a number's time.
+   *
+   * @internal
+   */
+  view: DataView | undefined = undefined
 
   constructor(
     source: I | Source<I>,
@@ -301,7 +349,7 @@ export class State<I extends Input = Input> {
       readonly offset?: number | undefined
     }
   ) {
-    const input = fromSource(source as Input) as I
+    const input = fromSource<I>(source)
     this.input = input
     this.end = input.length
     this.pos = options?.offset ?? 0
@@ -349,7 +397,11 @@ export class State<I extends Input = Input> {
    *
    * Every per-run field is reset: the cursor and end, the latest failure,
    * hints and furthest failure, recorded recoveries, the tracer and tracing
-   * depth, the recorded encoding and streaming checkpoints. Like the
+   * depth, the recorded encoding and streaming checkpoints. For string
+   * input, what the state has learnt about the string (where the stop
+   * characters of `takeTill` and the literals of `takeUntilAny` occur) is
+   * kept, as a string cannot change; for bytes and arrays it is dropped, so
+   * a buffer refilled in place between runs is searched afresh. Like the
    * constructor, `partial` defaults to `false` and `context` to the empty
    * context, so pass them again on every reset.
    *
@@ -388,11 +440,20 @@ export class State<I extends Input = Input> {
     this.hintExpected = empty
     this.deepestFailure = undefined
     this.deepestIsLatest = false
+    this.compiledRun = false
     this.recovered = undefined
     this.tracer = undefined
     this.depth = 0
     this.encoding = undefined
     this.resume = undefined
+    // For a string, `searches` is kept: it remembers where stop characters
+    // and literals occur by absolute position, and a string never changes,
+    // so it holds at any offset. A lexer that resets before each token
+    // otherwise searched to the end of the buffer again for every token
+    // (#126). Bytes and arrays can be refilled in place between runs (a
+    // `Uint8Array` source is viewed, not copied), so theirs is dropped.
+    if (this.inputKind !== 0) this.searches = undefined
+    this.asciiRun = undefined
     return this
   }
 
@@ -445,7 +506,14 @@ export class State<I extends Input = Input> {
    * Extracts the slice `[start, end)` of the input.
    */
   slice(start: number, end: number): Slice<I> {
-    const input = this.input as any
+    // SAFETY: `inputKind` 1 is a `Uint8Array`, whose `subarray` returns a
+    // `Uint8Array` view (its `Slice`); 0 and 2 are a string and an array, whose
+    // `slice` returns a string and an array of the same elements (their
+    // `Slice`). `subarray` is only called for kind 1
+    const input = this.input as {
+      slice(start: number, end: number): Slice<I>
+      subarray(start: number, end: number): Slice<I>
+    } & I
     switch (this.inputKind) {
       case 0:
         return input.slice(start, end)
@@ -460,6 +528,10 @@ export class State<I extends Input = Input> {
    * Records a recoverable failure at the current offset and returns {@link Fail}.
    */
   backtrack(kind: ErrorKind, expected: ReadonlyArray<string> = empty, offset: number = this.pos): Fail {
+    if (this.compiledRun) {
+      this.mode = "Backtrack"
+      return Fail
+    }
     return this.failWith("Backtrack", this.makeFailure(offset, kind, expected))
   }
 
@@ -467,6 +539,10 @@ export class State<I extends Input = Input> {
    * Records an unrecoverable failure at the current offset and returns {@link Fail}.
    */
   cut(kind: ErrorKind, expected: ReadonlyArray<string> = empty, offset: number = this.pos): Fail {
+    if (this.compiledRun) {
+      this.mode = "Cut"
+      return Fail
+    }
     return this.failWith("Cut", this.makeFailure(offset, kind, expected))
   }
 
@@ -598,14 +674,30 @@ export class State<I extends Input = Input> {
   }
 }
 
+/**
+ * The last merges {@link mergeExpected} made, as `[a, b, merged]` triples. A
+ * parse merges the same few pairs of expectation arrays over and over (a
+ * whitespace skipper's hint with a repetition's, then with the failure of
+ * the token after them), and expectation arrays are never mutated, so a
+ * merge seen recently returns its earlier result, which in turn keeps the
+ * next merge's input the same array.
+ */
+const merges: Array<ReadonlyArray<string>> = /*#__PURE__*/ new Array(12).fill(empty)
+let mergeSlot = 0
+
 /** @internal */
 export const mergeExpected = (a: ReadonlyArray<string>, b: ReadonlyArray<string>): ReadonlyArray<string> => {
   if (Arr.isReadonlyArrayEmpty(a)) return b
   if (Arr.isReadonlyArrayEmpty(b)) return a
+  for (let i = 0; i < 12; i += 3) if (merges[i] === a && merges[i + 1] === b) return merges[i + 2]
   const out = a.slice()
   for (const e of b) {
     if (!out.includes(e)) out.push(e)
   }
+  merges[mergeSlot] = a
+  merges[mergeSlot + 1] = b
+  merges[mergeSlot + 2] = out
+  mergeSlot = mergeSlot === 9 ? 0 : mergeSlot + 3
   return out
 }
 

package/src/Nom.ts

@@ -132,7 +132,9 @@ export const take = Token.take
  */
 export const takeWhile = <I extends Input = string>(
   predicate: (token: TokenOf<I>) => boolean
-): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeWhile<I>(predicate as any)
+): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>
+  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind
+  Token.takeWhile<I>(predicate as Token.TokenSet<I>)
 
 /**
  * @since 0.1.0
@@ -140,7 +142,9 @@ export const takeWhile = <I extends Input = string>(
  */
 export const takeWhile1 = <I extends Input = string>(
   predicate: (token: TokenOf<I>) => boolean
-): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeWhile<I>(predicate as any, { min: 1 })
+): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>
+  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind
+  Token.takeWhile<I>(predicate as Token.TokenSet<I>, { min: 1 })
 
 /**
  * @since 0.1.0
@@ -150,7 +154,9 @@ export const takeWhileMN = <I extends Input = string>(
   m: number,
   n: number,
   predicate: (token: TokenOf<I>) => boolean
-): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeWhile<I>(predicate as any, { min: m, max: n })
+): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>
+  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind
+  Token.takeWhile<I>(predicate as Token.TokenSet<I>, { min: m, max: n })
 
 /**
  * @since 0.1.0
@@ -158,7 +164,9 @@ export const takeWhileMN = <I extends Input = string>(
  */
 export const takeTill = <I extends Input = string>(
   predicate: (token: TokenOf<I>) => boolean
-): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeTill<I>(predicate as any)
+): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>
+  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind
+  Token.takeTill<I>(predicate as Token.TokenSet<I>)
 
 /**
  * @since 0.1.0
@@ -166,7 +174,9 @@ export const takeTill = <I extends Input = string>(
  */
 export const takeTill1 = <I extends Input = string>(
   predicate: (token: TokenOf<I>) => boolean
-): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> => Token.takeTill<I>(predicate as any, { min: 1 })
+): Parser<Slice<NoInfer<I>>, never, never, NoInfer<I>> =>
+  // SAFETY: a predicate over the input's tokens is a member of `TokenSet<I>` for each input kind
+  Token.takeTill<I>(predicate as Token.TokenSet<I>, { min: 1 })
 
 /**
  * @since 0.1.0