eyeprolog 1.3.82 → 1.3.84

package/package.json

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

package/src/repl.js

@@ -720,6 +720,15 @@ function formatAnswer(engine, state, variables, env) {
   const valueMaxPriority = equality == null
     ? 699
     : equality.specifier === 'xfy' ? equality.priority : equality.priority - 1;
+  const answerWriteOptions = {
+    quoted: true,
+    minimalOperatorSpacing: true,
+    operators,
+    variableNames: names,
+    operatorAtomsAsArgs: true,
+    dottedGraphicAtoms: true,
+    doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+  };
   let generated = 0;
 
   // Meta-predicate wrappers can make a query variable alias an internal fresh
@@ -734,30 +743,18 @@ function formatAnswer(engine, state, variables, env) {
     if (value.type === 'var' &&
         (value.name === variable.name || !queryVariableNames.has(value.name))) continue;
     bindings.push(`${variable.name} = ${engine.formatTermForWrite(value, env, {
-      quoted: true,
-      operators,
-      variableNames: names,
+      ...answerWriteOptions,
       maxPriority: valueMaxPriority,
       // A binding value is the right-hand `arg` of =/2.  ISO 6.3.3.1 permits
       // current operator atoms in argument and list-element positions without
       // quotes, just as writeq/1 already prints them.
-      operatorAtomsAsArgs: true,
-      dottedGraphicAtoms: true,
-      doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
     })}`);
   }
   for (const constraint of env.variableConstraints?.() ?? []) {
     const residual = constraint.residualGoal?.(env);
     if (residual == null) continue;
     collectUnboundVariables(engine, residual, env, names, () => `_${letterName(generated++)}`);
-    bindings.push(engine.formatTermForWrite(residual, env, {
-      quoted: true,
-      operators,
-      variableNames: names,
-      operatorAtomsAsArgs: true,
-      dottedGraphicAtoms: true,
-      doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
-    }));
+    bindings.push(engine.formatTermForWrite(residual, env, answerWriteOptions));
   }
   const projectedAttributeRoots = new Set();
   for (const variable of variables) {
@@ -767,14 +764,7 @@ function formatAnswer(engine, state, variables, env) {
     names.set(root.name, variable.name);
     for (const residual of state.solver.attributeResidualGoals(root, env)) {
       collectUnboundVariables(engine, residual, env, names, () => `_${letterName(generated++)}`);
-      bindings.push(engine.formatTermForWrite(residual, env, {
-        quoted: true,
-        operators,
-        variableNames: names,
-        operatorAtomsAsArgs: true,
-        dottedGraphicAtoms: true,
-        doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
-      }));
+      bindings.push(engine.formatTermForWrite(residual, env, answerWriteOptions));
     }
   }
   return bindings.length === 0 ? 'true' : bindings.join(', ');

package/test/run-regression.mjs

@@ -186,7 +186,7 @@ function regressionCases() {
         });
         assertEqual(residuals.status, 0, 'dif/2 residual display status');
         assertEqual(residuals.stdout,
-          '?-    C = z, D = z, dif(A - z, B - z).\n' +
+          '?-    C = z, D = z, dif(A-z, B-z).\n' +
           '?-    A = [[]], B = [], dif([[]], [C]).\n' +
           '?-    X = Y.\n' +
           '?- ',
@@ -1449,7 +1449,7 @@ c4 ?- call((!;1)).
           input: 'read(T).\n!,*.\n.\nread(T).\na\n.\nhalt.\n',
         });
         assertEqual(continuedGraphic.status, 0, 'continued graphic operator REPL status');
-        assertIncludes(continuedGraphic.stdout, 'T = (!, *.).', 'continued graphic operator answer');
+        assertIncludes(continuedGraphic.stdout, 'T = (!,*.).', 'continued graphic operator answer');
         assertIncludes(continuedGraphic.stdout, 'T = a.', 'read after continued graphic operator');
         assertNotIncludes(continuedGraphic.stdout, 'syntax_error', 'continued graphic operator syntax');
         assertEqual(continuedGraphic.stderr, '', 'continued graphic operator REPL stderr');
@@ -2456,10 +2456,10 @@ c4 ?- call((!;1)).
         });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout,
-          '?-    T = (a = b).\n' +
-          '?-    U = (a, b).\n' +
-          '?-    V = (a ; b).\n' +
-          '?-    W = a + b.\n' +
+          '?-    T = (a=b).\n' +
+          '?-    U = (a,b).\n' +
+          '?-    V = (a;b).\n' +
+          '?-    W = a+b.\n' +
           '?- ',
           'stdout');
         assertEqual(result.stderr, '', 'stderr');
@@ -2665,9 +2665,9 @@ c4 ?- call((!;1)).
         });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout,
-          '?-   |:  X = (_A = a).\n' +
-          '?-   |:  X = (_A = a).\n' +
-          "?-   |:  X = (_A = pair(_A, _B)), Vs = [_A, _B], Names = ['X' = _A, 'Y' = _B], Singletons = ['Y' = _B].\n" +
+          '?-   |:  X = (_A=a).\n' +
+          '?-   |:  X = (_A=a).\n' +
+          "?-   |:  X = (_A=pair(_A, _B)), Vs = [_A, _B], Names = ['X'=_A, 'Y'=_B], Singletons = ['Y'=_B].\n" +
           '?- ',
           'stdout');
         assertEqual(result.stderr, '', 'stderr');
@@ -3881,6 +3881,21 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
         assertEqual(run(source, { goal: 'emit' }).stdout, '1+2|a+ -b|a+b*c\nemit.\n', 'minimal operator spacing');
       },
     },
+    {
+      name: 'REPL answers use only lexically required operator spacing (issue #76)',
+      run: () => {
+        const result = runCli([], {
+          input: 'X=1*1.\nX=a + -b.\nhalt.\n',
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?-    X = 1*1.\n' +
+          '?-    X = a+ -b.\n' +
+          '?- ',
+          'minimal operator layout preserves required token separation');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'write predicates and write_term options select distinct formats',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5427,7 +5427,9 @@ still retained where adjacent graphic tokens would otherwise merge, as in
 `variable_names/1`. Normal mode additionally accepts the EyeProlog extension
 `double_quotes(true|false)`: `true` lets eligible character/code lists use the
 current `double_quotes` representation, while strict ISO mode rejects this
-non-standard write option.
+non-standard write option. The REPL follows the same minimal-separator rule as
+term output, so `X=1*1` is displayed as `X = 1*1`, while a separator is retained
+in `X = a+ -b` because the adjacent graphic tokens would otherwise merge.
 
 Character operations are `get_char`, `peek_char`, `put_char`, `get_code`,
 `peek_code`, and `put_code`; byte streams use the corresponding byte
@@ -6120,7 +6122,7 @@ the beginning. A peek does not mark the stream as past-end.
 | `write(+Term)`, `write(+Stream,+Term)` | Writes readable operator notation without quoting atoms merely because quoting would be required for reparsing. Number variables are enabled. |
 | `writeq(+Term)`, `writeq(+Stream,+Term)` | Like `write`, but quotes atoms when required for unambiguous input syntax. |
 | `write_canonical(+Term)`, `write_canonical(+Stream,+Term)` | Writes quoted canonical functor notation while ignoring operators and without interpreting *$VAR/1*. |
-| `write_term(+Term,+Options)`, `write_term(+Stream,+Term,+Options)` | Writes with *quoted(true or false)*, *ignore_ops(true or false)*, *numbervars(true or false)*, and *variable_names([Name=Variable,...])*. |
+| `write_term(+Term,+Options)`, `write_term(+Stream,+Term,+Options)` | Writes with *quoted(true or false)*, *ignore_ops(true or false)*, *numbervars(true or false)*, and *variable_names([Name=Variable,...])*. Normal mode also supports *double_quotes(true or false)*. |
 
 Term input uses the program's current operator table and the same ISO quoted-character
 syntax as source text, including backslash-terminated octal and hexadecimal