eyeprolog 1.3.83 → 1.3.84

package/package.json

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

package/src/iso.js

@@ -804,7 +804,18 @@ function* currentPrologFlagBuiltin({ solver, goal, env }) {
 }
 
 function* setPrologFlagBuiltin({ solver, goal, env }) {
-  solver.setPrologFlag(goal.args[0], goal.args[1], env);
+  const flag = deref(goal.args[0], env);
+  const value = deref(goal.args[1], env);
+  if (flag.type === VAR || value.type === VAR) throw new PrologError('instantiation_error');
+  if (flag.type !== ATOM) throw new PrologError('type_error(atom)', flag);
+  const definition = solver.prologFlags.get(flag.name);
+  if (!definition) throw new PrologError('domain_error(prolog_flag)', flag);
+  const expectedType = definition.valueType ?? ATOM;
+  if (value.type !== expectedType || !definition.allowed.includes(value.name)) {
+    throw new PrologError('domain_error(flag_value)', compound('+', [flag, value]));
+  }
+  if (!definition.changeable) throw new PrologError('permission_error(modify, flag)', flag);
+  definition.value = atom(value.name);
   yield env;
 }
 
@@ -1709,15 +1720,6 @@ function writeOptionBoolean(value, env, option) {
   return value.name === 'true';
 }
 
-function writeOptionSpacing(value, env, option) {
-  value = deref(value, env);
-  if (value.type === VAR) throw new PrologError('instantiation_error');
-  if (value.type !== ATOM || !['standard', 'minimal'].includes(value.name)) {
-    throw new PrologError('domain_error(write_option)', copyResolved(option, env));
-  }
-  return value.name;
-}
-
 function writeVariableNames(value, env, option) {
   value = deref(value, env);
   if (value.type === VAR) throw new PrologError('instantiation_error');
@@ -1746,10 +1748,8 @@ function writeVariableNames(value, env, option) {
   return names;
 }
 
-function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = null, initial = null) {
-  const result = initial == null
-    ? defaultTermWriteOptions(mode)
-    : { ...initial, variableNames: new Map(initial.variableNames ?? []) };
+function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = null) {
+  const result = defaultTermWriteOptions(mode);
   for (const option of options) {
     if (option.type !== COMPOUND || option.arity !== 1) {
       throw new PrologError('domain_error(write_option)', copyResolved(option, env));
@@ -1760,8 +1760,6 @@ function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = n
     else if (option.name === 'variable_names') result.variableNames = writeVariableNames(option.args[0], env, option);
     else if (option.name === 'double_quotes' && !solver?.isoStrict) {
       result.doubleQuotes = writeOptionBoolean(option.args[0], env, option);
-    } else if (option.name === 'spacing' && !solver?.isoStrict) {
-      result.minimalOperatorSpacing = writeOptionSpacing(option.args[0], env, option) === 'minimal';
     } else {
       throw new PrologError('domain_error(write_option)', copyResolved(option, env));
     }
@@ -1769,12 +1767,6 @@ function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = n
   return result;
 }
 
-export function parseTermWriteOptions(optionTerm, env, mode = 'write_term', solver = null, initial = null) {
-  const preflight = preflightOptionList(optionTerm, env);
-  const items = requireProperOptionList(preflight);
-  return termWriteOptionsFromItems(items, env, mode, solver, initial);
-}
-
 
 function writeBuiltin(mode) {
   return function* ({ solver, goal, env }) {

package/src/repl.js

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import { readSync } from 'node:fs';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
-import { formalErrorTerm, parseTermWriteOptions } from './iso.js';
+import { formalErrorTerm } from './iso.js';
 import {
   characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
 } from './syntax-scan.js';
@@ -303,18 +303,20 @@ function makeState(engine, sources, output, options = {}, previousState = null,
   const flagOverrides = new Map(previousState?.flagOverrides ?? []);
   for (const [name, value] of flagOverrides) {
     const definition = solver.prologFlags.get(name);
-    if (definition?.changeable) definition.value = value;
+    if (definition?.changeable && definition.allowed.includes(value)) {
+      definition.value = engine.atom(value);
+    }
   }
   return { program: solver.program, solver, strictIso, flagOverrides };
 }
 
 function snapshotFlagValues(solver) {
-  return new Map([...solver.prologFlags].map(([name, definition]) => [name, definition.value]));
+  return new Map([...solver.prologFlags].map(([name, definition]) => [name, definition.value?.name]));
 }
 
 function rememberFlagOverrides(state, before) {
   for (const [name, definition] of state.solver.prologFlags) {
-    const value = definition.value;
+    const value = definition.value?.name;
     if (before.get(name) !== value) state.flagOverrides.set(name, value);
   }
 }
@@ -718,7 +720,15 @@ function formatAnswer(engine, state, variables, env) {
   const valueMaxPriority = equality == null
     ? 699
     : equality.specifier === 'xfy' ? equality.priority : equality.priority - 1;
-  const writeOptions = answerTermWriteOptions(state, env);
+  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
@@ -733,28 +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, {
-      ...writeOptions,
-      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,
     })}`);
   }
   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, {
-      ...writeOptions,
-      operators,
-      variableNames: names,
-      operatorAtomsAsArgs: true,
-      dottedGraphicAtoms: true,
-    }));
+    bindings.push(engine.formatTermForWrite(residual, env, answerWriteOptions));
   }
   const projectedAttributeRoots = new Set();
   for (const variable of variables) {
@@ -764,38 +764,12 @@ 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, {
-        ...writeOptions,
-        operators,
-        variableNames: names,
-        operatorAtomsAsArgs: true,
-        dottedGraphicAtoms: true,
-      }));
+      bindings.push(engine.formatTermForWrite(residual, env, answerWriteOptions));
     }
   }
   return bindings.length === 0 ? 'true' : bindings.join(', ');
 }
 
-function answerTermWriteOptions(state, env) {
-  const doubleQuotes = state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars';
-  const initial = {
-    quoted: true,
-    ignoreOps: false,
-    numbervars: true,
-    variableNames: new Map(),
-    compact: false,
-    minimalOperatorSpacing: false,
-    operatorAtomsAsArgs: true,
-    doubleQuotes,
-  };
-  const optionTerm = state.solver.prologFlags.get('answer_write_options')?.value;
-  if (optionTerm == null) return initial;
-  const options = parseTermWriteOptions(optionTerm, env, 'write_term', state.solver, initial);
-  if (options.doubleQuotes === true) options.doubleQuotes = doubleQuotes;
-  else if (options.doubleQuotes === false) options.doubleQuotes = null;
-  return options;
-}
-
 function collectUnboundVariables(engine, term, env, names, nextName) {
   const stack = [term];
   const seen = new Set();

package/src/solver.js

@@ -1,12 +1,12 @@
 // Depth-first EyeProlog solver with builtin dispatch, memoization, and guarded recursion handling.
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
 import {
-  ATOM, COMPOUND, NUMBER, STRING, VAR, Env, atom, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
+  ATOM, COMPOUND, NUMBER, STRING, VAR, Env, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
   flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList,
-  listFromItems, numberTerm, numberTextFromDouble, properListItems, termIsGround, termToString, unify, variable, variantTerms,
+  numberTerm, numberTextFromDouble, properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
 import { numberValueKey, sameNumberValue } from './number-value.js';
-import { PrologError, getStrictIsoRegistry, parseTermWriteOptions } from './iso.js';
+import { PrologError, getStrictIsoRegistry } from './iso.js';
 import { getEyePrologRegistry } from './standard-library.js';
 import { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program-indexing.js';
 import { StreamManager } from './io.js';
@@ -144,7 +144,15 @@ export class Solver {
         this.prologFlags.get('double_quotes').value = compound(program.doubleQuotes, []);
       }
       for (const [flag, value] of program.prologFlagDirectives ?? []) {
-        this.setPrologFlag(flag, value, new Env());
+        if (flag.type === 'var' || value.type === 'var') throw new PrologError('instantiation_error');
+        if (flag.type !== 'atom') throw new PrologError('type_error(atom)', flag);
+        const definition = this.prologFlags.get(flag.name);
+        if (!definition) throw new PrologError('domain_error(prolog_flag)', flag);
+        if (value.type !== 'atom' || !definition.allowed.includes(value.name)) {
+          throw new PrologError('domain_error(flag_value)', compound('+', [flag, value]));
+        }
+        if (!definition.changeable) throw new PrologError('permission_error(modify, flag)', flag);
+        definition.value = value;
       }
     }
     if (!options.charConversions) {
@@ -198,35 +206,6 @@ export class Solver {
     };
   }
 
-  setPrologFlag(flagTerm, valueTerm, env = new Env()) {
-    const flag = deref(flagTerm, env);
-    const value = deref(valueTerm, env);
-    if (flag.type === VAR || value.type === VAR) throw new PrologError('instantiation_error');
-    if (flag.type !== ATOM) throw new PrologError('type_error(atom)', flag);
-    const definition = this.prologFlags.get(flag.name);
-    if (!definition) throw new PrologError('domain_error(prolog_flag)', flag);
-
-    if (definition.writeOptions === true) {
-      if (!termIsGround(value, env)) throw new PrologError('instantiation_error');
-      try {
-        parseTermWriteOptions(value, env, 'write_term', this);
-      } catch (error) {
-        if (error instanceof PrologError && error.formal === 'instantiation_error') throw error;
-        throw new PrologError('domain_error(flag_value)', compound('+', [flag, copyResolved(value, env)]));
-      }
-      if (!definition.changeable) throw new PrologError('permission_error(modify, flag)', flag);
-      definition.value = copyResolved(value, env);
-      return;
-    }
-
-    const expectedType = definition.valueType ?? ATOM;
-    if (value.type !== expectedType || !definition.allowed.includes(value.name)) {
-      throw new PrologError('domain_error(flag_value)', compound('+', [flag, value]));
-    }
-    if (!definition.changeable) throw new PrologError('permission_error(modify, flag)', flag);
-    definition.value = atom(value.name);
-  }
-
   cloneForInnerGoal(solutionLimit = this.solutionLimit, options = {}) {
     const solver = new Solver(this.program, {
       registry: this.registry,
@@ -1093,12 +1072,6 @@ function defaultPrologFlags(unknown = 'error', strictIso = false) {
     ['unknown', { value: compound(unknown, []), allowed: ['error', 'fail', 'warning'], changeable: true }],
     ['double_quotes', { value: compound('chars', []), allowed: ['chars', 'codes', 'atom'], changeable: true }],
     ['occurs_check', { value: compound('true', []), allowed: ['true', 'error'], changeable: true }],
-    ['answer_write_options', {
-      value: listFromItems([compound('spacing', [compound('standard', [])])]),
-      allowed: [],
-      changeable: true,
-      writeOptions: true,
-    }],
   ]);
   if (strictIso) flags.delete('occurs_check');
   return flags;

package/test/conformance/ISO-COMPLIANCE.md

@@ -97,8 +97,8 @@ required permission error. `read_term/3`, `write_term/3`, `op/3`, and
 EyeProlog's chosen simultaneous-error behavior stable. Section 7.12 makes that
 choice implementation dependent when several error conditions hold at once. Strict `write_term/2-3` accepts only
 the Part 1 plus Corrigendum 3 option surface; the normal-profile
-`double_quotes/1` and `spacing/1` write options remain explicitly documented
-EyeProlog extensions.
+`double_quotes/1` write option remains an explicitly documented EyeProlog
+extension.
 
 
 The preparation, stream, conversion, sorting, and arithmetic audit expands the coverage into Prolog-text,

package/test/conformance/ISO-IMPLEMENTATION-DEFINED.md

@@ -120,11 +120,11 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 | 5.5.5 Directives | `module/2`, `use_module/1-2`, `meta_predicate/1` and normal-profile library behavior | Rejected as implementation-specific Part 1 directives. |
 | 5.5.6 Side effects | Normal mode adds `statistics/0-2`, cleanup/library state, and optional proof/statistics host instrumentation. | The strict registry excludes Prolog-visible statistics/cleanup/library adapters; ordinary Part 1 I/O/database/flag/operator side effects remain. Host proof/statistics collection observes execution through the embedding API rather than adding a strict Prolog goal effect. **covered** — strict registry/execution regression. |
 | 5.5.7 Control constructs | `tnot/1` and normal-profile execution optimizations | `tnot/1` is absent; automatic tabling/recursion guards are disabled. |
-| 5.5.8 Flags | `occurs_check`; `answer_write_options`, whose normal-mode default is `[spacing(standard)]` and whose value controls REPL answer rendering | Both extension flags are absent in strict mode. |
+| 5.5.8 Flags | `occurs_check` | Absent in strict mode. |
 | 5.5.9 Built-in predicates | EyeProlog libraries, CLP(Z), statistics, Part 3 `phrase/2-3`, and interop autoloaded predicates | Strict registry contains only the Part 1 + Corrigenda core registry. |
 | 5.5.10 Evaluable functors | Normal mode additionally accepts the EyeProlog evaluable atom `e`; the remaining arithmetic functors accepted by strict mode are the Part 1 + Corrigenda set. | Strict mode rejects `e/0` as non-evaluable and retains the Corrigendum arithmetic additions. **covered** — strict extension-boundary regression plus `src/iso-arithmetic.js`. |
 | 5.5.11 Reserved atoms | None | None. |
-| Cor.3 5.5.12 Options | Extra library/host options may exist outside core option lists | Normal mode additionally accepts the EyeProlog `write_term/2-3` options `double_quotes(true|false)` and `spacing(standard|minimal)`. Strict core excludes those extensions and accepts only the Part 1 plus Corrigendum 3 write-option surface; unknown extension options raise `domain_error(write_option,...)`. |
+| Cor.3 5.5.12 Options | Extra library/host options may exist outside core option lists | Normal mode additionally accepts the EyeProlog `write_term/2-3` option `double_quotes(true|false)`. Strict core excludes that extension and accepts only the Part 1 plus Corrigendum 3 write-option surface; unknown extension options raise `domain_error(write_option,...)`. |
 
 Normal mode provides documented module and DCG compatibility profiles whose
 features overlap standardized Part 2 and Part 3 facilities. They are extensions

package/test/conformance/expected/iso/exceptions_and_flags.pl

@@ -1,3 +1,3 @@
 answer(7, red, caught(eyeprolog), first, caught(eyeprolog)).
 answer(7, red, caught(eyeprolog), second, caught(eyeprolog)).
-flags(off, on, [pair(bounded, false), pair(integer_rounding_function, toward_zero), pair(char_conversion, on), pair(debug, off), pair(max_arity, unbounded), pair(unknown, fail), pair(double_quotes, chars), pair(occurs_check, true), pair(answer_write_options, [spacing(standard)])]).
+flags(off, on, [pair(bounded, false), pair(integer_rounding_function, toward_zero), pair(char_conversion, on), pair(debug, off), pair(max_arity, unbounded), pair(unknown, fail), pair(double_quotes, chars), pair(occurs_check, true)]).

package/test/run-iso-strict.mjs

@@ -41,7 +41,6 @@ export function runIsoStrict(reporter = new TestReporter()) {
   reporter.test('exposes only ISO core Prolog flags', () => {
     const solver = new Solver(Program.parse('', { isoStrict: true }), { isoStrict: true });
     equal(solver.prologFlags.has('occurs_check'), false, 'occurs_check');
-    equal(solver.prologFlags.has('answer_write_options'), false, 'answer_write_options');
     equal(solver.prologFlags.get('unknown')?.value?.name, 'error', 'unknown default');
   });
 
@@ -284,16 +283,8 @@ export function runIsoStrict(reporter = new TestReporter()) {
     }));
     equal(strictError.formal, 'domain_error(write_option)', 'strict extension rejection');
 
-    const strictSpacingError = capture(() => run('', {
-      isoStrict: true,
-      goal: 'write_term(1*1,[spacing(minimal)])',
-    }));
-    equal(strictSpacingError.formal, 'domain_error(write_option)', 'strict spacing extension rejection');
-
     const normal = run('', { goal: 'write_term("ab",[double_quotes(true)])' });
     includes(normal.stdout, '"ab"', 'normal-profile extension remains available');
-    includes(run('', { goal: 'write_term(1*1,[spacing(standard)])' }).stdout,
-      '1 * 1', 'normal-profile spacing extension remains available');
   });
 
   reporter.test('follows Corrigendum 3 variable metadata traversal and write naming', () => {

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');
@@ -3882,67 +3882,18 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
       },
     },
     {
-      name: 'answer write options make operator spacing explicit and persistent (issue #76)',
+      name: 'REPL answers use only lexically required operator spacing (issue #76)',
       run: () => {
-        const source = [
-          'emit :-',
-          '  write_term(1*1, [spacing(standard)]), put_char(\'|\'),',
-          '  write_term(1*1, [spacing(minimal)]), put_char(\'|\'),',
-          '  write_term(1*1, [spacing(standard),spacing(minimal)]).',
-          '',
-        ].join('\n');
-        assertEqual(run(source, { goal: 'emit' }).stdout, '1 * 1|1*1|1*1emit.\n',
-          'explicit and rightmost spacing options');
-        assertEqual(run([
-          ':- set_prolog_flag(answer_write_options, [spacing(minimal)]).',
-          'emit :- current_prolog_flag(answer_write_options, [spacing(minimal)]).',
-        ], { goal: 'emit' }).stdout, 'emit.\n', 'source flag directive');
-
         const result = runCli([], {
-          input:
-            'current_prolog_flag(answer_write_options, Os).\n' +
-            'X=1*1.\n' +
-            'set_prolog_flag(answer_write_options,[spacing(minimal)]).\n' +
-            'use_module(library(lists)).\n' +
-            'X=1*1.\n' +
-            'current_prolog_flag(answer_write_options, Os).\n' +
-            'halt.\n',
+          input: 'X=1*1.\nX=a + -b.\nhalt.\n',
         });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout,
-          '?-    Os = [spacing(standard)].\n' +
-          '?-    X = 1 * 1.\n' +
-          '?-    true.\n' +
-          '?-    true.\n' +
           '?-    X = 1*1.\n' +
-          '?-    Os = [spacing(minimal)].\n' +
+          '?-    X = a+ -b.\n' +
           '?- ',
-          'discoverable top-level option and persistence across module reload');
+          'minimal operator layout preserves required token separation');
         assertEqual(result.stderr, '', 'stderr');
-
-        let writeOptionError = null;
-        try {
-          run('', { goal: 'write_term(a,[spacing(other)])' });
-        } catch (error) {
-          writeOptionError = error;
-        }
-        assertEqual(writeOptionError?.formal, 'domain_error(write_option)', 'spacing value domain');
-
-        let flagValueError = null;
-        try {
-          run('', { goal: 'set_prolog_flag(answer_write_options,[spacing(other)])' });
-        } catch (error) {
-          flagValueError = error;
-        }
-        assertEqual(flagValueError?.formal, 'domain_error(flag_value)', 'answer option flag domain');
-
-        let nongroundFlagError = null;
-        try {
-          run('', { goal: 'set_prolog_flag(answer_write_options,[spacing(X)])' });
-        } catch (error) {
-          nongroundFlagError = error;
-        }
-        assertEqual(nongroundFlagError?.formal, 'instantiation_error', 'answer options must be ground');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -5426,10 +5426,10 @@ still retained where adjacent graphic tokens would otherwise merge, as in
 `write_term/2-3` supports `quoted/1`, `ignore_ops/1`, `numbervars/1`, and
 `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. It also accepts
-`spacing(standard|minimal)`: `standard` places layout around operators, while
-`minimal` emits only the separators required to avoid lexical ambiguity.
-Strict ISO mode rejects both non-standard write options.
+current `double_quotes` representation, while strict ISO mode rejects this
+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
@@ -6002,7 +6002,7 @@ silently changing a static program.
 | `char_conversion(+Input,+Output)` | Installs a one-character conversion. In prepared Prolog text, later **unquoted** characters are converted when `char_conversion=on`; quoted characters are unchanged. The same mapping initializes execution-time term input. Mapping a character to itself removes its custom mapping. |
 | `current_char_conversion(?Input,?Output)` | Enumerates installed nonidentity conversions. |
 | `current_prolog_flag(?Flag,?Value)` | Enumerates flags or retrieves one named flag. An unknown bound flag raises *domain_error(prolog_flag)*. |
-| `set_prolog_flag(+Flag,+Value)` | Changes a supported mutable flag after validating its value. Read-only flags raise a permission error. |
+| `set_prolog_flag(+Flag,+Value)` | Changes a supported mutable flag after validating its allowed atom value. Read-only flags raise a permission error. |
 
 | Flag | Default in normal EyeProlog | Allowed values | Mutable |
 | --- | --- | --- | --- |
@@ -6016,7 +6016,6 @@ silently changing a static program.
 | `unknown` | `error` | `error`, `fail`, `warning` | yes |
 | `double_quotes` | `chars` | `chars`, `codes`, `atom` | yes |
 | `occurs_check` | `true` | `true`, `error` | yes |
-| `answer_write_options` | `[spacing(standard)]` | A ground proper list of supported normal-mode `write_term/2-3` options | yes |
 
 Because `bounded=false`, `current_prolog_flag(max_integer, _)` and
 `current_prolog_flag(min_integer, _)` fail as required by ISO 7.11.1.1;
@@ -6051,24 +6050,6 @@ codes("ab").                 % codes([97,98])
 quoted_atom("ab").           % quoted_atom(ab)
 ```
 
-Normal mode also exposes the REPL's term-writing options through the mutable
-`answer_write_options` flag. Its explicit default explains the spaces in an
-answer such as `X = 1 * 1`; selecting minimal spacing is discoverable and
-reusable from Prolog:
-
-```text
-?- current_prolog_flag(answer_write_options, Options).
-   Options = [spacing(standard)].
-?- set_prolog_flag(answer_write_options, [spacing(minimal)]).
-   true.
-?- X = 1*1.
-   X = 1*1.
-```
-
-The setting survives interactive `consult/1` and `use_module/1-2` program
-rebuilds. `answer_write_options` is a normal-mode host flag and is absent in
-strict ISO mode.
-
 ### Atomic-term operations and conversions
 
 | Predicate and principal call | Behavior |
@@ -6141,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,...])*. Normal mode also supports *double_quotes(true or false)* and *spacing(standard or minimal)*. |
+| `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
@@ -7786,8 +7767,8 @@ Notable implementation boundaries are:
 - `write_term/2-3` implements the Part 1 plus Corrigendum 3 `quoted/1`,
   `ignore_ops/1`, `numbervars/1`, and `variable_names/1` option surface,
   including option validation and traversal rules; normal mode also offers
-  `double_quotes(true|false)` and `spacing(standard|minimal)` as explicitly
-  non-standard extensions, which strict mode rejects;
+  `double_quotes(true|false)` as an explicitly non-standard extension, which
+  strict mode rejects;
 - unification consistently performs an occurs check, rejecting rational-tree
   bindings accepted as extensions by some systems.