eyeprolog 1.3.4 → 1.3.8

package/test/run-regression.mjs

@@ -3307,6 +3307,68 @@ check(A, B, C, D, E, F) :-
         assertIncludes(result.stdout, 'check("ab", "a", "ab", [a - 1, b - 2], 6, "a").\n', 'stdout');
       },
     },
+    {
+      name: 'library(lambda) supports Scryer-style maplist lambdas',
+      run: () => {
+        const source = String.raw`:- use_module(library(lambda)).
+:- use_module(library(lists)).
+answer :- maplist(\X^(X>3), [4,5,9]).
+`;
+        const result = run(source, { goal: 'answer' });
+        assertEqual(result.stdout, 'answer.\n', 'stdout');
+      },
+    },
+    {
+      name: 'library(lambda) refreshes local variables on each invocation',
+      run: () => {
+        const source = String.raw`:- use_module(library(lambda)).
+:- use_module(library(lists)).
+answer :- maplist(\X^(Y=X), [a,b]).
+`;
+        const result = run(source, { goal: 'answer' });
+        assertEqual(result.stdout, 'answer.\n', 'fresh local variables');
+      },
+    },
+    {
+      name: 'library(lambda) preserves explicitly free variables with +\\',
+      run: () => {
+        const source = String.raw`:- use_module(library(lambda)).
+:- use_module(library(lists)).
+answer(Y) :- maplist(Y+\X^(Y=X), [a,a]).
+`;
+        const program = Program.parse(source);
+        const imported = [...program.operators.values()].find((operator) => operator.name === '+\\');
+        assertEqual(`${imported?.priority}/${imported?.specifier}`, '201/xfx', '+\\ operator import');
+        const result = run(program, { goal: 'answer(Y)' });
+        assertEqual(result.stdout, 'answer(a).\n', 'free variable sharing');
+      },
+    },
+    {
+      name: 'library(lambda) supports continuations and seven call arguments',
+      run: () => {
+        const source = String.raw`:- use_module(library(lambda)).
+f(x,y).
+tuple(a,b,c,d,e,f,g).
+answer(A,B) :-
+  call(\X^f(X), A, B),
+  call(\X^Y^f(X,Y), A, B),
+  call(\P^Q^R^S^T^U^V^tuple(P,Q,R,S,T,U,V), a,b,c,d,e,f,g).
+`;
+        const result = run(source, { goal: 'answer(A,B)' });
+        assertEqual(result.stdout, 'answer(x, y).\n', 'continuations');
+      },
+    },
+    {
+      name: 'library(lambda) diagnoses a missing lambda parameter',
+      run: () => {
+        const source = String.raw`:- use_module(library(lambda)).
+answer(ok) :-
+  catch(call(\X^true), error(existence_error(lambda_parameter,_),_), true).
+`;
+        const result = run(source, { goal: 'answer(X)' });
+        assertEqual(result.stdout, 'answer(ok).\n', 'lambda parameter error');
+      },
+    },
     {
       name: 'autoload metadata records canonical interop imports',
       run: () => {
@@ -3444,6 +3506,103 @@ check(A, B, C, D, E, F) :-
         assertEqual(result.stdout, '250000', 'distinct number syntax attempts');
       },
     },
+    {
+      name: 'recursive phrase tables stay bounded across distinct inputs (issues #28/#48)',
+      run: () => {
+        const engineUrl = new URL('../src/index.js', import.meta.url).href;
+        const programText = `
+          :- use_module(library(prologue)).
+          ... --> [].
+          ... --> [_], ... .
+
+          vchars("0123456789.").
+
+          ti(Nth:E:Chs, Pot, Start) :-
+            length(Chs, _),
+            call_nth(chs(Chs), Nth), Nth >= Start,
+            Nth mod 10^Pot =:= 0,
+            E = cnt.
+
+          chs(Chs) :-
+            vchars(VChs),
+            maplistch(Chs, VChs),
+            catch(number_chars(_, Chs), error(syntax_error(_), _), false),
+            \\+ phrase((..., ("//"|"++")), Chs).
+
+          maplistch([], _).
+          maplistch([Ch|Chs], VChs) :-
+            member(Ch, VChs),
+            maplistch(Chs, VChs).
+        `;
+        const script = `
+          import { Program, Solver, Env, parseGoalText, getEyePrologRegistry } from ${JSON.stringify(engineUrl)};
+          const program = Program.parse(${JSON.stringify(programText)}, { autoloadGoals: ['ti(R,3,0)'] });
+          const listTailGroup = program.findGroup('...', 2, 'user');
+          if (listTailGroup?.listTailRecursive !== true) {
+            throw new Error('recursive DCG tail-consumption was not recognized');
+          }
+          const solver = new Solver(program, { registry: getEyePrologRegistry(), maxMemoryBytes: Infinity });
+          const goal = parseGoalText('ti(R,3,0)', {
+            doubleQuotes: 'chars',
+            operatorDefinitions: [...program.operators.values()],
+          });
+          let count = 0;
+          for (const _ of solver.solve([goal], new Env(), 0)) {
+            if (++count === 20) break;
+          }
+          if (count !== 20) throw new Error('unexpected checkpoint count: ' + count);
+          const scope = solver.innerTableScopes.get('phrase');
+          if (scope == null) throw new Error('missing phrase table scope');
+          if (scope.memo.size !== 0) throw new Error('distinct tail-DCG inputs should not retain phrase tables: ' + scope.memo.size);
+          process.stdout.write(count + ':' + scope.memo.size);
+        `;
+        const result = spawnSync(process.execPath, [
+          // This corresponds to 20,000 accepted number candidates. Before the
+          // phrase-local cache, every distinct recursive DCG tail stayed rooted
+          // in the caller memo and this workload exhausted a 32 MiB old space.
+          '--max-old-space-size=32',
+          '--input-type=module',
+          '--eval',
+          script,
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 30000 });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `bounded phrase-table child status; stderr=${result.stderr}`);
+        const [countText, cacheText] = result.stdout.trim().split(':');
+        assertEqual(countText, '20', 'recursive phrase checkpoints');
+        assertEqual(cacheText, '0', 'distinct tail-DCG phrase cache');
+      },
+    },
+    {
+      name: 'repeated identical phrase invocation reuses a compact table (issue #48)',
+      run: () => {
+        const program = Program.parse(`
+          :- use_module(library(prologue)).
+          ... --> [].
+          ... --> [_], ... .
+        `, { autoloadGoals: ['phrase((...,("ba"|"gh")),"abcdef")'] });
+        const solver = new Solver(program, { registry: getEyePrologRegistry(), maxMemoryBytes: Infinity });
+        const goal = parseGoalText('phrase((...,("ba"|"gh")),"abcdef")', {
+          doubleQuotes: 'chars',
+          operatorDefinitions: [...program.operators.values()],
+        });
+        const runFailure = () => {
+          let answers = 0;
+          for (const _ of solver.solve([goal], new Env(), 0)) answers++;
+          assertEqual(answers, 0, 'failing phrase answer count');
+        };
+        runFailure();
+        assertEqual(solver.stats.table_fixpoint_rounds, 0, 'first distinct tail-DCG invocation stays untabled');
+        runFailure();
+        const roundsAfterSecond = solver.stats.table_fixpoint_rounds;
+        if (roundsAfterSecond <= 0) throw new Error('repeated phrase invocation did not build reusable table');
+        const scope = solver.innerTableScopes.get('phrase');
+        if (scope == null || scope.memo.size <= 0 || scope.memo.size > 1024) {
+          throw new Error('unexpected repeated phrase table size: ' + (scope?.memo.size ?? 'missing'));
+        }
+        runFailure();
+        assertEqual(solver.stats.table_fixpoint_rounds, roundsAfterSecond, 'third identical phrase call reuses completed table');
+      },
+    },
     {
       name: 'host Map/Set capacity errors become resource_error(memory)',
       run: () => {
@@ -3626,24 +3785,26 @@ check(A, B, C, D, E, F) :-
         assertEqual(Boolean(registry.get('is', 2)), true, 'ISO is/2 exists');
         assertEqual(Boolean(registry.get('append', 3)), false, 'append/3 is not ISO core');
         assertEqual(library.eyePrologLibrary, true, 'complete registry marker');
-        assertEqual(library.defs.size, 155, 'EyeProlog registry contains ISO definitions, observability extensions, and private library adapters');
+        assertEqual(library.defs.size, 156, 'EyeProlog registry contains ISO definitions, observability extensions, WFS tnot/1, and private library adapters');
         assertEqual(Boolean(registry.get('phrase', 2)), true, 'Part 3 phrase/2 exists');
         assertEqual(Boolean(registry.get('phrase', 3)), true, 'Part 3 phrase/3 exists');
         assertEqual(registry.get('statistics', 0), null, 'statistics/0 is absent from the ISO registry');
         assertEqual(registry.get('statistics', 2), null, 'statistics/2 is absent from the ISO registry');
         assertEqual(Boolean(library.get('statistics', 0)), true, 'statistics/0 is an EyeProlog observability extension');
         assertEqual(Boolean(library.get('statistics', 2)), true, 'statistics/2 is an EyeProlog observability extension');
+        assertEqual(registry.get('tnot', 1), null, 'tnot/1 is absent from the ISO registry');
+        assertEqual(Boolean(library.get('tnot', 1)), true, 'tnot/1 is an EyeProlog WFS extension');
         assertEqual(registeredNativeEyePrologLibraryNames().length, 40, 'public native EyeProlog builtin count');
-        assertEqual(eyePrologPortableLibraryIndicators.length, 62, 'portable Prolog library count');
+        assertEqual(eyePrologPortableLibraryIndicators.length, 86, 'portable Prolog library count');
         assertEqual(eyePrologInteropLibraryIndicators.length, 27, 'cross-implementation interop profile count');
-        assertEqual(eyePrologInteropLibraryModules.join(','), 'lists,iso_ext', 'common explicit library module profile');
+        assertEqual(eyePrologInteropLibraryModules.join(','), 'lists,iso_ext,lambda', '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'], 'iso_ext', 'call_nth/2 canonical interop 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');
-        assertEqual(eyePrologLibraryIndicators.length, 102, 'complete EyeProlog library surface');
+        assertEqual(eyePrologLibraryIndicators.length, 126, 'complete EyeProlog library surface');
         assertEqual(registry.get('eyeprolog__call_nth', 2), null, 'private call_nth adapter is absent from ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__call_nth', 2)), true, 'private call_nth adapter is registered for EyeProlog');
         assertEqual(library.get('eyeprolog__call_nth', 2)?.eyePrologLibrary, true, 'private adapter is marked as library support');
@@ -4266,6 +4427,94 @@ function whiteBoxCases() {
         assertEqual(program.findGroup('q', 1).tabled, false, 'q/1 not positively tabled');
       },
     },
+    {
+      name: 'large finite Datalog uses an indexed least model only for broad calls',
+      run: () => {
+        const edges = Array.from({ length: 130 }, (_, i) => `edge(n${i}, n${i + 1}).`).join('\n');
+        const source = `${edges}\npath(X,Y) :- edge(X,Y).\npath(X,Y) :- edge(X,Z), path(Z,Y).\n`;
+        const program = Program.parse(source);
+        const group = program.findGroup('path', 2);
+        assertEqual(group.datalogLeastModel, true, 'large range-restricted Datalog is eligible');
+
+        const broad = run(program, { goal: 'path(X,Y)' });
+        assertEqual(broad.stdout.trim().split('\n').length, 8515, 'semi-naive closure has every chain pair');
+        assertEqual(broad.stats.datalog_evaluations, 1, 'broad query builds one least model');
+
+        const ground = run(program, { goal: 'path(n0,n130)' });
+        assertEqual(ground.stdout, 'path(n0, n130).\n', 'ground chain still succeeds');
+        assertEqual(ground.stats.datalog_evaluations, 0, 'ground query keeps the ordinary indexed chain path');
+      },
+    },
+    {
+      name: 'findall length counting preserves multiplicity and observable bags',
+      run: () => {
+        const source = `
+p(a).
+p(b).
+q(X) :- p(X).
+q(X) :- p(X).
+bench(N) :- findall(X, q(X), Bag), length(Bag, N).
+collect(Bag,N) :- findall(X, q(X), Bag), length(Bag, N).
+`;
+        assertEqual(run(source, { goal: 'bench(N)' }).stdout, 'bench(4).\n', 'dead bag counts all four proof solutions');
+        assertEqual(run(source, { goal: 'collect(Bag,N)' }).stdout, 'collect("abab", 4).\n', 'bag exposed through the rule head is materialized');
+      },
+    },
+    {
+      name: 'ground negation probes a complete positive Datalog model',
+      run: () => {
+        const edges = Array.from({ length: 130 }, (_, i) => `edge(n${i}, n${i + 1}).`).join('\n');
+        const source = `${edges}
+path(X,Y) :- edge(X,Y).
+path(X,Y) :- edge(X,Z), path(Z,Y).
+blocked(X,Y) :- path(X,Y).
+candidate(n0,n130).
+candidate(n130,n0).
+keep(X,Y) :- candidate(X,Y), \\+ blocked(X,Y).
+`;
+        const result = run(source, { goal: 'keep(X,Y)' });
+        assertEqual(result.stdout, 'keep(n130, n0).\n', 'negation sees the complete transitive closure');
+        assertEqual(result.stats.datalog_evaluations, 1, 'ground truth probe reuses one complete least model');
+      },
+    },
+    {
+      name: 'tnot enables finite Datalog well-founded semantics without changing ISO negation',
+      run: () => {
+        const program = Program.parse(`
+move(1, 2).
+move(2, 3).
+move(3, 4).
+move(4, 1).
+win(X) :- move(X, Y), tnot(win(Y)).
+`);
+        assertEqual(program.findGroup('win', 1).wfsDatalog, true, 'win/1 uses finite WFS evaluation');
+        assertEqual(program.findGroup('win', 1).tabled, false, 'win/1 is not positive least-model tabled');
+        const result = run(program, { goal: 'win(X)' });
+        assertEqual(result.stdout.trim().split('\n').length, 4, 'negative cycle yields four conditional WFS answers');
+        assertEqual(result.stats.wfs_fixpoint_rounds, 2, 'alternating fixed point converges in two rounds');
+        assertEqual(result.stats.wfs_undefined_answers, 4, 'cycle answers are undefined rather than unconditional truths');
+
+        const nafProgram = Program.parse('p(X) :- \\+ q(X).\nq(X) :- p(X).\n');
+        assertEqual(nafProgram.findGroup('p', 1).wfsDatalog, false, '\\+/1 remains ordinary negation as failure');
+      },
+    },
+    {
+      name: 'finite WFS distinguishes true false and undefined for ground tnot calls',
+      run: () => {
+        const source = `
+move(a, b).
+move(c, d).
+move(d, c).
+win(X) :- move(X, Y), tnot(win(Y)).
+true_case :- win(a).
+false_case :- tnot(win(a)).
+undefined_case :- tnot(win(c)).
+`;
+        assertEqual(run(source, { goal: 'true_case' }).stdout, 'true_case.\n', 'win(a) is true because b is false');
+        assertEqual(run(source, { goal: 'false_case' }).stdout, '', 'tnot(win(a)) fails for a true atom');
+        assertEqual(run(source, { goal: 'undefined_case' }).stdout, 'undefined_case.\n', 'tnot of an undefined WFS atom is a conditional success');
+      },
+    },
     {
       name: 'cyclic tabling reaches a complete fixed point',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -1121,13 +1121,36 @@ particular user is unblocked.
   <figcaption>Absence becomes informative only inside a declared complete boundary: Clara is allowed because the event registry is complete and she is not on its blocked list.</figcaption>
 </figure>
 
-Negative dependencies should be stratified: compute a lower relation, then
-negate it from a higher layer. Use `--warnings` to report negative recursion:
+For ordinary `\+/1`, negative dependencies should normally be stratified:
+compute a lower relation, then negate it from a higher layer. Use `--warnings`
+to report negative recursion:
 
 ```sh
 eyeprolog --warnings program.pl
 ```
 
+Some finite rule systems intentionally contain recursion through negation. In
+normal mode, EyeProlog provides explicit `tnot/1` for that case. When the
+reachable component is finite, function-free, and range-restricted Datalog,
+cycles through `tnot/1` are evaluated with the well-founded semantics (WFS)
+rather than ordinary negation-as-failure. WFS has three truth states: true,
+false, and undefined. A negative cycle may therefore produce a conditional
+answer instead of forcing an arbitrary true/false choice.
+
+```eyeprolog
+move(a, b).
+move(b, a).
+win(X) :- move(X, Y), tnot(win(Y)).
+```
+
+Here neither `win(a)` nor `win(b)` is unconditionally established; both belong
+to the undefined part of the well-founded model. EyeProlog exposes undefined
+WFS answers as conditional successes, including inside finite collectors.
+Direct calls to `tnot/1` must be ground. In WFS rules, variables occurring in
+the head or a negated literal must be range-restricted by positive body
+literals. Ordinary `\+/1` is unchanged, and strict ISO mode does not provide
+`tnot/1`.
+
 Universal checking needs no extension predicate: define the counterexample and
 negate it.
 
@@ -1574,9 +1597,20 @@ analysis, and other recursive relations with overlapping subproblems.
 
 Ordinary goals use indexed depth-first resolution. Positive recursive groups
 are tabled automatically. Bound recursive calls reuse answers and cyclic calls
-iterate toward a fixed point. Fully open or structurally unbounded calls may
-retain ordinary resolution. Recursive components with negative dependencies
-are not positive fixed points.
+iterate toward a fixed point. For sufficiently large finite, function-free
+Datalog dependency cones, EyeProlog may share one most-general relation table
+across call variants. This turns an open closure such as `tc(X, Y)` into one
+finite relation computation rather than many overlapping bound subcomputations;
+bound consumers can then use indexes over the stored answers. The exact
+admission policy is an engine optimization, not part of the language contract.
+Fully open or structurally unbounded recursive programs may retain ordinary
+resolution.
+
+Recursive components with negative dependencies are not positive least-fixed-
+point problems. When such a component uses explicit `tnot/1` and satisfies the
+finite, range-restricted, function-free Datalog restrictions, EyeProlog instead
+computes the alternating fixed point of the well-founded semantics. Existing
+`\+/1` code remains ordinary negation-as-failure.
 
 ### Deeper implementation: how clause indexing stays semantic
 
@@ -1612,8 +1646,12 @@ eyeprolog --stats examples/observability-log-correlation.pl
 The reported counters include completed goal lists, calls to the goal solver
 and single-goal solver, unification attempts, maximum depth and goal-list size,
 deterministic built-in successes and failures, and table fixed-point rounds.
-They describe work performed, not logical truth. Compare counters only across
-equivalent queries and the same implementation version.
+WFS execution additionally reports `wfs_fixpoint_rounds` and
+`wfs_undefined_answers`. The latter counts undefined-answer observations made
+while producing query results; it is an execution statistic, not a declaration
+that those atoms are true. All statistics describe work performed, not logical
+truth. Compare counters only across equivalent queries and the same
+implementation version.
 
 Common sources of nontermination are recursive calls made before constraints,
 ever-growing terms, infinite open mathematical queries, negative cycles, and
@@ -1947,6 +1985,8 @@ Part III moved from obtaining answers to trusting them:
 - a query selects a question; a proof records one successful justification;
 - an explicit integrity query identifies input that a host may reject;
 - automatic tabling computes fixed points for eligible positive recursion;
+- explicit `tnot/1` gives eligible finite Datalog components well-founded,
+  three-valued negation without changing ordinary `\+/1`;
 - indexing and ready filters improve control without changing intended meaning;
 - knowledge engineering separates sources, concepts, decisions, and reasons;
 - explicit host boundaries divide input validation from logical derivation;
@@ -1965,7 +2005,10 @@ turned fixed-point ideas into a goal-directed technique that shares recursive
 calls and accumulates answers. EyeProlog's automatic positive tabling is smaller
 than the general systems in that literature, but inherits their central
 insight: remembering a recursive question can change termination without
-changing what the relation says.
+changing what the relation says. For finite Datalog with recursion through
+explicit `tnot/1`, EyeProlog also uses the alternating-fixed-point account of
+the well-founded semantics so a negative cycle may remain undefined instead of
+being collapsed into ordinary negation-as-failure.
 
 In parallel, deductive databases asked where facts come from and how derived
 claims retain provenance. EyeProlog adopts the expectation that conclusions
@@ -3556,6 +3599,25 @@ component grows monotonically with newly discovered answers until no rule adds
 another. The implementation is performing a local, demand-driven fixed-point
 calculation.
 
+There is an important lifetime distinction between a table that is needed to
+finish one fixed point and a cache of tables retained for possible later reuse.
+For recursive grammars invoked through `phrase/2-3`, EyeProlog uses a separate
+invocation-keyed table scope rather than the caller's general table map. Static
+analysis also recognizes the normalized DCG form of strict list-tail recursion
+(for example `... --> [_], ...`). On a new input, such a grammar runs directly
+without automatic tabling because every recursive call consumes the input and
+there is no fixed-point cycle to close. This prevents a stream of distinct
+sequences from constructing a useless suffix-table family for every input.
+
+The optimization is deliberately asymmetric. If the same `phrase/2-3`
+invocation repeats, normal tabling is allowed again so the compact completed
+table from that invocation can serve subsequent repetitions. That is useful for
+workloads that probe one grammar/input many thousands of times. Only one
+invocation signature is retained in the phrase scope, completed entries are
+still subject to a bound, and active fixed points are never evicted. Thus the
+policy limits cross-call retention without turning each distinct input into an
+O(cache-size) eviction pass or changing the declarative answers.
+
 **Exercises.**
 
 1. Run the triple program with one, two, and three arguments bound. Compare the
@@ -5977,19 +6039,19 @@ so side effects occur in Prolog execution order.
 
 ### The EyeProlog library
 
-EyeProlog exposes **102 library predicate indicators** in addition to the 129
-indicators in its isolated ISO profile. **63 are defined as ordinary Prolog
+EyeProlog exposes **126 library predicate indicators** in addition to the 129
+indicators in its isolated ISO profile. **87 are defined as ordinary Prolog
 clauses** in focused modules under `src/lib/`. The remaining 39
 are public wrappers around backtrackable host support: Prologue `call_nth/2` and
 `freeze/2`, plus the 37-predicate finite-domain `library(clpz)` kernel. The
-resulting normal EyeProlog language surface is therefore **228 public predicate
+resulting normal EyeProlog language surface is therefore **255 public predicate
 indicators**. Internally, the runtime registry contains the 129 ISO definitions
 plus 23 private library adapters; public relations remain module source clauses.
 
 The sources are `src/lib/aggregate.pl`, `src/lib/clpz.pl`, `src/lib/comparison.pl`,
-`src/lib/dates.pl`, `src/lib/iso_ext.pl`, `src/lib/lists.pl`,
-`src/lib/primes.pl`, `src/lib/prologue.pl`, `src/lib/random.pl`,
-`src/lib/strings.pl`, and `src/lib/uuid.pl`. Each declares a same-named module
+`src/lib/dates.pl`, `src/lib/iso_ext.pl`, `src/lib/lambda.pl`,
+`src/lib/lists.pl`, `src/lib/primes.pl`, `src/lib/prologue.pl`,
+`src/lib/random.pl`, `src/lib/strings.pl`, and `src/lib/uuid.pl`. Each declares a same-named module
 with `module/2`; there is no catch-all `library(eyeprolog)`. A program imports
 only the modules it needs, and
 `use_module/2` can select an even smaller indicator list. The Prologue
@@ -6021,6 +6083,7 @@ between solution branches.
 | `library(comparison)` | `lt/2`, `gt/2`, `le/2`, `ge/2` |
 | `library(dates)` | `difference/3` |
 | `library(iso_ext)` | `call_nth/2`, `countall/2`, `forall/2`, `succ/2`, `cfor/3`, `findall/4`, `variant/2` |
+| `library(lambda)` | `^/3`, `^/4`, `^/5`, `^/6`, `^/7`, `^/8`, `^/9`, `^/10`, `\/1`, `\/2`, `\/3`, `\/4`, `\/5`, `\/6`, `\/7`, `\/8`, `+\/2`, `+\/3`, `+\/4`, `+\/5`, `+\/6`, `+\/7`, `+\/8`, `+\/9` |
 | `library(lists)` | `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`, `list_to_set/2`, `set_nth0/4`, `take/3`, `drop/3`, `slice/4` |
 | `library(primes)` | `smallest_divisor_from/3` |
 | `library(prologue)` | `member/2`, `append/3`, `length/2`, `between/3`, `select/3`, `succ/2`, `maplist/2`, `maplist/3`, `maplist/4`, `maplist/5`, `maplist/6`, `maplist/7`, `maplist/8`, `nth0/3`, `nth0/4`, `nth1/3`, `nth1/4`, `call_nth/2`, `freeze/2`, `foldl/4`, `foldl/5`, `foldl/6`, `countall/2` |
@@ -6056,6 +6119,39 @@ so a source file may import both without an accidental predicate collision.
 overlap these modules; use selective imports when legacy code combines it with
 the aligned libraries.
 
+`library(lambda)` is an explicitly imported Scryer-aligned module for
+higher-order programming. Its implementation is adapted from Ulrich Neumerkel's
+`library(lambda)` as distributed by Scryer Prolog, retaining the upstream
+copyright and redistribution notice. The public syntax is:
+
+```text
+\X1^X2^...^XN^Goal
+Free+\X1^X2^...^XN^Goal
+```
+
+The first form has no explicitly shared free variables. Before each invocation
+EyeProlog copies the closure term, so local variables are fresh on successive
+`maplist/2-8`, `foldl/4-6`, or direct `call/N` uses. In the second form, the
+variables contained in `Free` remain shared with the surrounding goal. Importing
+the library installs `+\` as a priority-201 `xfx` operator; `\` and `^` use
+their existing ISO operator definitions. Parenthesize lower-priority goal
+operators after `^`, for example `\X^(X > 3)`.
+
+A continuation lambda may leave arguments for a later call:
+
+```text
+f(x, y).
+
+answer(A, B) :- call(\X^f(X), A, B).
+```
+
+This is equivalent to supplying both arguments directly. A lambda that is
+called with too few parameters raises `existence_error(lambda_parameter, ...)`,
+matching the diagnostic intent of the Scryer library. EyeProlog uses its ISO
+`copy_term/2` implementation for the fresh-copy step; in EyeProlog this gives
+the natural-copy behavior needed by the library without requiring a separate
+`copy_term_nat/2` predicate.
+
 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)`, `call_nth/2` from `library(iso_ext)`, and

package/why-eyeprolog.md

@@ -31,6 +31,8 @@ keeps a narrow architecture:
 
 - one parser and term model;
 - one solver with automatic tabling for eligible positive recursion;
+- explicit `tnot/1` with well-founded semantics for finite, range-restricted,
+  function-free Datalog components;
 - the ISO built-in registry;
 - lean portable ISO Part 2 library modules;
 - ISO Part 3 definite clause grammars and `phrase/2-3`;
@@ -43,6 +45,21 @@ relations such as list processing remain ordinary Prolog clauses imported with
 standard sorting, arithmetic, meta-calls, streams, and database operations use
 their ISO definitions directly.
 
+
+## Why keep well-founded negation explicit?
+
+Ordinary Prolog `\+/1` is negation-as-failure and remains useful when a closed,
+usually stratified relation has already been computed. Non-stratified rule
+systems need a different semantic choice. EyeProlog therefore does not silently
+change `\+/1`; normal mode provides `tnot/1` for finite Datalog components that
+need the three-valued well-founded semantics. This keeps the extension visible
+in source code and lets strict ISO mode remove it cleanly.
+
+The same boundary guides performance work. EyeProlog may evaluate large finite
+positive Datalog closures with a shared relation-wide table, but the admission
+heuristics are implementation details. Programs should rely on the documented
+semantics and finiteness conditions, not on a particular internal threshold.
+
 ## Why proofs?
 
 An answer says that a goal succeeded. A proof records one successful route