eyeprolog 1.5.80 → 1.5.82

package/conformance-report.md

@@ -7,7 +7,7 @@ when this report is generated; it is not inferred from fixture counts.
 ## Latest Neumerkel evidence
 
 See the tracked [latest Neumerkel conformity report](test/conformance/NEUMERKEL-LATEST.md).
-`npm test` fetches all seven TU Wien sources once and executes the discovered inventory.
+`npm test` fetches all eight TU Wien sources once and executes the discovered inventory.
 The release workflow then synchronizes this tracked report from those exact successful
 cached source bytes, avoiding a second live fetch and its race window.
 

package/examples/defeasible-reasoning.pl

@@ -0,0 +1,120 @@
+% Defeasible reasoning: an employee travel-expense reimbursement policy.
+%
+% Defeasible rules state a default and let a more specific rule override it.
+% Most of that is ordinary, stratified negation as failure (7.3, \+/1): compute
+% the exception from facts, then let the default rule negate the exception.
+% Nothing here needs the well-founded semantics (WFS) yet.
+%
+% The last section is different on purpose. It models two independent
+% reimbursement policies that can both claim the same expense with no company
+% rule saying which one wins — team_offsite_hotel qualifies for both the flat
+% per-diem blanket allowance and itemized reimbursement, and neither policy
+% was written anticipating the other. Three ways to handle that:
+%
+%   1) Plain \+/1, each side negating the other. That is an unstratified
+%      negation cycle: proving either side requires failing the other, which
+%      requires proving the first again. Try it (swap tnot/1 for \+/1 below
+%      and run with --warnings): the engine loops until it runs out of stack.
+%   2) tnot/1 and wfs_truth/2. EyeProlog evaluates the same cycle under WFS
+%      and reports both sides `undefined` instead of picking one arbitrarily
+%      — honest, since the policies themselves do not resolve the conflict,
+%      but callers now have to know to ask wfs_truth/2 instead of just
+%      calling covered_by_blanket/1 or itemized/1 directly.
+%   3) An explicit conflict predicate, the way examples/nixon-diamond.pl
+%      already handles the same shape of problem (two independent defaults,
+%      no priority between them): join the two eligibility facts directly and
+%      name the outcome. No negation, no cycle, nothing for --warnings to
+%      flag, and the result is an ordinary fact any caller can query without
+%      having to know WFS exists.
+%
+% Here (3) is the better fit, and is this codebase's actual convention for
+% this situation. Reach for tnot/1 and wfs_truth/2 when the mutual defeat is
+% already how the rules are naturally stated as each other's negation — a
+% permission that holds unless its prohibition holds and vice versa, as
+% examples/odrl-policy-reasoning.pl's profile rules do for a real policy
+% language — not to manufacture a cycle for a conflict a direct join would
+% already detect. And for everyday defeasible overriding, where a more
+% specific rule is meant to win outright, plain stratified \+/1 already says
+% exactly that and is ISO-portable; WFS would not change the answer there,
+% only the machinery needed to get it.
+
+%% goal: reimbursementQuestion(X0, X1, X2)
+%% goal: conflictQuestion(X0, X1, X2)
+%% goal: explicitConflictQuestion(X0, X1, X2)
+
+% --- Submitted expenses and the facts a claims clerk would see ------------
+
+submitted(taxi_receipt).
+submitted(client_dinner_wine).
+submitted(client_dinner_wine_preapproved).
+submitted(team_offsite_hotel).
+
+category(client_dinner_wine, alcohol).
+category(client_dinner_wine_preapproved, alcohol).
+
+% A manager can preapprove alcohol as part of client entertainment; that is
+% the exception to the exception.
+preapproved_entertainment(client_dinner_wine_preapproved).
+
+% --- Ordinary defeasible tier: specificity resolves every case -------------
+%
+%   default:            an expense is reimbursable
+%   exception:           ... unless it is alcohol
+%   exception to that:   ... unless the alcohol was preapproved entertainment
+%
+% Each rule only negates a lower, already-computed layer, so this is
+% stratified and plain \+/1 is all it takes.
+
+excluded(Expense) :-
+  category(Expense, alcohol),
+  \+ preapproved_entertainment(Expense).
+
+reimbursable(Expense) :-
+  submitted(Expense),
+  \+ excluded(Expense).
+
+% --- The one case with a genuine, unresolved conflict, two ways ------------
+%
+% team_offsite_hotel independently qualifies for both the flat per-diem
+% blanket allowance and itemized reimbursement.
+blanket_eligible(team_offsite_hotel).
+itemizable(team_offsite_hotel).
+
+% 2) WFS via tnot/1: each classification defeats the other, leaving both
+% `undefined` rather than an arbitrary pick.
+covered_by_blanket(Expense) :-
+  blanket_eligible(Expense),
+  tnot(itemized(Expense)).
+itemized(Expense) :-
+  itemizable(Expense),
+  tnot(covered_by_blanket(Expense)).
+
+% 3) This codebase's usual idiom (examples/nixon-diamond.pl): detect the
+% conflict directly from the two eligibility facts, no negation involved.
+policy_conflict(Expense, blanket_allowance, itemized_reimbursement) :-
+  blanket_eligible(Expense),
+  itemizable(Expense).
+
+% --- Curated questions -----------------------------------------------------
+
+% Plain expense, alcohol excluded by default, and the preapproved override —
+% all decided by ordinary negation as failure, no WFS involved.
+reimbursementQuestion(plain, taxi_receipt, Verdict) :-
+  wfs_truth(reimbursable(taxi_receipt), Verdict).
+reimbursementQuestion(alcohol_excluded, client_dinner_wine, Verdict) :-
+  wfs_truth(reimbursable(client_dinner_wine), Verdict).
+reimbursementQuestion(alcohol_preapproved, client_dinner_wine_preapproved, Verdict) :-
+  wfs_truth(reimbursable(client_dinner_wine_preapproved), Verdict).
+
+% The unresolved policy conflict under WFS: both classifications come back
+% `undefined`, which only tells a caller anything if it remembers to ask
+% wfs_truth/2 in the first place.
+conflictQuestion(blanket_allowance, team_offsite_hotel, Verdict) :-
+  wfs_truth(covered_by_blanket(team_offsite_hotel), Verdict).
+conflictQuestion(itemized_reimbursement, team_offsite_hotel, Verdict) :-
+  wfs_truth(itemized(team_offsite_hotel), Verdict).
+
+% The same conflict, detected directly: an ordinary fact any caller can query
+% without knowing WFS is involved at all.
+explicitConflictQuestion(team_offsite_hotel, blanket_allowance, itemized_reimbursement) :-
+  policy_conflict(team_offsite_hotel, blanket_allowance, itemized_reimbursement).

package/examples/output/defeasible-reasoning.pl

@@ -0,0 +1,6 @@
+reimbursementQuestion(plain, taxi_receipt, true).
+reimbursementQuestion(alcohol_excluded, client_dinner_wine, false).
+reimbursementQuestion(alcohol_preapproved, client_dinner_wine_preapproved, true).
+conflictQuestion(blanket_allowance, team_offsite_hotel, undefined).
+conflictQuestion(itemized_reimbursement, team_offsite_hotel, undefined).
+explicitConflictQuestion(team_offsite_hotel, blanket_allowance, itemized_reimbursement).

package/index.d.ts

@@ -96,6 +96,12 @@ export interface EyePrologQuadResult {
   kind?: 'failed' | 'malformed' | 'bad_identifier' | 'unsupported' | 'undecided';
   expected?: EyePrologTerm;
   reason?: string;
+  /** The quad's query term, for a caller building its own per-result label. */
+  query?: EyePrologTerm;
+  /** The quad's identifier, or null when the quad has none. */
+  id?: EyePrologTerm | null;
+  /** The source line this answer description starts on, when known. */
+  line?: number | null;
 }
 
 export interface EyePrologQuadRunResult {
@@ -312,6 +318,8 @@ export function hasForwardRules(program: Program): boolean;
 /** Execute EyeProlog `:+/2` rules to closure using an existing solver. */
 export function executeForwardRules(program: Program, solver: Solver, options?: EyePrologForwardRunOptions): EyePrologForwardRunResult;
 export function runQuads(source: string | Program, options?: EyePrologQuadRunOptions): EyePrologQuadRunResult;
+/** Render a quad term (query, identifier, or expected answer) the way quad failure reports do. */
+export function formatQuadTerm(program: Program, term: EyePrologTerm): string;
 export interface EyePrologProofMethod {
   type: 'source' | 'builtin' | 'library' | 'conjunction';
   kind?: 'fact' | 'rule';
@@ -433,6 +441,7 @@ declare const eyeprolog: {
   hasForwardRules: typeof hasForwardRules;
   executeForwardRules: typeof executeForwardRules;
   runQuads: typeof runQuads;
+  formatQuadTerm: typeof formatQuadTerm;
   proofCertificate: typeof proofCertificate;
   proofCertificatesFromText: typeof proofCertificatesFromText;
   verifyProof: typeof verifyProof;

package/package.json

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

package/playground.html

@@ -498,6 +498,7 @@
           "deep-taxonomy-1000",
           "deep-taxonomy-10000",
           "deep-taxonomy-100000",
+          "defeasible-reasoning",
           "delfour",
           "deontic-logic",
           "derived-backward-rule",

package/src/explain.js

@@ -69,7 +69,7 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active, de
         env: proofEnv,
         node: {
           goal: resolveForProof(goal, proofEnv),
-          method: builtinMethod(goal),
+          method: goalMethod('builtin', goal),
           sourceHead: resolveForProof(goal, proofEnv),
           sourceBody: [],
           bindings: [],
@@ -97,7 +97,7 @@ function* proveGoalAll(program, goal, env, depth, maxDepth, registry, active, de
         env: proofEnv,
         node: {
           goal: resolveForProof(goal, proofEnv),
-          method: libraryMethod(goal),
+          method: goalMethod('library', goal),
           sourceHead: resolveForProof(goal, proofEnv),
           sourceBody: [],
           bindings: [],
@@ -254,17 +254,9 @@ function sourceMethod(clause, kind) {
   };
 }
 
-function builtinMethod(goal) {
+function goalMethod(type, goal) {
   return {
-    type: 'builtin',
-    name: goal.type === COMPOUND ? goal.name : 'goal',
-    arity: goal.type === COMPOUND ? goal.arity : 0,
-  };
-}
-
-function libraryMethod(goal) {
-  return {
-    type: 'library',
+    type,
     name: goal.type === COMPOUND ? goal.name : 'goal',
     arity: goal.type === COMPOUND ? goal.arity : 0,
   };
@@ -380,15 +372,15 @@ function certificateText(term) {
   throw new Error('expected certificate text');
 }
 
-function containsLibraryBoundary(node) {
-  if (node.method?.type === 'library') return true;
-  return node.children.some(containsLibraryBoundary);
+function proofTreeContains(node, predicate) {
+  return predicate(node) || node.children.some((child) => proofTreeContains(child, predicate));
 }
 
-function containsExpandedLibrarySource(node) {
-  if (node.method?.type === 'source' && String(node.method.filename ?? '').startsWith('src/lib/')) return true;
-  return node.children.some(containsExpandedLibrarySource);
-}
+const containsLibraryBoundary = (node) => proofTreeContains(node, (n) => n.method?.type === 'library');
+
+const containsExpandedLibrarySource = (node) => proofTreeContains(
+  node, (n) => n.method?.type === 'source' && String(n.method.filename ?? '').startsWith('src/lib/'),
+);
 
 export function verifyProof(program, input, options = {}) {
   const certificate = input?.certificate ?? input;
@@ -557,8 +549,9 @@ function verifyBindings(bindings, variables, env, program) {
 
 function renderMethodTerm(method) {
   if (method && method.type === 'source') return `${method.kind}(${quoteString(method.filename)}, clause(${method.clause}))`;
-  if (method && method.type === 'builtin') return `builtin(${quoteAtomText(method.name)}, ${method.arity})`;
-  if (method && method.type === 'library') return `library(${quoteAtomText(method.name)}, ${method.arity})`;
+  if (method && (method.type === 'builtin' || method.type === 'library')) {
+    return `${method.type}(${quoteAtomText(method.name)}, ${method.arity})`;
+  }
   return String(method);
 }
 

package/src/index.js

@@ -28,7 +28,7 @@ export {
   eyePrologInteropLibraryModules,
 } from './standard-library.js';
 export { StreamManager } from './io.js';
-export { runQuads } from './quads.js';
+export { formatQuadTerm, runQuads } from './quads.js';
 export { executeForwardRules, hasForwardRules } from './execute.js';
 
 import { installCleanupLifecycle } from './cleanup.js';

package/src/iso.js

@@ -680,10 +680,7 @@ function validPredicateIndicator(term) {
       (term.args[1].type === NUMBER && isDecimalInteger(term.args[1].name) && BigInt(term.args[1].name) >= 0n));
 }
 
-function currentPredicateBuiltin(context) {
-  const state = { pending: false };
-  return withPendingState(currentPredicateSolutions(context, state), state);
-}
+const currentPredicateBuiltin = pendingBuiltin(currentPredicateSolutions);
 
 function* currentPredicateSolutions({ solver, goal, env }, state) {
   const indicator = copyResolved(goal.args[0], env);
@@ -719,10 +716,7 @@ function clauseBodyTerm(body) {
   return result;
 }
 
-function clauseBuiltin(context) {
-  const state = { pending: false };
-  return withPendingState(clauseSolutions(context, state), state);
-}
+const clauseBuiltin = pendingBuiltin(clauseSolutions);
 
 function* clauseSolutions({ solver, goal, env }, state) {
   const head = deref(goal.args[0], env);
@@ -851,12 +845,7 @@ function assertBuiltin(atStart) {
   };
 }
 
-function retractBuiltin(context) {
-  const state = { pending: true };
-  const iterator = retractSolutions(context, state);
-  iterator.hasPendingAlternatives = () => state.pending;
-  return iterator;
-}
+const retractBuiltin = pendingBuiltin(retractSolutions, true);
 
 function* retractSolutions({ solver, goal, env }, state) {
   const parts = clauseParts(goal.args[0], env);
@@ -941,10 +930,7 @@ function* abolishBuiltin({ solver, goal, env }) {
   yield env;
 }
 
-function currentPrologFlagBuiltin(context) {
-  const state = { pending: false };
-  return withPendingState(currentPrologFlagSolutions(context, state), state);
-}
+const currentPrologFlagBuiltin = pendingBuiltin(currentPrologFlagSolutions);
 
 function* currentPrologFlagSolutions({ solver, goal, env }, state) {
   const flag = deref(goal.args[0], env);
@@ -1058,10 +1044,7 @@ function* opBuiltin({ solver, goal, env }) {
   yield env;
 }
 
-function currentOpBuiltin(context) {
-  const state = { pending: false };
-  return withPendingState(currentOpSolutions(context, state), state);
-}
+const currentOpBuiltin = pendingBuiltin(currentOpSolutions);
 
 function* currentOpSolutions({ solver, goal, env }, state) {
   const priority = deref(goal.args[0], env);
@@ -1124,10 +1107,7 @@ function* charConversionBuiltin({ solver, goal, env }) {
   else solver.charConversions.set(input.name, output.name);
   yield env;
 }
-function currentCharConversionBuiltin(context) {
-  const state = { pending: false };
-  return withPendingState(currentCharConversionSolutions(context, state), state);
-}
+const currentCharConversionBuiltin = pendingBuiltin(currentCharConversionSolutions);
 
 function* currentCharConversionSolutions({ solver, goal, env }, state) {
   const input = conversionCharacter(goal.args[0], env, true, solver);
@@ -1355,28 +1335,23 @@ function* closeBuiltin({ solver, goal, env }) {
   yield env;
 }
 
-function* currentInputBuiltin({ solver, goal, env }) {
-  const value = deref(goal.args[0], env);
-  if (value.type !== VAR) {
-    const id = streamTermReference(goal.args[0], env);
-    // A closed handle is still a stream-term, but cannot be current (#107).
-    // Validate its shape, then test identity rather than requiring an open stream.
-    if (id === solver.io.currentInput) yield env;
-    return;
-  }
-  const next = env.clone();
-  if (unify(goal.args[0], streamHandle(solver.io.currentInput), next)) yield next;
-}
-function* currentOutputBuiltin({ solver, goal, env }) {
-  const value = deref(goal.args[0], env);
-  if (value.type !== VAR) {
-    const id = streamTermReference(goal.args[0], env);
-    if (id === solver.io.currentOutput) yield env;
-    return;
-  }
-  const next = env.clone();
-  if (unify(goal.args[0], streamHandle(solver.io.currentOutput), next)) yield next;
+function currentStreamBuiltin(which) {
+  // A closed handle is still a stream-term, but cannot be current (#107).
+  // Validate its shape, then test identity rather than requiring an open stream.
+  return function* ({ solver, goal, env }) {
+    const value = deref(goal.args[0], env);
+    const current = solver.io[which];
+    if (value.type !== VAR) {
+      const id = streamTermReference(goal.args[0], env);
+      if (id === current) yield env;
+      return;
+    }
+    const next = env.clone();
+    if (unify(goal.args[0], streamHandle(current), next)) yield next;
+  };
 }
+const currentInputBuiltin = currentStreamBuiltin('currentInput');
+const currentOutputBuiltin = currentStreamBuiltin('currentOutput');
 
 function setCurrentStreamBuiltin(mode) {
   return function* ({ solver, goal, env }) {
@@ -1456,10 +1431,7 @@ function isStreamPropertyPattern(value) {
   ].includes(value.name);
 }
 
-function streamPropertyBuiltin(context) {
-  const state = { pending: false };
-  return withPendingState(streamPropertySolutions(context, state), state);
-}
+const streamPropertyBuiltin = pendingBuiltin(streamPropertySolutions);
 
 function* streamPropertySolutions({ solver, goal, env }, state) {
   const reference = deref(goal.args[0], env);
@@ -2068,14 +2040,6 @@ function* writeTermBuiltin({ solver, goal, env }) {
   yield env;
 }
 
-function resolvedOrVariable(term, env, expected) {
-  const value = deref(term, env);
-  if (value.type !== VAR && value.type !== expected) {
-    throw new PrologError(`type_error(${expected === ATOM ? 'atom' : 'number'})`, value);
-  }
-  return value;
-}
-
 function characters(text) {
   return Array.from(text);
 }
@@ -2095,10 +2059,7 @@ function* atomLengthBuiltin({ goal, env }) {
   if (unify(goal.args[1], numberTerm(characters(value.name).length), next)) yield next;
 }
 
-function atomConcatBuiltin(context) {
-  const state = { pending: false };
-  return withPendingState(atomConcatSolutions(context, state), state);
-}
+const atomConcatBuiltin = pendingBuiltin(atomConcatSolutions);
 
 function* atomConcatSolutions({ goal, env }, state) {
   const first = deref(goal.args[0], env);
@@ -2142,10 +2103,7 @@ function optionalInteger(term, env) {
   return BigInt(value.name);
 }
 
-function subAtomBuiltin(context) {
-  const state = { pending: false };
-  return withPendingState(subAtomSolutions(context, state), state);
-}
+const subAtomBuiltin = pendingBuiltin(subAtomSolutions);
 
 function* subAtomSolutions({ goal, env }, state) {
   const source = deref(goal.args[0], env);
@@ -2625,10 +2583,7 @@ function sortedUnique(items) {
 }
 
 function allSolutionsBuiltin(asSet) {
-  return function allSolutions(context) {
-    const state = { pending: false };
-    return withPendingState(allSolutionsGroups(context, asSet, state), state);
-  };
+  return pendingBuiltin((context, state) => allSolutionsGroups(context, asSet, state));
 }
 
 function* allSolutionsGroups({ solver, goal, env }, asSet, state) {
@@ -2697,6 +2652,15 @@ function withPendingState(iterator, state) {
   iterator.hasPendingAlternatives = () => state.pending;
   return iterator;
 }
+
+// Most builtins share this shape: create a { pending } cell, run a solutions
+// generator against it, and expose that cell through hasPendingAlternatives.
+function pendingBuiltin(solutionsFn, initialPending = false) {
+  return (context) => {
+    const state = { pending: initialPending };
+    return withPendingState(solutionsFn(context, state), state);
+  };
+}
 function validateControlCallable(term, culprit, env) {
   // Only control constructs need their nested goals validated at meta-call
   // entry. Walk them iteratively and dereference each nested goal lazily so
@@ -2770,9 +2734,9 @@ function expandCallGoal({ goal, env }) {
   if (converted.module == null) converted.module = module;
   return converted;
 }
-function* callBuiltin(context) {
+function* invokeExpandedGoal(context, expand) {
   const { solver, env } = context;
-  const invoked = expandCallGoal(context);
+  const invoked = expand(context);
   const child = solver.cloneForInnerGoal();
   try {
     yield* child.solve([invoked], env, 0);
@@ -2780,6 +2744,9 @@ function* callBuiltin(context) {
     solver.absorbStatsFrom(child);
   }
 }
+function* callBuiltin(context) {
+  yield* invokeExpandedGoal(context, expandCallGoal);
+}
 function expandCallClosureGoal({ goal, env }) {
   const closure = callable(goal.args[0], env);
   const existing = closure.type === COMPOUND ? closure.args : [];
@@ -2792,14 +2759,7 @@ function expandCallClosureGoal({ goal, env }) {
   return invoked;
 }
 function* callClosureBuiltin(context) {
-  const { solver, env } = context;
-  const invoked = expandCallClosureGoal(context);
-  const child = solver.cloneForInnerGoal();
-  try {
-    yield* child.solve([invoked], env, 0);
-  } finally {
-    solver.absorbStatsFrom(child);
-  }
+  yield* invokeExpandedGoal(context, expandCallClosureGoal);
 }
 
 export function* countAllBuiltin({ solver, goal, env }) {
@@ -2846,10 +2806,7 @@ function writeElapsedTime(solver, startedAt, inferences) {
   );
 }
 
-export function timeBuiltin(context) {
-  const state = { pending: true };
-  return withPendingState(timeSolutions(context, state), state);
-}
+export const timeBuiltin = pendingBuiltin(timeSolutions, true);
 
 function* timeSolutions({ solver, goal, env }, state) {
   const invoked = callable(goal.args[0], env);
@@ -2877,10 +2834,7 @@ function* timeSolutions({ solver, goal, env }, state) {
   }
 }
 
-export function callNthBuiltin(context) {
-  const state = { pending: true };
-  return withPendingState(callNthSolutions(context, state), state);
-}
+export const callNthBuiltin = pendingBuiltin(callNthSolutions, true);
 
 function* callNthSolutions({ solver, goal, env }, state) {
   const requestedTerm = deref(goal.args[1], env);
@@ -3005,37 +2959,7 @@ export function callResidueVarsBuiltin({ solver, goal, env }) {
   return iterator;
 }
 
-function freezeBuiltin(context) {
-  const state = { pending: true };
-  return withPendingState(freezeSolutions(context, state), state);
-}
-
-function* freezeSolutions({ solver, goal, env }, state) {
-  const watched = deref(goal.args[0], env);
-  if (watched.type !== VAR) {
-    const child = solver.cloneForInnerGoal();
-    try {
-      for (const answerEnv of child.solve([callable(goal.args[1], env)], env, 0)) {
-        state.pending = child.hasPendingAlternatives();
-        yield answerEnv;
-        if (!state.pending) return;
-      }
-      state.pending = false;
-    } finally {
-      solver.absorbStatsFrom(child);
-    }
-    return;
-  }
-  const next = env.clone();
-  next.delay(watched.name, goal.args[1], goal.module ?? 'user');
-  state.pending = false;
-  yield next;
-}
-
-function phraseBuiltin(context) {
-  const state = { pending: true };
-  return withPendingState(phraseSolutions(context, state), state);
-}
+const phraseBuiltin = pendingBuiltin(phraseSolutions, true);
 
 function* phraseSolutions({ solver, goal, env }, state) {
   const grammarBody0 = deref(goal.args[0], env);
@@ -3161,10 +3085,7 @@ function prologErrorBall(error) {
   if (hasDefaultGroundErrorShape(error) || termIsGround(term)) return term;
   return freshCopy(term, new Env());
 }
-function catchBuiltin(context) {
-  const state = { pending: true };
-  return withPendingState(catchSolutions(context, state), state);
-}
+const catchBuiltin = pendingBuiltin(catchSolutions, true);
 
 function* catchSolutions({ solver, goal, env }, state) {
   let child = null;
@@ -3293,12 +3214,7 @@ function* solveControlBranch(solver, goal, env, observePending = null) {
     yield answer;
   }
 }
-function disjunctionBuiltin(context) {
-  const state = { pending: true };
-  const iterator = disjunctionSolutions(context, state);
-  iterator.hasPendingAlternatives = () => state.pending;
-  return iterator;
-}
+const disjunctionBuiltin = pendingBuiltin(disjunctionSolutions, true);
 function* disjunctionSolutions({ solver, goal, env }, state) {
   const left = deref(goal.args[0], env);
   if (left.type === COMPOUND && left.name === '->' && left.arity === 2) {
@@ -3333,10 +3249,7 @@ function* disjunctionSolutions({ solver, goal, env }, state) {
     (pending) => { state.pending = pending; });
   state.pending = false;
 }
-function ifThenBuiltin(context) {
-  const state = { pending: true };
-  return withPendingState(ifThenSolutions(context, state), state);
-}
+const ifThenBuiltin = pendingBuiltin(ifThenSolutions, true);
 
 function* ifThenSolutions({ solver, goal, env }, state) {
   for (const conditionEnv of solver.cloneForInnerGoal(1).solve([callable(goal.args[0], env)], env.clone(), 0)) {