eyeprolog 1.5.97 → 1.5.98

package/package.json

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

package/src/quads.js

@@ -322,6 +322,7 @@ function describeLeaf(term) {
   const leaf = {
     bindings: [],
     approximations: [],
+    literalApproximations: [],
     unexpected: false,
     more: false,
     sto: false,
@@ -360,8 +361,21 @@ function describeLeaf(term) {
       continue;
     }
     if (item.type === COMPOUND && item.name === '~~' && item.arity === 2) {
-      if (item.args[0].type !== VAR || approximateDecimalInterval(item.args[1]) == null) leaf.malformed ??= item;
-      else leaf.approximations.push(item);
+      // The left-hand side names either one of the query's own variables
+      // (the usual case: compare what the query actually bound it to) or,
+      // just as legitimately, a literal number written directly in the
+      // answer description -- a free-standing "this value approximately
+      // denotes this decimal interval" claim with no query variable
+      // involved at all (issue #113: `0.04 ~~ '0.0'` was rejected as
+      // malformed purely for lacking a variable on the left, with no
+      // deeper reason for that restriction). Both are validated the same
+      // way one level up, in matchLeaf/substitutionMatches: syntactic
+      // acceptance here does not yet mean the value actually falls in the
+      // stated interval.
+      const lhsIsVarOrNumber = item.args[0].type === VAR || item.args[0].type === NUMBER;
+      if (!lhsIsVarOrNumber || approximateDecimalInterval(item.args[1]) == null) leaf.malformed ??= item;
+      else if (item.args[0].type === VAR) leaf.approximations.push(item);
+      else leaf.literalApproximations.push(item);
       continue;
     }
     if (item.type === COMPOUND && item.name === 'inputs' && item.arity === 1) {
@@ -385,6 +399,7 @@ function describeLeaf(term) {
     else leaf.malformed ??= item;
   }
   leaf.hasExpectation = leaf.bindings.length > 0 || leaf.approximations.length > 0 ||
+    leaf.literalApproximations.length > 0 ||
     leaf.truth || leaf.false || leaf.maybe || leaf.loops || leaf.waits ||
     leaf.error != null || leaf.output != null;
   if (!leaf.hasExpectation && !leaf.more && !leaf.sto && leaf.unsupported == null) leaf.malformed ??= term;
@@ -528,6 +543,10 @@ function matchLeaf(program, query, leaf, actual, position) {
   // its absence requires an unconstrained answer. In either case the stated
   // substitutions remain exact and are checked below.
   if (leaf.maybe !== hasPendingConstraints(solution.env)) return false;
+  // Literal `~~` claims (issue #113) name no query variable at all, so
+  // they carry no per-position runtime state to look up; they either hold
+  // or they don't, the same at every position.
+  if (leaf.literalApproximations.some((item) => !approximatelyMatches(item.args[0], item.args[1]))) return false;
   return substitutionMatches(query, leaf.bindings, leaf.approximations, solution.env);
 }
 

package/test/regression/cases-regression.mjs

@@ -1195,6 +1195,26 @@ why(
         assertEqual(malformedAtom.failed, 1, 'non-decimal atom is rejected');
         assertIncludes(malformedAtom.stdout, 'MALFORMED', 'non-decimal atom diagnostic');
 
+        // Issue #113: a literal number on the left of `~~` names no query
+        // variable at all -- it is a free-standing "this value approximately
+        // denotes this decimal interval" claim, and there is no deeper reason
+        // to require a variable there. It must be accepted (and actually
+        // checked against the interval, not accepted unconditionally), the
+        // same as the query-variable form already was.
+        const literalOk = publicApi.runQuads('?- true.\n   0.04 ~~ \'0.0\'.\n');
+        assertEqual(literalOk.total, 1, 'literal approximation total');
+        assertEqual(literalOk.passed, 1, 'literal approximation passed');
+        assertEqual(literalOk.stdout, 'quads: 1 run, 1 passed, 0 failed.\n', 'literal approximation report');
+
+        const literalOutOfRange = publicApi.runQuads('?- true.\n   0.04 ~~ \'5.0\'.\n');
+        assertEqual(literalOutOfRange.failed, 1, 'literal outside the claimed interval fails, not malformed');
+        assertIncludes(literalOutOfRange.stdout, 'quads: FAILED', 'literal out-of-range diagnostic');
+        assertNotIncludes(literalOutOfRange.stdout, 'MALFORMED', 'literal out-of-range is not malformed');
+
+        const literalNonNumberLhs = publicApi.runQuads('?- true.\n   foo ~~ \'0.0\'.\n');
+        assertEqual(literalNonNumberLhs.failed, 1, 'a non-variable, non-number left side remains malformed');
+        assertIncludes(literalNonNumberLhs.stdout, 'MALFORMED', 'non-number left side diagnostic');
+
         const duplicate = publicApi.runQuads(`?- V is 14.2.
    V = 14.2, V ~~ '14.2000'.
 `);