eyeprolog 1.3.91 → 1.3.93

package/examples/book/README.md

@@ -250,3 +250,4 @@ npm run generate
 - [01-color.pl](chapter-40/01-color.pl) — Embedded quad tests
 - [02-program.pl](chapter-40/02-program.pl)
 - [03-program-2.pl](chapter-40/03-program-2.pl)
+- [04-program-3.pl](chapter-40/04-program-3.pl)

package/examples/book/chapter-40/02-program.pl

@@ -1,5 +1,6 @@
 % From The Art of EyeProlog, Chapter 40.
-?- read(X).
-   inputs("1."), X = 1, unexpected.
-   inputs("1."), peeks(" "), X = 1.
-   inputs("1. "), peeks(" "), X = 1, unexpected.
+?- dif(X,Y), X = a.
+   true, unexpected.
+   X = a, unexpected.
+   X = a, maybe.
+   maybe, unexpected.

package/examples/book/chapter-40/03-program-2.pl

@@ -1,5 +1,5 @@
 % From The Art of EyeProlog, Chapter 40.
-inf :- inf, inf.
-
-?- inf.
-   loops.
+?- read(X).
+   inputs("1."), X = 1, unexpected.
+   inputs("1."), peeks(" "), X = 1.
+   inputs("1. "), peeks(" "), X = 1, unexpected.

package/examples/book/chapter-40/04-program-3.pl

@@ -0,0 +1,5 @@
+% From The Art of EyeProlog, Chapter 40.
+inf :- inf, inf.
+
+?- inf.
+   loops.

package/index.d.ts

@@ -182,7 +182,12 @@ export interface BuiltinDefinition {
   eyePrologLibrary: boolean;
 }
 
-export type BuiltinHandler = (context: { solver: Solver; goal: EyePrologTerm; env: Env }) => Iterable<Env>;
+export interface BuiltinIterator extends IterableIterator<Env> {
+  hasPendingAlternatives?: () => boolean;
+}
+
+export type BuiltinHandler =
+  (context: { solver: Solver; goal: EyePrologTerm; env: Env }) => BuiltinIterator;
 
 export class BuiltinRegistry {
   constructor();

package/package.json

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

package/src/iso.js

@@ -627,16 +627,30 @@ function validPredicateIndicator(term) {
       (term.args[1].type === NUMBER && isDecimalInteger(term.args[1].name) && BigInt(term.args[1].name) >= 0n));
 }
 
-function* currentPredicateBuiltin({ solver, goal, env }) {
+function currentPredicateBuiltin(context) {
+  const state = { pending: false };
+  return withPendingState(currentPredicateSolutions(context, state), state);
+}
+
+function* currentPredicateSolutions({ solver, goal, env }, state) {
   const indicator = copyResolved(goal.args[0], env);
   if (indicator.type !== VAR && !validPredicateIndicator(indicator)) {
     throw new PrologError('type_error(predicate_indicator)', indicator);
   }
-  for (const group of solver.program.groups.values()) {
+  const groups = [...solver.program.groups.values()].filter((group) =>
+    indicator.type === VAR ||
+    (indicator.args[0].type === VAR || indicator.args[0].name === group.name) &&
+    (indicator.args[1].type === VAR || BigInt(indicator.args[1].name) === BigInt(group.arity)));
+  for (let index = 0; index < groups.length; index++) {
+    const group = groups[index];
     const next = env.clone();
     const candidate = compound('/', [atom(group.name), numberTerm(group.arity)]);
-    if (unify(goal.args[0], candidate, next)) yield next;
+    if (unify(goal.args[0], candidate, next)) {
+      state.pending = index + 1 < groups.length;
+      yield next;
+    }
   }
+  state.pending = false;
 }
 
 function callableOrVariable(term, env) {
@@ -652,7 +666,12 @@ function clauseBodyTerm(body) {
   return result;
 }
 
-function* clauseBuiltin({ solver, goal, env }) {
+function clauseBuiltin(context) {
+  const state = { pending: false };
+  return withPendingState(clauseSolutions(context, state), state);
+}
+
+function* clauseSolutions({ solver, goal, env }, state) {
   const head = deref(goal.args[0], env);
   if (head.type === VAR) throw new PrologError('instantiation_error');
   if (head.type !== ATOM && head.type !== COMPOUND) throw new PrologError('type_error(callable)', head);
@@ -667,12 +686,17 @@ function* clauseBuiltin({ solver, goal, env }) {
   }
   callableOrVariable(goal.args[1], env);
   if (!group) return;
-  for (const clause of group.clauses) {
+  for (let index = 0; index < group.clauses.length; index++) {
+    const clause = group.clauses[index];
     const pair = compound('$clause', [clause.head, clauseBodyTerm(clause.body)]);
     const copied = freshCopy(pair, new Env());
     const next = env.clone();
-    if (unify(goal.args[0], copied.args[0], next) && unify(goal.args[1], copied.args[1], next)) yield next;
+    if (unify(goal.args[0], copied.args[0], next) && unify(goal.args[1], copied.args[1], next)) {
+      state.pending = index + 1 < group.clauses.length;
+      yield next;
+    }
   }
+  state.pending = false;
 }
 
 function clauseParts(term, env) {
@@ -845,21 +869,32 @@ function* abolishBuiltin({ solver, goal, env }) {
   yield env;
 }
 
-function* currentPrologFlagBuiltin({ solver, goal, env }) {
+function currentPrologFlagBuiltin(context) {
+  const state = { pending: false };
+  return withPendingState(currentPrologFlagSolutions(context, state), state);
+}
+
+function* currentPrologFlagSolutions({ solver, goal, env }, state) {
   const flag = deref(goal.args[0], env);
   if (flag.type !== VAR && flag.type !== ATOM) throw new PrologError('type_error(atom)', flag);
   if (flag.type === ATOM && !solver.prologFlags.has(flag.name)) {
     throw new PrologError('domain_error(prolog_flag)', flag);
   }
-  for (const [name, definition] of solver.prologFlags) {
+  const definitions = [...solver.prologFlags]
+    .filter(([name, definition]) => definition.value != null && (flag.type === VAR || flag.name === name));
+  for (let index = 0; index < definitions.length; index++) {
+    const [name, definition] = definitions[index];
     // ISO 7.11.1.1: when bounded=false, max_integer and min_integer have no
     // current value and current_prolog_flag/2 must therefore not enumerate
     // them. The definitions remain registered so attempts to change these
     // non-changeable flags still receive the normal flag error handling.
-    if (definition.value == null) continue;
     const next = env.clone();
-    if (unify(goal.args[0], atom(name), next) && unify(goal.args[1], definition.value, next)) yield next;
+    if (unify(goal.args[0], atom(name), next) && unify(goal.args[1], definition.value, next)) {
+      state.pending = index + 1 < definitions.length;
+      yield next;
+    }
   }
+  state.pending = false;
 }
 
 function* setPrologFlagBuiltin({ solver, goal, env }) {
@@ -946,7 +981,12 @@ function* opBuiltin({ solver, goal, env }) {
   yield env;
 }
 
-function* currentOpBuiltin({ solver, goal, env }) {
+function currentOpBuiltin(context) {
+  const state = { pending: false };
+  return withPendingState(currentOpSolutions(context, state), state);
+}
+
+function* currentOpSolutions({ solver, goal, env }, state) {
   const priority = deref(goal.args[0], env);
   const specifier = deref(goal.args[1], env);
   const name = deref(goal.args[2], env);
@@ -962,12 +1002,21 @@ function* currentOpBuiltin({ solver, goal, env }) {
     throw new PrologError('domain_error(operator_specifier)', specifier);
   }
   if (name.type !== VAR && name.type !== ATOM) throw new PrologError('type_error(atom)', name);
-  for (const definition of solver.program.operators.values()) {
+  const definitions = [...solver.program.operators.values()].filter((definition) =>
+    (priority.type === VAR || BigInt(priority.name) === BigInt(definition.priority)) &&
+    (specifier.type === VAR || specifier.name === definition.specifier) &&
+    (name.type === VAR || name.name === definition.name));
+  for (let index = 0; index < definitions.length; index++) {
+    const definition = definitions[index];
     const next = env.clone();
     if (unify(goal.args[0], numberTerm(definition.priority), next) &&
         unify(goal.args[1], atom(definition.specifier), next) &&
-        unify(goal.args[2], atom(definition.name), next)) yield next;
+        unify(goal.args[2], atom(definition.name), next)) {
+      state.pending = index + 1 < definitions.length;
+      yield next;
+    }
   }
+  state.pending = false;
 }
 
 function conversionCharacter(term, env, current = false, solver = null) {
@@ -998,13 +1047,25 @@ function* charConversionBuiltin({ solver, goal, env }) {
   else solver.charConversions.set(input.name, output.name);
   yield env;
 }
-function* currentCharConversionBuiltin({ solver, goal, env }) {
+function currentCharConversionBuiltin(context) {
+  const state = { pending: false };
+  return withPendingState(currentCharConversionSolutions(context, state), state);
+}
+
+function* currentCharConversionSolutions({ solver, goal, env }, state) {
   const input = conversionCharacter(goal.args[0], env, true, solver);
   const output = conversionCharacter(goal.args[1], env, true, solver);
-  for (const [from, to] of [...solver.charConversions]) {
+  const conversions = [...solver.charConversions].filter(([from, to]) =>
+    (input.type === VAR || input.name === from) && (output.type === VAR || output.name === to));
+  for (let index = 0; index < conversions.length; index++) {
+    const [from, to] = conversions[index];
     const next = env.clone();
-    if (unify(input, atom(from), next) && unify(output, atom(to), next)) yield next;
+    if (unify(input, atom(from), next) && unify(output, atom(to), next)) {
+      state.pending = index + 1 < conversions.length;
+      yield next;
+    }
   }
+  state.pending = false;
 }
 function* haltBuiltin({ goal, env }) {
   const code = goal.arity === 0 ? 0n : requireInteger(goal.args[0], env);
@@ -1293,7 +1354,12 @@ function isStreamPropertyPattern(value) {
   ].includes(value.name);
 }
 
-function* streamPropertyBuiltin({ solver, goal, env }) {
+function streamPropertyBuiltin(context) {
+  const state = { pending: false };
+  return withPendingState(streamPropertySolutions(context, state), state);
+}
+
+function* streamPropertySolutions({ solver, goal, env }, state) {
   const reference = deref(goal.args[0], env);
   const propertyPattern = deref(goal.args[1], env);
   let fixedStreamId = null;
@@ -1311,12 +1377,24 @@ function* streamPropertyBuiltin({ solver, goal, env }) {
   const streams = reference.type === VAR
     ? [...solver.io.streams.values()]
     : [solver.io.resolve(fixedStreamId)].filter(Boolean);
+  const candidates = [];
   for (const stream of streams) {
     for (const property of streamProperties(stream)) {
-      const next = env.clone();
-      if (unify(goal.args[0], streamHandle(stream.id), next) && unify(goal.args[1], property, next)) yield next;
+      if (propertyPattern.type === VAR ||
+          (property.type === propertyPattern.type && property.name === propertyPattern.name)) {
+        candidates.push([stream, property]);
+      }
+    }
+  }
+  for (let index = 0; index < candidates.length; index++) {
+    const [stream, property] = candidates[index];
+    const next = env.clone();
+    if (unify(goal.args[0], streamHandle(stream.id), next) && unify(goal.args[1], property, next)) {
+      state.pending = index + 1 < candidates.length;
+      yield next;
     }
   }
+  state.pending = false;
 }
 
 function inputStreamFor(solver, goal, env) {
@@ -1919,7 +1997,12 @@ function* atomLengthBuiltin({ goal, env }) {
   if (unify(goal.args[1], numberTerm(characters(value.name).length), next)) yield next;
 }
 
-function* atomConcatBuiltin({ goal, env }) {
+function atomConcatBuiltin(context) {
+  const state = { pending: false };
+  return withPendingState(atomConcatSolutions(context, state), state);
+}
+
+function* atomConcatSolutions({ goal, env }, state) {
   const first = deref(goal.args[0], env);
   const second = deref(goal.args[1], env);
   const whole = deref(goal.args[2], env);
@@ -1942,11 +2025,16 @@ function* atomConcatBuiltin({ goal, env }) {
   } else if (second.type === ATOM && whole.type === ATOM && whole.name.endsWith(second.name)) {
     candidates.push([whole.name.slice(0, whole.name.length - second.name.length), second.name, whole.name]);
   }
-  for (const [a, b, c] of candidates) {
+  for (let index = 0; index < candidates.length; index++) {
+    const [a, b, c] = candidates[index];
     const next = env.clone();
     if (unify(goal.args[0], atom(a), next) && unify(goal.args[1], atom(b), next) &&
-        unify(goal.args[2], atom(c), next)) yield next;
+        unify(goal.args[2], atom(c), next)) {
+      state.pending = index + 1 < candidates.length;
+      yield next;
+    }
   }
+  state.pending = false;
 }
 
 function optionalInteger(term, env) {
@@ -1956,7 +2044,12 @@ function optionalInteger(term, env) {
   return BigInt(value.name);
 }
 
-function* subAtomBuiltin({ goal, env }) {
+function subAtomBuiltin(context) {
+  const state = { pending: false };
+  return withPendingState(subAtomSolutions(context, state), state);
+}
+
+function* subAtomSolutions({ goal, env }, state) {
   const source = deref(goal.args[0], env);
   if (source.type === VAR) throw new PrologError('instantiation_error');
   if (source.type !== ATOM) throw new PrologError('type_error(atom)', source);
@@ -1977,11 +2070,34 @@ function* subAtomBuiltin({ goal, env }) {
     throw new PrologError('domain_error(not_less_than_zero)', deref(goal.args[3], env));
   }
   const chars = characters(source.name);
-  for (let start = 0; start <= chars.length; start++) {
-    if (before != null && before !== BigInt(start)) continue;
-    for (let size = 0; size <= chars.length - start; size++) {
+  let starts;
+  if (before != null) {
+    starts = before <= BigInt(chars.length) ? [Number(before)] : [];
+  } else if (length != null && after != null) {
+    const onlyStart = BigInt(chars.length) - length - after;
+    starts = onlyStart >= 0n ? [Number(onlyStart)] : [];
+  } else {
+    const maximumStart = length != null
+      ? BigInt(chars.length) - length
+      : after != null ? BigInt(chars.length) - after : BigInt(chars.length);
+    starts = maximumStart < 0n
+      ? []
+      : Array.from({ length: Number(maximumStart) + 1 }, (_, index) => index);
+  }
+  for (let startIndex = 0; startIndex < starts.length; startIndex++) {
+    const start = starts[startIndex];
+    let sizes;
+    if (length != null) {
+      sizes = length <= BigInt(chars.length - start) ? [Number(length)] : [];
+    } else if (after != null) {
+      const onlySize = BigInt(chars.length - start) - after;
+      sizes = onlySize >= 0n ? [Number(onlySize)] : [];
+    } else {
+      sizes = Array.from({ length: chars.length - start + 1 }, (_, index) => index);
+    }
+    for (let sizeIndex = 0; sizeIndex < sizes.length; sizeIndex++) {
+      const size = sizes[sizeIndex];
       const remaining = chars.length - start - size;
-      if (length != null && length !== BigInt(size)) continue;
       if (after != null && after !== BigInt(remaining)) continue;
       const text = chars.slice(start, start + size).join('');
       if (sub.type === ATOM && sub.name !== text) continue;
@@ -1989,9 +2105,13 @@ function* subAtomBuiltin({ goal, env }) {
       if (unify(goal.args[1], numberTerm(start), next) &&
           unify(goal.args[2], numberTerm(size), next) &&
           unify(goal.args[3], numberTerm(remaining), next) &&
-          unify(goal.args[4], atom(text), next)) yield next;
+          unify(goal.args[4], atom(text), next)) {
+        state.pending = sizeIndex + 1 < sizes.length || startIndex + 1 < starts.length;
+        yield next;
+      }
     }
   }
+  state.pending = false;
 }
 
 function listElements(term, env) {
@@ -2406,42 +2526,52 @@ function sortedUnique(items) {
 }
 
 function allSolutionsBuiltin(asSet) {
-  return function* ({ solver, goal, env }) {
-    // EyeProlog validates the iterated goal before Instances. ISO 7.12 makes
-    // simultaneous-error selection implementation dependent; keep this stable as
-    // a processor choice rather than describing it as mandatory table ordering.
-    const { iterated, quantified } = bagGoalParts(goal.args[1], env);
-    assertListOrPartial(goal.args[2], env);
-    const free = freeVariables(iterated, goal.args[0], quantified, env);
-    const collector = solver.cloneForInnerGoal(10000000);
-    const groups = [];
-    for (const answerEnv of collector.solve([iterated], env.clone(), 0)) {
-      const copied = freshCopy(compound('$bag', [
-        compound('$witness', free),
-        goal.args[0],
-      ]), answerEnv);
-      let group = groups.find((candidate) => sameWitness(candidate.witness, copied.args[0]));
-      if (!group) {
-        group = { witness: copied.args[0], templates: [] };
-        groups.push(group);
-        group.templates.push(copied.args[1]);
-      } else {
-        const alignment = new Env();
-        unify(copied.args[0], group.witness, alignment);
-        group.templates.push(copyResolved(copied.args[1], alignment));
-      }
+  return function allSolutions(context) {
+    const state = { pending: false };
+    return withPendingState(allSolutionsGroups(context, asSet, state), state);
+  };
+}
+
+function* allSolutionsGroups({ solver, goal, env }, asSet, state) {
+  // EyeProlog validates the iterated goal before Instances. ISO 7.12 makes
+  // simultaneous-error selection implementation dependent; keep this stable as
+  // a processor choice rather than describing it as mandatory table ordering.
+  const { iterated, quantified } = bagGoalParts(goal.args[1], env);
+  assertListOrPartial(goal.args[2], env);
+  const free = freeVariables(iterated, goal.args[0], quantified, env);
+  const collector = solver.cloneForInnerGoal(10000000);
+  const groups = [];
+  for (const answerEnv of collector.solve([iterated], env.clone(), 0)) {
+    const copied = freshCopy(compound('$bag', [
+      compound('$witness', free),
+      goal.args[0],
+    ]), answerEnv);
+    let group = groups.find((candidate) => sameWitness(candidate.witness, copied.args[0]));
+    if (!group) {
+      group = { witness: copied.args[0], templates: [] };
+      groups.push(group);
+      group.templates.push(copied.args[1]);
+    } else {
+      const alignment = new Env();
+      unify(copied.args[0], group.witness, alignment);
+      group.templates.push(copyResolved(copied.args[1], alignment));
     }
-    solver.absorbStatsFrom(collector);
-    for (const group of groups) {
-      const next = env.clone();
-      let matches = true;
-      for (let i = 0; i < free.length; i++) {
-        if (!unify(free[i], group.witness.args[i], next)) { matches = false; break; }
-      }
-      const templates = asSet ? sortedUnique(group.templates) : group.templates;
-      if (matches && unify(goal.args[2], listFromItems(templates), next)) yield next;
+  }
+  solver.absorbStatsFrom(collector);
+  for (let index = 0; index < groups.length; index++) {
+    const group = groups[index];
+    const next = env.clone();
+    let matches = true;
+    for (let i = 0; i < free.length; i++) {
+      if (!unify(free[i], group.witness.args[i], next)) { matches = false; break; }
     }
-  };
+    const templates = asSet ? sortedUnique(group.templates) : group.templates;
+    if (matches && unify(goal.args[2], listFromItems(templates), next)) {
+      state.pending = index + 1 < groups.length;
+      yield next;
+    }
+  }
+  state.pending = false;
 }
 const bagofBuiltin = allSolutionsBuiltin(false);
 const setofBuiltin = allSolutionsBuiltin(true);
@@ -2964,8 +3094,12 @@ function* onceBuiltin({ solver, goal, env }) {
   }
   solver.absorbStatsFrom(child);
 }
-function* repeatBuiltin({ env }) {
-  while (true) yield env;
+function repeatBuiltin({ env }) {
+  const iterator = (function* repeatSolutions() {
+    while (true) yield env;
+  })();
+  iterator.hasPendingAlternatives = () => true;
+  return iterator;
 }
 function* negationBuiltin({ solver, goal, env }) {
   const invoked = callable(goal.args[0], env);

package/src/quads.js

@@ -1,6 +1,8 @@
 // Embedded quad tests: a query followed by one or more answer descriptions.
 // The syntax follows the portable "queries using answer descriptions" format
 // used by Trealla and the ISO Prolog working examples linked from issue #1.
+// A `maybe` annotation denotes a successful answer with residual constraints;
+// it does not relax the ordinary answer-substitution comparison.
 import {
   ATOM, COMPOUND, VAR, Env, atom, compound, copyResolved, deref,
   flattenConjunction, listFromItems, properListItems, termIsGround,
@@ -203,6 +205,7 @@ function describeLeaf(term) {
     sto: false,
     false: false,
     truth: false,
+    maybe: false,
     loops: false,
     waits: false,
     error: null,
@@ -218,6 +221,7 @@ function describeLeaf(term) {
       if (item.name === 'unexpected' || item.name === 'inattendue') leaf.unexpected = true;
       else if (item.name === '...' || item.name === 'ad_infinitum') leaf.more = true;
       else if (item.name === 'sto') leaf.sto = true;
+      else if (item.name === 'maybe') leaf.maybe = true;
       else if (item.name === 'loops') leaf.loops = true;
       else if (item.name === 'waits') leaf.waits = true;
       else if (item.name === 'other_answer_sequence') {
@@ -253,10 +257,11 @@ 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.waits ||
+  leaf.hasExpectation = leaf.bindings.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;
   if ([leaf.false, leaf.truth, leaf.error != null].filter(Boolean).length > 1) leaf.malformed ??= term;
+  if (leaf.maybe && (leaf.false || leaf.loops || leaf.waits || leaf.error != null)) leaf.malformed ??= term;
   return leaf;
 }
 
@@ -386,9 +391,26 @@ function matchLeaf(program, query, leaf, actual, position) {
   }
   const solution = actual.solutions[position];
   if (!solution || !outputMatches(program, leaf.output, solution.output)) return false;
+  // Portable answer descriptions distinguish plain success from success with
+  // residual constraints. `maybe` requires at least one pending residue, while
+  // 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;
   return substitutionMatches(query, leaf.bindings, solution.env);
 }
 
+function hasPendingConstraints(env) {
+  for (const constraint of env.variableConstraints?.() ?? []) {
+    if (constraint.status?.(env) === 'pending') return true;
+  }
+  // Prolog attributed variables and delayed goals are the other residual-state
+  // mechanisms exposed by call_residue_vars/2. Treat either as pending residue
+  // even when a library does not provide a printable projection goal.
+  if ((env.attributedVariableNames?.() ?? []).length > 0) return true;
+  if ((env.delayedVariableNames?.() ?? []).length > 0) return true;
+  return false;
+}
+
 function descriptionDeclaresSto(description) {
   return splitOperator(description, '|').some((alternative) =>
     splitOperator(alternative, ';').some((term) => describeLeaf(term).sto));

package/src/scryer-compat.js

@@ -103,7 +103,14 @@ function validCharType(term) {
     (term.type === COMPOUND && ['lower', 'upper'].includes(term.name) && term.arity === 1);
 }
 
-function* charTypeBuiltin({ goal, env }) {
+function charTypeBuiltin(context) {
+  const state = { pending: false };
+  const iterator = charTypeSolutions(context, state);
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
+}
+
+function* charTypeSolutions({ goal, env }, state) {
   const char = deref(goal.args[0], env);
   const type = deref(goal.args[1], env);
   if (char.type === VAR && type.type === VAR) throw new PrologError('instantiation_error');
@@ -112,20 +119,23 @@ function* charTypeBuiltin({ goal, env }) {
   }
   if (type.type !== VAR && !validCharType(type)) throw new PrologError('domain_error(char_type)', type);
 
-  const chars = char.type === VAR
-    ? (function* unicodeScalars() {
-        for (let code = 0; code <= 0x10ffff; code++) {
-          if (code >= 0xd800 && code <= 0xdfff) continue;
-          yield String.fromCodePoint(code);
-        }
-      })()
-    : [char.name];
-  for (const ch of chars) {
-    for (const candidate of charTypeCandidates(ch)) {
+  const firstCode = char.type === VAR ? 0 : char.name.codePointAt(0);
+  const lastCode = char.type === VAR ? 0x10ffff : firstCode;
+  for (let code = firstCode; code <= lastCode; code++) {
+    if (code >= 0xd800 && code <= 0xdfff) continue;
+    const ch = String.fromCodePoint(code);
+    const candidates = charTypeCandidates(ch).filter((candidate) =>
+      type.type === VAR || (candidate.type === type.type && candidate.name === type.name));
+    for (let index = 0; index < candidates.length; index++) {
+      const candidate = candidates[index];
       const next = env.clone();
-      if (unify(goal.args[0], atom(ch), next) && unify(goal.args[1], candidate, next)) yield next;
+      if (unify(goal.args[0], atom(ch), next) && unify(goal.args[1], candidate, next)) {
+        state.pending = index + 1 < candidates.length || code < lastCode;
+        yield next;
+      }
     }
   }
+  state.pending = false;
 }
 
 const shortMonths = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',