eyeprolog 1.3.7 → 1.3.9

package/README.md

@@ -189,12 +189,13 @@ noun --> [world] | [prolog].
 %% goal: phrase(sentence, Words)
 ```
 
-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
+EyeProlog also adds 126 public library predicate indicators to its 129-entry ISO
+profile. **87 are implemented entirely as ordinary Prolog clauses** in focused
+modules under `src/lib/`; the remaining 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
-`library(lists)`, `library(strings)`, `library(aggregate)`, or `library(clpz)`.
+`library(lists)`, `library(lambda)`, `library(strings)`, `library(aggregate)`, or
+`library(clpz)`.
 Portable text
 predicates use ISO atoms or character lists. The old catch-all
 `library(eyeprolog)` module is no longer needed.
@@ -207,7 +208,9 @@ 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, ...`.
+2, ...`. Open-ended generation uses the normal memory guard with recovery
+headroom, so an exhausted finite heap is reported as a catchable
+`resource_error(memory)` instead of degenerating into quadratic list checks.
 
 `library(iso_ext)` is also accepted as a common interop module name.
 EyeProlog exports `call_nth/2` there, so Scryer-style source can explicitly use
@@ -217,6 +220,24 @@ 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(lambda)` follows Scryer's higher-order lambda notation, adapted from
+Ulrich Neumerkel's permissively licensed implementation. Importing it installs
+the `+\` operator and enables closures such as `\X^Goal` and
+`Free+\X^Goal`. Parameters are supplied by `call/N`; variables not listed in
+`Free` are copied afresh for each invocation, while explicitly free variables
+remain shared. For example:
+
+```prolog
+:- use_module(library(lambda)).
+:- use_module(library(lists)).
+
+all_positive(Xs) :- maplist(\X^(X > 0), Xs).
+all_equal(Y, Xs) :- maplist(Y+\X^(X = Y), Xs).
+```
+
+The explicit import is intentional: unlike ordinary predicate autoloading, the
+lambda syntax also changes the active operator table.
+
 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

package/package.json

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

package/src/lib/lambda.pl

@@ -0,0 +1,116 @@
+/*
+    Author:        Ulrich Neumerkel
+    E-mail:        ulrich@complang.tuwien.ac.at
+    Copyright (C): 2009 Ulrich Neumerkel. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY Ulrich Neumerkel ``AS IS'' AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Ulrich Neumerkel OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation
+are those of the authors and should not be interpreted as representing
+official policies, either expressed or implied, of Ulrich Neumerkel.
+
+Adapted for EyeProlog from Scryer Prolog library(lambda):
+https://github.com/mthom/scryer-prolog/blob/master/src/lib/lambda.pl
+*/
+
+/** Lambda expressions for higher-order programming based on call/N.
+
+    Supported forms follow Scryer Prolog library(lambda):
+
+        Free+\X1^X2^...^XN^Goal
+             \X1^X2^...^XN^Goal
+
+    The second form is shorthand for a lambda with no explicitly shared free
+    variables. Variables not listed in Free are copied afresh for each call.
+*/
+
+:- module(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
+]).
+
+% Scryer exports this operator from library(lambda). EyeProlog applies module
+% operator directives while loading the library, so importing the module makes
+% the same syntax available to the importing compilation unit and REPL state.
+:- op(201, xfx, +\).
+
+:- meta_predicate(^(?, 0, ?)).
+:- meta_predicate(^(?, 1, ?, ?)).
+:- meta_predicate(^(?, 2, ?, ?, ?)).
+:- meta_predicate(^(?, 3, ?, ?, ?, ?)).
+:- meta_predicate(^(?, 4, ?, ?, ?, ?, ?)).
+:- meta_predicate(^(?, 5, ?, ?, ?, ?, ?, ?)).
+:- meta_predicate(^(?, 6, ?, ?, ?, ?, ?, ?, ?)).
+:- meta_predicate(^(?, 7, ?, ?, ?, ?, ?, ?, ?, ?)).
+:- meta_predicate(\(0)).
+:- meta_predicate(\(1, ?)).
+:- meta_predicate(\(2, ?, ?)).
+:- meta_predicate(\(3, ?, ?, ?)).
+:- meta_predicate(\(4, ?, ?, ?, ?)).
+:- meta_predicate(\(5, ?, ?, ?, ?, ?)).
+:- meta_predicate(\(6, ?, ?, ?, ?, ?, ?)).
+:- meta_predicate(\(7, ?, ?, ?, ?, ?, ?, ?)).
+:- meta_predicate(+\(?, 0)).
+:- meta_predicate(+\(?, 1, ?)).
+:- meta_predicate(+\(?, 2, ?, ?)).
+:- meta_predicate(+\(?, 3, ?, ?, ?)).
+:- meta_predicate(+\(?, 4, ?, ?, ?, ?)).
+:- meta_predicate(+\(?, 5, ?, ?, ?, ?, ?)).
+:- meta_predicate(+\(?, 6, ?, ?, ?, ?, ?, ?)).
+:- meta_predicate(+\(?, 7, ?, ?, ?, ?, ?, ?, ?)).
+
+^(V1, C0, V1) :- lambda__no_hat_call(C0).
+^(V1, C1, V1, V2) :- call(C1, V2).
+^(V1, C2, V1, V2, V3) :- call(C2, V2, V3).
+^(V1, C3, V1, V2, V3, V4) :- call(C3, V2, V3, V4).
+^(V1, C4, V1, V2, V3, V4, V5) :- call(C4, V2, V3, V4, V5).
+^(V1, C5, V1, V2, V3, V4, V5, V6) :- call(C5, V2, V3, V4, V5, V6).
+^(V1, C6, V1, V2, V3, V4, V5, V6, V7) :- call(C6, V2, V3, V4, V5, V6, V7).
+^(V1, C7, V1, V2, V3, V4, V5, V6, V7, V8) :- call(C7, V2, V3, V4, V5, V6, V7, V8).
+
+\(FC0) :- copy_term(FC0, C0), lambda__no_hat_call(C0).
+\(FC1, V1) :- copy_term(FC1, C1), call(C1, V1).
+\(FC2, V1, V2) :- copy_term(FC2, C2), call(C2, V1, V2).
+\(FC3, V1, V2, V3) :- copy_term(FC3, C3), call(C3, V1, V2, V3).
+\(FC4, V1, V2, V3, V4) :- copy_term(FC4, C4), call(C4, V1, V2, V3, V4).
+\(FC5, V1, V2, V3, V4, V5) :- copy_term(FC5, C5), call(C5, V1, V2, V3, V4, V5).
+\(FC6, V1, V2, V3, V4, V5, V6) :- copy_term(FC6, C6), call(C6, V1, V2, V3, V4, V5, V6).
+\(FC7, V1, V2, V3, V4, V5, V6, V7) :- copy_term(FC7, C7), call(C7, V1, V2, V3, V4, V5, V6, V7).
+
++\(GV, FC0) :- copy_term(GV+FC0, GV+C0), lambda__no_hat_call(C0).
++\(GV, FC1, V1) :- copy_term(GV+FC1, GV+C1), call(C1, V1).
++\(GV, FC2, V1, V2) :- copy_term(GV+FC2, GV+C2), call(C2, V1, V2).
++\(GV, FC3, V1, V2, V3) :- copy_term(GV+FC3, GV+C3), call(C3, V1, V2, V3).
++\(GV, FC4, V1, V2, V3, V4) :- copy_term(GV+FC4, GV+C4), call(C4, V1, V2, V3, V4).
++\(GV, FC5, V1, V2, V3, V4, V5) :- copy_term(GV+FC5, GV+C5), call(C5, V1, V2, V3, V4, V5).
++\(GV, FC6, V1, V2, V3, V4, V5, V6) :- copy_term(GV+FC6, GV+C6), call(C6, V1, V2, V3, V4, V5, V6).
++\(GV, FC7, V1, V2, V3, V4, V5, V6, V7) :- copy_term(GV+FC7, GV+C7), call(C7, V1, V2, V3, V4, V5, V6, V7).
+
+lambda__no_hat_call(Goal) :-
+    nonvar(Goal),
+    Goal = (_^_),
+    !,
+    throw(error(existence_error(lambda_parameter, Goal), _)).
+lambda__no_hat_call(Goal) :- call(Goal).

package/src/solver.js

@@ -17,6 +17,12 @@ import { evaluatePositiveDatalog, relationForDatalogGroup, datalogCandidateIndex
 
 let freshCounter = 0;
 const DEFAULT_INNER_TABLE_SCOPE_LIMIT = 1024;
+// Conservative live-storage estimate for one generated length/2 list cell
+// (cons object, argument vector, fresh variable, and its generated name).
+const GENERATED_LENGTH_CELL_RESERVE_BYTES = 256;
+const MAX_GENERATED_LENGTH_RESERVE_STEPS = BigInt(
+  Math.floor(Number.MAX_SAFE_INTEGER / GENERATED_LENGTH_CELL_RESERVE_BYTES),
+);
 
 function qualifyTerm(term, module) {
   if (!term || (term.type !== COMPOUND && term.type !== 'atom')) return term;
@@ -1239,13 +1245,17 @@ function* generatedLengthSolutions(solver, list, length, env) {
   let suffix = emptyList();
   for (let extra = 0n; ; extra++) {
     const next = env.clone();
-    solver.stats.unify_calls++;
-    if (unify(cursor, suffix, next)) {
-      const answer = bindGeneratedLength(solver, length, count + extra, next);
-      if (answer != null) yield answer;
-    }
+    // cursor is a dereferenced plain variable and suffix is made only from
+    // freshly generated variables, so this binding cannot create a cycle.
+    // Binding directly avoids an O(extra) occurs-check over the complete
+    // growing suffix for every answer; without this, unbounded length/2
+    // generation becomes quadratic and can spend hours before reaching the
+    // normal memory resource guard (issue #49).
+    next.bind(cursor.name, suffix);
+    const answer = bindGeneratedLength(solver, length, count + extra, next);
+    if (answer != null) yield answer;
     suffix = cons(variable(`__length${id}_${extra}`), suffix);
-    lengthAllocationCheckpoint(solver, ++steps);
+    generatedLengthAllocationCheckpoint(solver, extra + 1n);
   }
 }
 
@@ -1263,6 +1273,19 @@ function lengthAllocationCheckpoint(solver, steps) {
   if ((steps & 255n) === 0n) solver.checkMemoryLimit(true);
 }
 
+function generatedLengthAllocationCheckpoint(solver, steps) {
+  if ((steps & 255n) !== 0n) return;
+  // The open-ended generator retains its current list spine between answers.
+  // Reserve room proportional to that live spine so the protected length/2
+  // call raises resource_error(memory) before its caller's outer solver hits
+  // the same heap limit. This makes the error catchable by catch/3.
+  const estimatedSpineBytes = steps > MAX_GENERATED_LENGTH_RESERVE_STEPS
+    ? Number.MAX_SAFE_INTEGER
+    : Number(steps) * GENERATED_LENGTH_CELL_RESERVE_BYTES;
+  solver.checkMemoryReservation(estimatedSpineBytes);
+  solver.checkMemoryLimit(true);
+}
+
 function pushFastPiFrames(stack, goal, rest, env, depth, active) {
   const values = goal.args.map((arg) => deref(arg, env));
   if ([0, 1, 2, 4].some((index) => values[index].type !== 'number')) return false;

package/src/standard-library.js

@@ -13,6 +13,7 @@ const moduleFiles = Object.freeze({
   comparison: 'comparison.pl',
   dates: 'dates.pl',
   iso_ext: 'iso_ext.pl',
+  lambda: 'lambda.pl',
   lists: 'lists.pl',
   primes: 'primes.pl',
   prologue: 'prologue.pl',
@@ -68,6 +69,9 @@ export const eyePrologPortableLibraryIndicators = Object.freeze([
   'length/2', 'sum_list/2', 'min_list/2', 'max_list/2', 'list_to_set/2',
   'succ/2', 'foldl/4', 'foldl/5', 'foldl/6',
   'forall/2', 'cfor/3', 'findall/4', 'variant/2', 'uuid/3',
+  '^/3', '^/4', '^/5', '^/6', '^/7', '^/8', '^/9', '^/10',
+  '\\/1', '\\/2', '\\/3', '\\/4', '\\/5', '\\/6', '\\/7', '\\/8',
+  '+\\/2', '+\\/3', '+\\/4', '+\\/5', '+\\/6', '+\\/7', '+\\/8', '+\\/9',
 ]);
 export const eyePrologLibraryIndicators = Object.freeze([
   ...eyePrologPortableLibraryIndicators,
@@ -127,7 +131,7 @@ export const eyePrologInteropLibraryIndicators = Object.freeze(
 // Libraries whose *name* is part of the current interop profile.  A program
 // may freely use_module/1 with these common module names; predicates in those
 // modules outside eyePrologInteropLibraryIndicators are still diagnosed when used.
-export const eyePrologInteropLibraryModules = Object.freeze(['lists', 'iso_ext']);
+export const eyePrologInteropLibraryModules = Object.freeze(['lists', 'iso_ext', 'lambda']);
 
 function* tabledNegationBuiltin({ solver, goal, env }) {
   yield* solver.solveTabledNegation(goal.args[0], env);

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: () => {
@@ -3565,6 +3627,45 @@ check(A, B, C, D, E, F) :-
         }
       },
     },
+    {
+      name: 'unbounded length/2 reaches a catchable memory resource error (issue #49)',
+      run: () => {
+        const engineUrl = new URL('../src/index.js', import.meta.url).href;
+        const script = `
+          import { Program, Solver, Env, deref, variable, parseGoalText, getEyePrologRegistry } from ${JSON.stringify(engineUrl)};
+          const program = Program.parse(${JSON.stringify(':- use_module(library(lists)).\n')}, { sourceMetadata: false });
+          const solver = new Solver(program, { registry: getEyePrologRegistry() });
+          const goal = parseGoalText('catch(length(L,N),error(E,_),true),L=N', {
+            operatorDefinitions: [...program.operators.values()],
+          });
+          let answer = null;
+          for (const env of solver.solve([goal], new Env(), 0)) {
+            answer = env;
+            break;
+          }
+          if (answer == null) throw new Error('issue #49 query produced no caught answer');
+          const formal = deref(variable('E'), answer);
+          if (formal?.name !== 'resource_error' || deref(formal.args?.[0], answer)?.name !== 'memory') {
+            throw new Error('unexpected caught error: ' + JSON.stringify(formal));
+          }
+          const left = deref(variable('L'), answer);
+          const right = deref(variable('N'), answer);
+          if (left.type !== 'var' || right.type !== 'var' || left.name !== right.name) {
+            throw new Error('recovery did not leave L=N');
+          }
+          process.stdout.write('caught');
+        `;
+        const result = spawnSync(process.execPath, [
+          '--max-old-space-size=64',
+          '--input-type=module',
+          '--eval',
+          script,
+        ], { cwd: packageRoot, encoding: 'utf8', timeout: 5000 });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, `issue #49 bounded-heap child status; stderr=${result.stderr}`);
+        assertEqual(result.stdout, 'caught', 'issue #49 resource error is caught by catch/3');
+      },
+    },
     {
       name: 'discarded fixed-length lists stay compact under a bounded heap',
       run: () => {
@@ -3733,16 +3834,16 @@ check(A, B, C, D, E, F) :-
         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');

package/the-art-of-eyeprolog.md

@@ -1900,9 +1900,15 @@ unification, another list predicate, or answer readback inspects it. This is a
 storage optimization, not a distinct Prolog term or list semantics. Embedders
 that inspect the JavaScript term model can recognize this representation with
 `CompactListTerm`, `isCompactList`, and `compactListLength`, or construct one
-with `compactVariableList`. The ordinary clauses remain the authoritative module
-definition and are used unchanged by the ISO-only registry and whenever delays
-or finite-domain constraints require their normal wake-up points.
+with `compactVariableList`. For open-ended `length(List, N)` generation, the
+bundled path binds each fresh generated spine directly instead of re-running an
+occurs-check over the whole growing list. It also reserves recovery headroom
+proportional to the retained spine, so a finite heap limit is raised inside the
+`length/2` search as a catchable `resource_error(memory)` rather than allowing
+an outer solver frame to encounter the limit first. The ordinary clauses remain
+the authoritative module definition and are used unchanged by the ISO-only
+registry and whenever delays or finite-domain constraints require their normal
+wake-up points.
 
 ### Implementation boundary
 
@@ -6039,19 +6045,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
@@ -6083,6 +6089,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` |
@@ -6118,6 +6125,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