eyeprolog 1.6.38 → 1.6.39

package/package.json

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

package/src/check-proof.js

@@ -212,6 +212,7 @@ export function readProofDocument(text, program, fail = () => {}) {
       doubleQuotes: program?.doubleQuotes ?? 'chars',
       operatorDefinitions: [...(program?.operators?.values() ?? [])],
       sourceMetadata: false,
+      generalParser: true,
     });
   } catch (error) {
     fail('C3', `the document does not read: ${error?.message ?? String(error)}`, null);

package/src/parser.js

@@ -51,10 +51,14 @@ function scanFastRangeToken(text, i, end) {
   return i;
 }
 
+// The Unicode property tests below are needed only past ASCII: for a code
+// under 128 the plain code tests give exactly the same answer, and these
+// helpers run once per source character.
 function isWhitespaceCharacter(character) {
   if (!character) return false;
   const code = character.charCodeAt(0);
-  return isWhitespaceCode(code) || /\p{White_Space}/u.test(character);
+  if (code < 128) return isWhitespaceCode(code);
+  return /\p{White_Space}/u.test(character);
 }
 
 function isUnicodeUpperCharacter(character) {
@@ -82,21 +86,24 @@ function isNameContinueCode(code) {
 }
 
 function isNameContinueCharacter(character) {
-  return Boolean(character) && (isNameContinueCode(character.charCodeAt(0)) ||
-    isUnicodeNameContinueCharacter(character));
+  if (!character) return false;
+  const code = character.charCodeAt(0);
+  if (code < 128) return isNameContinueCode(code);
+  return isUnicodeNameContinueCharacter(character);
 }
 
 function isVariableStartCharacter(character) {
   if (!character) return false;
   const code = character.charCodeAt(0);
-  return code === 95 || (code >= 65 && code <= 90) || isUnicodeUpperCharacter(character);
+  if (code < 128) return code === 95 || (code >= 65 && code <= 90);
+  return isUnicodeUpperCharacter(character);
 }
 
 function isPlainAtomStartCharacter(character) {
   if (!character) return false;
   const code = character.charCodeAt(0);
-  return (code >= 97 && code <= 122) ||
-    (isUnicodeLetterCharacter(character) && !isUnicodeUpperCharacter(character));
+  if (code < 128) return code >= 97 && code <= 122;
+  return isUnicodeLetterCharacter(character) && !isUnicodeUpperCharacter(character);
 }
 
 const graphicAtomChars = '#$&*+-./<=>?@^~\\:';
@@ -311,6 +318,11 @@ function isCodePointOutOfRange(code) {
   return code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff);
 }
 
+const PUNCTUATION_TOKENS = new Map([
+  ['(', TOK.LPAREN], [')', TOK.RPAREN], ['[', TOK.LBRACKET], [']', TOK.RBRACKET],
+  ['{', TOK.LBRACE], ['}', TOK.RBRACE], [',', TOK.COMMA], ['|', TOK.BAR], ['.', TOK.DOT],
+]);
+
 class Parser {
   constructor(source, options = {}) {
     this.source = String(source ?? '');
@@ -368,6 +380,7 @@ class Parser {
     return ch;
   }
   convertedSlice(start, end) {
+    if (this.parserFlagState.charConversions.size === 0) return this.source.slice(start, end);
     let out = '';
     for (const ch of this.source.slice(start, end)) out += this.convertCharacter(ch);
     return out;
@@ -614,13 +627,10 @@ class Parser {
       return { type: TOK.ATOM, text: ';', line };
     }
 
-    const punct = {
-      '(': TOK.LPAREN, ')': TOK.RPAREN, '[': TOK.LBRACKET, ']': TOK.RBRACKET,
-      '{': TOK.LBRACE, '}': TOK.RBRACE, ',': TOK.COMMA, '|': TOK.BAR, '.': TOK.DOT,
-    };
-    if (punct[ch]) {
+    const punctuation = PUNCTUATION_TOKENS.get(ch);
+    if (punctuation) {
       this.take();
-      return { type: punct[ch], text: ch, line, precededByLayout };
+      return { type: punctuation, text: ch, line, precededByLayout };
     }
     if (ch === ':' && this.peek(1) === '-' &&
         !(isGraphicAtomCode(this.peek(2).charCodeAt(0)) && !this.terminatingFullStop(this.pos + 2))) {
@@ -671,7 +681,9 @@ class Parser {
     // A signed numeric literal is only recognized where a term may start.
     // Otherwise the minus is the standard infix operator, so compact ISO
     // syntax such as `X-1` must not be read as `X` followed by `-1`.
-    const previousEndsTerm = this.previousToken && (
+    // Whether the previous token ends a term matters only for a minus sign
+    // before a digit, so it is decided only then.
+    const previousEndsTerm = () => this.previousToken && (
       [TOK.VAR, TOK.NUMBER, TOK.STRING, TOK.RPAREN, TOK.RBRACKET, TOK.RBRACE].includes(this.previousToken.type) ||
       (this.previousToken.type === TOK.ATOM &&
        (this.postfixOperators.has(this.previousToken.text) ||
@@ -679,7 +691,7 @@ class Parser {
          !this.prefixOperators.has(this.previousToken.text))))
     );
     if (isDigitCode(ch.charCodeAt(0)) ||
-        (ch === '-' && isDigitCode(this.peek(1).charCodeAt(0)) && !previousEndsTerm)) {
+        (ch === '-' && isDigitCode(this.peek(1).charCodeAt(0)) && !previousEndsTerm())) {
       const start = this.pos;
       const negative = this.peek() === '-';
       if (negative) this.take();
@@ -1435,7 +1447,10 @@ export function parseClauses(source, options = {}) {
   const parserOptions = ownsParserFlagState
     ? { ...options, parserFlagState: { doubleQuotes: initialDoubleQuotes, charConversion: 'on', charConversions: new Map() } }
     : options;
-  if (options.sourceMetadata === false && options.readTermEnd == null) {
+  // `generalParser` reads with the general parser from the start: a text of
+  // large, nested terms, such as a proof document, gains nothing from the
+  // line-oriented fast path and pays for a parser per term in it.
+  if (options.sourceMetadata === false && options.readTermEnd == null && options.generalParser !== true) {
     const clauses = parseClausesFastNoSource(source, null, null, parserOptions);
     if (clauses) return clauses;
     if (ownsParserFlagState) {

package/src/source-expansion.js

@@ -62,10 +62,27 @@ function copyHookResult(term, env, inputNames) {
   return copy(term);
 }
 
+// Whether some clause of a hook could unify with `input` as its first
+// argument. A clause whose first argument has another type, name or arity
+// cannot, so when none can the hook does not run at all: a library such as
+// CLP(Z) expands only its own goals, and asking a fresh solver about every
+// other clause and goal of a program cost more than loading it.
+function hookMayApply(group, input) {
+  if (input?.type === VAR) return true;
+  for (const clause of group.clauses) {
+    const first = clause.head?.args?.[0];
+    if (first == null || first.type === VAR) return true;
+    if (first.type !== input.type || first.name !== input.name) continue;
+    if (first.type !== COMPOUND || first.args.length === input.args.length) return true;
+  }
+  return false;
+}
+
 function runHook(program, module, name, input, loadContext = null) {
   for (const owner of hookModules(module)) {
     const group = exactHookGroup(program, owner, name);
     if (group == null || group.clauses.length === 0) continue;
+    if (!hookMayApply(group, input)) continue;
 
     const output = variable(`\u0000source-expansion:${++expansionFresh}`);
     const goal = compound(name, [input, output]);

package/test/parallel-tasks.mjs

@@ -1,7 +1,10 @@
 // A small ordered worker pool for the suites that do the same work once per
 // file: run every example, prove every example, check every packaged proof.
 //
-// Results are reported in task order however the workers finish, so a parallel
+// Tasks are handed to workers most expensive first when the caller can
+// estimate a task's cost: a suite whose slowest task starts late spends its
+// last seconds running that one task alone. Results are still reported in task
+// order however the workers finish, so a parallel
 // suite numbers its tests exactly as the sequential one did and a failure still
 // stops the run at the same test. Each suite compares inside its worker, so
 // only a name, an elapsed time, an optional failure, and a small plain-data
@@ -17,6 +20,7 @@ export async function runTasksInParallel({
   maxWorkers,
   runLocally,
   onResult,
+  cost = null,
 }) {
   if (names.length === 0) return;
   const parallelism = os.availableParallelism?.() ?? os.cpus().length;
@@ -35,6 +39,13 @@ export async function runTasksInParallel({
   }
 
   const completedResults = new Map();
+  // Dispatch order: task indexes by descending estimated cost, ties in task
+  // order. Reporting still follows the task order itself.
+  const dispatch = names.map((_, index) => index);
+  if (typeof cost === 'function') {
+    const costs = names.map((name) => cost(name));
+    dispatch.sort((left, right) => costs[right] - costs[left] || left - right);
+  }
   let nextTask = 0;
   let nextReport = 0;
   let completed = 0;
@@ -72,7 +83,8 @@ export async function runTasksInParallel({
 
     const assign = (worker) => {
       if (nextTask >= names.length || settled) return;
-      worker.postMessage({ ...message, id: nextTask, name: names[nextTask++] });
+      const id = dispatch[nextTask++];
+      worker.postMessage({ ...message, id, name: names[id] });
     };
 
     for (const worker of workers) {

package/test/run-examples.mjs

@@ -50,6 +50,16 @@ const exampleTaskKinds = {
 };
 
 
+// A packaged proof grows with the derivation it records, so its size is a
+// cheap estimate of how long an example takes to run, prove, and check.
+export function exampleCost(name) {
+  try {
+    return fs.statSync(path.join(expectedProofDir, name)).size;
+  } catch {
+    return 0;
+  }
+}
+
 function runExampleTasks(names, kind, reporter) {
   return runTasksInParallel({
     names,
@@ -57,6 +67,7 @@ function runExampleTasks(names, kind, reporter) {
     workerData: { exampleWorker: true },
     message: { kind },
     maxWorkers: 3,
+    cost: exampleCost,
     runLocally: (name) => exampleTaskKinds[kind](name),
     onResult: (name, result) => reporter.testResult(name, result),
   });

package/test/run-proof-checking.mjs

@@ -15,7 +15,7 @@ import { isMainThread, parentPort, workerData } from 'node:worker_threads';
 import { Program } from '../src/index.js';
 import { checkProofDocument, checkReportTerms, sourceGoals, verdict } from '../src/check-proof.js';
 import { TestReporter, assertEqual, isMainModule, runStandalone } from './test-style.mjs';
-import { proofExamples } from './run-examples.mjs';
+import { exampleCost, proofExamples } from './run-examples.mjs';
 import { runTasksInParallel, serveTasks } from './parallel-tasks.mjs';
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
@@ -37,6 +37,7 @@ export async function runProofChecking(reporter = new TestReporter()) {
     workerUrl: new URL(import.meta.url),
     workerData: { proofCheckingWorker: true },
     maxWorkers: 3,
+    cost: exampleCost,
     runLocally: (name) => checkPackagedProof(name),
     onResult: (name, result) => {
       for (const field of Object.keys(totals)) totals[field] += result.value?.[field] ?? 0;