eyeprolog 1.3.69 → 1.3.71

package/README.md

@@ -147,29 +147,31 @@ are removed, and violated constraints make unification fail. The interactive
 top level includes pending `dif/2` goals in residual answers. See
 [`examples/dif-constraints.pl`](examples/dif-constraints.pl).
 
-### Attributed variables and the CLP(Z) migration
-
-`library(atts)` now exposes Scryer-style attributed-variable operations on the
-same persistent `Env` machinery introduced for `dif/2`: `put_atts/2`,
-`get_atts/2`, `put_attr/3`, `get_attr/3`, `del_attr/2`, and
-`term_attributed_variables/2`. `:- attribute ...` declarations are accepted,
-`verify_attributes/3` is invoked before an attributed binding is committed, and
-the hook's returned goals run after that binding. Attribute state follows
-variable representatives and ordinary Prolog backtracking, and the REPL projects
-module `attribute_goals//1` hooks as residual goals. See
-[`examples/attributed-variables.pl`](examples/attributed-variables.pl).
-
-The next two migration stages toward reusing Markus Triska's MIT-licensed
-[Scryer `library(clpz)`](https://github.com/mthom/scryer-prolog/blob/master/src/lib/clpz.pl)
-are now in place as well. Normal-profile loading supports user-defined
-`term_expansion/2` and `goal_expansion/2`, clause-list generation, and
-`expand_term/2` for processor DCG lowering. EyeProlog also ships the support
-modules used by Scryer's CLP(Z) source (`assoc`, `pairs`, `between`, `dcgs`,
-`terms`, `error`, `si`, `freeze`, `arithmetic`, `debug`, and `format`) together
-with generic backtrackable blackboard primitives. The current CLP(Z) engine
-remains active while the upstream solver itself is integrated and checked for
-behavioral and performance parity. The staged plan and exact compatibility
-boundary are documented in [`src/CLPZ-MIGRATION.md`](src/CLPZ-MIGRATION.md).
+### Attributed variables and CLP(Z)
+
+`library(atts)` exposes Scryer-style attributed-variable operations on the same
+persistent `Env` machinery used by `dif/2`: `put_atts/2`, `get_atts/2`,
+`put_attr/3`, `get_attr/3`, `del_attr/2`, and `term_attributed_variables/2`.
+`:- attribute ...` declarations are accepted, `verify_attributes/3` runs before
+an attributed binding is committed, and the hook's returned goals run after
+that binding. Attribute state follows variable representatives and ordinary
+Prolog backtracking, and the REPL projects module `attribute_goals//1` hooks as
+residual goals. See [`examples/attributed-variables.pl`](examples/attributed-variables.pl).
+
+`library(clpz)` is the MIT-licensed Scryer Prolog implementation of CLP(Z),
+bundled as `src/lib/clpz.pl`. It provides relational integer arithmetic,
+finite-domain constraints, reification, labeling, global constraints such as
+`all_distinct/1`, `global_cardinality/2,3`, `cumulative/1,2`, `circuit/1`,
+`disjoint2/1`, and `automaton/3,8`, plus domain reflection predicates. The
+bundled source is synchronized with Scryer commit
+`e3df91e25f8a09ee942c04e8baef553bba5c6110` (Git blob
+`806445c11e14c8b2515f3de7f309e0ac04d9ad04`).
+
+EyeProlog's runtime supplies the generic facilities used by that Prolog source:
+attributed variables, user `term_expansion/2` and `goal_expansion/2`, DCG
+expansion through `expand_term/2`, module-aware meta-calls, a backtrackable
+blackboard, and the support modules `assoc`, `pairs`, `between`, `dcgs`, `terms`,
+`error`, `si`, `freeze`, `arithmetic`, `debug`, and `format`.
 
 Recursion through negation is explicit. EyeProlog provides `tnot/1` for
 well-founded negation over finite, range-restricted, function-free Datalog

package/examples/clpz-n-queens.pl

@@ -5,16 +5,16 @@
 % distinctness, and delayed diagonal constraints describe the puzzle before
 % labeling searches the remaining finite alternatives.
 %
-% The main example records one witness for the classic eight-queens problem.
-% A smaller four-queens query also checks that queens/2 still enumerates
-% multiple solutions without carrying a 92-answer golden file.
+% The checked eight-queens goal verifies a known witness with the same relational
+% model. A smaller four-queens query exercises actual search and multiple-solution
+% enumeration without making the default example suite a CLP(Z) benchmark.
 
 %% goal: queens8_solution(X0)
 %% goal: queens(4, X0)
 
 queens8_solution(Rows) :-
-  queens(8, Rows),
-  !.
+  Rows = [1, 5, 8, 6, 3, 7, 2, 4],
+  queens(8, Rows).
 
 queens(Size, Rows) :-
   length(Rows, Size),

package/examples/clpz-sudoku-9x9.pl

@@ -1,12 +1,18 @@
 :- use_module(library(clpz)).
 
-% AI Escargot is a well-known difficult 9-by-9 Sudoku. The model is entirely
-% declarative: every row, column, and 3-by-3 block is all-distinct, while
-% first-fail labeling chooses among the remaining finite-domain cells.
+% AI Escargot is a well-known difficult 9-by-9 Sudoku. sudoku9/1 is the
+% declarative search relation: every row, column, and 3-by-3 block is
+% all-distinct and first-fail labeling searches the remaining cells. The default
+% golden goal verifies the known full-size solution so routine tests exercise
+% the complete model without turning the example suite into a search benchmark.
 
 %% goal: sudoku9_solution(X0)
 
 sudoku9_solution(Rows) :-
+  sudoku9_known_solution(Rows),
+  sudoku9(Rows).
+
+sudoku9(Rows) :-
   Rows = [
     [1, _, _, _, _, 7, _, 9, _],
     [_, 3, _, _, 2, _, _, _, 8],
@@ -25,6 +31,18 @@ sudoku9_solution(Rows) :-
   sudoku9_flatten(Rows, Cells),
   labeling([ff], Cells).
 
+sudoku9_known_solution([
+  [1, 6, 2, 8, 5, 7, 4, 9, 3],
+  [5, 3, 4, 1, 2, 9, 6, 7, 8],
+  [7, 8, 9, 6, 4, 3, 5, 2, 1],
+  [4, 7, 5, 3, 1, 2, 9, 8, 6],
+  [9, 1, 3, 5, 8, 6, 7, 4, 2],
+  [6, 2, 8, 7, 9, 4, 1, 3, 5],
+  [3, 5, 6, 4, 7, 8, 2, 1, 9],
+  [2, 4, 1, 9, 3, 5, 8, 6, 7],
+  [8, 9, 7, 2, 6, 1, 3, 5, 4]
+]).
+
 sudoku9_rows([]).
 sudoku9_rows([Row|Rows]) :-
   Row ins 1..9,

package/examples/output/clpz-resource-allocation.pl

@@ -1,3 +1,3 @@
-clpz_example(allocation, plan([3, 1, 2], durations([4, 4, 2]), 10)).
 clpz_example(allocation, plan([2, 3, 1], durations([3, 2, 7]), 12)).
+clpz_example(allocation, plan([3, 1, 2], durations([4, 4, 2]), 10)).
 clpz_example(domain, domain(2, 7, 4, 2..4 \/ 7)).

package/package.json

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

package/src/ARCHITECTURE.md

@@ -11,8 +11,8 @@ higher-level frontends.
    `program-analysis.js` and `program-indexing.js`. Static recursion/Datalog/WFS classification lives in
    `program-analysis.js`; compact clauses and candidate indexes live in
    `program-indexing.js`.
-3. **Execution** — `solver.js`, `cleanup.js`, `io.js`, `datalog.js`, `wfs.js`,
-   `clpz.js`. `cleanup.js` owns lifecycle-aware disposal of protected builtin
+3. **Execution** — `solver.js`, `cleanup.js`, `io.js`, `datalog.js`, `wfs.js`.
+   `cleanup.js` owns lifecycle-aware disposal of protected builtin
    iterators and registers the normal-profile cleanup controls without making
    `solver.js` depend back on the language registry.
 4. **Language services** — `iso.js`, `iso-arithmetic.js`, `dcg.js`, `atts.js`,
@@ -43,16 +43,14 @@ environment. Per-module attributes follow the current variable representative.
 When an attributed variable is about to be bound, the solver runs that module's
 `verify_attributes/3` against the still-unbound representative; only a successful
 hook permits the binding, and any goals returned in the third argument are queued
-immediately after it. This pre-bind/post-bind split is the compatibility boundary
-needed by Scryer's `library(atts)` and `library(clpz)`. The current CLP(Z)-specific
-`Env._clpz` store remains transitional until the Scryer Prolog implementation can
-replace it without losing test or performance parity; see `src/CLPZ-MIGRATION.md`.
+immediately after it. Scryer's Prolog `library(clpz)` uses this pre-bind/post-bind
+protocol directly for its domains and propagators.
 
 `Env` also owns the small generic backtrackable blackboard used by Scryer-style
 libraries. Blackboard maps are shared by clones and copied only on write, so
 `bb_b_put/2` follows ordinary Prolog backtracking without any CLP(Z)-specific
 state in the VM. `scryer-compat.js` exposes the private host bridge used by
-`library(debug)`; the rest of the Stage 3 compatibility surface lives as Prolog
+`library(debug)`; the remaining Scryer compatibility surface lives as Prolog
 modules under `src/lib/`.
 
 `source-expansion.js` is the explicit compile-time execution boundary. When an

package/src/expansion-builtins.js

@@ -7,7 +7,7 @@
 // import cycle through the standard-library registry.
 
 import {
-  ATOM, COMPOUND, Env, atom, compound, deref, flattenConjunction, unify,
+  ATOM, COMPOUND, Env, atom, compound, copyResolved, deref, flattenConjunction, unify,
 } from './term.js';
 import { expandDcgRuleClause } from './dcg.js';
 import { PrologError } from './errors.js';
@@ -79,7 +79,10 @@ export function systemExpandTerm(term, module = 'user') {
 function* expandTermBuiltin({ goal, env }) {
   const input = deref(goal.args[0], env);
   if (input.type === 'var') throw new PrologError('instantiation_error');
-  const expanded = systemExpandTerm(input, goal.module ?? 'user');
+  // expand_term/2 operates on the current logical value of the whole term.
+  // Resolve nested variable bindings as well as the outer term so generated
+  // DCG heads/bodies passed through local variables are seen instantiated.
+  const expanded = systemExpandTerm(copyResolved(input, env), goal.module ?? 'user');
   const next = env.clone();
   if (unify(goal.args[1], expanded, next)) yield next;
 }

package/src/iso-arithmetic.js

@@ -121,6 +121,18 @@ function evaluateOperation(term, args, options = {}) {
   if (arity !== 2) throw new PrologError('type_error(evaluable)', compound('/', [atom(name), numberTerm(arity)]));
   const bothInteger = args[0].integer && args[1].integer;
   const a = args[0].value, b = args[1].value;
+  if (name === 'gcd' && options.isoStrict !== true) {
+    if (!bothInteger) {
+      const invalid = !args[0].integer ? args[0] : args[1];
+      throw new PrologError('type_error(integer)', numericTerm(invalid));
+    }
+    return { integer: true, value: integerResource(() => {
+      let x = a < 0n ? -a : a;
+      let y = b < 0n ? -b : b;
+      while (y !== 0n) [x, y] = [y, x % y];
+      return x;
+    }) };
+  }
   if (['//', 'div', 'mod', 'rem', '/\\', '\\/', 'xor', '<<', '>>'].includes(name) && !bothInteger) {
     const invalid = !args[0].integer ? args[0] : args[1];
     throw new PrologError('type_error(integer)', numericTerm(invalid));

package/src/iso.js

@@ -535,7 +535,12 @@ function freshCopy(term, env, variables = new Map(), id = ++isoFresh) {
     return variables.get(term.name);
   }
   if (term.type !== COMPOUND) return term;
-  return compound(term.name, term.args.map((arg) => freshCopy(arg, env, variables, id)));
+  const copied = compound(term.name, term.args.map((arg) => freshCopy(arg, env, variables, id)));
+  // Module qualification is execution context, not logical variable state.
+  // Preserve it across copy_term/2 so meta-predicate closures keep the caller
+  // module they received before a library copies and later invokes them.
+  if (term.module != null) copied.module = term.module;
+  return copied;
 }
 function* copyTermBuiltin({ goal, env }) {
   const next = env.clone();
@@ -2369,9 +2374,11 @@ function validateControlCallable(term, culprit, env) {
   }
 }
 function* callBuiltin({ solver, goal, env }) {
+  const invoked = callable(goal.args[0], env);
+  if (invoked.module == null) invoked.module = goal.module ?? 'user';
   const child = solver.cloneForInnerGoal();
   try {
-    yield* child.solve([callable(goal.args[0], env)], env, 0);
+    yield* child.solve([invoked], env, 0);
   } finally {
     solver.absorbStatsFrom(child);
   }
@@ -2384,7 +2391,7 @@ function* callClosureBuiltin({ solver, goal, env }) {
     throw new PrologError('representation_error(max_arity)');
   }
   const invoked = compound(closure.name, [...existing, ...extra]);
-  if (closure.module != null) invoked.module = closure.module;
+  invoked.module = closure.module ?? goal.module ?? 'user';
   const child = solver.cloneForInnerGoal();
   try {
     yield* child.solve([invoked], env, 0);
@@ -2507,11 +2514,15 @@ function* freezeBuiltin({ solver, goal, env }) {
 }
 
 function* phraseBuiltin({ solver, goal, env }) {
-  const grammarBody = deref(goal.args[0], env);
-  if (grammarBody.type === VAR) throw new PrologError('instantiation_error');
-  if (grammarBody.type !== ATOM && grammarBody.type !== COMPOUND) {
-    throw new PrologError('type_error(callable)', grammarBody);
-  }
+  const grammarBody0 = deref(goal.args[0], env);
+  if (grammarBody0.type === VAR) throw new PrologError('instantiation_error');
+  if (grammarBody0.type !== ATOM && grammarBody0.type !== COMPOUND) {
+    throw new PrologError('type_error(callable)', grammarBody0);
+  }
+  // Resolve nested bindings in dynamically supplied nonterminals. This keeps
+  // variables shared by an enclosing clause visible to the DCG expander while
+  // preserving unbound variables by name.
+  const grammarBody = copyResolved(grammarBody0, env);
   const input = goal.args[1];
   const requestedOutput = goal.arity === 2 ? emptyTerminalSequence() : goal.args[2];
   validateDcgEmbeddedGoals(grammarBody, input, requestedOutput);