eyeprolog 1.6.37 → 1.6.38

package/examples/output/bayes-therapy.pl

@@ -10,7 +10,7 @@ expectedSuccess(oseltamivir, 0.28514101258814745).
 expectedSuccess(antihistamine, 0.10026891936485297).
 expectedSuccess(antibiotic, 0.1109525797960936).
 expectedSuccess(supportiveCare, 0.2915119539701381).
-expectedAdverse(paxlovid, 0.10).
+expectedAdverse(paxlovid, 0.1).
 expectedAdverse(oseltamivir, 0.08).
 expectedAdverse(antihistamine, 0.03).
 expectedAdverse(antibiotic, 0.07).

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.6.37",
+  "version": "1.6.38",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/explain.js

@@ -54,6 +54,10 @@ let liveSolver = null;
 // sets an explicit `maxDepth` gets that depth as a hard limit instead.
 let chainBeyondDepth = true;
 
+// Proofs of ground goals already found while explaining one document, keyed by
+// module and goal; null outside such a document.
+let groundProofs = null;
+
 function hostSolver(program, registry) {
   return liveSolver && liveSolver.program === program ? liveSolver : new Solver(program, { registry });
 }
@@ -177,6 +181,23 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active, de
     }
     return;
   }
+  // A goal that is already ground binds nothing when proved, so which of its
+  // proofs is used cannot matter to the goals after it. Within one proof
+  // document its first proof is therefore recorded once and reused: a run
+  // whose answers share subderivations -- tabled trajectories, closures --
+  // no longer replays the shared part once per answer. This stays inside one
+  // generator: a replay nests a generator per level, and one more frame per
+  // level would overflow the host stack on deep derivations.
+  const memoKey = groundProofs && termIsGround(goal, env)
+    ? `${group.module}\u0000${termToString(goal, env, true)}`
+    : null;
+  if (memoKey) {
+    const known = groundProofs.get(memoKey);
+    if (known) {
+      yield { env, node: known };
+      return;
+    }
+  }
   // Explanation replay does not use the solver's answer tables, so its cycle
   // guard applies even when normal execution tables this predicate.
   if (activeVariant(goal, env, active)) return;
@@ -199,7 +220,7 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active, de
       const substitutions = collectClauseSubstitutions(clause, freshHead, freshBody);
 
       if (freshBody.length === 0) {
-        yield {
+        const proved = {
           env: next,
           node: {
           raw: goal,
@@ -215,6 +236,11 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active, de
             children: [],
           },
         };
+        if (memoKey) {
+          yield rememberGroundProof(memoKey, proved);
+          return;
+        }
+        yield proved;
         continue;
       }
 
@@ -224,7 +250,7 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active, de
         for (const proved of proveGoalsAll(program, freshBody, next, depth + 1, maxDepth, registry, active, detail)) {
           active.pop();
           activePushed = false;
-          yield {
+          const result = {
             env: proved.env,
             node: {
           raw: goal,
@@ -237,6 +263,11 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active, de
               children: proved.children,
             },
           };
+          if (memoKey) {
+            yield rememberGroundProof(memoKey, result);
+            return;
+          }
+          yield result;
           active.push({ goal, env });
           activePushed = true;
         }
@@ -472,6 +503,59 @@ function sourceMethod(clause, kind) {
   };
 }
 
+// Built-in and library steps whose replay has no effect beyond its bindings:
+// arithmetic, comparison, term inspection, and pure list relations. Anything
+// else -- I/O, database updates, constraint stores, generated names -- keeps a
+// derivation from being reused across answers.
+const PURE_REPLAY_STEPS = new Set([
+  'true/0', 'is/2', '=:=/2', '=\\=/2', '</2', '>/2', '=</2', '>=/2',
+  '=/2', '\\=/2', '==/2', '\\==/2', '@</2', '@>/2', '@=</2', '@>=/2', 'compare/3',
+  'var/1', 'nonvar/1', 'atom/1', 'number/1', 'integer/1', 'float/1', 'atomic/1',
+  'compound/1', 'callable/1', 'ground/1', 'is_list/1',
+  'functor/3', 'arg/3', '=../2', 'copy_term/2', 'succ/2', 'plus/3',
+  'char_code/2', 'atom_codes/2', 'atom_chars/2', 'atom_length/2', 'atom_concat/3',
+  'sub_atom/5', 'number_codes/2', 'number_chars/2', 'atom_number/2',
+  'sort/2', 'msort/2', 'keysort/2', 'between/3', 'length/2',
+  'member/2', 'memberchk/2', 'append/3', 'append/2', 'reverse/2', 'nth0/3', 'nth1/3',
+  'last/2', 'select/3', 'sum_list/2', 'max_list/2', 'min_list/2', 'list_to_set/2',
+  'once/1', 'findall/3', 'forall/2', '\\+/1',
+]);
+
+// Settle a ground goal's first proof while its environment still holds every
+// binding inside it, and keep it for reuse when replaying it has no effects:
+// a proof that writes a stream or updates the database must perform those
+// effects again, so it is not recorded.
+function rememberGroundProof(key, proved) {
+  const node = settleProofNode(proved.node, proved.env);
+  if (replayIsPure(node)) groundProofs.set(key, node);
+  return { env: proved.env, node };
+}
+
+// The answer is cached on the node, so a deep derivation whose every level is
+// remembered asks it once per level rather than once per level per descendant.
+function replayIsPure(root) {
+  if (root.pureReplay !== undefined) return root.pureReplay;
+  const stack = [root];
+  let pure = true;
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node !== root && node.pureReplay !== undefined) {
+      if (node.pureReplay) continue;
+      pure = false;
+      break;
+    }
+    const method = node.method;
+    if (method && typeof method === 'object' && (method.type === 'builtin' || method.type === 'library') &&
+        !PURE_REPLAY_STEPS.has(`${method.name}/${method.arity}`)) {
+      pure = false;
+      break;
+    }
+    for (const child of node.children ?? []) stack.push(child);
+  }
+  root.pureReplay = pure;
+  return pure;
+}
+
 function goalMethod(type, goal) {
   return {
     type,
@@ -946,12 +1030,18 @@ export function clauseNumbering(program) {
     offset += span;
   }
 
+  // Keyed by file, then by clause position: one string key per clause cost
+  // more than the numbering itself on programs with hundreds of thousands of
+  // clauses.
   const bySource = new Map();
   const byNumber = new Map();
   for (const clause of program.clauses ?? []) {
     if (!isProgramClause(clause) || isUnnumberedDeclaration(clause)) continue;
-    const number = (offsets.get(clause.source.filename) ?? 0) + clause.source.clause;
-    bySource.set(`${clause.source.filename}\u0000${clause.source.clause}`, number);
+    const { filename, clause: position } = clause.source;
+    const number = (offsets.get(filename) ?? 0) + position;
+    let numbers = bySource.get(filename);
+    if (!numbers) bySource.set(filename, numbers = new Map());
+    numbers.set(position, number);
     byNumber.set(number, { head: clause.head, body: clause.body ?? [] });
   }
   return { bySource, byNumber };
@@ -971,7 +1061,7 @@ export function isLibraryClause(clause) {
 }
 
 function clauseNumberFor(numbering, method) {
-  return numbering.bySource.get(`${method.filename}\u0000${method.clause}`) ?? null;
+  return numbering.bySource.get(method.filename)?.get(method.clause) ?? null;
 }
 
 // The conclusion a node contributes, which is how a step names what it used.
@@ -1125,6 +1215,10 @@ function settleProofNode(root, env) {
   const stack = [root];
   while (stack.length) {
     const node = stack.pop();
+    // A settled node was settled with its whole subtree; a remembered ground
+    // proof reached again from a deeper level need not be walked again.
+    if (node.settled) continue;
+    node.settled = true;
     if (node.raw) {
       node.goal = resolve(node.raw);
       if (node.method?.type === 'builtin' || node.method?.type === 'library') node.sourceHead = node.goal;
@@ -1210,6 +1304,7 @@ function settlingResolver(env) {
 export function proofNodeFor(program, goal, options = {}) {
   liveSolver = options.solver ?? null;
   chainBeyondDepth = options.maxDepth == null;
+  groundProofs = options.groundProofs ?? null;
   const maxDepth = options.maxDepth ?? 256;
   const registry = options.registry ?? getEyePrologRegistry();
   const env = options.env ?? new Env();

package/src/parser.js

@@ -317,7 +317,9 @@ class Parser {
     this.filename = options.filename ?? '<input>';
     this.pos = 0;
     this.line = 1;
-    this.anonymous = 0;
+    // Anonymous variables are numbered through a whole text; a caller parsing
+    // one text in pieces continues the count.
+    this.anonymous = options.anonymousStart ?? 0;
     this.variables = new Map();
     this.sourceMetadata = options.sourceMetadata !== false;
     this.onWarning = typeof options.onWarning === 'function' ? options.onWarning : null;
@@ -346,8 +348,10 @@ class Parser {
     this.token = this.nextToken();
   }
   convertCharacter(character) {
-    if (this.parserFlagState.charConversion !== 'on' || !character) return character;
-    return this.parserFlagState.charConversions.get(character) ?? character;
+    const state = this.parserFlagState;
+    // Almost no text installs a conversion; skip the map lookup per character.
+    if (state.charConversions.size === 0 || state.charConversion !== 'on' || !character) return character;
+    return state.charConversions.get(character) ?? character;
   }
   rawPeek(offset = 0) {
     // The processor character set is an implementation-defined processor
@@ -1482,6 +1486,18 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
   let anonymous = 0;
   let chunk = '';
   let chunkStartLine = 1;
+  let operatorState = null;
+  // With source metadata, this path numbers clauses exactly as the general
+  // parser does: one number per clause and per counted directive, none for a
+  // query or a quad. Compact binary clauses carry no source, so they are not
+  // used then.
+  const trackSource = options.sourceMetadata === true;
+  const sourceFilename = options.filename ?? '<input>';
+  let clauseNumber = 0;
+  const numbered = (clause, line) => {
+    if (trackSource) clause.source = { filename: sourceFilename, line, clause: ++clauseNumber };
+    return clause;
+  };
 
   const cached = (cache, key, create) => {
     const existing = cache.get(key);
@@ -1491,22 +1507,19 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     return value;
   };
 
-  // SIMPLE_NUMBER-matched text is already lexically valid Prolog number
-  // syntax, and this fast path deliberately leaves a numeric literal's
-  // spelling otherwise untouched (test/conformance/cases/arithmetic/
-  // 024_numeric_literal_readback.pl: decimal and exponent literals retain
-  // their lexical form here, so e.g. 6.02e23 must not become 6.02e+23).
-  // Two things still cannot be left as raw matched text, though: an integer
-  // is never left non-canonical anywhere else in the language (a leading
-  // zero, or the "-0" from issue #114, must collapse the same way the
-  // scanner's own adjacent-minus BigInt construction already does), and a
-  // float whose value is exactly zero must never print with a stray minus --
-  // this implementation deliberately never produces -0.0 (term.js
-  // numberTextFromDouble) -- without reformatting any non-zero float.
+  // A number is a value, not a spelling (ISO 7.1.3), so the fast path writes
+  // numbers exactly as the general parser does: an integer in canonical
+  // decimal (a leading zero or "-0" collapses, issue #114), and a float as the
+  // shortest text that reads back to the same double (term.js
+  // numberTextFromDouble), so 0.10 is 0.1 and 6.02e23 is 6.02e+23 whichever
+  // parser read the literal. A run therefore prints the same numbers with and
+  // without --proof.
   const canonicalFastNumberText = (text) => {
-    if (text.includes('.') || text.includes('e') || text.includes('E')) {
-      return (text.charCodeAt(0) === 45 && Number(text) === 0) ? text.slice(1) : text;
+    if (text.includes('.')) {
+      const value = Number(text);
+      return Number.isFinite(value) ? numberTextFromDouble(value) : text;
     }
+    if (text.includes('e') || text.includes('E')) return text;
     const first = text.charCodeAt(0);
     if (first !== 45 && (text.length === 1 || first !== 48)) return text;
     return BigInt(text).toString();
@@ -1826,15 +1839,46 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     const simple = preparationConversionActive() ? null : parseSimple(text);
     if (simple) {
       reportClauseSingletonWarnings(simple, options.onWarning, options.filename ?? '<input>', sourceLine);
-      accept(simple);
+      accept(numbered(simple, sourceLine));
       return true;
     }
     try {
       const nestedWarning = typeof options.onWarning === 'function'
         ? (warning) => options.onWarning({ ...warning, line: warning.line + sourceLine - 1 })
         : null;
-      const parsed = new Parser(text, { ...options, sourceMetadata: false, onWarning: nestedWarning }).parseProgram();
-      for (const clause of parsed) accept(clause);
+      // One operator table serves every clause of this source: building it
+      // per clause dominated the parse of large generated programs, and an
+      // op/3 directive in one clause must govern the clauses after it anyway.
+      operatorState ??= options.operatorState ?? createParserOperatorState(
+        options.operatorDefinitions ?? [],
+        options.includeDefaultOperators !== false,
+        { isoStrict: options.isoStrict === true },
+      );
+      const parser = new Parser(text, {
+        ...options,
+        operatorState,
+        sourceMetadata: trackSource,
+        filename: sourceFilename,
+        onWarning: nestedWarning,
+        anonymousStart: trackSource ? anonymous : 0,
+      });
+      const parsed = parser.parseProgram();
+      if (trackSource) anonymous = parser.anonymous;
+      // The nested parser numbers lines and clauses from the start of this
+      // chunk; place them in the whole source.
+      let counted = 0;
+      for (const clause of parsed) {
+        if (trackSource && clause.source) {
+          const relative = clause.source.clause;
+          clause.source = { ...clause.source, line: clause.source.line + sourceLine - 1 };
+          if (relative != null) {
+            clause.source.clause = relative + clauseNumber;
+            if (relative > counted) counted = relative;
+          }
+        }
+        accept(clause);
+      }
+      clauseNumber += counted;
       return true;
     } catch (_) {
       return false;
@@ -1853,13 +1897,13 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null, option
     contentEnd = trimRangeEnd(source, contentStart, contentEnd);
     if (contentStart < contentEnd && source.charCodeAt(contentStart) !== 37) {
       if (!chunk && source.charCodeAt(contentEnd - 1) === 46 && !preparationConversionActive()) {
-        if (emitFastBinaryRange(source, contentStart, contentEnd, lineNumber)) {
+        if (!trackSource && emitFastBinaryRange(source, contentStart, contentEnd, lineNumber)) {
           // The program builder accepted a compact binary clause directly.
         } else {
           const simple = parseFastRange(source, contentStart, contentEnd);
           if (simple) {
             reportClauseSingletonWarnings(simple, options.onWarning, options.filename ?? '<input>', lineNumber);
-            accept(simple);
+            accept(numbered(simple, lineNumber));
           } else {
             chunkStartLine = lineNumber;
             chunk = source.slice(lineStart, lineEnd) + '\n';

package/src/program.js

@@ -958,6 +958,19 @@ function buildProgramFromSources(sources, options) {
     const builder = new ProgramBuilder(options);
     if (loadSourcesIntoBuilder(builder, sources, options, 'hybrid')) return builder.finish();
   }
+  // With source metadata the compact parser still applies; it numbers clauses
+  // as the general parser does, and falls back to it for anything it cannot
+  // read. Strict ISO keeps the general parser throughout, and so does a text
+  // with a `?-` outside a comment: a quad's indented answer lines are layout
+  // the line-oriented compact parser does not read.
+  const hasQueries = sources.some((source) => {
+    const text = typeof source === 'string' ? source : source?.text ?? source?.source ?? '';
+    return /^[^%\n]*\?-/m.test(text);
+  });
+  if (options.sourceMetadata !== false && !hasModuleDirectives && !hasQueries && options.isoStrict !== true) {
+    const builder = new ProgramBuilder(options);
+    if (loadSourcesIntoBuilder(builder, sources, options, true)) return builder.finish();
+  }
 
   const builder = new ProgramBuilder(options);
   loadSourcesIntoBuilder(builder, sources, options, false);

package/src/proof-document.js

@@ -36,8 +36,9 @@ export function checkedProofBlocks(program, claimed, { registry, proofDetail = '
   const roots = [];
   const unexplained = [];
   const questions = goals.filter((goal) => typeof goal !== 'string');
+  const groundProofs = new Map();
   for (const fact of claimed) {
-    const node = proofNodeFor(program, fact, { registry, proofDetail, solver, questions });
+    const node = proofNodeFor(program, fact, { registry, proofDetail, solver, questions, groundProofs });
     if (node) roots.push(node);
     else unexplained.push(fact);
   }

package/src/write.js

@@ -211,7 +211,18 @@ function operatorName(name) {
   return quoteAtom(name);
 }
 
+// Writers pass the same definitions array for every term of a run, so build
+// its lookup table once instead of once per written term.
+const operatorTables = new WeakMap();
+
 function operatorTable(definitions) {
+  if (!definitions) return buildOperatorTable(definitions);
+  let table = operatorTables.get(definitions);
+  if (!table) operatorTables.set(definitions, table = buildOperatorTable(definitions));
+  return table;
+}
+
+function buildOperatorTable(definitions) {
   const table = new Map();
   for (const definition of definitions ?? []) {
     if (!definition || definition.priority === 0) continue;

package/test/conformance/cases/arithmetic/024_numeric_literal_readback.pl

@@ -1,4 +1,4 @@
-% Reference 3.3, 11: signed, decimal, and exponent numeric literals retain lexical form.
+% Signed, decimal, and exponent numeric literals read back as their values (ISO 7.1.3, 7.10.5 c).
 raw(negative_decimal, -3.5).
 raw(positive_exp, 6.02e23).
 raw(negative_exp, -1.0e-3).

package/test/conformance/expected/arithmetic/024_numeric_literal_readback.pl

@@ -1,3 +1,3 @@
 answer(negative_decimal, -3.5).
-answer(positive_exp, 6.02e23).
-answer(negative_exp, -1.0e-3).
+answer(positive_exp, 6.02e+23).
+answer(negative_exp, -0.001).

package/test/conformance/expected/terms/003_terms_and_readback.pl

@@ -5,7 +5,7 @@ value(empty_atom, '').
 value(char_list, "line\nquote: \"ok\"").
 value(integer, -42).
 value(decimal, 0.25).
-value(scientific, 1.25e-3).
+value(scientific, 0.00125).
 value(compound, pair(3, nested(atom, "xy"))).
 value(arity_zero_atom, nil).
 value(empty_list, []).

package/test/regression/cases-regression.mjs

@@ -6013,21 +6013,16 @@ answer(Result) :- countdown(2048, Result), Result = 2048.
           const stdout = run(program, { goal }).stdout;
           assertEqual(stdout.split('\n')[0], expected, `${program.trim()}: ${goal}`);
         }
-        // The fast loader also deliberately retains a numeric literal's exact
-        // lexical spelling otherwise (test/conformance/cases/arithmetic/
-        // 024_numeric_literal_readback.pl): the zero-canonicalization above
-        // must not turn into a general reformatting pass that rewrites a
-        // non-zero float's notation.
-        assertEqual(
-          run('raw(a, 6.02e23).\n', { goal: 'raw(_, B), write_canonical(B), nl' }).stdout.split('\n')[0],
-          '6.02e23',
-          'non-zero exponent notation is preserved, not reformatted to 6.02e+23',
-        );
-        assertEqual(
-          run('raw(a, -1.0e-3).\n', { goal: 'raw(_, B), write_canonical(B), nl' }).stdout.split('\n')[0],
-          '-1.0e-3',
-          'non-zero negative exponent notation is preserved, not reformatted to -0.001',
-        );
+        // A float is a value, not a spelling (ISO 7.1.3, 7.10.5 c): the fast
+        // loader writes it as the general parser does, so a run prints the same
+        // number with and without --proof. A three-argument fact is outside the
+        // compact shape and so is read by the general parser.
+        for (const [literal, expected] of [['6.02e23', '6.02e+23'], ['-1.0e-3', '-0.001'], ['0.10', '0.1']]) {
+          const fast = run(`raw(a, ${literal}).\n`, { goal: 'raw(_, B), write_canonical(B), nl' }).stdout.split('\n')[0];
+          const general = run(`raw(a, b, ${literal}).\n`, { goal: 'raw(_, _, B), write_canonical(B), nl' }).stdout.split('\n')[0];
+          assertEqual(fast, expected, `${literal} through the fast loader`);
+          assertEqual(general, expected, `${literal} through the general parser`);
+        }
       },
     },
     {