eyeprolog 1.5.104 → 1.5.106

package/package.json

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

package/src/iso.js

@@ -674,21 +674,29 @@ function* termVariablesBuiltin({ goal, env }) {
 }
 
 function validPredicateIndicator(term) {
-  if (term.type !== COMPOUND || term.name !== '/' || term.arity !== 2) return false;
-  const [name, arity] = term.args;
-  // Name/Arity denotes a predicate indicator only when some instance of it
-  // could be one: Name an atom, Arity a non-negative integer. The same
-  // shared variable in both positions (current_predicate(X/X), issue #115)
-  // looks valid argument-by-argument -- each position individually accepts
-  // an unbound variable -- but no instantiation can satisfy both at once,
-  // since binding that one variable to an atom makes Arity an atom too, not
-  // an integer. stc#79 treats this as no valid instance existing at all,
-  // the same as a bare atom argument, so it must raise
-  // type_error(predicate_indicator, _) rather than just finding no matches.
-  if (name.type === VAR && arity.type === VAR && name.name === arity.name) return false;
-  return (name.type === VAR || name.type === ATOM) &&
-    (arity.type === VAR ||
-      (arity.type === NUMBER && isDecimalInteger(arity.name) && BigInt(arity.name) >= 0n));
+  // ISO 13211-1 8.8.2.3's sole error condition is "PI is neither a variable
+  // nor a predicate indicator -> type_error(predicate_indicator, PI)", and
+  // 8.8.2.4's own worked example -- current_predicate(Name/1) succeeds,
+  // backtracking through every matching Name -- shows that a compound whose
+  // Name is merely a variable already counts as "a predicate indicator" for
+  // this check, not just one whose Name and Arity are already bound to an
+  // atom and a non-negative integer as 7.1.6.6 defines the type. So each
+  // position is checked independently here, not "could some single
+  // instantiation satisfy both at once": current_predicate(X/X) (issue #115)
+  // passes this check exactly like current_predicate(X/Y) does, and is left
+  // to the ordinary group search below (8.8.2.1 a-c), which unifies
+  // goal.args[0] (still X/X, the two positions aliased) against each
+  // candidate Name/Arity in turn. Name and Arity are never the same type, so
+  // that unification always fails for every candidate and the goal simply
+  // finds no solutions -- 8.8.2.1's own procedure gives no other outcome for
+  // an empty candidate set than "the goal fails" (step c), with no separate
+  // provision for an argument that turned out unable to ever unify. A
+  // predicate_indicator type error remains for a term that cannot look like
+  // a Name/Arity pair at all (a bare atom, a negative arity, ...).
+  return term.type === COMPOUND && term.name === '/' && term.arity === 2 &&
+    (term.args[0].type === VAR || term.args[0].type === ATOM) &&
+    (term.args[1].type === VAR ||
+      (term.args[1].type === NUMBER && isDecimalInteger(term.args[1].name) && BigInt(term.args[1].name) >= 0n));
 }
 
 const currentPredicateBuiltin = pendingBuiltin(currentPredicateSolutions);

package/test/run-iso-strict.mjs

@@ -1541,12 +1541,6 @@ export function runIsoStrict(reporter = new TestReporter()) {
       ['clause(X,_)', 'instantiation_error', 'clause/2 variable head'],
       ['clause(4,_)', 'type_error(callable)', 'clause/2 head type'],
       ['current_predicate(4)', 'type_error(predicate_indicator)', 'current_predicate/1 indicator type'],
-      // The same variable filling both Name and Arity (issue #115, stc#79)
-      // looks valid position-by-position -- each alone accepts an unbound
-      // variable -- but no instantiation can satisfy both at once, since
-      // binding it to an atom makes Arity an atom too, not an integer.
-      ['current_predicate(X/X)', 'type_error(predicate_indicator)', 'current_predicate/1 aliased name/arity variable'],
-      ['X = Y, current_predicate(X/Y)', 'type_error(predicate_indicator)', 'current_predicate/1 previously unified name/arity variables'],
       ['asserta(_)', 'instantiation_error', 'asserta/1 variable head'],
       ['asserta(4)', 'type_error(callable)', 'asserta/1 head type'],
       ['asserta((p:-4))', 'type_error(callable)', 'asserta/1 body conversion'],
@@ -1597,6 +1591,37 @@ export function runIsoStrict(reporter = new TestReporter()) {
 
     const current = run('p(a).\nq.\n', { isoStrict: true, goal: 'current_predicate(p/1)' });
     equal(current.stats.completed_goal_lists, 1, 'current_predicate/1 finds a user procedure');
+
+    // ISO 13211-1 8.8.2.4's own worked example: current_predicate(Name/1)
+    // succeeds with an unbound Name, backtracking through every arity-1
+    // predicate. A compound with an unbound component already counts as "a
+    // predicate indicator" for 8.8.2.3's error check, not only one whose
+    // Name and Arity are already bound to an atom and a non-negative
+    // integer as 7.1.6.6 defines the type.
+    equal(
+      run('elk(a).\ninsect(b).\n', { isoStrict: true, goal: 'current_predicate(Name/1)' }).stats.completed_goal_lists,
+      2,
+      'current_predicate/1 enumerates every matching Name with Arity fixed and Name unbound',
+    );
+
+    // The same variable filling both Name and Arity (issue #115) looks
+    // valid position-by-position by that same per-component check -- each
+    // position alone accepts an unbound variable, and current_predicate/1
+    // must support both fully unbound (current_predicate(X/Y), a generator,
+    // just demonstrated above) -- but no instantiation can satisfy both
+    // positions of one shared variable at once, since binding it to an atom
+    // makes Arity an atom too, not an integer. 8.8.2.3 has only the one
+    // error condition above, and 8.8.2.1's procedure gives no outcome for an
+    // empty candidate set (step a-c) besides "the goal fails" (step c) --
+    // there is no separate provision for an argument that turned out unable
+    // to ever unify with anything. current_predicate/1 follows that: it
+    // fails rather than raising an error.
+    for (const [goal, label] of [
+      ['current_predicate(X/X)', 'current_predicate/1 aliased name/arity variable fails'],
+      ['X = Y, current_predicate(X/Y)', 'current_predicate/1 previously unified name/arity variables fails'],
+    ]) {
+      equal(run('', { isoStrict: true, goal }).stats.completed_goal_lists, 0, label);
+    }
   });
 
   reporter.test('preserves 7.6.2 source-body conversion identity for clause/2 and retract/1', () => {