eyeprolog 1.2.44 → 1.3.1

package/README.md

@@ -123,8 +123,8 @@ noun --> [world] | [prolog].
 %% goal: phrase(sentence, Words)
 ```
 
-EyeProlog also adds 99 public library predicate indicators to its 129-entry ISO
-profile. **60 are implemented entirely as ordinary Prolog clauses** in focused
+EyeProlog also adds 102 public library predicate indicators to its 129-entry ISO
+profile. **63 are implemented entirely as ordinary Prolog clauses** in focused
 modules under `src/lib/`; the control predicates and finite-domain
 `library(clpz)` kernel use backtrackable host support.
 They are ISO/IEC 13211-2 modules loaded explicitly by purpose, such as
@@ -133,6 +133,38 @@ Portable text
 predicates use ISO atoms or character lists. The old catch-all
 `library(eyeprolog)` module is no longer needed.
 
+## Trealla and Scryer interoperability
+
+EyeProlog keeps a conservative source-level interoperability profile separate
+from the larger EyeProlog library surface. `library(lists)` follows the common
+Trealla/Scryer organization for predicates such as `member/2`, `memberchk/2`,
+`append/2-3`, `nth0/3-4`, `nth1/3-4`, `length/2`, `maplist/2-8`, and
+`foldl/4-6`. Its `length/2` remains relational: with both arguments variable,
+`length(Xs, N)` enumerates lists of increasing length together with `N = 0, 1,
+2, ...`.
+
+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)`, while `between/3` and
+`call_nth/2` can use EyeProlog's internal Prologue implementation without
+requiring portable source to name `library(prologue)`. Use `--no-autoload` to
+disable this convenience. Strict ISO mode never autoloads library predicates.
+
+Use `-w` / `--warnings` to diagnose dependencies outside the interop profile,
+or `--portable` to make such diagnostics fail the run. This catches both
+implementation-specific library names and EyeProlog-only predicates such as
+`set_nth0/4` even when they live in an otherwise common module.
+
+Cross-engine smoke tests live in `test/run-interop.mjs`. With Trealla (`tpl`)
+and Scryer (`scryer-prolog`) installed, run:
+
+```sh
+npm run test:interop
+```
+
+The GitHub interoperability workflow builds both implementations and runs the
+same portable Sudoku source under EyeProlog, Trealla, and Scryer.
+
 ## Development
 
 ```sh

package/examples/book/chapter-06/03-square.pl

@@ -1,5 +1,4 @@
 % From The Art of EyeProlog, Chapter 6.
-:- use_module(library(prologue), [between/3]).
 :- use_module(library(lists)).
 
 square(N, Square) :-

package/examples/fast-fourier-transform.pl

@@ -1,3 +1,5 @@
+:- use_module(library(lists), [memberchk/2]).
+
 % Fast Fourier Transform
 % Code from the book "Clause and Effect" Chapter 10
 

package/examples/output/fast-fourier-transform.pl

@@ -1 +1 @@
-fft([0, 1, 2, 3, 4, 5, 6, 7], [n(232, op(+, 216, 231)), n(231, op(*, 217, 230)), n(230, op(+, 222, 229)), n(229, op(*, 223, 228)), n(228, op(+, 224, 227)), n(227, op(*, 225, 226)), n(226, a(7)), n(225, w ^ 4), n(224, a(3)), n(223, w ^ 6), n(222, op(+, 218, 221)), n(221, op(*, 219, 220)), n(220, a(5)), n(219, w ^ 4), n(218, a(1)), n(217, w ^ 7), n(216, op(+, 208, 215)), n(215, op(*, 209, 214)), n(214, op(+, 210, 213)), n(213, op(*, 211, 212)), n(212, a(6)), n(211, w ^ 4), n(210, a(2)), n(209, w ^ 6), n(208, op(+, 204, 207)), n(207, op(*, 205, 206)), n(206, a(4)), n(205, w ^ 4), n(204, a(0)), n(203, op(+, 187, 202)), n(202, op(*, 188, 201)), n(201, op(+, 193, 200)), n(200, op(*, 194, 199)), n(199, op(+, 195, 198)), n(198, op(*, 196, 197)), n(197, a(7)), n(196, w ^ 0), n(195, a(3)), n(194, w ^ 4), n(193, op(+, 189, 192)), n(192, op(*, 190, 191)), n(191, a(5)), n(190, w ^ 0), n(189, a(1)), n(188, w ^ 6), n(187, op(+, 179, 186)), n(186, op(*, 180, 185)), n(185, op(+, 181, 184)), n(184, op(*, 182, 183)), n(183, a(6)), n(182, w ^ 0), n(181, a(2)), n(180, w ^ 4), n(179, op(+, 175, 178)), n(178, op(*, 176, 177)), n(177, a(4)), n(176, w ^ 0), n(175, a(0)), n(174, op(+, 158, 173)), n(173, op(*, 159, 172)), n(172, op(+, 164, 171)), n(171, op(*, 165, 170)), n(170, op(+, 166, 169)), n(169, op(*, 167, 168)), n(168, a(7)), n(167, w ^ 4), n(166, a(3)), n(165, w ^ 2), n(164, op(+, 160, 163)), n(163, op(*, 161, 162)), n(162, a(5)), n(161, w ^ 4), n(160, a(1)), n(159, w ^ 5), n(158, op(+, 150, 157)), n(157, op(*, 151, 156)), n(156, op(+, 152, 155)), n(155, op(*, 153, 154)), n(154, a(6)), n(153, w ^ 4), n(152, a(2)), n(151, w ^ 2), n(150, op(+, 146, 149)), n(149, op(*, 147, 148)), n(148, a(4)), n(147, w ^ 4), n(146, a(0)), n(145, op(+, 129, 144)), n(144, op(*, 130, 143)), n(143, op(+, 135, 142)), n(142, op(*, 136, 141)), n(141, op(+, 137, 140)), n(140, op(*, 138, 139)), n(139, a(7)), n(138, w ^ 0), n(137, a(3)), n(136, w ^ 0), n(135, op(+, 131, 134)), n(134, op(*, 132, 133)), n(133, a(5)), n(132, w ^ 0), n(131, a(1)), n(130, w ^ 4), n(129, op(+, 121, 128)), n(128, op(*, 122, 127)), n(127, op(+, 123, 126)), n(126, op(*, 124, 125)), n(125, a(6)), n(124, w ^ 0), n(123, a(2)), n(122, w ^ 0), n(121, op(+, 117, 120)), n(120, op(*, 118, 119)), n(119, a(4)), n(118, w ^ 0), n(117, a(0)), n(116, op(+, 100, 115)), n(115, op(*, 101, 114)), n(114, op(+, 106, 113)), n(113, op(*, 107, 112)), n(112, op(+, 108, 111)), n(111, op(*, 109, 110)), n(110, a(7)), n(109, w ^ 4), n(108, a(3)), n(107, w ^ 6), n(106, op(+, 102, 105)), n(105, op(*, 103, 104)), n(104, a(5)), n(103, w ^ 4), n(102, a(1)), n(101, w ^ 3), n(100, op(+, 92, 99)), n(99, op(*, 93, 98)), n(98, op(+, 94, 97)), n(97, op(*, 95, 96)), n(96, a(6)), n(95, w ^ 4), n(94, a(2)), n(93, w ^ 6), n(92, op(+, 88, 91)), n(91, op(*, 89, 90)), n(90, a(4)), n(89, w ^ 4), n(88, a(0)), n(87, op(+, 71, 86)), n(86, op(*, 72, 85)), n(85, op(+, 77, 84)), n(84, op(*, 78, 83)), n(83, op(+, 79, 82)), n(82, op(*, 80, 81)), n(81, a(7)), n(80, w ^ 0), n(79, a(3)), n(78, w ^ 4), n(77, op(+, 73, 76)), n(76, op(*, 74, 75)), n(75, a(5)), n(74, w ^ 0), n(73, a(1)), n(72, w ^ 2), n(71, op(+, 63, 70)), n(70, op(*, 64, 69)), n(69, op(+, 65, 68)), n(68, op(*, 66, 67)), n(67, a(6)), n(66, w ^ 0), n(65, a(2)), n(64, w ^ 4), n(63, op(+, 59, 62)), n(62, op(*, 60, 61)), n(61, a(4)), n(60, w ^ 0), n(59, a(0)), n(58, op(+, 42, 57)), n(57, op(*, 43, 56)), n(56, op(+, 48, 55)), n(55, op(*, 49, 54)), n(54, op(+, 50, 53)), n(53, op(*, 51, 52)), n(52, a(7)), n(51, w ^ 4), n(50, a(3)), n(49, w ^ 2), n(48, op(+, 44, 47)), n(47, op(*, 45, 46)), n(46, a(5)), n(45, w ^ 4), n(44, a(1)), n(43, w ^ 1), n(42, op(+, 34, 41)), n(41, op(*, 35, 40)), n(40, op(+, 36, 39)), n(39, op(*, 37, 38)), n(38, a(6)), n(37, w ^ 4), n(36, a(2)), n(35, w ^ 2), n(34, op(+, 30, 33)), n(33, op(*, 31, 32)), n(32, a(4)), n(31, w ^ 4), n(30, a(0)), n(29, op(+, 13, 28)), n(28, op(*, 14, 27)), n(27, op(+, 19, 26)), n(26, op(*, 20, 25)), n(25, op(+, 21, 24)), n(24, op(*, 22, 23)), n(23, a(7)), n(22, w ^ 0), n(21, a(3)), n(20, w ^ 0), n(19, op(+, 15, 18)), n(18, op(*, 16, 17)), n(17, a(5)), n(16, w ^ 0), n(15, a(1)), n(14, w ^ 0), n(13, op(+, 5, 12)), n(12, op(*, 6, 11)), n(11, op(+, 7, 10)), n(10, op(*, 8, 9)), n(9, a(6)), n(8, w ^ 0), n(7, a(2)), n(6, w ^ 0), n(5, op(+, 1, 4)), n(4, op(*, 2, 3)), n(3, a(4)), n(2, w ^ 0), n(1, a(0))]).
+fft([0, 1, 2, 3, 4, 5, 6, 7], [n(64, op(+, 49, 63)), n(63, op(*, 62, 52)), n(62, w ^ 7), n(61, op(+, 42, 60)), n(60, op(*, 47, 44)), n(59, op(+, 31, 58)), n(58, op(*, 57, 38)), n(57, w ^ 5), n(56, op(+, 11, 55)), n(55, op(*, 24, 21)), n(54, op(+, 49, 53)), n(53, op(*, 50, 52)), n(52, op(+, 34, 51)), n(51, op(*, 47, 36)), n(50, w ^ 3), n(49, op(+, 26, 48)), n(48, op(*, 47, 29)), n(47, w ^ 6), n(46, op(+, 42, 45)), n(45, op(*, 27, 44)), n(44, op(+, 15, 43)), n(43, op(*, 24, 19)), n(42, op(+, 5, 41)), n(41, op(*, 24, 9)), n(40, op(+, 31, 39)), n(39, op(*, 32, 38)), n(38, op(+, 34, 37)), n(37, op(*, 27, 36)), n(36, op(+, 16, 35)), n(35, op(*, 24, 17)), n(34, op(+, 12, 33)), n(33, op(*, 24, 13)), n(32, w ^ 1), n(31, op(+, 26, 30)), n(30, op(*, 27, 29)), n(29, op(+, 6, 28)), n(28, op(*, 24, 7)), n(27, w ^ 2), n(26, op(+, 1, 25)), n(25, op(*, 24, 3)), n(24, w ^ 4), n(23, op(+, 11, 22)), n(22, op(*, 2, 21)), n(21, op(+, 15, 20)), n(20, op(*, 2, 19)), n(19, op(+, 16, 18)), n(18, op(*, 2, 17)), n(17, a(7)), n(16, a(3)), n(15, op(+, 12, 14)), n(14, op(*, 2, 13)), n(13, a(5)), n(12, a(1)), n(11, op(+, 5, 10)), n(10, op(*, 2, 9)), n(9, op(+, 6, 8)), n(8, op(*, 2, 7)), n(7, a(6)), n(6, a(2)), n(5, op(+, 1, 4)), n(4, op(*, 2, 3)), n(3, a(4)), n(2, w ^ 0), n(1, a(0))]).

package/examples/sudoku.pl

@@ -1,4 +1,3 @@
-:- use_module(library(prologue), [between/3]).
 :- use_module(library(lists)).
 
 % A deterministic 9x9 Sudoku solver.
@@ -108,6 +107,7 @@ segment_unused(Cells, StartColumn, Digit) :-
   Digit \= C.
 
 set_cell(Grid, Row, Column, Digit, Result) :-
-  nth0(Row, Grid, Cells),
-  set_nth0(Column, Cells, Digit, UpdatedCells),
-  set_nth0(Row, Grid, UpdatedCells, Result).
+  nth0(Row, Grid, Cells, OtherRows),
+  nth0(Column, Cells, _Old, OtherCells),
+  nth0(Column, UpdatedCells, Digit, OtherCells),
+  nth0(Row, Result, UpdatedCells, OtherRows).

package/index.d.ts

@@ -21,6 +21,8 @@ export interface EyePrologRunOptions {
   analyzeNegation?: boolean;
   /** Restrict parsing and execution to ISO/IEC 13211-1:1995 plus Corrigenda 1-3. */
   isoStrict?: boolean;
+  /** Autoload uniquely mapped predicates from the conservative interop profile. Defaults to true outside strict ISO mode. */
+  autoload?: boolean;
   /** Initial ISO interpretation of double-quoted list notation. Defaults to chars. */
   doubleQuotes?: 'chars' | 'codes' | 'atom';
   ioOptions?: {
@@ -248,6 +250,9 @@ export const standardLibrarySources: ReadonlyMap<string, { filename: string; sou
 export const eyePrologLibraryIndicators: readonly string[];
 export const eyePrologNativeLibraryIndicators: readonly string[];
 export const eyePrologPortableLibraryIndicators: readonly string[];
+export const eyePrologInteropAutoload: Readonly<Record<string, string>>;
+export const eyePrologInteropLibraryIndicators: readonly string[];
+export const eyePrologInteropLibraryModules: readonly string[];
 export class PrologError extends Error {
   formal: string;
   culprit: EyePrologTerm | null;
@@ -326,6 +331,9 @@ declare const eyeprolog: {
   eyePrologLibraryIndicators: typeof eyePrologLibraryIndicators;
   eyePrologNativeLibraryIndicators: typeof eyePrologNativeLibraryIndicators;
   eyePrologPortableLibraryIndicators: typeof eyePrologPortableLibraryIndicators;
+  eyePrologInteropAutoload: typeof eyePrologInteropAutoload;
+  eyePrologInteropLibraryIndicators: typeof eyePrologInteropLibraryIndicators;
+  eyePrologInteropLibraryModules: typeof eyePrologInteropLibraryModules;
   run: typeof run;
   runQuads: typeof runQuads;
   whyProof: typeof whyProof;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.44",
+  "version": "1.3.1",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -50,6 +50,7 @@
     "test:eyeprolog": "node test/run-all.mjs",
     "test:conformance": "node test/run-conformance.mjs",
     "test:iso-strict": "node test/run-iso-strict.mjs",
+    "test:interop": "node test/run-interop.mjs",
     "test:wg17": "node test/run-wg17.mjs",
     "test:examples": "node test/run-examples.mjs",
     "test:regression": "node test/run-regression.mjs",

package/src/cli.js

@@ -28,6 +28,8 @@ export async function main(argv) {
     quads: false,
     stats: false,
     isoStrict: false,
+    portable: false,
+    autoload: true,
     version: false,
     warnings: false,
     goals: [],
@@ -51,6 +53,10 @@ export async function main(argv) {
       options.stats = true;
     } else if (!endOptions && arg === '--iso-strict') {
       options.isoStrict = true;
+    } else if (!endOptions && arg === '--portable') {
+      options.portable = true;
+    } else if (!endOptions && arg === '--no-autoload') {
+      options.autoload = false;
     } else if (!endOptions && (arg === '--version' || arg === '-v')) {
       options.version = true;
     } else if (!endOptions && (arg === '--warnings' || arg === '-w')) {
@@ -146,9 +152,16 @@ export async function main(argv) {
   let program = engine.Program.parseSources(sourceParts, {
     sourceMetadata: options.proof || options.isoStrict,
     isoStrict: options.isoStrict,
+    autoload: options.autoload,
+    autoloadGoals: options.goals,
   });
 
-  if (options.warnings) printWarnings(program);
+  const portabilityFailures = program.interopPortabilityWarnings ?? [];
+  if (options.warnings || (options.portable && portabilityFailures.length > 0)) printWarnings(program);
+  if (options.portable && portabilityFailures.length > 0) {
+    process.exitCode = 1;
+    return;
+  }
 
   if (!options.quads || options.goals.length > 0) await runDefault(engine, program, options);
   if (options.quads) {
@@ -263,6 +276,8 @@ Options:
   -s, --stats           Print solver and memory statistics to stderr after execution.
   --iso-strict          Use ISO/IEC 13211-1 core + Corrigenda 1-3 only;
                         reject EyeProlog language extensions and disable automatic tabling.
+  --portable            Enforce the EyeProlog/Trealla/Scryer interop profile.
+  --no-autoload         Disable conservative interop predicate autoloading.
   -v, --version         Show the package version and exit.
   -w, --warnings        Print non-fatal portability warnings to stderr.
   -g, --goal goal       Solve goal and print its ground answers; may be repeated.
@@ -284,6 +299,16 @@ function readStdin() {
 }
 
 function printWarnings(program) {
+  for (const warning of program.interopPortabilityWarnings ?? []) {
+    if (warning.kind === 'library') {
+      process.stderr.write('eyeprolog warning: non-portable library dependency\n');
+      process.stderr.write(`  library(${warning.library}) is outside the EyeProlog/Trealla/Scryer interop profile\n`);
+    } else if (warning.kind === 'predicate') {
+      process.stderr.write('eyeprolog warning: non-portable library predicate\n');
+      process.stderr.write(`  ${warning.indicator} from library(${warning.library}) is outside the interop profile\n`);
+    }
+  }
+
   const errors = program.negationStratificationErrors;
   if (errors.length === 0) return;
 

package/src/index.js

@@ -20,6 +20,9 @@ export {
   eyePrologLibraryIndicators,
   eyePrologNativeLibraryIndicators,
   eyePrologPortableLibraryIndicators,
+  eyePrologInteropAutoload,
+  eyePrologInteropLibraryIndicators,
+  eyePrologInteropLibraryModules,
 } from './standard-library.js';
 export { StreamManager } from './io.js';
 export { runQuads } from './quads.js';
@@ -39,7 +42,12 @@ export function run(source, options = {}) {
   if (source instanceof Program && requestedStrictIso && source.strictIso !== true) {
     throw new Error('strict ISO mode requires a Program parsed with isoStrict: true');
   }
-  const parseOptions = { ...options, sourceMetadata: includeWhy || requestedStrictIso };
+  const requestedGoals = options.goals ?? (options.goal == null ? [] : [options.goal]);
+  const parseOptions = {
+    ...options,
+    sourceMetadata: includeWhy || requestedStrictIso,
+    autoloadGoals: requestedGoals,
+  };
   let program = source instanceof Program ? source : Program.parse(source, parseOptions);
   const strictIso = requestedStrictIso || program.strictIso === true;
   const runOptions = strictIso

package/src/iso.js

@@ -1198,15 +1198,6 @@ function scopeReadTerm(term) {
 
 function parseReadTermText(text, solver) {
   const converted = convertedTermText(text, solver);
-  // A standalone number needs no general term parser or operator tables.
-  // Reuse the same bounded numeric scanner as number_chars/2 so stream reads
-  // and number conversion agree on every accepted numeric token. The stream
-  // scanner has already established that the final full stop is a candidate
-  // terminator; trim only ISO layout immediately before that terminator.
-  const numericText = converted.slice(0, -1).replace(/[\u0009-\u000d\u0020]+$/, '');
-  const numericTerm = parseIsoNumber(numericText);
-  if (numericTerm != null) return numericTerm;
-
   const operatorState = createParserOperatorState(solver.program.operators.values(), false);
   const clauses = parseClauses(converted, {
     sourceMetadata: false,

package/src/lib/lists.pl

@@ -1,15 +1,29 @@
 /** List relations, following the library(lists) organization used by Scryer. */
 
 :- module(lists, [
-    maplist/3,
-    append/3,
     member/2,
+    memberchk/2,
     select/3,
+    append/2,
+    append/3,
     last/2,
+    same_length/2,
     nth0/3,
+    nth0/4,
     nth1/3,
+    nth1/4,
     reverse/2,
     length/2,
+    maplist/2,
+    maplist/3,
+    maplist/4,
+    maplist/5,
+    maplist/6,
+    maplist/7,
+    maplist/8,
+    foldl/4,
+    foldl/5,
+    foldl/6,
     sum_list/2,
     min_list/2,
     max_list/2,
@@ -21,42 +35,130 @@
     slice/4
 ]).
 
+:- 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(foldl(3, '?', '?', '?')).
+:- meta_predicate(foldl(4, '?', '?', '?', '?')).
+:- meta_predicate(foldl(5, '?', '?', '?', '?', '?')).
 :- meta_predicate(countall(0, '?')).
 
 % Common pure-Prolog library predicates for EyeProlog.
 %
-% Load this module explicitly with use_module(library(lists)). The module
-% boundary keeps these widespread names separate from same-named predicates in
-% other modules.
+% The common Trealla/Scryer-facing surface can be imported explicitly with
+% use_module(library(lists)); EyeProlog may also autoload those common
+% indicators when an otherwise undefined unqualified call is encountered.
+% EyeProlog-specific helpers remain explicit and are diagnosed by --warnings.
+
+maplist(_, []).
+maplist(Closure, [A|As]) :-
+    call(Closure, A),
+    maplist(Closure, As).
 
 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).
+
+append([], []).
+append([Xs|Xss], Ys) :-
+    append(Xs, Rest, Ys),
+    append(Xss, Rest).
+
 append([], Ys, Ys).
 append([X|Xs], Ys, [X|Zs]) :- append(Xs, Ys, Zs).
 
 member(X, [X|_]).
 member(X, [_|Xs]) :- member(X, Xs).
 
+memberchk(X, Xs) :- member(X, Xs), !.
+
 select(X, [X|Xs], Xs).
 select(X, [Y|Ys], [Y|Zs]) :- select(X, Ys, Zs).
 
 last([X], X).
 last([_|Xs], X) :- last(Xs, X).
 
-nth0(0, [X|_], X).
-nth0(N, [_|Xs], X) :- var(N), nth0(N0, Xs, X), N is N0 + 1.
-nth0(N, [_|Xs], X) :- nonvar(N), N > 0, N1 is N - 1, nth0(N1, Xs, X).
+same_length([], []).
+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]) :-
+    var(N),
+    nth0(N0, Xs, Elem, Rest),
+    N is N0 + 1.
+nth0(N, [X|Xs], Elem, [X|Rest]) :-
+    nonvar(N),
+    N > 0,
+    N0 is N - 1,
+    nth0(N0, Xs, Elem, Rest).
+
+nth1(N, List, Elem) :- nth1(N, List, Elem, _).
 
-nth1(N, List, X) :- nth0(N0, List, X), N is N0 + 1.
+nth1(N, List, Elem, Rest) :-
+    N \== 0,
+    nth0(N, [_|List], Elem, [_|Rest]),
+    N \== 0.
 
 reverse(List, Reversed) :- lists__reverse(List, [], Reversed).
 
-length(List, Length) :- nonvar(List), lists__length_count(List, 0, Length).
-length(List, Length) :- var(List), integer(Length), Length >= 0, lists__length_make(Length, List).
+% Keep the common lists:length/2 relation fully relational.  In particular,
+% length(List, Length) with both arguments variable enumerates lists of
+% increasing length, as required by portable generators such as the issue #28
+% number_chars/2 stress test.
+length(List, Length) :-
+    nonvar(Length), !,
+    lists__integer(Length),
+    lists__not_less_than_zero(Length),
+    lists__length_fixed(Length, List).
+length(List, Length) :-
+    lists__length_generate(List, 0, Length).
+
+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).
 
 sum_list(List, Sum) :- lists__sum_list(List, 0, Sum).
 
@@ -93,10 +195,25 @@ slice(Start, Count, List, Slice) :-
 lists__reverse([], Acc, Acc).
 lists__reverse([X|Xs], Acc, Out) :- lists__reverse(Xs, [X|Acc], Out).
 
-lists__length_count([], N, N).
-lists__length_count([_|Xs], N0, N) :- N1 is N0 + 1, lists__length_count(Xs, N1, N).
-lists__length_make(0, []).
-lists__length_make(N, [_|Xs]) :- N > 0, N1 is N - 1, lists__length_make(N1, Xs).
+lists__length_fixed(0, []).
+lists__length_fixed(N, [_|Xs]) :-
+    N > 0,
+    N1 is N - 1,
+    lists__length_fixed(N1, Xs).
+
+lists__length_generate([], N, N).
+lists__length_generate([_|Xs], N0, N) :-
+    N1 is N0 + 1,
+    lists__length_generate(Xs, N1, N).
+
+lists__integer(X) :- integer(X), !.
+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__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).
 
 lists__sum_list([], Sum, Sum).
 lists__sum_list([X|Xs], Acc, Sum) :- Next is Acc + X, lists__sum_list(Xs, Next, Sum).