eyeprolog 1.5.55 → 1.5.57

package/examples/combinatorics-findall-sort.pl

@@ -14,16 +14,16 @@
 
 % select/3 nondeterministically removes one item from a list; because it is an
 % ordinary rule, the example also demonstrates user-level list recursion.
-select(Item, [Item | Rest], Rest).
+select_item(Item, [Item | Rest], Rest).
 % The recursive clause keeps the non-selected head and searches the tail.
-select(Item, [Head | Tail], [Head | Rest]) :-
-  select(Item, Tail, Rest).
+select_item(Item, [Head | Tail], [Head | Rest]) :-
+  select_item(Item, Tail, Rest).
 
 % combination/3 builds an unordered K-combination by repeated selection.
 combination(0, _items, []).
 combination(I, Items, Combination) :-
   (I > 0),
-  select(Item, Items, Remaining),
+  select_item(Item, Items, Remaining),
   (J is I - 1),
   combination(J, Remaining, Partial),
   sort([Item | Partial], Combination).

package/examples/d3-group.pl

@@ -21,42 +21,42 @@ symmetry(reflection_b).
 symmetry(reflection_c).
 
 % Cayley table for D3 composition.
-compose(identity, identity, identity).
-compose(identity, rotation_120, rotation_120).
-compose(identity, rotation_240, rotation_240).
-compose(identity, reflection_a, reflection_a).
-compose(identity, reflection_b, reflection_b).
-compose(identity, reflection_c, reflection_c).
-compose(rotation_120, identity, rotation_120).
-compose(rotation_120, rotation_120, rotation_240).
-compose(rotation_120, rotation_240, identity).
-compose(rotation_120, reflection_a, reflection_b).
-compose(rotation_120, reflection_b, reflection_c).
-compose(rotation_120, reflection_c, reflection_a).
-compose(rotation_240, identity, rotation_240).
-compose(rotation_240, rotation_120, identity).
-compose(rotation_240, rotation_240, rotation_120).
-compose(rotation_240, reflection_a, reflection_c).
-compose(rotation_240, reflection_b, reflection_a).
-compose(rotation_240, reflection_c, reflection_b).
-compose(reflection_a, identity, reflection_a).
-compose(reflection_a, rotation_120, reflection_c).
-compose(reflection_a, rotation_240, reflection_b).
-compose(reflection_a, reflection_a, identity).
-compose(reflection_a, reflection_b, rotation_240).
-compose(reflection_a, reflection_c, rotation_120).
-compose(reflection_b, identity, reflection_b).
-compose(reflection_b, rotation_120, reflection_a).
-compose(reflection_b, rotation_240, reflection_c).
-compose(reflection_b, reflection_a, rotation_120).
-compose(reflection_b, reflection_b, identity).
-compose(reflection_b, reflection_c, rotation_240).
-compose(reflection_c, identity, reflection_c).
-compose(reflection_c, rotation_120, reflection_b).
-compose(reflection_c, rotation_240, reflection_a).
-compose(reflection_c, reflection_a, rotation_240).
-compose(reflection_c, reflection_b, rotation_120).
-compose(reflection_c, reflection_c, identity).
+compose_op(identity, identity, identity).
+compose_op(identity, rotation_120, rotation_120).
+compose_op(identity, rotation_240, rotation_240).
+compose_op(identity, reflection_a, reflection_a).
+compose_op(identity, reflection_b, reflection_b).
+compose_op(identity, reflection_c, reflection_c).
+compose_op(rotation_120, identity, rotation_120).
+compose_op(rotation_120, rotation_120, rotation_240).
+compose_op(rotation_120, rotation_240, identity).
+compose_op(rotation_120, reflection_a, reflection_b).
+compose_op(rotation_120, reflection_b, reflection_c).
+compose_op(rotation_120, reflection_c, reflection_a).
+compose_op(rotation_240, identity, rotation_240).
+compose_op(rotation_240, rotation_120, identity).
+compose_op(rotation_240, rotation_240, rotation_120).
+compose_op(rotation_240, reflection_a, reflection_c).
+compose_op(rotation_240, reflection_b, reflection_a).
+compose_op(rotation_240, reflection_c, reflection_b).
+compose_op(reflection_a, identity, reflection_a).
+compose_op(reflection_a, rotation_120, reflection_c).
+compose_op(reflection_a, rotation_240, reflection_b).
+compose_op(reflection_a, reflection_a, identity).
+compose_op(reflection_a, reflection_b, rotation_240).
+compose_op(reflection_a, reflection_c, rotation_120).
+compose_op(reflection_b, identity, reflection_b).
+compose_op(reflection_b, rotation_120, reflection_a).
+compose_op(reflection_b, rotation_240, reflection_c).
+compose_op(reflection_b, reflection_a, rotation_120).
+compose_op(reflection_b, reflection_b, identity).
+compose_op(reflection_b, reflection_c, rotation_240).
+compose_op(reflection_c, identity, reflection_c).
+compose_op(reflection_c, rotation_120, reflection_b).
+compose_op(reflection_c, rotation_240, reflection_a).
+compose_op(reflection_c, reflection_a, rotation_240).
+compose_op(reflection_c, reflection_b, rotation_120).
+compose_op(reflection_c, reflection_c, identity).
 % Each candidate subgroup must also contain inverses.
 inverse(identity, identity).
 inverse(rotation_120, rotation_240).
@@ -78,7 +78,7 @@ all_symmetries(Symmetries) :-
 
 % A valid subgroup is closed under both composition and inverse.
 closed_under_composition(Group) :-
-  \+ (member(X, Group), member(Y, Group), compose(X, Y, Z), \+ member(Z, Group)).
+  \+ (member(X, Group), member(Y, Group), compose_op(X, Y, Z), \+ member(Z, Group)).
 
 closed_under_inverse(Group) :-
   \+ (member(X, Group), inverse(X, Y), \+ member(Y, Group)).

package/examples/eulerian-path.pl

@@ -39,9 +39,9 @@ incident(V, E) :- edge(E, _u, V).
 adjacent_by_edge(V, U, E) :- edge(E, V, U).
 adjacent_by_edge(V, U, E) :- edge(E, U, V).
 
-select(Item, [Item | Rest], Rest).
-select(Item, [Head | Tail], [Head | Rest]) :-
-  select(Item, Tail, Rest).
+select_item(Item, [Item | Rest], Rest).
+select_item(Item, [Head | Tail], [Head | Rest]) :-
+  select_item(Item, Tail, Rest).
 
 % Eulerian paths start at an odd-degree vertex when exactly two exist.
 odd_degree(V) :-
@@ -77,7 +77,7 @@ eulerian_path(Path) :-
 dfs_euler(_current, Path, [], Path).
 dfs_euler(Current, Visited, Remaining, Path) :-
   adjacent_by_edge(Current, Next, Edge),
-  select(Edge, Remaining, Newremaining),
+  select_item(Edge, Remaining, Newremaining),
   dfs_euler(Next, [Next | Visited], Newremaining, Path).
 
 oddVertices(eulerian_path_case, Odds) :-

package/examples/graph-reachability.pl

@@ -18,14 +18,14 @@ edge(d, f).
 edge(e, f).
 edge(f, g).
 
-reachable(Node, Node, _visited).
-reachable(Start, Goal, Visited) :-
+reachable_via(Node, Node, _visited).
+reachable_via(Start, Goal, Visited) :-
   edge(Start, Next),
   \+ member(Next, Visited),
-  reachable(Next, Goal, [Next|Visited]).
+  reachable_via(Next, Goal, [Next|Visited]).
 
 is_reachable(Start, Goal) :-
-  reachable(Start, Goal, [Start]).
+  reachable_via(Start, Goal, [Start]).
 
 reachable(reachability_case, path(a, f)) :-
   is_reachable(a, f).

package/examples/monkey-bananas.pl

@@ -20,16 +20,16 @@ plan(Moves) :-
   candidate_plan(Moves),
   initial_state(I),
   goal_state(G),
-  reachable(I, Moves, G).
+  reachable_state(I, Moves, G).
 
 candidate_plan([_, _, _]).
 candidate_plan([_, _, _, _]).
 candidate_plan([_, _, _, _, _]).
 
-reachable(S, [], S).
-reachable(S1, [M|L], S3) :-
+reachable_state(S, [], S).
+reachable_state(S1, [M|L], S3) :-
   legal_move(S1, M, S2),
-  reachable(S2, L, S3).
+  reachable_state(S2, L, S3).
 
 initial_state([loc1, loc2, loc3, n, n]).
 goal_state([_, _, _, _, y]).

package/examples/proof/graph-reachability.pl

@@ -11,7 +11,7 @@ why(
         bindings([binding("Start", a), binding("Goal", f)]),
         uses([
           proof(
-            goal(reachable(a, f, "a")),
+            goal(reachable_via(a, f, "a")),
             by(rule("graph-reachability.pl", clause(9))),
             bindings([binding("Start", a), binding("Goal", f), binding("Visited", "a"), binding("Next", b)]),
             uses([
@@ -24,7 +24,7 @@ why(
                 by(builtin('\\+', 1))
               ),
               proof(
-                goal(reachable(b, f, "ba")),
+                goal(reachable_via(b, f, "ba")),
                 by(rule("graph-reachability.pl", clause(9))),
                 bindings([binding("Start", b), binding("Goal", f), binding("Visited", "ba"), binding("Next", d)]),
                 uses([
@@ -37,7 +37,7 @@ why(
                     by(builtin('\\+', 1))
                   ),
                   proof(
-                    goal(reachable(d, f, "dba")),
+                    goal(reachable_via(d, f, "dba")),
                     by(rule("graph-reachability.pl", clause(9))),
                     bindings([binding("Start", d), binding("Goal", f), binding("Visited", "dba"), binding("Next", f)]),
                     uses([
@@ -50,7 +50,7 @@ why(
                         by(builtin('\\+', 1))
                       ),
                       proof(
-                        goal(reachable(f, f, "fdba")),
+                        goal(reachable_via(f, f, "fdba")),
                         by(fact("graph-reachability.pl", clause(8))),
                         bindings([binding("Node", f), binding("_visited", "fdba")])
                       )
@@ -79,7 +79,7 @@ why(
         bindings([binding("Start", c), binding("Goal", g)]),
         uses([
           proof(
-            goal(reachable(c, g, "c")),
+            goal(reachable_via(c, g, "c")),
             by(rule("graph-reachability.pl", clause(9))),
             bindings([binding("Start", c), binding("Goal", g), binding("Visited", "c"), binding("Next", e)]),
             uses([
@@ -92,7 +92,7 @@ why(
                 by(builtin('\\+', 1))
               ),
               proof(
-                goal(reachable(e, g, "ec")),
+                goal(reachable_via(e, g, "ec")),
                 by(rule("graph-reachability.pl", clause(9))),
                 bindings([binding("Start", e), binding("Goal", g), binding("Visited", "ec"), binding("Next", f)]),
                 uses([
@@ -105,7 +105,7 @@ why(
                     by(builtin('\\+', 1))
                   ),
                   proof(
-                    goal(reachable(f, g, "fec")),
+                    goal(reachable_via(f, g, "fec")),
                     by(rule("graph-reachability.pl", clause(9))),
                     bindings([binding("Start", f), binding("Goal", g), binding("Visited", "fec"), binding("Next", g)]),
                     uses([
@@ -118,7 +118,7 @@ why(
                         by(builtin('\\+', 1))
                       ),
                       proof(
-                        goal(reachable(g, g, "gfec")),
+                        goal(reachable_via(g, g, "gfec")),
                         by(fact("graph-reachability.pl", clause(8))),
                         bindings([binding("Node", g), binding("_visited", "gfec")])
                       )

package/package.json

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

package/src/cli.js

@@ -196,6 +196,10 @@ export async function main(argv) {
   });
 
   const portabilityFailures = program.interopPortabilityWarnings ?? [];
+  // Shadowing is reported unconditionally: silently replacing a library
+  // predicate for the whole program is the failure mode this diagnostic exists
+  // to surface, so it must not depend on opting in to --warnings.
+  printLibraryShadowingWarnings(program);
   if (options.warnings || (options.portable && portabilityFailures.length > 0)) printWarnings(program);
   if (options.portable && portabilityFailures.length > 0) {
     process.exitCode = 1;
@@ -331,6 +335,7 @@ Options:
   --proof-detail mode   Use abstract or expanded proof detail (implies --proof).
   --verify-proof file   Verify why/2 proof certificates against the input program.
   -q, --quads           Run embedded quad tests and fail if any do not hold.
+                        Note: -q is quads, not quiet; --quiet has no short form.
   --quiet               Suppress answer terms while preserving Prolog output.
   -s, --stats           Print solver and memory statistics to stderr after execution.
   --iso-strict          Use ISO/IEC 13211-1 core + Corrigenda 1-3 only;
@@ -364,6 +369,14 @@ function printSourceWarning(warning) {
 `);
 }
 
+function printLibraryShadowingWarnings(program) {
+  for (const warning of program.libraryShadowingWarnings ?? []) {
+    process.stderr.write('eyeprolog warning: user definition shadows a bundled library predicate\n');
+    process.stderr.write(`  ${warning.indicator} replaces library(${warning.library}) ${warning.indicator} for all user code in this program\n`);
+    process.stderr.write(`  import it explicitly with :- use_module(library(${warning.library}), [${warning.indicator}]). to make this an error\n`);
+  }
+}
+
 function printWarnings(program) {
   for (const warning of program.interopPortabilityWarnings ?? []) {
     if (warning.kind === 'library') {

package/src/parser.js

@@ -1138,7 +1138,7 @@ class Parser {
         }
         const operator = this.applyOperatorDirective(directive, line);
         if (!coreDirective && !extensionDirective && !operator) {
-          throw new Error(`parse line ${line}: bad term`);
+          throw new Error(`parse line ${line}: ${unsupportedDirectiveMessage(directive, this.strictIso)}`);
         }
         this.expect(TOK.DOT, '.');
         this.applyParserFlagDirective(directive, line);
@@ -1911,3 +1911,76 @@ export function parseGoalText(text, options = {}) {
   }
   return head.args[0];
 }
+
+// Directives are accepted from a fixed list, so an unrecognized one is a
+// different mistake from unparseable input and deserves a different message.
+// The three cases below cover what people actually write: a bare goal that
+// belongs in initialization/1, a misspelt directive name, and a term that is
+// not a directive at all.
+const CORE_DIRECTIVE_INDICATORS = [
+  'dynamic/1', 'multifile/1', 'discontiguous/1', 'initialization/1', 'include/1',
+  'ensure_loaded/1', 'char_conversion/2', 'set_prolog_flag/2', 'op/3',
+];
+const EXTENSION_DIRECTIVE_INDICATORS = [
+  'use_module/1', 'use_module/2', 'meta_predicate/1', 'attribute/1', 'table/1',
+  'public/1', 'module/2',
+];
+
+function directiveNameDistance(a, b) {
+  // Small Levenshtein distance, used only to suggest a near-miss spelling.
+  const rows = a.length + 1;
+  const cols = b.length + 1;
+  let previous = Array.from({ length: cols }, (_, i) => i);
+  for (let i = 1; i < rows; i++) {
+    const current = [i];
+    for (let j = 1; j < cols; j++) {
+      current[j] = Math.min(
+        previous[j] + 1,
+        current[j - 1] + 1,
+        previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1),
+      );
+    }
+    previous = current;
+  }
+  return previous[cols - 1];
+}
+
+function nearestDirectiveName(name, available) {
+  let best = null;
+  let bestDistance = Infinity;
+  for (const indicator of available) {
+    const candidate = indicator.slice(0, indicator.lastIndexOf('/'));
+    const distance = directiveNameDistance(name, candidate);
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      best = candidate;
+    }
+  }
+  // Only suggest a genuinely close spelling, not the alphabetically nearest.
+  return bestDistance <= Math.max(1, Math.floor(name.length / 3)) ? best : null;
+}
+
+function unsupportedDirectiveMessage(directive, strictIso) {
+  const available = strictIso
+    ? CORE_DIRECTIVE_INDICATORS
+    : [...CORE_DIRECTIVE_INDICATORS, ...EXTENSION_DIRECTIVE_INDICATORS];
+  if (directive.type !== COMPOUND && directive.type !== ATOM) {
+    return 'a directive must be a callable term';
+  }
+  const name = directive.name;
+  const arity = directive.type === COMPOUND ? directive.arity : 0;
+  const indicator = `${name}/${arity}`;
+  const known = available.filter((entry) => entry.slice(0, entry.lastIndexOf('/')) === name);
+  if (known.length > 0) {
+    return `directive ${indicator} has the wrong arity; expected ${known.join(' or ')}`;
+  }
+  const suggestion = nearestDirectiveName(name, available);
+  if (suggestion != null) {
+    return `unknown directive ${indicator}; did you mean ${suggestion}?`;
+  }
+  // A goal such as `:- write(hello), nl.` is well-formed but is not one of the
+  // recognized declarations, so point at initialization/1 rather than reporting
+  // a syntax error.
+  return `unknown directive ${indicator}; to run a goal at load time use ` +
+    ':- initialization(Goal).';
+}

package/src/program.js

@@ -153,6 +153,7 @@ export class Program {
     this.autoloadedPredicates = [];
     this.libraryImports = [];
     this.interopPortabilityWarnings = [];
+    this.libraryShadowingWarnings = [];
     this.dynamicPredicates = new Set();
     // ISO 7.5.3 notes that a public/1 directive declaring user-defined
     // procedures to be public would be an extension. Such a procedure stays
@@ -1428,6 +1429,55 @@ function analyzeInteropPortability(program, extraGoals = []) {
     });
   }
   program.interopPortabilityWarnings = [...warnings.values()];
+  analyzeLibraryShadowing(program);
+}
+
+// A user-defined procedure replaces the bundled-library procedure of the same
+// name and arity: the library clauses are never autoloaded, so other parts of
+// the same program that expected the library behaviour just see the user's
+// clauses. Bundled library modules keep resolving their own internal calls, so
+// this only affects user code, but within user code it acts at a distance
+// across included files.
+//
+// How strictly this is treated depends on how explicit the program was. The
+// first two tiers match what Trealla and Scryer do for the same program
+// (`:- use_module(library(lists)).` followed by clauses for append/3): both
+// warn and continue, Trealla with `overwriting user:'append'/3` and Scryer with
+// `overwriting append/3 because the clauses are discontiguous`. SWI-Prolog
+// treats imported predicates as weak symbols and warns likewise. No system
+// raises an error there, so neither does EyeProlog:
+//
+//   implicit autoload                          -> warning
+//   use_module(library(L))                     -> warning
+//   use_module(library(L), [Name/Arity])       -> permission_error
+//
+// Only the last case is an outright contradiction: the program asked for that
+// exact predicate to be imported and then supplied clauses for it. The first
+// two stay warnings so that flat, module-free programs keep loading here
+// exactly as they do on Scryer and Trealla, which was checked directly rather
+// than inferred. Note that ISO reserves permission_error(modify, static_procedure)
+// for built-in predicates (7.5.3); library predicates are not built-ins, so
+// this error is raised only where the program's own import list demands it.
+function analyzeLibraryShadowing(program) {
+  const explicitlyImported = new Map();
+  for (const entry of program.libraryImports) {
+    if (entry.imports == null) continue;
+    for (const indicator of entry.imports) {
+      explicitlyImported.set(`${entry.targetModule}:${indicator.key}`, entry.library);
+    }
+  }
+
+  const shadowed = new Map();
+  for (const group of program.groups.values()) {
+    if (group.module !== 'user') continue;
+    const key = `${group.name}/${group.arity}`;
+    const explicitLibrary = explicitlyImported.get(`${group.module}:${key}`);
+    if (explicitLibrary != null) throw staticProcedureModificationError(group.name, group.arity);
+    const library = eyePrologLibraryAutoload[key];
+    if (library == null || shadowed.has(key)) continue;
+    shadowed.set(key, { kind: 'shadowed-library-predicate', indicator: key, library });
+  }
+  program.libraryShadowingWarnings = [...shadowed.values()];
 }
 
 function sourceOptionsFor(source, options) {

package/test/conformance/ISO-PROLOG-TEXT-EXECUTION-MATRIX.md

@@ -23,7 +23,7 @@ chosen behavior is also indexed by `ISO-IMPLEMENTATION-DEFINED.md`.
 | 7.4.2.7 `include/1` | covered | The included text is prepared at the directive position and shares operator/character/flag preparation state with its parent. |
 | 7.4.2.8 `ensure_loaded/1` | covered | A source is prepared at most once in the current load graph, including repeated references and self/top-level references. |
 | 7.4.2.9 `set_prolog_flag/2` | covered | Preparation-time flag changes affect subsequent text and are replayed into execution state; strict flag names/values/changeability remain governed by the closed 7.11 review. |
-| 7.4.3 source clauses | covered | Source heads/bodies are validated like program clauses, standardized static/control procedures are protected, declarations can create empty procedures, and body conversion follows 7.6.2 while preserving head/body variable identity. The built-in restriction applies in every execution mode, so consulting a clause for a built-in predicate or control construct reports the same `permission_error(modify, static_procedure)` as `assert`ing one; EyeProlog's own library and extension predicates are not standard built-ins and stay redefinable. Corpus: `error/iso/consult_redefines_builtin`. |
+| 7.4.3 source clauses | covered | Source heads/bodies are validated like program clauses, standardized static/control procedures are protected, declarations can create empty procedures, and body conversion follows 7.6.2 while preserving head/body variable identity. The built-in restriction applies in every execution mode, so consulting a clause for a built-in predicate or control construct reports the same `permission_error(modify, static_procedure)` as `assert`ing one; EyeProlog's own library and extension predicates are not standard built-ins, so ISO does not protect them. They stay redefinable when they reach the program implicitly, through autoloading or a whole-module `use_module(library(L))`, but the redefinition is reported as a shadowing warning because it replaces the library predicate for all user code in the program. Naming a predicate in an explicit import list, `use_module(library(L), [Name/Arity])`, and then supplying clauses for it is a contradiction and reports `permission_error(modify, static_procedure)`. Bundled library modules keep resolving their own internal calls, so a user redefinition never changes library behaviour. Trealla and Scryer also warn and continue for the whole-module case rather than raising an error, so the warning tiers match those systems. Corpus: `error/iso/consult_redefines_builtin`. |
 
 The strict release test `closes ISO 7.4 Prolog-text preparation and directive
 rows` exercises the cross-text operator/character/flag state, include and

package/test/conformance/expected-errors/syntax/extra_missing_head_rejected.txt

@@ -1 +1 @@
-parse line 1: bad term
+parse line 1: unknown directive q/1; to run a goal at load time use :- initialization(Goal).