eyeprolog 1.3.82 → 1.3.83

package/package.json

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

package/src/iso.js

@@ -804,18 +804,7 @@ function* currentPrologFlagBuiltin({ solver, goal, env }) {
 }
 
 function* setPrologFlagBuiltin({ solver, goal, 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);
+  solver.setPrologFlag(goal.args[0], goal.args[1], env);
   yield env;
 }
 
@@ -1720,6 +1709,15 @@ 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');
@@ -1748,8 +1746,10 @@ function writeVariableNames(value, env, option) {
   return names;
 }
 
-function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = null) {
-  const result = defaultTermWriteOptions(mode);
+function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = null, initial = null) {
+  const result = initial == null
+    ? defaultTermWriteOptions(mode)
+    : { ...initial, variableNames: new Map(initial.variableNames ?? []) };
   for (const option of options) {
     if (option.type !== COMPOUND || option.arity !== 1) {
       throw new PrologError('domain_error(write_option)', copyResolved(option, env));
@@ -1760,6 +1760,8 @@ 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));
     }
@@ -1767,6 +1769,12 @@ 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 } from './iso.js';
+import { formalErrorTerm, parseTermWriteOptions } from './iso.js';
 import {
   characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
 } from './syntax-scan.js';
@@ -303,20 +303,18 @@ 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.allowed.includes(value)) {
-      definition.value = engine.atom(value);
-    }
+    if (definition?.changeable) definition.value = value;
   }
   return { program: solver.program, solver, strictIso, flagOverrides };
 }
 
 function snapshotFlagValues(solver) {
-  return new Map([...solver.prologFlags].map(([name, definition]) => [name, definition.value?.name]));
+  return new Map([...solver.prologFlags].map(([name, definition]) => [name, definition.value]));
 }
 
 function rememberFlagOverrides(state, before) {
   for (const [name, definition] of state.solver.prologFlags) {
-    const value = definition.value?.name;
+    const value = definition.value;
     if (before.get(name) !== value) state.flagOverrides.set(name, value);
   }
 }
@@ -720,6 +718,7 @@ function formatAnswer(engine, state, variables, env) {
   const valueMaxPriority = equality == null
     ? 699
     : equality.specifier === 'xfy' ? equality.priority : equality.priority - 1;
+  const writeOptions = answerTermWriteOptions(state, env);
   let generated = 0;
 
   // Meta-predicate wrappers can make a query variable alias an internal fresh
@@ -734,7 +733,7 @@ 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,
+      ...writeOptions,
       operators,
       variableNames: names,
       maxPriority: valueMaxPriority,
@@ -743,7 +742,6 @@ function formatAnswer(engine, state, variables, env) {
       // 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?.() ?? []) {
@@ -751,12 +749,11 @@ function formatAnswer(engine, state, variables, env) {
     if (residual == null) continue;
     collectUnboundVariables(engine, residual, env, names, () => `_${letterName(generated++)}`);
     bindings.push(engine.formatTermForWrite(residual, env, {
-      quoted: true,
+      ...writeOptions,
       operators,
       variableNames: names,
       operatorAtomsAsArgs: true,
       dottedGraphicAtoms: true,
-      doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
     }));
   }
   const projectedAttributeRoots = new Set();
@@ -768,18 +765,37 @@ function formatAnswer(engine, state, variables, env) {
     for (const residual of state.solver.attributeResidualGoals(root, env)) {
       collectUnboundVariables(engine, residual, env, names, () => `_${letterName(generated++)}`);
       bindings.push(engine.formatTermForWrite(residual, env, {
-        quoted: true,
+        ...writeOptions,
         operators,
         variableNames: names,
         operatorAtomsAsArgs: true,
         dottedGraphicAtoms: true,
-        doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
       }));
     }
   }
   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, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
+  ATOM, COMPOUND, NUMBER, STRING, VAR, Env, atom, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
   flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList,
-  numberTerm, numberTextFromDouble, properListItems, termIsGround, termToString, unify, variable, variantTerms,
+  listFromItems, numberTerm, numberTextFromDouble, properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
 import { numberValueKey, sameNumberValue } from './number-value.js';
-import { PrologError, getStrictIsoRegistry } from './iso.js';
+import { PrologError, getStrictIsoRegistry, parseTermWriteOptions } from './iso.js';
 import { getEyePrologRegistry } from './standard-library.js';
 import { selectClauseCandidates, selectClauseCandidatesForValues, selectGroundClauseCandidates } from './program-indexing.js';
 import { StreamManager } from './io.js';
@@ -144,15 +144,7 @@ export class Solver {
         this.prologFlags.get('double_quotes').value = compound(program.doubleQuotes, []);
       }
       for (const [flag, value] of program.prologFlagDirectives ?? []) {
-        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;
+        this.setPrologFlag(flag, value, new Env());
       }
     }
     if (!options.charConversions) {
@@ -206,6 +198,35 @@ 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,
@@ -1072,6 +1093,12 @@ 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` write option remains an explicitly documented EyeProlog
-extension.
+`double_quotes/1` and `spacing/1` write options remain explicitly documented
+EyeProlog extensions.
 
 
 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` | Absent in strict mode. |
+| 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.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` 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,...)`. |
+| 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,...)`. |
 
 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)]).
+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)])]).

package/test/run-iso-strict.mjs

@@ -41,6 +41,7 @@ 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');
   });
 
@@ -283,8 +284,16 @@ 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

@@ -3881,6 +3881,70 @@ 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: 'answer write options make operator spacing explicit and persistent (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',
+        });
+        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' +
+          '?- ',
+          'discoverable top-level option and persistence across module reload');
+        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');
+      },
+    },
     {
       name: 'write predicates and write_term options select distinct formats',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5426,8 +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, while strict ISO mode rejects this
-non-standard write option.
+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.
 
 Character operations are `get_char`, `peek_char`, `put_char`, `get_code`,
 `peek_code`, and `put_code`; byte streams use the corresponding byte
@@ -6000,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 allowed atom value. Read-only flags raise a permission error. |
+| `set_prolog_flag(+Flag,+Value)` | Changes a supported mutable flag after validating its value. Read-only flags raise a permission error. |
 
 | Flag | Default in normal EyeProlog | Allowed values | Mutable |
 | --- | --- | --- | --- |
@@ -6014,6 +6016,7 @@ 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;
@@ -6048,6 +6051,24 @@ 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 |
@@ -6120,7 +6141,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)* and *spacing(standard or minimal)*. |
 
 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
@@ -7765,8 +7786,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)` as an explicitly non-standard extension, which
-  strict mode rejects;
+  `double_quotes(true|false)` and `spacing(standard|minimal)` as explicitly
+  non-standard extensions, which strict mode rejects;
 - unification consistently performs an occurs check, rejecting rational-tree
   bindings accepted as extensions by some systems.