eyeprolog 1.5.68 → 1.5.70

package/package.json

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

package/src/lib/error.pl

@@ -55,6 +55,7 @@ error__must_be(acyclic, Term) :- !,
 error__must_be(list, Term) :- !,
     error__list(Term, Term, must_be/2, complete).
 error__must_be(list(Type), Term) :- !,
+    error__require_type(Type, must_be/2),
     error__list(Term, Term, must_be/2, complete),
     error__proper_list_of(Term, Type).
 error__must_be(character, Term) :- !,
@@ -75,10 +76,30 @@ error__must_be(pair, Term) :- !,
 error__must_be(not_less_than_zero, Term) :- !,
     must_be(integer, Term),
     ( Term >= 0 -> true ; domain_error(not_less_than_zero, Term) ).
-error__must_be(Type, Term) :-
-    ( var(Term) -> error__must_be_throw(instantiation_error)
-    ; error__must_be_throw(type_error(Type, Term))
-    ).
+error__must_be(Type, _) :-
+    error__must_be_throw(type_error(type, Type)).
+
+% Check the type descriptor before accepting a variable or an empty list.
+% The variable guard also prevents validation from instantiating a descriptor.
+error__require_type(Type, Predicate) :- var(Type), !,
+    throw(error(instantiation_error, [predicate-Predicate])).
+error__require_type(list(Type), Predicate) :- !,
+    error__require_type(Type, Predicate).
+error__require_type(Type, Predicate) :-
+    ( error__known_type(Type) -> true
+    ; throw(error(type_error(type, Type), [predicate-Predicate])) ).
+
+error__known_type(integer).
+error__known_type(atom).
+error__known_type(number).
+error__known_type(var).
+error__known_type(ground).
+error__known_type(acyclic).
+error__known_type(list).
+error__known_type(character).
+error__known_type(chars).
+error__known_type(pair).
+error__known_type(not_less_than_zero).
 
 % A list ends in []; a partial list ends in a variable (including a variable
 % alone). Inspect before matching so validation never completes a partial list.
@@ -102,8 +123,8 @@ error__proper_list_of(Term, _) :-
     ).
 
 can_be(Type, Term) :-
-    ( var(Type) -> error__can_be_throw(instantiation_error)
-    ; var(Term) -> true
+    error__require_type(Type, can_be/2),
+    ( var(Term) -> true
     ; error__can_be(Type, Term)
     ).
 

package/src/solver.js

@@ -838,6 +838,16 @@ export class Solver {
           continue;
         }
 
+        const appendIterator = bundledAppendIterator(this, group, goal, env);
+        if (appendIterator != null) {
+          const firstResult = appendIterator.next();
+          if (firstResult.done) break;
+          goals = rest;
+          env = firstResult.value;
+          depth++;
+          continue;
+        }
+
         const comparisonIterator = bundledCompareSiIterator(this, group, goal, env);
         if (comparisonIterator != null) {
           const firstResult = comparisonIterator.next();
@@ -1896,6 +1906,44 @@ function* bundledBetweenSolutions(solver, goal, env, state) {
   state.pending = false;
 }
 
+function bundledAppendIterator(solver, group, goal, env) {
+  if (solver.registry.eyePrologLibrary !== true || group.bundledLibrary !== true ||
+      group.module !== 'lists' || group.name !== 'append' || group.arity !== 3 ||
+      group.tabled || group.clauses.length !== 2) return null;
+  // Preserve source-defined hook ordering and occurs-check diagnostics. Only
+  // forward construction with a plain, unbound result is specialized.
+  if (env._prologAttributes != null || env._delays != null ||
+      solver.prologFlags.get('occurs_check')?.value?.name === 'error' ||
+      deref(goal.args[2], env).type !== VAR) return null;
+
+  const items = [];
+  const seen = new Set();
+  let cursor = deref(goal.args[0], env);
+  while (isCons(cursor)) {
+    if (seen.has(cursor)) return null;
+    seen.add(cursor);
+    items.push(cursor.args[0]);
+    if ((items.length & 255) === 0) solver.checkMemoryLimit(true);
+    cursor = deref(cursor.args[1], env);
+  }
+  if (!isEmptyList(cursor)) return null;
+  return bundledAppendSolutions(solver, goal, env, items);
+}
+
+function* bundledAppendSolutions(solver, goal, env, items) {
+  // Copy just the prefix spine, preserving its variables and sharing the
+  // suffix. One normal, occurs-checked unification replaces repeated clause
+  // freshening and scans over every remaining variable-list suffix.
+  let joined = goal.args[1];
+  for (let i = items.length - 1; i >= 0; i--) {
+    joined = cons(items[i], joined);
+    if ((i & 255) === 0) solver.checkMemoryLimit(true);
+  }
+  const next = env.clone();
+  solver.stats.unify_calls++;
+  if (unify(goal.args[2], joined, next)) yield next;
+}
+
 function bundledMemberIterator(solver, group, goal, env) {
   if (solver.registry.eyePrologLibrary !== true ||
       group.module !== 'lists' || group.name !== 'member' || group.arity !== 2 ||

package/test/regression/cases-regression.mjs

@@ -28,6 +28,89 @@ import {
 
 export function regressionCases() {
   return [
+    {
+      name: 'must_be/2 and can_be/2 reject invalid type descriptors before checking values (issue #106)',
+      run: () => {
+        for (const predicate of ['must_be', 'can_be']) {
+          for (const type of ['nontype', '42', 'foo(integer)', 'list(nontype)', 'list(list(nontype))']) {
+            const culprit = type.startsWith('list(') ? 'nontype' : type;
+            for (const value of ['0', 'X', '[]']) {
+              const result = runEyeProlog(`answer(ok) :- catch((${predicate}(${type},${value}),fail),error(type_error(type,${culprit}),[predicate-${predicate}/2]),true),var(X).`, { goals: ['answer(X)'] });
+              assertIncludes(result.stdout, 'answer(ok)', `${predicate}(${type},${value})`);
+            }
+          }
+          for (const type of ['T', 'list(T)', 'list(list(T))']) {
+            const result = runEyeProlog(`answer(ok) :- catch((${predicate}(${type},[]),fail),error(instantiation_error,[predicate-${predicate}/2]),true),var(T).`, { goals: ['answer(X)'] });
+            assertIncludes(result.stdout, 'answer(ok)', `${predicate}(${type},[])`);
+          }
+        }
+        const valid = [
+          ['integer', '1'], ['atom', 'a'], ['number', '1.5'], ['var', 'X'],
+          ['ground', 'f(a)'], ['acyclic', 'f(X)'], ['list', '[X]'],
+          ['character', 'a'], ['chars', '[a,b]'], ['pair', 'a-b'],
+          ['not_less_than_zero', '0'], ['list(integer)', '[1,2]'],
+          ['list(list(integer))', '[[1],[]]'],
+        ];
+        for (const [type, value] of valid) {
+          const result = runEyeProlog(`answer(ok) :- must_be(${type},${value}),can_be(${type},${value}),can_be(${type},Fresh),var(Fresh).`, { goals: ['answer(X)'] });
+          assertIncludes(result.stdout, 'answer(ok)', `supported type ${type}`);
+        }
+        const context = runEyeProlog('answer(ok) :- catch((call_with_error_context(can_be(nontype,X),outer-1),fail),error(type_error(type,nontype),[outer-1,predicate-can_be/2]),true),var(X).', { goals: ['answer(X)'] });
+        assertIncludes(context.stdout, 'answer(ok)', 'composable error context');
+      },
+    },
+    {
+      name: 'forward bundled append/3 matches the portable relation across sharing and fallback modes',
+      run: () => {
+        const goals = [
+          'append([],Y,Z),Y=tail',
+          'append([X,Y],[Y,X],Z),X=a,Y=b',
+          'append([X],T,Z),T=[X|Rest],Rest=tail',
+          'append([a,b],tail,Z)',
+          'append([X],[],X)',
+          'append([a],Z,Z)',
+          'append([X],[],Z),X=Z',
+          'append([a],T,Z),T=Z',
+          'append([a],[],[b])',
+          'append([a|T],[b],[a,c,b])',
+          'append([a|bad],[],Z)',
+          'append(X,Y,[a,b])',
+          '(append([a],[],Z);append([b],[],Z))',
+          'freeze(X,Y=woke),append([X],[],Z),X=a',
+          'dif(X,a),append([X],[],Z),X=b',
+          'set_prolog_flag(occurs_check,error),catch(append([X],[],X),error(E,_),true)',
+        ];
+        for (const goal of goals) {
+          const source = `answer(X,Y,Z,T,Rest,E) :- ${goal}.`;
+          const options = { goals: ['answer(X,Y,Z,T,Rest,E)'] };
+          const optimized = runEyeProlog(source, options);
+          const portable = runEyeProlog(
+            'portable_append([],Ys,Ys). portable_append([X|Xs],Ys,[X|Zs]) :- portable_append(Xs,Ys,Zs).\n' +
+            source.replaceAll('append(', 'portable_append('), options);
+          assertEqual(optimized.stdout, portable.stdout, goal);
+          assertEqual(optimized.stderr, portable.stderr, `${goal} diagnostics`);
+        }
+        const custom = runEyeProlog('append(custom,_,ok).', { goals: ['append(custom,[],Z)'] });
+        assertIncludes(custom.stdout, 'append(custom, [], ok)', 'user definition');
+      },
+    },
+    {
+      name: 'forward append/3 constructs long shared-variable lists within a bounded heap and time',
+      run: () => {
+        const script = `
+          import {run} from './src/index.js';
+          const result=run('answer(ok) :- length(P,8192),append(P,[1],L1),append(P,[2],L2),compare(R,L1,L2),compare_si(S,L1,L2),R==(<),S==(<).', {goals:['answer(X)']});
+          if (!result.stdout.includes('answer(ok)')) throw new Error(result.stdout+'\\n'+result.stderr);
+          console.log('ok');
+        `;
+        const result = spawnSync(process.execPath, ['--max-old-space-size=128', '--stack-size=256', '--input-type=module', '--eval', script], {
+          cwd: packageRoot, encoding: 'utf8', timeout: 10000,
+        });
+        if (result.error) throw result.error;
+        assertEqual(result.status, 0, result.stderr);
+        assertIncludes(result.stdout, 'ok', 'long forward append');
+      },
+    },
     {
       name: 'autoload follows declared meta-predicates and closure arities (issue #105)',
       run: () => {
@@ -114,8 +197,12 @@ export function regressionCases() {
     {
       name: 'REPL prints the complete 8192-cell timed comparison answer (issue #105)',
       run: () => {
+        // Keep the large variable-list answer that overflowed REPL printing,
+        // but prepend the differing elements to avoid expensive append/3 setup.
+        // The adjacent cases cover long shared-prefix comparison and append/3
+        // backtracking separately.
         const result = runCli([], { input:
-          'length(_,I),I=13,N is 2^I,length(P,N),append(P,[1],L1),append(P,[2],L2),' +
+          'length(_,I),I=13,N is 2^I,length(P,N),L1=[1|P],L2=[2|P],' +
           'time(compare(R,L1,L2)),time(compare_si(S,L1,L2)).\n.\nhalt.\n',
           timeout: 60000,
         });