@thomasfosterau/effect-parse 0.4.0 → 0.5.0

package/src/internal/compiler/entries.ts

@@ -24,11 +24,13 @@ export const pairOf = (p: ParserLike): EntryPair | undefined => {
   return { parsers: node.parsers, key: output[0], value: output[1] }
 }
 
-const isDiagnostic = (
+/** Whether a node only changes diagnostics: its parser parses as its child does. */
+export const isDiagnostic = (
   node: Node
-): node is NodeOf<"Context" | "Expected" | "MapError" | "OrFail" | "Trace" | "Syntax" | "RetryAfter"> =>
+): node is NodeOf<"Context" | "Expected" | "Quiet" | "MapError" | "OrFail" | "Trace" | "Syntax" | "RetryAfter"> =>
   Predicate.isTagged(node, "Context") ||
   Predicate.isTagged(node, "Expected") ||
+  Predicate.isTagged(node, "Quiet") ||
   Predicate.isTagged(node, "MapError") ||
   Predicate.isTagged(node, "OrFail") ||
   Predicate.isTagged(node, "Trace") ||

package/src/internal/compiler/first.ts

@@ -92,6 +92,7 @@ export class FirstSets {
   }
 
   private compute(node: Node): First {
+    // SAFETY: `compute` is only called from `of`, which returns before it when `kind` is 2
     const kind = this.kind as 0 | 1
     switch (node._tag) {
       case "Succeed":
@@ -111,6 +112,7 @@ export class FirstSets {
         if (node.encoding !== undefined) {
           if (kindOfEncoding(node.encoding) !== kind) return unknown
           if (node.caseless) return isEmptyUnits(lit) ? unknown : anyUnit
+          // SAFETY: a `Literal` with an encoding is a `Text` literal, which records the string it encodes
           const encoded = node.encoding.encode(lit as string)
           if (isEmptyUnits(encoded)) return emptyOptional
           return ofUnits([Predicate.isString(encoded) ? encoded.charCodeAt(0) : encoded[0]])
@@ -141,13 +143,18 @@ export class FirstSets {
       case "Tap":
       case "TryMap":
       case "FilterMap":
+      case "MapOrFail":
       case "Filter":
       case "Taken":
       case "WithTaken":
       case "Span":
       case "WithSpan":
+      case "MapSpan":
       case "Context":
       case "Expected":
+      case "Quiet":
+      // A fast path accepts what its grammar accepts (`Parser.withFastPath`)
+      case "FastPath":
       case "MapError":
       case "OrFail":
       case "Peek":
@@ -173,6 +180,7 @@ export class FirstSets {
       }
       case "Seq":
       case "Struct":
+      case "SeqWith":
         return this.sequence(node.parsers)
       case "ZipWith":
         return this.sequence([node.self, node.that])
@@ -198,6 +206,8 @@ export class FirstSets {
       }
       case "Suspend":
         return this.of(node.resolve())
+      case "Fixed":
+        return kind !== 1 ? unknown : node.size === 0 ? emptyOptional : anyUnit
       default:
         return unknown
     }

package/src/internal/compiler/graph.ts

@@ -0,0 +1,68 @@
+/**
+ * The shape of a grammar, as the code-generating compilers (the JIT and the
+ * WebAssembly compiler) see it: which parsers are leaves, which are shared
+ * and which are small enough to inline everywhere.
+ */
+import * as Predicate from "effect/Predicate"
+import type { Node, ParserLike } from "../node.js"
+import { children, nodeOf } from "../node.js"
+
+/** Whether a node is a token or a constant, always generated inline. */
+export const isLeaf = (node: Node): boolean =>
+  Predicate.isTagged(node, "Succeed") ||
+  Predicate.isTagged(node, "Fail") ||
+  Predicate.isTagged(node, "Eof") ||
+  Predicate.isTagged(node, "Location") ||
+  Predicate.isTagged(node, "RestLen") ||
+  Predicate.isTagged(node, "Any") ||
+  Predicate.isTagged(node, "Literal") ||
+  Predicate.isTagged(node, "OneOf") ||
+  Predicate.isTagged(node, "TakeWhile")
+
+/** The number of distinct parents of each parser reachable from `root`. */
+export const countRefs = (root: ParserLike): WeakMap<ParserLike, number> => {
+  const refs = new WeakMap<ParserLike, number>()
+  const seen = new WeakSet<ParserLike>()
+  const stack = [root]
+  for (let p = stack.pop(); p !== undefined; p = stack.pop()) {
+    if (seen.has(p)) continue
+    seen.add(p)
+    const counted = new WeakSet<ParserLike>()
+    for (const c of children(nodeOf(p))) {
+      if (counted.has(c)) continue
+      counted.add(c)
+      refs.set(c, (refs.get(c) ?? 0) + 1)
+      stack.push(c)
+    }
+  }
+  return refs
+}
+
+/** Whether a parser is small enough to inline wherever it is used. */
+export const isSmall = (p: ParserLike): boolean => {
+  let budget = 6
+  const visit = (q: ParserLike): boolean => {
+    const node = nodeOf(q)
+    if (
+      --budget < 0 ||
+      Predicate.isTagged(node, "Suspend") ||
+      Predicate.isTagged(node, "Escaped") ||
+      Predicate.isTagged(node, "Dispatch")
+    )
+      return false
+    return children(node).every(visit)
+  }
+  return visit(p)
+}
+
+/** The node a `dispatch` selects on, and whether it is looked at with `peek`. */
+export const selectorOf = (selector: ParserLike): { readonly node: Node; readonly peek: boolean } => {
+  const node = nodeOf(selector)
+  return Predicate.isTagged(node, "Peek") ? { node: nodeOf(node.self), peek: true } : { node, peek: false }
+}
+
+/** ASCII lower case. */
+export const lowerAscii = (c: number): number => (c >= 65 && c <= 90 ? c + 32 : c)
+
+/** Whether a code is an ASCII letter. */
+export const isLetter = (c: number): boolean => (c >= 65 && c <= 90) || (c >= 97 && c <= 122)