eyeprolog 1.5.103 → 1.5.105

package/package.json

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

package/src/iso.js

@@ -674,21 +674,26 @@ 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));
+  // Each position is checked independently, not "could some single
+  // instantiation satisfy both at once" -- so current_predicate(X/X)
+  // (issue #115) passes this check exactly like current_predicate(X/Y)
+  // does, and is then left to the ordinary group search below, 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 and the goal simply finds no
+  // solutions, the same way ISO's own current_op/3 (8.14.4.1) is specified:
+  // its candidate set is built by unifying a triple's priority (an integer)
+  // and specifier (an atom) against Priority and Op-specifier, so aliasing
+  // those two arguments the same way makes every candidate fail to unify
+  // and the set come up empty -- current_op/3's own Errors subclause
+  // (8.14.4.3) has no special case for it, only domain errors for an
+  // argument that is instantiated and outright wrong on its own. 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,11 +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'],
       ['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'],
@@ -1596,6 +1591,26 @@ 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');
+
+    // The same variable filling both Name and Arity (issue #115, stc#79)
+    // looks valid position-by-position -- each alone accepts an unbound
+    // variable, and current_predicate/1 must support both fully unbound
+    // (current_predicate(X/Y), a generator) -- 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. ISO does not
+    // special-case this for the structurally identical current_op/3
+    // (8.14.4.1): its candidate set is built by unifying a triple's integer
+    // priority and atom specifier against Priority and Op-specifier, so
+    // aliasing those two arguments the same way simply makes every
+    // candidate fail to unify and the set come up empty, and current_op/3's
+    // own Errors subclause (8.14.4.3) has no case for it. current_predicate
+    // /1 follows that precedent: 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', () => {