eyeprolog 1.5.36 → 1.5.38

package/README.md

@@ -86,7 +86,7 @@ The checked [Symbiotic Knowledge Graphs example](examples/symbiotic-knowledge-gr
 The same RDF → Prolog → RDF boundary is exercised by five additional checked scenarios: [cross-organization data sharing](https://eyereasoner.github.io/eyeprolog/examples/deck/cross-organization-data-sharing), [explainable EV-depot configuration](https://eyereasoner.github.io/eyeprolog/examples/deck/explainable-ev-depot-configuration), [operational incident response](https://eyereasoner.github.io/eyeprolog/examples/deck/operational-incident-response), [software supply-chain vulnerability response](https://eyereasoner.github.io/eyeprolog/examples/deck/sbom-vulnerability-response), and a [scientific evidence graph](https://eyereasoner.github.io/eyeprolog/examples/deck/scientific-evidence-graph). Together they cover policy decisions, reversible configuration reasoning, dependency-graph diagnosis, transitive SBOM exposure, and evidence aggregation with explicit disagreement.
 
 ## Benchmarks
-EyeProlog has 21 checksum-protected wall-clock benchmarks spanning recursion/indexing, constraints, tabling/WFS, DCGs, Eyelet, search, term I/O, attributes, rewriting, and the classic Prolog naive-reverse workload. Short workloads are adaptively batched before timing so millisecond-scale noise is not mistaken for a regression. Run `npm run benchmark`; create a machine-local comparison point with `npm run benchmark:baseline`; use `npm run test:benchmark` for harness checks. The checked [`examples/bench.pl`](examples/bench.pl) preserves the classic Quintus 1984 `nrev/2` workload on a 30-element list. For a comparable LIPS number, run `npm run benchmark:lips`: it executes the classic failure-driven `dobench/1` and `dodummy/1` loops in Prolog, subtracts dummy-loop CPU time, and applies the historical 496 procedure calls per reversal. The generic benchmark table still shows a quick wall-clock LIPS estimate for `classic-nrev`, but `benchmark:lips` is the canonical engine-speed measurement. LIPS is a historical basic-engine-speed indicator, not a whole-system performance score. Details are in [*The Art of EyeProlog*](the-art-of-eyeprolog.md).
+EyeProlog has 19 checksum-protected wall-clock benchmarks spanning recursion/indexing, constraints, tabling/WFS, DCGs, Eyelet, search, term I/O, attributes, rewriting, and the classic Prolog naive-reverse workload. Short workloads are adaptively batched before timing so millisecond-scale noise is not mistaken for a regression. Run `npm run benchmark`; create a machine-local comparison point with `npm run benchmark:baseline`; use `npm run test:benchmark` for harness checks. The checked [`examples/bench.pl`](examples/bench.pl) preserves the classic Quintus 1984 `nrev/2` workload on a 30-element list. For a comparable LIPS number, run `npm run benchmark:lips`: it executes the classic failure-driven `dobench/1` and `dodummy/1` loops in Prolog, subtracts dummy-loop CPU time, and applies the historical 496 procedure calls per reversal. The generic benchmark table still shows a quick wall-clock LIPS estimate for `classic-nrev`, but `benchmark:lips` is the canonical engine-speed measurement. LIPS is a historical basic-engine-speed indicator, not a whole-system performance score. Details are in [*The Art of EyeProlog*](the-art-of-eyeprolog.md).
 For the project policy on post-ISO-standard and WG17 compatibility features such as digit separators, see [ISO/WG17 compatibility extensions](test/conformance/ISO-WG17-EXTENSIONS.md).
 ## Development
 ```sh

package/examples/bulk-stream-write.pl

@@ -0,0 +1,42 @@
+% Bulk character-by-character writes to a non-console text stream.
+%
+% put_char/2 writes one character at a time to an open file stream, and each
+% write logically appends at the current stream position (ISO 7.10.2.8). This
+% is the common pattern for hand-rolled serializers that emit one character or
+% code point per call rather than a single bulk write/1 call. The example
+% writes a repeating a-z run to a temporary file, closes it, then reopens and
+% reads the file back one character at a time with get_char/2 to confirm every
+% character round-trips. The path is under /tmp so the source tree is
+% unchanged.
+
+%% goal: bulk_write_result(X0, X1)
+
+bulk_write_chars(_, 0) :- !.
+bulk_write_chars(Stream, N) :-
+  N > 0,
+  Code is 0'a + (N mod 26),
+  char_code(Char, Code),
+  put_char(Stream, Char),
+  N1 is N - 1,
+  bulk_write_chars(Stream, N1).
+
+count_chars(Stream, Acc, Count) :-
+  get_char(Stream, Char),
+  count_chars_step(Char, Stream, Acc, Count).
+
+count_chars_step(end_of_file, _, Count, Count) :- !.
+count_chars_step(_, Stream, Acc, Count) :-
+  Acc1 is Acc + 1,
+  count_chars(Stream, Acc1, Count).
+
+bulk_write_path('/tmp/eyeprolog-bulk-stream-write-example.txt').
+
+bulk_write_result(Requested, Counted) :-
+  Requested = 5000,
+  bulk_write_path(Path),
+  open(Path, write, Out, [type(text)]),
+  bulk_write_chars(Out, Requested),
+  close(Out),
+  open(Path, read, In, [type(text)]),
+  count_chars(In, 0, Counted),
+  close(In).

package/examples/output/bulk-stream-write.pl

@@ -0,0 +1 @@
+bulk_write_result(5000, 5000).

package/package.json

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

package/playground.html

@@ -459,6 +459,7 @@
           "bmi",
           "braking-safety-worlds",
           "buck-converter-design",
+          "bulk-stream-write",
           "cache-performance",
           "canary-release",
           "cat-koko",

package/src/explain.js

@@ -218,7 +218,12 @@ function builtinIsUsedForGoal(def, solver, goal, env) {
 function selectReadyDeterministicBuiltin(goals, env, registry) {
   for (let i = 0; i < goals.length; i++) {
     const goal = goals[i];
-    if (goal.type !== COMPOUND) continue;
+    // Match solver.js's goal-type check: a 0-arity builtin (ATOM) is just as
+    // eligible for this fast path as a COMPOUND one. No bundled builtin
+    // currently pairs arity 0 with a custom ready() gate, so this has no
+    // observable effect today, but it keeps the proof-explanation path from
+    // silently diverging from actual execution if one is added later.
+    if (goal.type !== COMPOUND && goal.type !== ATOM) continue;
     const def = registry.get(goal.name, goal.arity);
     if (!def?.deterministic || typeof def.ready !== 'function') continue;
     if (typeof def.shouldUse === 'function') continue;

package/src/io.js

@@ -186,6 +186,21 @@ export class StreamManager {
     }
     const text = String(value);
     const content = String(stream.content);
+    // The overwhelming majority of text-stream writes append at the current
+    // end of the sink: bulk write/1 calls and repeated put_char/put_code
+    // loops alike. Handling that case as a plain concatenation, separate
+    // from the general reposition rebuild below, keeps the two ISO-distinct
+    // cases self-documenting instead of folding them into one three-part
+    // slice expression that always pays for the overwrite case's shape.
+    // This split is for clarity, not raw throughput: measured end to end,
+    // the general expression already performs comparably for this pattern.
+    if (stream.position === content.length) {
+      stream.content = content + text;
+      stream.position += text.length;
+      return;
+    }
+    // 7.10.2.8: output after repositioning overwrites the existing sink
+    // contents at the selected stream position rather than always appending.
     const end = Math.min(content.length, stream.position + text.length);
     stream.content = `${content.slice(0, stream.position)}${text}${content.slice(end)}`;
     stream.position += text.length;

package/src/lib/dates.pl

@@ -66,14 +66,13 @@ dates__date_not_before(EY, _, _, SY, _, _) :- EY > SY.
 dates__date_not_before(Y, EM, _, Y, SM, _) :- EM > SM.
 dates__date_not_before(Y, M, ED, Y, M, SD) :- ED >= SD.
 
-dates__borrow_days(EY, EM, ED, SD, EY, EM, ED) :- ED >= SD.
+dates__borrow_days(EY, EM, ED, SD, EY, EM, ED) :- ED >= SD, !.
 dates__borrow_days(EY0, EM0, ED0, SD, EY, EM, ED) :-
     ED0 < SD,
     dates__previous_month(EY0, EM0, PY, PM),
     dates__days_in_month(PY, PM, Days),
-    ED is ED0 + Days,
-    EY = PY,
-    EM = PM.
+    ED1 is ED0 + Days,
+    dates__borrow_days(PY, PM, ED1, SD, EY, EM, ED).
 
 dates__borrow_months(EY, EM, SM, EY, EM) :- EM >= SM.
 dates__borrow_months(EY0, EM0, SM, EY, EM) :-

package/test/bench/benchmarks.json

@@ -72,15 +72,6 @@
     ],
     "expectedSha256": "b4a153234f3daf1e2ba6c26843349a1bc1919ebd9f9e98559835eb5ef915716b"
   },
-  {
-    "name": "dcg-command",
-    "group": "dcg",
-    "file": "examples/dcg-command-parser.pl",
-    "goals": [
-      "dcg_example(X0, X1)"
-    ],
-    "expectedSha256": "6f640fb0d327eb9139d3568cf7a86ad55a52afdbb0208ca35a70419be2bf1b9c"
-  },
   {
     "name": "dcg-expression",
     "group": "dcg",
@@ -106,24 +97,6 @@
     ],
     "expectedSha256": "a7c33872b86aa7877b9c38ec41c447fc96a328d40f512428993d662f28a097ad"
   },
-  {
-    "name": "clpz-register-allocation",
-    "group": "clpz",
-    "file": "examples/register-allocation.pl",
-    "goals": [
-      "registerAnswer(X0, X1)"
-    ],
-    "expectedSha256": "1ed0b4a90deff2908463774d0025210d58b89366efb5d82b94ff5b51daca046b"
-  },
-  {
-    "name": "clpb-feature-model",
-    "group": "clpb",
-    "file": "examples/clpb-feature-model.pl",
-    "goals": [
-      "feature_plan(X0)"
-    ],
-    "expectedSha256": "47abfd8a87efb595ffb11c6c8cbda3cb5855e95124bc574e3cae387c12318f33"
-  },
   {
     "name": "attributed-variables",
     "group": "attributes",
@@ -190,5 +163,14 @@
       "type_answer(X0, X1)"
     ],
     "expectedSha256": "acad9ddb995d9ddef091e17cc91659d36ed7f9014d6714fd40100d85a53ae203"
+  },
+  {
+    "name": "bulk-stream-write",
+    "group": "term-io",
+    "file": "examples/bulk-stream-write.pl",
+    "goals": [
+      "bulk_write_result(X0, X1)"
+    ],
+    "expectedSha256": "8471da130a4a3a92dd31ee6cf285b1e129886177d7be367d51650a48b8920324"
   }
 ]

package/test/conformance/expected/arithmetic/061_date_difference.pl

@@ -1,2 +1,2 @@
 answer(duration, 'P4Y1D').
-answer(month_borrow, 'P1M-1D').
+answer(month_borrow, 'P30D').

package/test/run-benchmark-tests.mjs

@@ -42,7 +42,7 @@ function runWorker(item) {
   ]);
 }
 
-ok(Array.isArray(manifest) && manifest.length === 21, 'benchmark manifest should contain exactly 21 representative workloads');
+ok(Array.isArray(manifest) && manifest.length === 19, 'benchmark manifest should contain exactly 19 representative workloads');
 ok(new Set(manifest.map((item) => item.name)).size === manifest.length, 'benchmark names should be unique');
 const classicNrev = manifest.find((item) => item.name === 'classic-nrev');
 ok(classicNrev?.logicalInferences === 496, 'classic nrev should retain the traditional 496-call LIPS accounting');
@@ -61,7 +61,7 @@ for (const item of manifest) {
 
 const adaptive = await spawnJson([
   path.join(root, 'test', 'benchmark.mjs'),
-  '--filter', 'dcg-command',
+  '--filter', 'dcg-expression',
   '--runs', '1',
   '--warmup', '0',
   '--target-ms', '50',
@@ -69,7 +69,7 @@ const adaptive = await spawnJson([
 ]);
 ok(adaptive.results.length === 1, 'adaptive benchmark smoke test should select one workload');
 ok(adaptive.results[0].batchSize > 1, 'adaptive benchmark smoke test should batch a short workload');
-ok(adaptive.results[0].sha256 === manifest.find((item) => item.name === 'dcg-command').expectedSha256,
+ok(adaptive.results[0].sha256 === manifest.find((item) => item.name === 'dcg-expression').expectedSha256,
   'adaptive batching should preserve the semantic checksum');
 
 const nrev = await spawnJson([

package/the-art-of-eyeprolog.md

@@ -5867,9 +5867,9 @@ and reports the portable ISO `type_error(list)` error term.
 #### A bidirectional expression grammar
 
 DCGs become more useful when the grammar produces a structured term rather than
-merely accepting a token list.  The checked
+merely accepting a token list. The checked
 [`dcg-expression-language.pl`](https://github.com/eyereasoner/eyeprolog/blob/main/examples/dcg-expression-language.pl)
-example implements a small arithmetic language in both directions.  Its parser
+example implements a small arithmetic language in both directions. Its parser
 respects precedence and left associativity while constructing an abstract syntax
 tree:
 
@@ -5887,17 +5887,17 @@ additive_tail(AST, AST) --> [].
 
 The accumulator removes left recursion without moving parsing into JavaScript.
 A second DCG walks the AST in the other direction and emits only the parentheses
-needed to preserve its structure.  The example therefore exercises parsing,
+needed to preserve its structure. The example therefore exercises parsing,
 semantic actions, nonterminal-to-nonterminal state hand-off, generation,
 backtracking, `phrase/3` remainder handling, and AST-to-token-to-AST
-round-tripping.  The checked answers are in
+round-tripping. The checked answers are in
 [`examples/output/dcg-expression-language.pl`](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/dcg-expression-language.pl).
 
 #### Deep sequence hand-off
 
 `library(iso_ext)` provides the common `... //0` helper, which describes an
-arbitrary number of input elements.  It is not part of ISO Part 3, but it is a
-useful interoperability and stress-test relation.  A compact hand-off test is:
+arbitrary number of input elements. It is not part of ISO Part 3, but it is a
+useful interoperability and stress-test relation. A compact hand-off test is:
 
 ```text
 a --> ..., epsilon.
@@ -5905,11 +5905,11 @@ epsilon --> [].
 ```
 
 Here the remaining sequence is repeatedly passed from `... //0` to another
-nonterminal.  For a finite compact list, EyeProlog can scan the arbitrary
+nonterminal. For a finite compact list, EyeProlog can scan the arbitrary
 sequence iteratively instead of consuming one ordinary solver depth level per
-list cell.  If the continuation is structurally proven to be a zero-width
+list cell. If the continuation is structurally proven to be a zero-width
 identity grammar such as `epsilon//0`, the hand-off can be continued without
-constructing a fresh general clause-resolution frame at every suffix.  The list
+constructing a fresh general clause-resolution frame at every suffix. The list
 spine is still traversed; this is a control/allocation optimization rather than
 an O(1) semantic shortcut.
 
@@ -6062,7 +6062,8 @@ contains 129 name/arity entries across 100 names.
 `;/2` recognizes an `->/2` term on its left and implements the ISO
 if-then-else commitment described above. Cuts and committed conditions are
 operational controls; use ordinary relations when all alternatives should
-remain observable. 
+remain observable.
+
 #### Definite clause grammar processing
 
 - **`phrase(+Body,?Sequence)`** — Parses or generates `Sequence` with a Part 3 grammar body and requires complete consumption.
@@ -9743,7 +9744,7 @@ Review questions:
 </figure>
 
 The [examples directory](https://github.com/eyereasoner/eyeprolog/tree/main/examples/) is the book's executable companion. The
-top-level directory contains **225 self-contained runnable programs**. Every
+top-level directory contains **226 self-contained runnable programs**. Every
 source program has an exact answer file under
 [examples/output](https://github.com/eyereasoner/eyeprolog/tree/main/examples/output/), and **61 selected programs** have a checked
 explanation under [examples/proof](https://github.com/eyereasoner/eyeprolog/tree/main/examples/proof/). The thematic lists link every top-level program and open the program
@@ -10176,7 +10177,7 @@ npm run benchmark:baseline
 npm run benchmark:lips
 ```
 
-The benchmark suite contains 21 representative workloads and stores their
+The benchmark suite contains 19 representative workloads and stores their
 semantic output digests in the repository, while wall-clock baselines remain
 machine-local under `.benchmarks/` because absolute timings are machine-specific.
 Each benchmark runs in its own fresh Node worker. Inside that worker, one untimed
@@ -10368,7 +10369,7 @@ specifications.
 
 - Kurt Gödel,
   [“Über formal unentscheidbare Sätze der *Principia Mathematica* und
-  verwandter Systeme I”](https://doi.org/10.1007/BF01700686),
+  verwandter Systeme I”](https://doi.org/10.1007/BF01700692),
   *Monatshefte für Mathematik und Physik* 38, 1931, pp. 173–198. The
   incompleteness theorems establish intrinsic limits for sufficiently
   expressive effectively axiomatized formal systems. Chapter 30 treats such