eyeprolog 1.3.0 → 1.3.1

package/README.md

@@ -138,14 +138,17 @@ predicates use ISO atoms or character lists. The old catch-all
 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`, `maplist/2-8`, and `foldl/4-6`.
+`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)` and `between/3` 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.
+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

package/package.json

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

package/src/lib/lists.pl

@@ -133,8 +133,17 @@ nth1(N, List, Elem, Rest) :-
 
 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) :-
@@ -186,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).

package/src/standard-library.js

@@ -109,6 +109,10 @@ export const eyePrologInteropAutoload = Object.freeze({
   'foldl/6': 'lists',
   'sum_list/2': 'lists',
   'list_to_set/2': 'lists',
+  // call_nth/2 is available in both Trealla and Scryer (the latter via
+  // library(iso_ext)).  EyeProlog keeps its adapter in library(prologue), so
+  // autoloading hides that implementation-specific location from source.
+  'call_nth/2': 'prologue',
   // Trealla and Scryer expose between/3 without an EyeProlog-style
   // library(prologue) dependency.  EyeProlog keeps its implementation in the
   // Prologue module but autoloads it so portable source need not name that

package/test/run-regression.mjs

@@ -2030,6 +2030,21 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'library(lists) length/2 stays relational and call_nth/2 autoloads (issue #28)',
+      run: () => {
+        const input = [
+          ':- use_module(library(lists)).',
+          '%% goal: fourth_length(N)',
+          'fourth_length(N) :- call_nth(length(_Xs, N), 4).',
+          '',
+        ].join('\n');
+        const result = runCli(['-'], { input });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, 'fourth_length(3).\n', 'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'strict ISO mode disables interop autoloading',
       run: () => {
@@ -3433,10 +3448,11 @@ check(A, B, C, D, E, F) :-
         assertEqual(Boolean(library.get('statistics', 2)), true, 'statistics/2 is an EyeProlog observability extension');
         assertEqual(registeredNativeEyePrologLibraryNames().length, 40, 'public native EyeProlog builtin count');
         assertEqual(eyePrologPortableLibraryIndicators.length, 62, 'portable Prolog library count');
-        assertEqual(eyePrologInteropLibraryIndicators.length, 26, 'cross-implementation interop profile count');
+        assertEqual(eyePrologInteropLibraryIndicators.length, 27, 'cross-implementation interop profile count');
         assertEqual(eyePrologInteropLibraryModules.join(','), 'lists', 'common explicit library module profile');
         assertEqual(eyePrologInteropAutoload['member/2'], 'lists', 'member/2 canonical autoload');
         assertEqual(eyePrologInteropAutoload['between/3'], 'prologue', 'between/3 canonical internal autoload');
+        assertEqual(eyePrologInteropAutoload['call_nth/2'], 'prologue', 'call_nth/2 canonical internal autoload');
         assertEqual(eyePrologInteropAutoload['set_nth0/4'] ?? null, null, 'EyeProlog-only set_nth0/4 is not autoloadable');
         assertEqual(eyePrologNativeLibraryIndicators.length, 40, 'native host library count');
         assertEqual(eyePrologNativeLibraryIndicators.slice(0, 2).join(','), 'call_nth/2,freeze/2', 'control predicates requiring host support');

package/the-art-of-eyeprolog.md

@@ -6037,17 +6037,21 @@ still have an API that is not shared by the other systems.
 `library(lists)` is the first aligned common module. Its interop surface includes
 `member/2`, `memberchk/2`, `select/3`, `append/2-3`, `last/2`,
 `same_length/2`, `nth0/3-4`, `nth1/3-4`, `reverse/2`, `length/2`,
-`maplist/2-8`, `foldl/4-6`, `sum_list/2`, and `list_to_set/2`. EyeProlog-only
-helpers such as `set_nth0/4`, `take/3`, `drop/3`, and `slice/4` remain available
-for compatibility but are outside this profile.
+`maplist/2-8`, `foldl/4-6`, `sum_list/2`, and `list_to_set/2`. Its `length/2`
+is fully relational: when both arguments are variables, `length(Xs, N)`
+enumerates `Xs = [], N = 0`, then one-element lists with `N = 1`, and so on.
+This generator mode is important for portable stress and enumeration programs.
+EyeProlog-only helpers such as `set_nth0/4`, `take/3`, `drop/3`, and `slice/4`
+remain available for compatibility but are outside this profile.
 
 Normal EyeProlog execution can autoload an otherwise undefined unqualified call
 only when the interop table assigns it one canonical provider. Thus `member/2`
-autoloads from `library(lists)`. `between/3` is also in the interop profile;
-EyeProlog can satisfy it from its internal `library(prologue)` implementation
-without forcing portable source to mention that EyeProlog-specific library
-name. Autoloading is disabled by `--no-autoload`, by the JavaScript option
-`autoload: false`, and always by `--iso-strict`.
+autoloads from `library(lists)`. `between/3` and `call_nth/2` are also in the
+interop profile; EyeProlog can satisfy them from its internal
+`library(prologue)` implementation without forcing portable source to mention
+that EyeProlog-specific library name. Autoloading is disabled by
+`--no-autoload`, by the JavaScript option `autoload: false`, and always by
+`--iso-strict`.
 
 `-w` / `--warnings` reports explicit non-profile library dependencies and calls
 to non-profile predicates from common libraries. `--portable` turns those