eyeprolog 1.3.7 → 1.3.8

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.
@@ -217,6 +218,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.8",
   "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/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: () => {
@@ -3733,16 +3795,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

@@ -6039,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
@@ -6083,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` |
@@ -6118,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