eyeprolog 1.3.76 → 1.3.78

package/README.md

@@ -335,10 +335,11 @@ may be imported explicitly, while source/CLI/API dependency loading can resolve
 their unqualified forms conservatively. For Trealla-style interactive timing,
 `time/1` is also available directly in the normal EyeProlog runtime; strict ISO
 mode does not expose it.
-The aligned `library(lists)` and `library(iso_ext)` exports are kept disjoint so
-they can be imported together without an accidental import conflict. EyeProlog's
-legacy `library(prologue)` remains a compatibility umbrella and should be
-selectively imported when mixed with the aligned modules.
+`library(lists)`, `library(iso_ext)`, and `library(freeze)` follow the focused
+module organization used by Trealla and Scryer. EyeProlog's legacy
+`library(prologue)` is now a compatibility facade over these canonical modules
+and `library(between)`, so it can be imported before or after the focused
+libraries without duplicate-import errors.
 
 `library(lambda)` follows Scryer's higher-order lambda notation, adapted from
 Ulrich Neumerkel's permissively licensed implementation. Importing it installs
@@ -362,8 +363,7 @@ Outside `--iso-strict`, an otherwise undefined unqualified call may autoload a
 predicate only when the interop profile has one canonical EyeProlog provider.
 For example, `member/2` autoloads from `library(lists)`, `call_nth/2` from
 `library(iso_ext)`, `call_residue_vars/2` from `library(atts)`, and `between/3`
-from EyeProlog's internal
-`library(prologue)` implementation. Use `--no-autoload` to disable this
+from `library(between)`. Use `--no-autoload` to disable this
 convenience. Strict ISO mode never autoloads library predicates.
 
 Use `-w` / `--warnings` to diagnose dependencies outside the interop profile,

package/examples/binomial-vandermonde.pl

@@ -1,5 +1,5 @@
 :- use_module(library(aggregate)).
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 
 % Binomial coefficients and Vandermonde's identity.
 %

package/examples/book/chapter-26/02-triple.pl

@@ -1,5 +1,5 @@
 % From The Art of EyeProlog, Chapter 26 — Answers are existential witnesses.
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 :- use_module(library(lists)).
 
 triple(A, B, C) :-

package/examples/book/chapter-28/02-triangle.pl

@@ -1,5 +1,5 @@
 % From The Art of EyeProlog, Chapter 28 — Symmetry reduces search.
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 :- use_module(library(lists)).
 
 triangle(A, B, C) :-

package/examples/book/chapter-28/04-integer_rectangle.pl

@@ -1,5 +1,5 @@
 % From The Art of EyeProlog, Chapter 28.
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 :- use_module(library(lists)).
 
 integer_rectangle(Area, W, H) :-

package/examples/book/chapter-29/01-counterexample_to_odd_square.pl

@@ -1,5 +1,5 @@
 % From The Art of EyeProlog, Chapter 29 — Examples suggest; proofs compel.
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 :- use_module(library(lists)).
 
 counterexample_to_odd_square(N) :-

package/examples/book/chapter-31/03-double.pl

@@ -1,5 +1,5 @@
 % From The Art of EyeProlog, Chapter 31 — Properties over finite domains.
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 :- use_module(library(lists)).
 
 double(N, D) :- (D is N + N).

package/examples/book/chapter-32/04-reference_square.pl

@@ -1,5 +1,5 @@
 % From The Art of EyeProlog, Chapter 32 — Compare specification and implementation.
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 :- use_module(library(lists)).
 
 reference_square(N, S) :-

package/examples/book/chapter-33/03-chosen_pair.pl

@@ -1,5 +1,5 @@
 % From The Art of EyeProlog, Chapter 33 — Pattern 3: Generate, constrain, describe.
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 :- use_module(library(lists)).
 
 chosen_pair(pair(X, Y), reason(sum_is_ten)) :-

package/examples/book/chapter-39/01-answer.pl

@@ -1,6 +1,6 @@
 % From The Art of EyeProlog, Chapter 39 — The EyeProlog library.
 :- use_module(library(dates)).
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 :- use_module(library(random)).
 :- use_module(library(lists)).
 

package/examples/catalan-convolution.pl

@@ -1,5 +1,5 @@
 :- use_module(library(aggregate)).
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 
 % Catalan numbers by automatically tabled convolution.
 %

package/examples/collatz-1000.pl

@@ -1,4 +1,4 @@
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 
 % Collatz conjecture suite translated from Eyeling's examples/collatz-1000.n3.
 % It enumerates starts N = 1000, 999, ..., 1 by deriving N = 1000 - N0

package/examples/continued-fraction-sqrt2.pl

@@ -1,5 +1,5 @@
 :- use_module(library(aggregate)).
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 
 % Convergents of sqrt(2) by automatically tabled recurrence.
 %

package/examples/easter-computus.pl

@@ -1,4 +1,4 @@
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 
 % Gregorian Easter computus adapted from Eyeling's easter.n3.
 % Each case is a year in a sample decade.  The rules derive the Meeus/Jones/

package/examples/equality-saturation.pl

@@ -1,5 +1,5 @@
 :- use_module(library(aggregate)).
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 :- use_module(library(lists)).
 :- use_module(library(iso_ext)).
 

package/examples/goldbach.pl

@@ -1,5 +1,5 @@
 :- use_module(library(primes)).
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 
 % Goldbach's_conjecture
 % See https://en.wikipedia.org/wiki/Goldbach%27s_conjecture:

package/examples/integer-partitions.pl

@@ -1,5 +1,5 @@
 :- use_module(library(aggregate)).
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 
 % Integer partition counts by tabled dynamic programming.
 %

package/examples/job-shop-scheduling.pl

@@ -1,5 +1,5 @@
 :- use_module(library(aggregate)).
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 :- use_module(library(lists)).
 :- use_module(library(iso_ext)).
 

package/examples/matrix-chain-order.pl

@@ -1,5 +1,5 @@
 :- use_module(library(aggregate)).
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 :- use_module(library(lists)).
 :- use_module(library(iso_ext)).
 

package/examples/missionaries-cannibals.pl

@@ -1,4 +1,4 @@
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 :- use_module(library(lists)).
 :- use_module(library(iso_ext)).
 

package/examples/pell-equation.pl

@@ -1,5 +1,5 @@
 :- use_module(library(aggregate)).
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 
 % Pell equation x^2 - 2y^2 = 1 by automatically tabled recurrence.
 %

package/examples/polynomial.pl

@@ -1,4 +1,4 @@
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 :- use_module(library(lists)).
 
 % Polynomial roots over complex integer candidates, adapted from Eyelet's

package/examples/prime-range.pl

@@ -1,4 +1,4 @@
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 :- use_module(library(lists)).
 :- use_module(library(iso_ext)).
 

package/examples/stirling-bell-numbers.pl

@@ -1,5 +1,5 @@
 :- use_module(library(aggregate)).
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 
 % Stirling numbers of the second kind and Bell numbers.
 %

package/examples/totient-summatory.pl

@@ -1,5 +1,5 @@
 :- use_module(library(aggregate)).
-:- use_module(library(prologue), [between/3]).
+:- use_module(library(between), [between/3]).
 :- use_module(library(lists)).
 :- use_module(library(iso_ext)).
 

package/package.json

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

package/src/iso.js

@@ -65,9 +65,9 @@ export const isoBuiltins = {
     registry.add('=..', 2, univBuiltin, { deterministic: true });
     registry.add('copy_term', 2, copyTermBuiltin, { deterministic: true });
     registry.add('term_variables', 2, termVariablesBuiltin, { deterministic: true });
-    registry.add('findall', 3, findallBuiltin);
-    registry.add('bagof', 3, bagofBuiltin);
-    registry.add('setof', 3, setofBuiltin);
+    registry.add('findall', 3, findallBuiltin, { deterministic: true });
+    registry.add('bagof', 3, bagofBuiltin, { deterministicWhen: allSolutionsHasAtMostOneGroup });
+    registry.add('setof', 3, setofBuiltin, { deterministicWhen: allSolutionsHasAtMostOneGroup });
     registry.add('clause', 2, clauseBuiltin, {
       shouldUse: ({ solver }) => solver.program.findGroup('clause', 2) == null,
     });
@@ -1586,23 +1586,39 @@ function readTermFromStream(stream, solver) {
   let requestedInteractiveTerm = false;
   while (true) {
     let sawCandidate = false;
-    for (const candidate of termTextCandidates(stream, solver)) {
-      sawCandidate = true;
-      if (candidate.lexicalError) {
-        stream.position = candidate.end;
-        throw new PrologError('syntax_error(read_term)');
-      }
-      try {
-        const term = parseReadTermText(candidate.text, solver);
-        stream.position = candidate.end;
-        return scopeReadTerm(term);
-      } catch (error) {
-        if (error instanceof NumberRepresentationError || error instanceof CharacterRepresentationError) {
-          throw new PrologError(error.formal);
+    let lastCandidateEnd = stream.position;
+    try {
+      for (const candidate of termTextCandidates(stream, solver)) {
+        sawCandidate = true;
+        lastCandidateEnd = candidate.end;
+        if (candidate.lexicalError) {
+          stream.position = candidate.end;
+          throw new PrologError('syntax_error(read_term)');
         }
-        // A dot inside a graphic operator, such as =.., is only a possible
-        // terminator. Keep scanning until a complete term parses.
+        try {
+          const term = parseReadTermText(candidate.text, solver);
+          stream.position = candidate.end;
+          return scopeReadTerm(term);
+        } catch (error) {
+          if (error instanceof NumberRepresentationError || error instanceof CharacterRepresentationError) {
+            throw new PrologError(error.formal);
+          }
+          // A dot inside a graphic operator, such as =.., is only a possible
+          // terminator. Keep scanning until a complete term parses.
+        }
+      }
+    } catch (error) {
+      // A synthetic input boundary uses an invalid-character sentinel after
+      // the required peek character. If a complete candidate already ended
+      // at that boundary but did not parse, the term itself is malformed;
+      // consume it and report syntax_error rather than blaming the sentinel.
+      if (sawCandidate && Number.isInteger(stream.syntheticInputBoundary) &&
+          lastCandidateEnd === stream.syntheticInputBoundary && error?.name === 'PrologError' &&
+          error.formal === 'representation_error(character)') {
+        stream.position = lastCandidateEnd;
+        throw new PrologError('syntax_error(read_term)');
       }
+      throw error;
     }
 
     // The interactive top level may attach a synchronous reader to the
@@ -2351,6 +2367,16 @@ function allSolutionsBuiltin(asSet) {
 const bagofBuiltin = allSolutionsBuiltin(false);
 const setofBuiltin = allSolutionsBuiltin(true);
 
+function allSolutionsHasAtMostOneGroup({ goal, env }) {
+  try {
+    const { iterated, quantified } = bagGoalParts(goal.args[1], env);
+    return freeVariables(iterated, goal.args[0], quantified, env).length === 0;
+  } catch (_) {
+    // Leave error selection and reporting to the builtin itself.
+    return false;
+  }
+}
+
 function callable(term, env) {
   term = deref(term, env);
   if (term.type === VAR) throw new PrologError('instantiation_error');
@@ -2807,35 +2833,57 @@ function* negationBuiltin({ solver, goal, env }) {
   for (const _ of solver.cloneForInnerGoal(1).solve([invoked], env.clone(), 0)) return;
   yield env;
 }
-function* solveControlBranch(solver, goal, env) {
+function* solveControlBranch(solver, goal, env, observePending = null) {
+  const existingStacks = new Set(solver.solveStacks);
   for (const answer of solver.solve([callable(goal, env)], env, 0)) {
     // A branch answer is internal to its enclosing control construct. The
     // surrounding solve will count the completed control goal after the
     // builtin yields it. Leaving both counts in place makes a bounded search
     // such as once/1 or negation stop before it can observe the branch answer.
     if (solver.solutionsSeen > 0) solver.solutionsSeen--;
+    observePending?.(solver.hasPendingAlternatives(existingStacks));
     yield answer;
   }
 }
-function* disjunctionBuiltin({ solver, goal, env }) {
+function disjunctionBuiltin(context) {
+  const state = { pending: true };
+  const iterator = disjunctionSolutions(context, state);
+  iterator.hasPendingAlternatives = () => state.pending;
+  return iterator;
+}
+function* disjunctionSolutions({ solver, goal, env }, state) {
   const left = deref(goal.args[0], env);
   if (left.type === COMPOUND && left.name === '->' && left.arity === 2) {
     for (const conditionEnv of solver.cloneForInnerGoal(1).solve([callable(left.args[0], env)], env.clone(), 0)) {
-      yield* solveControlBranch(solver, left.args[1], conditionEnv);
+      yield* solveControlBranch(solver, left.args[1], conditionEnv,
+        (pending) => { state.pending = pending; });
+      state.pending = false;
       return;
     }
-    yield* solveControlBranch(solver, goal.args[1], env.clone());
+    yield* solveControlBranch(solver, goal.args[1], env.clone(),
+      (pending) => { state.pending = pending; });
+    state.pending = false;
     return;
   }
   const marker = solver.active[solver.active.length - 1] ?? null;
   const markerCutEpoch = marker?.cutEpoch ?? 0;
   const solverCutEpoch = solver.cutEpoch;
-  yield* solveControlBranch(solver, goal.args[0], env.clone());
+  yield* solveControlBranch(solver, goal.args[0], env.clone(), (pending) => {
+    const cutThisScope = marker == null
+      ? solver.cutEpoch !== solverCutEpoch
+      : (marker.cutEpoch ?? 0) !== markerCutEpoch;
+    state.pending = pending || !cutThisScope;
+  });
   const cutThisScope = marker == null
     ? solver.cutEpoch !== solverCutEpoch
     : (marker.cutEpoch ?? 0) !== markerCutEpoch;
-  if (cutThisScope) return;
-  yield* solveControlBranch(solver, goal.args[1], env.clone());
+  if (cutThisScope) {
+    state.pending = false;
+    return;
+  }
+  yield* solveControlBranch(solver, goal.args[1], env.clone(),
+    (pending) => { state.pending = pending; });
+  state.pending = false;
 }
 function* ifThenBuiltin({ solver, goal, env }) {
   for (const conditionEnv of solver.cloneForInnerGoal(1).solve([callable(goal.args[0], env)], env.clone(), 0)) {
@@ -2859,6 +2907,7 @@ export class BuiltinRegistry {
       arity,
       handler,
       deterministic: options.deterministic ?? false,
+      deterministicWhen: options.deterministicWhen ?? null,
       ready: options.ready ?? null,
       fallbackWhenNotReady: options.fallbackWhenNotReady ?? false,
       shouldUse: options.shouldUse ?? null,

package/src/lib/lists.pl

@@ -111,16 +111,23 @@ same_length([_|Xs], [_|Ys]) :- same_length(Xs, Ys).
 
 nth0(N, List, Elem) :- nth0(N, List, Elem, _).
 
-nth0(0, [Elem|Rest], Elem, Rest).
-nth0(N, [X|Xs], Elem, [X|Rest]) :-
+nth0(N, List, Elem, Rest) :-
+    lists__integer_or_variable(N),
+    ( var(N) -> lists__nth0(N, List, Elem, Rest)
+    ; lists__not_less_than_zero(N),
+      lists__nth0(N, List, Elem, Rest)
+    ).
+
+lists__nth0(0, [Elem|Rest], Elem, Rest).
+lists__nth0(N, [X|Xs], Elem, [X|Rest]) :-
     var(N),
-    nth0(N0, Xs, Elem, Rest),
+    lists__nth0(N0, Xs, Elem, Rest),
     N is N0 + 1.
-nth0(N, [X|Xs], Elem, [X|Rest]) :-
+lists__nth0(N, [X|Xs], Elem, [X|Rest]) :-
     nonvar(N),
     N > 0,
     N0 is N - 1,
-    nth0(N0, Xs, Elem, Rest).
+    lists__nth0(N0, Xs, Elem, Rest).
 
 nth1(N, List, Elem) :- nth1(N, List, Elem, _).
 
@@ -208,6 +215,9 @@ lists__integer(X) :- var(X), !, 0 is X.
 % arg/3 performs the ISO integer type check before inspecting its term.
 lists__integer(X) :- arg(X, type_check, _).
 
+lists__integer_or_variable(X) :- var(X), !.
+lists__integer_or_variable(X) :- lists__integer(X).
+
 lists__not_less_than_zero(X) :- X >= 0, !.
 % atom_length/2 reports domain_error(not_less_than_zero) for a negative value.
 lists__not_less_than_zero(X) :- atom_length('', X).

package/src/lib/prologue.pl

@@ -1,4 +1,10 @@
-/** Predicates proposed by the ISO Prolog Prologue working draft. */
+/** Predicates proposed by the ISO Prolog Prologue working draft.
+
+    This legacy compatibility module is a facade over the canonical library
+    organization shared with Scryer and Trealla. Keeping one implementation
+    owner per predicate lets applications combine library(prologue) with the
+    specialized libraries without import conflicts.
+*/
 
 :- module(prologue, [
     member/2,
@@ -26,168 +32,26 @@
     countall/2
 ]).
 
-:- meta_predicate(maplist(1, '?')).
-:- meta_predicate(maplist(2, '?', '?')).
-:- meta_predicate(maplist(3, '?', '?', '?')).
-:- meta_predicate(maplist(4, '?', '?', '?', '?')).
-:- meta_predicate(maplist(5, '?', '?', '?', '?', '?')).
-:- meta_predicate(maplist(6, '?', '?', '?', '?', '?', '?')).
-:- meta_predicate(maplist(7, '?', '?', '?', '?', '?', '?', '?')).
-:- meta_predicate(call_nth(0, '?')).
-:- meta_predicate(freeze('?', 0)).
-:- meta_predicate(foldl(3, '?', '?', '?')).
-:- meta_predicate(foldl(4, '?', '?', '?', '?')).
-:- meta_predicate(foldl(5, '?', '?', '?', '?', '?')).
-:- meta_predicate(countall(0, '?')).
-
-member(X, [X|_]).
-member(X, [_|Xs]) :- member(X, Xs).
-
-append([], Ys, Ys).
-append([X|Xs], Ys, [X|Zs]) :- append(Xs, Ys, Zs).
-
-length(List, Length) :-
-    nonvar(Length), !,
-    prologue__integer(Length),
-    prologue__not_less_than_zero(Length),
-    prologue__length_fixed(Length, List).
-length(List, Length) :-
-    prologue__length_generate(List, 0, Length).
-
-prologue__length_fixed(0, []).
-prologue__length_fixed(N, [_|Xs]) :-
-    N > 0,
-    Next is N - 1,
-    prologue__length_fixed(Next, Xs).
-
-prologue__length_generate([], N, N).
-prologue__length_generate([_|Xs], N0, N) :-
-    N1 is N0 + 1,
-    prologue__length_generate(Xs, N1, N).
-
-between(Lower, Upper, X) :-
-    prologue__integer(Lower),
-    prologue__integer(Upper),
-    prologue__integer_or_variable(X),
-    prologue__between(Lower, Upper, X).
-
-prologue__between(Lower, Upper, Lower) :- Lower =< Upper.
-prologue__between(Lower, Upper, X) :-
-    Lower < Upper,
-    Next is Lower + 1,
-    prologue__between(Next, Upper, X).
-
-select(X, [X|Xs], Xs).
-select(X, [Y|Ys], [Y|Zs]) :- select(X, Ys, Zs).
-
-succ(X, S) :-
-    var(X), !,
-    ( var(S) -> 0 is S
-    ; prologue__integer(S),
-      prologue__not_less_than_zero(S),
-      S > 0,
-      X is S - 1
-    ).
-succ(X, S) :-
-    prologue__integer(X),
-    prologue__not_less_than_zero(X),
-    ( var(S) -> S is X + 1
-    ; prologue__integer(S),
-      prologue__not_less_than_zero(S),
-      S =:= X + 1
-    ).
-
-maplist(_, []).
-maplist(Closure, [X|Xs]) :-
-    call(Closure, X),
-    maplist(Closure, Xs).
-
-maplist(_, [], []).
-maplist(Closure, [A|As], [B|Bs]) :-
-    call(Closure, A, B),
-    maplist(Closure, As, Bs).
-
-maplist(_, [], [], []).
-maplist(Closure, [A|As], [B|Bs], [C|Cs]) :-
-    call(Closure, A, B, C),
-    maplist(Closure, As, Bs, Cs).
-
-maplist(_, [], [], [], []).
-maplist(Closure, [A|As], [B|Bs], [C|Cs], [D|Ds]) :-
-    call(Closure, A, B, C, D),
-    maplist(Closure, As, Bs, Cs, Ds).
-
-maplist(_, [], [], [], [], []).
-maplist(Closure, [A|As], [B|Bs], [C|Cs], [D|Ds], [E|Es]) :-
-    call(Closure, A, B, C, D, E),
-    maplist(Closure, As, Bs, Cs, Ds, Es).
-
-maplist(_, [], [], [], [], [], []).
-maplist(Closure, [A|As], [B|Bs], [C|Cs], [D|Ds], [E|Es], [F|Fs]) :-
-    call(Closure, A, B, C, D, E, F),
-    maplist(Closure, As, Bs, Cs, Ds, Es, Fs).
-
-maplist(_, [], [], [], [], [], [], []).
-maplist(Closure, [A|As], [B|Bs], [C|Cs], [D|Ds], [E|Es], [F|Fs], [G|Gs]) :-
-    call(Closure, A, B, C, D, E, F, G),
-    maplist(Closure, As, Bs, Cs, Ds, Es, Fs, Gs).
-
-nth0(N, List, Elem) :- nth0(N, List, Elem, _).
-
-nth0(N, List, Elem, Rest) :-
-    prologue__integer_or_variable(N),
-    ( var(N) -> prologue__nth0(N, List, Elem, Rest)
-    ; prologue__not_less_than_zero(N),
-      prologue__nth0(N, List, Elem, Rest)
-    ).
-
-prologue__nth0(0, [Elem|Rest], Elem, Rest).
-prologue__nth0(N, [X|Xs], Elem, [X|Rest]) :-
-    var(N),
-    prologue__nth0(N0, Xs, Elem, Rest),
-    N is N0 + 1.
-prologue__nth0(N, [X|Xs], Elem, [X|Rest]) :-
-    nonvar(N),
-    N > 0,
-    N0 is N - 1,
-    prologue__nth0(N0, Xs, Elem, Rest).
-
-nth1(N, List, Elem) :- nth1(N, List, Elem, _).
-
-nth1(N, List, Elem, Rest) :-
-    N \== 0,
-    nth0(N, [_|List], Elem, [_|Rest]),
-    N \== 0.
-
-call_nth(Goal, Nth) :- eyeprolog__call_nth(Goal, Nth).
-
-freeze(Var, Goal) :- eyeprolog__freeze(Var, Goal).
-
-foldl(_, [], Acc, Acc).
-foldl(Closure, [A|As], Acc0, Acc) :-
-    call(Closure, A, Acc0, Acc1),
-    foldl(Closure, As, Acc1, Acc).
-
-foldl(_, [], [], Acc, Acc).
-foldl(Closure, [A|As], [B|Bs], Acc0, Acc) :-
-    call(Closure, A, B, Acc0, Acc1),
-    foldl(Closure, As, Bs, Acc1, Acc).
-
-foldl(_, [], [], [], Acc, Acc).
-foldl(Closure, [A|As], [B|Bs], [C|Cs], Acc0, Acc) :-
-    call(Closure, A, B, C, Acc0, Acc1),
-    foldl(Closure, As, Bs, Cs, Acc1, Acc).
-
-countall(Goal, Count) :- eyeprolog__countall(Goal, Count).
-
-prologue__integer_or_variable(X) :- var(X), !.
-prologue__integer_or_variable(X) :- prologue__integer(X).
-
-prologue__integer(X) :- integer(X), !.
-prologue__integer(X) :- var(X), !, 0 is X.
-% arg/3 performs the required integer type check before inspecting its term.
-prologue__integer(X) :- arg(X, type_check, _).
-
-prologue__not_less_than_zero(X) :- X >= 0, !.
-% atom_length/2 reports domain_error(not_less_than_zero) for a negative value.
-prologue__not_less_than_zero(X) :- atom_length('', X).
+:- use_module(library(lists), [
+    member/2,
+    append/3,
+    length/2,
+    select/3,
+    maplist/2,
+    maplist/3,
+    maplist/4,
+    maplist/5,
+    maplist/6,
+    maplist/7,
+    maplist/8,
+    nth0/3,
+    nth0/4,
+    nth1/3,
+    nth1/4,
+    foldl/4,
+    foldl/5,
+    foldl/6
+]).
+:- use_module(library(between), [between/3]).
+:- use_module(library(iso_ext), [succ/2, call_nth/2, countall/2]).
+:- use_module(library(freeze), [freeze/2]).