eyeprolog 1.3.76 → 1.3.78

package/src/program.js

@@ -180,12 +180,18 @@ export class Program {
     for (let i = 0; i < head.arity; i++) indexOne(group.argIndexes[i], head.args[i], clause, group.clauses, clausePosition);
   }
   findGroup(name, arity, module = 'user') {
-    const direct = this.groups.get(modulePredicateKey(module, name, arity));
-    if (direct) return direct;
-    const importedModule = this.moduleImports.get(module)?.get(`${name}/${arity}`);
-    return importedModule == null
-      ? null
-      : this.groups.get(modulePredicateKey(importedModule, name, arity)) ?? null;
+    const indicator = `${name}/${arity}`;
+    const visited = new Set();
+    let current = module;
+    while (!visited.has(current)) {
+      visited.add(current);
+      const direct = this.groups.get(modulePredicateKey(current, name, arity));
+      if (direct) return direct;
+      const importedModule = this.moduleImports.get(current)?.get(indicator);
+      if (importedModule == null) return null;
+      current = importedModule;
+    }
+    return null;
   }
   defineModule(name, exports, filename = '<input>') {
     const indicators = new Map(exports.map((indicator) => [`${indicator.name}/${indicator.arity}`, indicator]));
@@ -202,10 +208,16 @@ export class Program {
         throw new PrologError('existence_error(procedure)', compound('/', [atom(indicator.name), numberTerm(indicator.arity)]));
       }
       const previous = imports.get(key);
-      if (previous != null && previous !== source) {
+      const resolved = this.findGroup(indicator.name, indicator.arity, source);
+      const canonicalSource = resolved?.module ?? source;
+      const previousResolved = previous == null
+        ? null
+        : this.findGroup(indicator.name, indicator.arity, previous);
+      const canonicalPrevious = previousResolved?.module ?? previous;
+      if (previous != null && canonicalPrevious !== canonicalSource) {
         throw new PrologError('permission_error(import, procedure)', compound('/', [atom(indicator.name), numberTerm(indicator.arity)]));
       }
-      imports.set(key, source);
+      imports.set(key, canonicalSource);
     }
     this.moduleImports.set(target, imports);
   }

package/src/quads.js

@@ -110,10 +110,15 @@ function checkAlternative(program, quad, alternative, options, context) {
   const actual = executeQuery(program, quad.query, input, maxSolutions, {
     ...options,
     detectLoops: leaves.some((leaf) => leaf.loops),
+    detectWaits: leaves.some((leaf) => leaf.waits),
     inputBoundary: hasInputSpec,
     inputPeek: peek,
   });
 
+  if (leaves.some((leaf) => leaf.waits)) {
+    return { ok: leaves.length === 1 && actual.inputWaitObserved };
+  }
+
   if (requiresSto) {
     // Trealla currently treats the answer part of an `sto`-annotated leaf as
     // implementation-dependent and skips it. EyeProlog can strengthen that
@@ -199,6 +204,7 @@ function describeLeaf(term) {
     false: false,
     truth: false,
     loops: false,
+    waits: false,
     error: null,
     input: null,
     peek: null,
@@ -213,7 +219,8 @@ function describeLeaf(term) {
       else if (item.name === '...' || item.name === 'ad_infinitum') leaf.more = true;
       else if (item.name === 'sto') leaf.sto = true;
       else if (item.name === 'loops') leaf.loops = true;
-      else if (item.name === 'waits' || item.name === 'other_answer_sequence') {
+      else if (item.name === 'waits') leaf.waits = true;
+      else if (item.name === 'other_answer_sequence') {
         leaf.unsupported ??= item;
       } else if (item.name === 'false') leaf.false = true;
       else if (item.name === 'true') leaf.truth = true;
@@ -246,7 +253,8 @@ function describeLeaf(term) {
     if (isErrorDescription(item)) leaf.error = item;
     else leaf.malformed ??= item;
   }
-  leaf.hasExpectation = leaf.bindings.length > 0 || leaf.truth || leaf.false || leaf.loops || leaf.error != null || leaf.output != null;
+  leaf.hasExpectation = leaf.bindings.length > 0 || leaf.truth || leaf.false || leaf.loops || leaf.waits ||
+    leaf.error != null || leaf.output != null;
   if (!leaf.hasExpectation && !leaf.more && !leaf.sto && leaf.unsupported == null) leaf.malformed ??= term;
   if ([leaf.false, leaf.truth, leaf.error != null].filter(Boolean).length > 1) leaf.malformed ??= term;
   return leaf;
@@ -254,6 +262,7 @@ function describeLeaf(term) {
 
 function executeQuery(program, query, input, maxSolutions, options) {
   let pendingOutput = '';
+  let inputWaitObserved = false;
   const boundedInput = options.inputBoundary
     ? `${input}${options.inputPeek ?? ''}${INVALID_UTF8_SENTINEL}`
     : input;
@@ -274,13 +283,24 @@ function executeQuery(program, query, input, maxSolutions, options) {
       write: (text) => { pendingOutput += String(text); },
     },
   });
+  if (options.detectWaits) {
+    const inputStream = solver.io.resolve('user_input');
+    const observeWait = () => {
+      inputWaitObserved = true;
+      return null;
+    };
+    inputStream.interactiveReadTerm = observeWait;
+    inputStream.interactiveReadUnit = observeWait;
+  }
   if (options.inputBoundary) {
     // Quads need a boundary that is neither EOF nor a valid character.  This
     // mirrors Trealla's sentinel technique: inputs/1 says exactly what was
     // consumed, while peeks/1 supplies one additional character that must
     // remain unread.  If the query asks for anything beyond that boundary it
     // sees representation_error(character), not an artificial EOF.
-    solver.io.resolve('user_input').strictUtf8 = true;
+    const inputStream = solver.io.resolve('user_input');
+    inputStream.strictUtf8 = true;
+    inputStream.syntheticInputBoundary = input.length;
   }
   // Undefined predicates are test failures rather than silent negative
   // answers unless the source explicitly selected another unknown policy.
@@ -338,6 +358,7 @@ function executeQuery(program, query, input, maxSolutions, options) {
     inputRemainder,
     complete,
     loopObserved,
+    inputWaitObserved,
     stoObserved: solver.occursCheckObserved,
     nstoObserved: complete && !solver.occursCheckObserved && !loopObserved &&
       !bounded && !resourceInterrupted,

package/src/repl.js

@@ -803,7 +803,7 @@ function letterName(index) {
 }
 
 function formatError(engine, state, error) {
-  if (error?.name === 'PrologError') {
+  if (error?.name === 'PrologError' || (error?.name === 'ThrownTerm' && error.term != null)) {
     const env = new engine.Env();
     const variableNames = new Map();
     let generated = 0;
@@ -811,7 +811,9 @@ function formatError(engine, state, error) {
     // Reuse the same conversion as catch/3 so uncaught errors at the top
     // level cannot lose the implementation-defined context or misplace a
     // culprit as the second argument of error/2.
-    const term = formalErrorTerm(error);
+    const term = error.name === 'ThrownTerm'
+      ? engine.compound('throw', [error.term])
+      : formalErrorTerm(error);
     collectUnboundVariables(engine, term, env, variableNames, () => `_${letterName(generated++)}`);
     return `${engine.formatTermForWrite(term, env, {
       quoted: true,

package/src/solver.js

@@ -607,14 +607,16 @@ export class Solver {
         const def = callable ? this.registry.get(goal.name, goal.arity) : null;
         this.active = active;
         if (def && builtinIsReadyOrAuthoritative(def, this, goal, env)) {
+          const deterministic = def.deterministic ||
+            def.deterministicWhen?.({ solver: this, goal, env }) === true;
           const iterator = def.handler({ solver: this, goal, env });
           const firstResult = iterator.next();
-          if (def.deterministic) {
+          if (deterministic) {
             if (!firstResult.done) this.stats.deterministic_builtin_successes++;
             else this.stats.deterministic_builtin_failures++;
           }
           if (firstResult.done) break;
-          if (!def.deterministic) {
+          if (!deterministic) {
             stack.push({
               kind: 'resumeBuiltin',
               iterator,
@@ -819,11 +821,22 @@ export class Solver {
     }
   }
 
-  hasPendingAlternatives() {
-    // When solve() is suspended at an answer, active solve stacks contain only
-    // unexplored work. The demand-driven REPL uses this without speculatively
-    // pulling the next answer.
-    return this.solveStacks.some((stack) => stack.length !== 0);
+  hasPendingAlternatives(excludedStacks = null) {
+    // When solve() is suspended at an answer, active solve stacks contain
+    // unexplored work or an iterator frame that can prove it just yielded its
+    // final answer. The demand-driven REPL uses this without speculatively
+    // pulling the next answer. Control builtins can exclude their caller's
+    // pre-existing stacks when inspecting a nested branch.
+    return this.solveStacks.some((stack) => !excludedStacks?.has(stack) && stack.some((frame) => {
+      if (frame.kind === 'resumeBuiltin' &&
+          typeof frame.iterator?.hasPendingAlternatives === 'function') {
+        return frame.iterator.hasPendingAlternatives();
+      }
+      if (frame.kind === 'userClause' && headCannotMatch(frame.goal, frame.clause.head, frame.env)) {
+        return false;
+      }
+      return true;
+    }));
   }
 
   fastCountGoal(goal, env) {
@@ -1428,19 +1441,22 @@ function pushWfsAnswerFrames(stack, model, group, goal, rest, env, depth, active
 
 function bundledBetweenIterator(solver, group, goal, env) {
   if (solver.registry.eyePrologLibrary !== true ||
-      group.module !== 'prologue' || group.name !== 'between' || group.arity !== 3 ||
+      group.module !== 'between' || group.name !== 'between' || group.arity !== 3 ||
       group.bundledLibrary !== true || group.clauses.length !== 1) {
     return null;
   }
 
-  // The portable Prologue definition is intentionally kept as the semantic
+  // The portable library(between) definition is kept as the semantic
   // source of between/3. Its recursive helper, however, carries the output
   // variable through one fresh clause instance per integer. With persistent
   // environments that builds a growing variable-alias chain, so dereferencing
   // the generated value in the caller repeatedly revisits all earlier frames.
   // Enumerate the canonical bundled relation directly while leaving user
   // definitions and non-EyeProlog registries on the ordinary Prolog path.
-  return bundledBetweenSolutions(solver, goal, env);
+  const state = { pending: true };
+  const iterator = bundledBetweenSolutions(solver, goal, env, state);
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
 }
 
 function requireBetweenInteger(term, env) {
@@ -1452,7 +1468,7 @@ function requireBetweenInteger(term, env) {
   return BigInt(value.name);
 }
 
-function* bundledBetweenSolutions(solver, goal, env) {
+function* bundledBetweenSolutions(solver, goal, env, state) {
   const lower = requireBetweenInteger(goal.args[0], env);
   const upper = requireBetweenInteger(goal.args[1], env);
   const requested = deref(goal.args[2], env);
@@ -1462,20 +1478,28 @@ function* bundledBetweenSolutions(solver, goal, env) {
       throw new PrologError('type_error(integer)', requested);
     }
     const value = BigInt(requested.name);
-    if (value >= lower && value <= upper) yield env;
+    if (value >= lower && value <= upper) {
+      state.pending = false;
+      yield env;
+    }
+    state.pending = false;
     return;
   }
 
   for (let value = lower; value <= upper; value++) {
     const next = env.clone();
     solver.stats.unify_calls++;
-    if (unify(goal.args[2], numberTerm(value), next)) yield next;
+    if (unify(goal.args[2], numberTerm(value), next)) {
+      state.pending = value < upper;
+      yield next;
+    }
   }
+  state.pending = false;
 }
 
 function bundledMemberIterator(solver, group, goal, env) {
   if (solver.registry.eyePrologLibrary !== true ||
-      !['lists', 'prologue'].includes(group.module) || group.name !== 'member' || group.arity !== 2 ||
+      group.module !== 'lists' || group.name !== 'member' || group.arity !== 2 ||
       group.bundledLibrary !== true || group.clauses.length !== 2) {
     return null;
   }
@@ -1487,17 +1511,33 @@ function bundledMemberIterator(solver, group, goal, env) {
   let cursor = deref(goal.args[1], env);
   while (isCons(cursor)) cursor = deref(cursor.args[1], env);
   if (!isEmptyList(cursor)) return null;
-  return bundledMemberSolutions(solver, goal, env);
+  const state = { pending: true };
+  const iterator = bundledMemberSolutions(solver, goal, env, state);
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
 }
 
-function* bundledMemberSolutions(solver, goal, env) {
+function* bundledMemberSolutions(solver, goal, env, state) {
   let cursor = deref(goal.args[1], env);
   while (isCons(cursor)) {
+    const item = cursor.args[0];
+    cursor = deref(cursor.args[1], env);
     const next = env.clone();
     solver.stats.unify_calls++;
-    if (unify(goal.args[0], cursor.args[0], next)) yield next;
+    if (unify(goal.args[0], item, next)) {
+      state.pending = bundledMemberMayMatch(goal.args[0], cursor, env);
+      yield next;
+    }
+  }
+  state.pending = false;
+}
+
+function bundledMemberMayMatch(target, cursor, env) {
+  while (isCons(cursor)) {
+    if (!goalHeadTermsCannotMatch(target, cursor.args[0], env)) return true;
     cursor = deref(cursor.args[1], env);
   }
+  return false;
 }
 
 function bundledEllipsisPlan(solver, group, goal, rest, env) {
@@ -1588,7 +1628,7 @@ function* bundledEllipsisSolutions(solver, output, input, env) {
 
 function bundledLengthIterator(solver, group, goal, env) {
   if (solver.registry.eyePrologLibrary !== true ||
-      !['lists', 'prologue'].includes(group.module) || group.name !== 'length' || group.arity !== 2 ||
+      group.module !== 'lists' || group.name !== 'length' || group.arity !== 2 ||
       group.bundledLibrary !== true || group.clauses.length !== 2) {
     return null;
   }
@@ -1900,7 +1940,7 @@ function findallLengthFusion(solver, goal, rest, env) {
   if (lengthGoal.type !== COMPOUND || lengthGoal.name !== 'length' || lengthGoal.arity !== 2) return null;
   const lengthGroup = solver.program.findGroup('length', 2, lengthGoal.module ?? 'user');
   if (!lengthGroup || lengthGroup.bundledLibrary !== true ||
-      !['lists', 'prologue'].includes(lengthGroup.module)) return null;
+      lengthGroup.module !== 'lists') return null;
   const lengthList = derefForLocal(lengthGoal.args[0], env);
   const countArg = derefForLocal(lengthGoal.args[1], env);
   if (lengthList.type !== 'var' || lengthList.name !== bag.name || countArg.type !== 'var') return null;
@@ -2849,11 +2889,22 @@ function headCannotMatch(goal, head, env) {
   if (goal.type !== COMPOUND || head.type !== COMPOUND) return false;
   if (goal.name !== head.name || goal.arity !== head.arity) return true;
   for (let i = 0; i < goal.arity; i++) {
-    const a = goal.args[i];
-    const b = head.args[i];
-    // Keep this only as a cheap scalar rejection. unify() remains authoritative.
-    const da = derefForLocal(a, env);
-    if (isScalarTerm(da) && isScalarTerm(b) && !sameScalarTerm(da, b)) return true;
+    if (goalHeadTermsCannotMatch(goal.args[i], head.args[i], env)) return true;
+  }
+  return false;
+}
+
+function goalHeadTermsCannotMatch(goalTerm, headTerm, env) {
+  const pending = [[goalTerm, headTerm]];
+  while (pending.length > 0) {
+    const [goalItem, headItem] = pending.pop();
+    const actual = derefForLocal(goalItem, env);
+    if (actual.type === VAR || headItem.type === VAR) continue;
+    if (actual.type !== headItem.type || actual.name !== headItem.name || actual.arity !== headItem.arity) return true;
+    if (actual.type !== COMPOUND) continue;
+    for (let index = 0; index < actual.arity; index++) {
+      pending.push([actual.args[index], headItem.args[index]]);
+    }
   }
   return false;
 }

package/src/standard-library.js

@@ -141,11 +141,10 @@ export const eyePrologInteropAutoload = Object.freeze({
   // unchanged while their implementations remain outside the ISO core.
   'time/1': 'iso_ext',
   '.../2': 'iso_ext',
-  // Trealla and Scryer expose between/3 without an EyeProlog-style
-  // library(prologue) dependency.  EyeProlog keeps its implementation in the
-  // Prologue module but autoloads it so portable source need not name that
-  // implementation-specific library.
-  'between/3': 'prologue',
+  // Scryer provides library(between), while Trealla exposes the relation as a
+  // system predicate. Keep EyeProlog's canonical portable owner in the
+  // specialized module; library(prologue) re-exports it for compatibility.
+  'between/3': 'between',
 });
 
 export const eyePrologInteropLibraryIndicators = Object.freeze(
@@ -155,7 +154,7 @@ export const eyePrologInteropLibraryIndicators = Object.freeze(
 // Libraries whose *name* is part of the current interop profile.  A program
 // may freely use_module/1 with these common module names; predicates in those
 // modules outside eyePrologInteropLibraryIndicators are still diagnosed when used.
-export const eyePrologInteropLibraryModules = Object.freeze(['lists', 'iso_ext', 'lambda', 'atts']);
+export const eyePrologInteropLibraryModules = Object.freeze(['lists', 'iso_ext', 'lambda', 'atts', 'freeze']);
 
 function* tabledNegationBuiltin({ solver, goal, env }) {
   yield* solver.solveTabledNegation(goal.args[0], env);

package/test/fixtures/README.md

@@ -9,6 +9,14 @@ Retrieved on 2026-08-11. It is vendored so the regression suite exercises all
 58 quads without depending on network access or availability of the source
 server.
 
+`variable_names_quad.pl` is an unmodified snapshot of the 75 machine-readable
+quads for the ISO read and write option `variable_names/1`:
+
+<https://www.complang.tuwien.ac.at/ulrich/iso-prolog/variable_names_quad.pl>
+
+Retrieved on 2026-08-25. It is vendored so all input, output, waiting, and
+error cases remain release-gated.
+
 `prologue_quad.pl` is an unmodified snapshot of the 33 machine-readable quads
 for the predicates proposed by the Prolog Prologue working draft:
 

package/test/fixtures/variable_names_quad.pl

@@ -0,0 +1,163 @@
+1  ?- write_term(T,[quoted(true),variable_names([N=T])]).
+      instantiation_error.
+2  ?- N = 'X', /**/write_term(T,[quoted(true),variable_names([N=T])]).
+      outputs("X"), N = 'X'.
+      outputs("X"), N = ... . % Same, ignoring 'X'
+3  ?- N = T, /**/write_term(T,[quoted(true),variable_names([N=T])]).
+      instantiation_error.
+4  ?- N = '_', /**/write_term(T,[quoted(true),variable_names([N=T])]).
+      outputs("_"), N = ... .
+65 ?- N = '_/*.*/', /**/write_term(T,[quoted(true),variable_names([N=T])]).
+      outputs("_/*.*/"), N = ... .
+5  ?- N = x, /**/write_term(T,[quoted(true),variable_names([N=T])]).
+      outputs("x"), N = ... .
+6  ?- N = 'x+y', /**/write_term(T,[quoted(true),variable_names([N=T])]).
+      outputs("x+y"), N = ... .
+50 ?- N = '))', /**/write_term(T,[quoted(true),variable_names([N=T])]).
+      outputs("))"), N = ... .
+7  ?- N = 7, /**/write_term(T,[quoted(true),variable_names([N=T])]).
+      domain_error(write_option, variable_names(...)).
+8  ?- N = 1+2, /**/write_term(T,[quoted(true),variable_names([N=T])]).
+      domain_error(write_option, variable_names(...)).
+9  ?- N = '$VAR'(9), /**/write_term(T,[quoted(true),variable_names([N=T])]).
+      domain_error(write_option, variable_names(...)).
+10 ?- T = a, /**/write_term(T,[quoted(true),variable_names([N=T])]).
+      instantiation_error.
+11 ?- T = a, N = 'Any', /**/write_term(T,[quoted(true),variable_names([N=T])]).
+      outputs("a"), T = ..., N = ... .
+12 ?- T = '$VAR'(9), N = '_', /**/write_term(T,[quoted(true),variable_names([N=T])]).
+      outputs("'$VAR'(9)"), T = ..., N = ... .
+74 ?- T = f(_), N = 'Bad', /**/write_term(T,[quoted(true),variable_names([N=T])]).
+      outputs(("f(_",...,")")), T = ..., N = ... .
+28 ?- freeze(T,throw(g(T))), N = 'X', /**/write_term(T,[quoted(true),variable_names([N=T])]), false.
+      outputs("X"), false.
+13 ?- write_term(T,[quoted(true),variable_names(['X'=X,'Y'=Y,'Z'=Z])]).
+      outputs(("_",...)).
+14 ?- T=(X,Y,Z), /**/write_term(T,[quoted(true),variable_names(['X'=X,'Y'=Y,'Z'=Z])]).
+      outputs("X,Y,Z"), T = ... .
+15 ?- Z=Y, T=(X,Y,Z), /**/write_term(T,[quoted(true),variable_names(['X'=X,'Y'=Y,'Z'=Z])]).
+      outputs("X,Y,Y"), Z = Y, T = ... .
+16 ?- Z=Y, Y=X, T=(X,Y,Z), /**/write_term(T,[quoted(true),variable_names(['X'=X,'Y'=Y,'Z'=Z])]).
+      outputs("X,X,X"), Z = X, Y = X, T = ... .
+17 ?- T=(Y,Z), /**/write_term(T,[quoted(true),variable_names(['X'=X,'Y'=Y,'Z'=Z])]).
+      outputs("Y,Z"), T = ... .
+18 ?- T=(Z,Y), /**/write_term(T,[quoted(true),variable_names(['X'=X,'Y'=Y,'Z'=Z])]).
+      outputs("Z,Y"), T = ... .
+19 ?- write_term(T,[quoted(true),variable_names(['Z'=Z,'Y'=Y,'X'=X])]).
+      outputs(("_",...)).
+20 ?- T=(X,Y,Z), /**/write_term(T,[quoted(true),variable_names(['Z'=Z,'Y'=Y,'X'=X])]).
+      outputs("X,Y,Z"), T = ... .
+21 ?- Z=Y, T=(X,Y,Z), /**/write_term(T,[quoted(true),variable_names(['Z'=Z,'Y'=Y,'X'=X])]).
+      outputs("X,Z,Z"), Z = Y, T = ... .
+22 ?- Z=Y, Y=X, T=(X,Y,Z), /**/write_term(T,[quoted(true),variable_names(['Z'=Z,'Y'=Y,'X'=X])]).
+      outputs("Z,Z,Z"), Z = X, Y = X, T = ... .
+23 ?- T=(Y,Z), /**/write_term(T,[quoted(true),variable_names(['Z'=Z,'Y'=Y,'X'=X])]).
+      outputs("Y,Z"), T = ... .
+24 ?- T=(Z,Y), /**/write_term(T,[quoted(true),variable_names(['Z'=Z,'Y'=Y,'X'=X])]).
+      outputs("Z,Y"), T = ... .
+25 ?- write_term(T,[quoted(true),variable_names(['X'=Z,'X'=Y,'X'=X])]).
+      outputs(("_",...)).
+26 ?- T=(X,Y,Z), /**/write_term(T,[quoted(true),variable_names(['X'=Z,'X'=Y,'X'=X])]).
+      outputs("X,X,X"), T = ... .
+27 ?- T=(1,2,3), T=(X,Y,Z), /**/write_term(T,[quoted(true),variable_names(['X'=Z,'X'=Y,'X'=X])]).
+      outputs("1,2,3"), T = ..., X = 1, Y = 2, Z = 3.
+32 ?- read_term(T,[variable_names(VN_list)]),VN_list=[_=1,_=2,_=3],writeq(VN_list).
+      waits.
+29 ?- /**/read_term(T,[variable_names(VN_list)]),VN_list=[_=1,_=2,_=3],writeq(VN_list).
+      inputs("B+C+A+B+C+A."), peeks("\n"),
+      outputs("['B'=1,'C'=2,'A'=3]"),
+      T = 1+2+3+1+2+3,
+      VN_list=['B'=1,'C'=2,'A'=3].
+30 ?- write_term(T,[variable_names(VN_list)]).
+      instantiation_error.
+31 ?- VN_list = 1, /**/write_term(T,[variable_names(VN_list)]).
+      domain_error(write_option, variable_names(1)).
+33 ?- VN_list = [[]], /**/write_term(T,[variable_names(VN_list)]).
+      domain_error(write_option, variable_names([[]])).
+34 ?- VN_list = non_list, /**/write_term(T,[variable_names(VN_list)]).
+      domain_error(write_option, variable_names(non_list)).
+35 ?- VN_list = [T='T'|non_list], /**/write_term(T,[variable_names(VN_list)]).
+      domain_error(write_option, variable_names([_='T'|non_list]))
+   |  instantiation_error.
+52 ?- VN_list = ['T'=T|_], /**/write_term(T,[variable_names(VN_list)]).
+      instantiation_error.
+51 ?- VN_list = ['T'=T|non_list], /**/write_term(T,[variable_names(VN_list)]).
+      domain_error(write_option, variable_names(...)).
+36 ?- VN_list = [T-'T'], /**/write_term(T,[variable_names(VN_list)]).
+      domain_error(write_option, variable_names(...)).
+63 ?- VN_list = [_,a], /**/write_term(T,[variable_names(VN_list)]).
+      domain_error(write_option, variable_names(...))
+   |  instantiation_error.
+64 ?- VN_list = [a,_], /**/write_term(T,[variable_names(VN_list)]).
+      domain_error(write_option, variable_names(...))
+   |  instantiation_error.
+66 ?- VN_list = [a|_], /**/write_term(T,[variable_names(VN_list)]).
+      domain_error(write_option, variable_names(...))
+   |  instantiation_error.
+67 ?- VN_list = [i=i,7=i], /**/write_term(T,[variable_names(VN_list)]).
+      domain_error(write_option,variable_names([i=i,7=i])).
+68 ?- VN_list = [_,_], /**/write_term(T,[variable_names(VN_list)]).
+      instantiation_error.
+43 ?- write_term(-X^2,[variable_names(['X'=X])]).
+      outputs("- (X^2)").
+44 ?- X=1, /**/write_term(-X^2,[variable_names(['X'=X])]).
+      outputs("- (1^2)"), X = ... .
+37 ?- open(f,write,_,[O]).
+      instantiation_error.
+38 ?- O = 1, /**/open(f,write,_,[O]).
+      domain_error(stream_option,1).
+56 ?- O = typex(_), /**/open(f,write,_,[O]).
+      domain_error(stream_option,typex(_)).
+57 ?- O = typex(1), /**/open(f,write,_,[O]).
+      domain_error(stream_option,typex(1)).
+62 ?- O = typex(s(_)), /**/open(f,write,_,[O]).
+      domain_error(stream_option,typex(s(_))).
+39 ?- O = type(text), /**/open(f,write,_,[O]).
+      O = ... .
+40 ?- O = type(1), /**/open(f,write,_,[O]).
+      domain_error(stream_option,type(1)).
+41 ?- O = type(_), /**/open(f,write,_,[O]).
+      instantiation_error.
+60 ?- O = alias(_), /**/open(f,write,_,[O]).
+      instantiation_error.
+42 ?- O = type(nontype), /**/open(f,write,_,[O]).
+      domain_error(stream_option,type(nontype)).
+61 ?- O = alias(1), /**/open(f,write,_,[O]).
+      domain_error(stream_option,alias(1)).
+45 ?- read_term(T,[variable_names(VN_list)]).
+      waits.
+46 ?- /**/read_term(T,[variable_names(VN_list)]).
+      inputs("a."), peeks("\n"),
+      T = a, VN_list = [].
+47 ?- VN_list = 42, /**/read_term(T,[variable_names(VN_list)]).
+      waits.
+48 ?- VN_list = 42, /**/read_term(T,[variable_names(VN_list)]).
+      inputs("a."), peeks("\n"),
+      false.
+49 ?- VN_list = 42, /**/read_term(T,[variable_names(VN_list)]).
+      inputs("a b."), peeks("\n"),
+      syntax_error(...).
+53 ?- write_term(S,[quoted(true),variable_names([N=T])]).
+      instantiation_error.
+54 ?- S=1+T,N='/*r*/V',/**/write_term(S,[quoted(true),variable_names([N=T])]).
+      outputs("1+/*r*/V"), S = ..., N = ...
+   |  outputs("1+ /*r*/V"), S = ..., N = ... .
+55 ?- S=1+T,N=' /*r*/V',/**/write_term(S,[quoted(true),variable_names([N=T])]).
+      outputs("1+ /*r*/V"), S = ..., N = ... .
+58 ?- S=1+T,N=(+),/**/write_term(S,[quoted(true),variable_names([N=T])]).
+      outputs("1++"), S = ..., N = ...
+   |  outputs("1+ +"), S = ..., N = ... .
+59 ?- S=T+1,N=(+),/**/write_term(S,[quoted(true),variable_names([N=T])]).
+      outputs("++1"), S = ..., N = ...
+   |  outputs("+ +1"), S = ..., N = ... .
+73 ?- S=(1 is T),N='X',/**/write_term(S,[quoted(true),variable_names([N=T])]).
+      outputs("1 is X"), S = ..., N = ... .
+69 ?- read_term(T,[singletons(1)]).
+        waits.
+70 ?- /**/read_term(T,[singletons(1)]).
+      inputs("a."), peeks("\n"),
+      false.
+71 ?- write_term(T,[variable_names(['Bad'=T]),variable_names(['Good'=T])]).
+      outputs("Good").
+72 ?- read_term(T,[singletons([])]).
+      waits.