eyelang 1.7.16 → 2.0.0

package/test/run-regression.mjs

@@ -66,7 +66,7 @@ function regressionCases() {
     {
       name: '--proof rule fact explanation output',
       run: () => runWhy({
-        program: 'type(socrates, man).\ntype(?x, mortal) :- type(?x, man).\n',
+        program: 'type(socrates, man).\ntype(X, mortal) :- type(X, man).\n',
         goalText: 'type(socrates, mortal)',
         expected: `type(socrates, mortal).
 why(
@@ -74,7 +74,7 @@ why(
   proof(
     goal(type(socrates, mortal)),
     by(rule("__FILE__", clause(2))),
-    bindings([binding("?x", socrates)]),
+    bindings([binding("X", socrates)]),
     uses([
       proof(
         goal(type(socrates, man)),
@@ -90,7 +90,7 @@ why(
     {
       name: '--proof numeric builtin explanation output',
       run: () => runWhy({
-        program: 'p(?x) :- between(536, 536, ?x).\n',
+        program: 'p(X) :- between(536, 536, X).\n',
         goalText: 'p(536)',
         expected: `p(536).
 why(
@@ -98,7 +98,7 @@ why(
   proof(
     goal(p(536)),
     by(rule("__FILE__", clause(1))),
-    bindings([binding("?x", 536)]),
+    bindings([binding("X", 536)]),
     uses([
       proof(
         goal(between(536, 536, 536)),
@@ -114,7 +114,7 @@ why(
     {
       name: '--proof list builtin explanation output',
       run: () => runWhy({
-        program: 'p(?x) :- member(?x, [a]).\n',
+        program: 'p(X) :- member(X, [a]).\n',
         goalText: 'p(a)',
         expected: `p(a).
 why(
@@ -122,7 +122,7 @@ why(
   proof(
     goal(p(a)),
     by(rule("__FILE__", clause(1))),
-    bindings([binding("?x", a)]),
+    bindings([binding("X", a)]),
     uses([
       proof(
         goal(member(a, [a])),
@@ -139,7 +139,7 @@ why(
       name: 'explanation backtracks across earlier subgoal alternatives',
       run: () => {
         const result = runWhyLoose({
-          program: 'p(ok) :- q(?x), r(?x).\nq(a).\nq(b).\nr(b).\n',
+          program: 'p(ok) :- q(X), r(X).\nq(a).\nq(b).\nr(b).\n',
           goalText: 'p(ok)',
         });
         assertIncludes(result.stdout, 'goal(q(b)),\n        by(fact("', 'stdout');
@@ -163,7 +163,7 @@ why(
       name: 'EYELANG_LOCAL_TIME fixes local_time builtin',
       run: () => {
         const result = runCli(['-'], {
-          input: 'materialize(local_time_answer, 1).\nlocal_time_answer(?d) :- local_time(?d).\n',
+          input: 'materialize(local_time_answer, 1).\nlocal_time_answer(D) :- local_time(D).\n',
           env: { EYELANG_LOCAL_TIME: '2024-01-02' },
         });
         assertEqual(result.status, 0, 'exit status');
@@ -176,7 +176,7 @@ why(
       run: () => {
         const result = runCli([]);
         assertEqual(result.status, 0, 'exit status');
-        assertIncludes(result.stdout, 'Usage:\n  eyelang [options] [file-or-url.eye|- ...]', 'stdout');
+        assertIncludes(result.stdout, 'Usage:\n  eyelang [options] [file-or-url.pl|- ...]', 'stdout');
         assertIncludes(result.stdout, '-p, --proof', 'stdout');
         assertIncludes(result.stdout, '-s, --stats', 'stdout');
         assertIncludes(result.stdout, '-v, --version', 'stdout');
@@ -220,7 +220,7 @@ why(
     {
       name: 'stdin input is accepted',
       run: () => {
-        const result = runCli(['-'], { input: 'p(a, b).\nq(?x, ?y) :- p(?x, ?y).\n' });
+        const result = runCli(['-'], { input: 'p(a, b).\nq(X, Y) :- p(X, Y).\n' });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout, 'q(a, b).\n', 'stdout');
         assertEqual(result.stderr, '', 'stderr');
@@ -230,7 +230,7 @@ why(
     {
       name: '--proof enables materialization explanations',
       run: () => {
-        const result = runCli(['--proof', '-'], { input: 'p(a, b).\nq(?x, ?y) :- p(?x, ?y).\n' });
+        const result = runCli(['--proof', '-'], { input: 'p(a, b).\nq(X, Y) :- p(X, Y).\n' });
         assertEqual(result.status, 0, 'exit status');
         assertIncludes(result.stdout, 'q(a, b).\nwhy(', 'stdout');
         assertEqual(result.stderr, '', 'stderr');
@@ -239,7 +239,7 @@ why(
     {
       name: '-p enables materialization explanations',
       run: () => {
-        const result = runCli(['-p', '-'], { input: 'p(a, b).\nq(?x, ?y) :- p(?x, ?y).\n' });
+        const result = runCli(['-p', '-'], { input: 'p(a, b).\nq(X, Y) :- p(X, Y).\n' });
         assertEqual(result.status, 0, 'exit status');
         assertIncludes(result.stdout, 'q(a, b).\nwhy(', 'stdout');
         assertEqual(result.stderr, '', 'stderr');
@@ -250,7 +250,7 @@ why(
     {
       name: '--stats prints solver statistics to stderr',
       run: () => {
-        const result = runCli(['--stats', '-'], { input: 'p(a, b).\nq(?x, ?y) :- p(?x, ?y).\n' });
+        const result = runCli(['--stats', '-'], { input: 'p(a, b).\nq(X, Y) :- p(X, Y).\n' });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout, 'q(a, b).\n', 'stdout');
         assertIncludes(result.stderr, 'eyelang stats:\n', 'stderr');
@@ -260,7 +260,7 @@ why(
     {
       name: '-s prints solver statistics to stderr',
       run: () => {
-        const result = runCli(['-s', '-'], { input: 'p(a, b).\nq(?x, ?y) :- p(?x, ?y).\n' });
+        const result = runCli(['-s', '-'], { input: 'p(a, b).\nq(X, Y) :- p(X, Y).\n' });
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout, 'q(a, b).\n', 'stdout');
         assertIncludes(result.stderr, 'eyelang stats:\n', 'stderr');
@@ -315,7 +315,7 @@ why(
       name: 'double dash permits option-shaped file names',
       run: () => {
         const file = path.join(tmp, '-h');
-        fs.writeFileSync(file, 'p(a, b).\nq(?x, ?y) :- p(?x, ?y).\n');
+        fs.writeFileSync(file, 'p(a, b).\nq(X, Y) :- p(X, Y).\n');
         const result = runCli(['--', file]);
         assertEqual(result.status, 0, 'exit status');
         assertEqual(result.stdout, 'q(a, b).\n', 'stdout');
@@ -411,7 +411,7 @@ function apiCases() {
     {
       name: 'run materialization through public API without proof by default',
       run: () => {
-        const result = run('p(a, b).\nq(?x, ?y) :- p(?x, ?y).\n');
+        const result = run('p(a, b).\nq(X, Y) :- p(X, Y).\n');
         assertEqual(result.stdout, 'q(a, b).\n', 'stdout');
       },
     },
@@ -442,7 +442,7 @@ function apiCases() {
     {
       name: 'run materialization can enable proof explanations',
       run: () => {
-        const result = run('p(a, b).\nq(?x, ?y) :- p(?x, ?y).\n', { proof: true });
+        const result = run('p(a, b).\nq(X, Y) :- p(X, Y).\n', { proof: true });
         assertIncludes(result.stdout, 'q(a, b).\nwhy(', 'stdout');
       },
     },
@@ -450,7 +450,7 @@ function apiCases() {
     {
       name: 'run accepts Program instances',
       run: () => {
-        const program = Program.parse('p(a, b).\nq(?x, ?y) :- p(?x, ?y).\n');
+        const program = Program.parse('p(a, b).\nq(X, Y) :- p(X, Y).\n');
         const result = run(program);
         assertEqual(result.stdout, 'q(a, b).\n', 'stdout');
       },
@@ -458,8 +458,8 @@ function apiCases() {
     {
       name: 'run keeps recursive materializations independent in one solver',
       run: () => {
-        const text = fs.readFileSync(path.join(packageRoot, 'examples', 'alignment-demo.eye'), 'utf8');
-        const program = Program.parseSources([{ text, filename: 'alignment-demo.eye' }]);
+        const text = fs.readFileSync(path.join(packageRoot, 'examples', 'alignment-demo.pl'), 'utf8');
+        const program = Program.parseSources([{ text, filename: 'alignment-demo.pl' }]);
         const result = run(program);
         assertIncludes(result.stdout, 'broaderTransitive(anpr_passenger_car, ref_car).\n', 'stdout');
         assertIncludes(result.stdout, 'narrowerOrEqualOf(anpr_passenger_car, ref_car).\n', 'stdout');
@@ -468,7 +468,7 @@ function apiCases() {
     {
       name: 'makeProgram creates indexed programs',
       run: () => {
-        const program = makeProgram('edge(a, b).\npath(?x, ?y) :- edge(?x, ?y).\n');
+        const program = makeProgram('edge(a, b).\npath(X, Y) :- edge(X, Y).\n');
         const group = program.findGroup('path', 2);
         assertEqual(Boolean(group), true, 'path/2 group exists');
         assertEqual(group.groupName ?? group.name, 'path', 'group name');
@@ -478,7 +478,7 @@ function apiCases() {
     {
       name: 'program keeps negation diagnostics lazy by default',
       run: () => {
-        const program = Program.parse('p(a).\nq(?x) :- not(p(?x)).\n');
+        const program = Program.parse('p(a).\nq(X) :- not(p(X)).\n');
         assertEqual(program._negationAnalysis, null, 'analysis starts lazy');
         assertEqual(program.negationDependencies.length, 1, 'dependency count');
         assertEqual(program._negationAnalysis !== null, true, 'analysis computed on demand');
@@ -487,7 +487,7 @@ function apiCases() {
     {
       name: 'analyzeNegation option computes diagnostics eagerly',
       run: () => {
-        const program = Program.parse('p(a).\nq(?x) :- not(p(?x)).\n', { analyzeNegation: true });
+        const program = Program.parse('p(a).\nq(X) :- not(p(X)).\n', { analyzeNegation: true });
         assertEqual(program._negationAnalysis !== null, true, 'analysis computed eagerly');
         assertEqual(program.stratifiedNegation, true, 'stratified negation');
       },
@@ -499,8 +499,8 @@ function apiCases() {
 materialize(open, 1).
 candidate(a).
 blocked(b).
-closed(?x) :- blocked(?x).
-open(?x) :- candidate(?x), not(closed(?x)).
+closed(X) :- blocked(X).
+open(X) :- candidate(X), not(closed(X)).
 `);
         assertEqual(program.isStratifiedNegation(), true, 'stratified negation');
         assertEqual(program.negationStratificationErrors.length, 0, 'stratification errors');
@@ -511,7 +511,7 @@ open(?x) :- candidate(?x), not(closed(?x)).
     {
       name: 'program detects unstratified negation cycles',
       run: () => {
-        const program = Program.parse('p(?x) :- q(?x).\nq(?x) :- not(p(?x)).\n');
+        const program = Program.parse('p(X) :- q(X).\nq(X) :- not(p(X)).\n');
         assertEqual(program.isStratifiedNegation(), false, 'unstratified negation');
         assertEqual(program.negationStratificationErrors.length, 1, 'stratification error count');
         assertEqual(program.negationStratificationErrors[0].from, 'q/1', 'error source');
@@ -528,7 +528,7 @@ open(?x) :- candidate(?x), not(closed(?x)).
       name: 'strictNegation option rejects unstratified programs',
       run: () => {
         let threw = false;
-        try { Program.parse('p(?x) :- not(p(?x)).\n', { strictNegation: true }); } catch (err) {
+        try { Program.parse('p(X) :- not(p(X)).\n', { strictNegation: true }); } catch (err) {
           threw = true;
           assertIncludes(err.message, 'p/1 depends negatively on p/1', 'error message');
         }
@@ -540,7 +540,7 @@ open(?x) :- candidate(?x), not(closed(?x)).
       run: () => {
         const program = Program.parse('p(a).\np(b).\n');
         const solver = new Solver(program);
-        const goal = parseGoalText('p(?x)');
+        const goal = parseGoalText('p(X)');
         const answers = [...solver.solve([goal], new Env(), 0)].map((env) => termToString(goal, env, true));
         assertEqual(answers.join('\n'), 'p(a)\np(b)', 'answers');
       },
@@ -550,7 +550,7 @@ open(?x) :- candidate(?x), not(closed(?x)).
       run: () => {
         const program = Program.parse('p(a).\np(b).\np(c).\n');
         const solver = new Solver(program, { solutionLimit: 2 });
-        const goal = parseGoalText('p(?x)');
+        const goal = parseGoalText('p(X)');
         const answers = [...solver.solve([goal], new Env(), 0)].map((env) => termToString(goal, env, true));
         assertEqual(answers.join('\n'), 'p(a)\np(b)', 'answers');
       },
@@ -563,9 +563,9 @@ open(?x) :- candidate(?x), not(closed(?x)).
           const next = env.clone();
           if (unify(goal.args[0], atom('world'), next)) yield next;
         });
-        const program = Program.parse('answer(?x) :- hello(?x).\n');
+        const program = Program.parse('answer(X) :- hello(X).\n');
         const solver = new Solver(program, { registry });
-        const goal = parseGoalText('answer(?x)');
+        const goal = parseGoalText('answer(X)');
         const answers = [...solver.solve([goal], new Env(), 0)].map((env) => termToString(goal, env, true));
         assertEqual(answers.join('\n'), 'answer(world)', 'answers');
       },
@@ -591,17 +591,17 @@ function whiteBoxCases() {
       name: 'unification binds variables in Env',
       run: () => {
         const env = new Env();
-        assertEqual(unify(variable('?x'), atom('socrates'), env), true, 'unify result');
-        assertEqual(termToString(variable('?x'), env, true), 'socrates', 'binding');
+        assertEqual(unify(variable('X'), atom('socrates'), env), true, 'unify result');
+        assertEqual(termToString(variable('X'), env, true), 'socrates', 'binding');
       },
     },
     {
       name: 'copyResolved and termIsGround follow bindings',
       run: () => {
         const env = new Env();
-        const term = compound('p', [variable('?x'), atom('b')]);
+        const term = compound('p', [variable('X'), atom('b')]);
         assertEqual(termIsGround(term, env), false, 'not ground before binding');
-        assertEqual(unify(variable('?x'), atom('a'), env), true, 'bind ?x');
+        assertEqual(unify(variable('X'), atom('a'), env), true, 'bind X');
         const resolved = copyResolved(term, env);
         assertEqual(termToString(resolved, new Env(), true), 'p(a, b)', 'resolved term');
         assertEqual(termIsGround(resolved), true, 'ground after copy');
@@ -627,21 +627,21 @@ function whiteBoxCases() {
     {
       name: 'parser preserves list syntax readback',
       run: () => {
-        const goal = parseGoalText('member(?x, [a, b])');
-        assertEqual(termToString(goal, new Env(), true), 'member(?x, [a, b])', 'goal');
+        const goal = parseGoalText('member(X, [a, b])');
+        assertEqual(termToString(goal, new Env(), true), 'member(X, [a, b])', 'goal');
       },
     },
     {
-      name: 'parser accepts question-mark variables',
+      name: 'parser accepts ISO-style uppercase variables',
       run: () => {
-        const goal = parseGoalText('member(?x, [a, b])');
-        assertEqual(termToString(goal, new Env(), true), 'member(?x, [a, b])', 'goal');
+        const goal = parseGoalText('member(X, [a, b])');
+        assertEqual(termToString(goal, new Env(), true), 'member(X, [a, b])', 'goal');
       },
     },
     {
-      name: 'parser treats bare question mark as anonymous',
+      name: 'parser treats bare underscore as anonymous',
       run: () => {
-        const clauses = parseProgramText('p(?, ?).\n');
+        const clauses = parseProgramText('p(_, _).\n');
         const left = clauses[0].head.args[0].name;
         const right = clauses[0].head.args[1].name;
         assertEqual(left.startsWith('__anon'), true, 'left anonymous');
@@ -650,19 +650,19 @@ function whiteBoxCases() {
       },
     },
     {
-      name: 'parser rejects old uppercase variable spelling',
+      name: 'parser rejects old question-mark variable spelling',
       run: () => {
         let threw = false;
-        try { parseProgramText('p(X).\n'); } catch (_) { threw = true; }
-        assertEqual(threw, true, 'uppercase variable syntax rejected');
+        try { parseProgramText('p(?x).\n'); } catch (_) { threw = true; }
+        assertEqual(threw, true, 'question-mark variable syntax rejected');
       },
     },
     {
-      name: 'parser rejects bare underscore variable spelling',
+      name: 'parser accepts bare underscore anonymous variable spelling',
       run: () => {
         let threw = false;
         try { parseProgramText('p(_).\n'); } catch (_) { threw = true; }
-        assertEqual(threw, true, 'bare underscore syntax rejected');
+        assertEqual(threw, false, 'bare underscore syntax accepted');
       },
     },
     {
@@ -681,17 +681,17 @@ function whiteBoxCases() {
       },
     },
     {
-      name: 'parser accepts angle-bracket absolute IRI atoms',
+      name: 'parser accepts quoted angle-bracket atoms',
       run: () => {
-        const clauses = parseProgramText('p(<https://example.org/alice>, <urn:example:bob>).\n');
-        assertEqual(termToString(clauses[0].head, new Env(), true), 'p(<https://example.org/alice>, <urn:example:bob>)', 'head');
+        const clauses = parseProgramText("p('<https://example.org/alice>', '<urn:example:bob>').\n");
+        assertEqual(termToString(clauses[0].head, new Env(), true), "p('<https://example.org/alice>', '<urn:example:bob>')", 'head');
       },
     },
     {
-      name: 'readback prints absolute IRI atoms with angle brackets',
+      name: 'readback leaves absolute IRI atoms as quoted atoms',
       run: () => {
         const clauses = parseProgramText("p('https://example.org/alice').\n");
-        assertEqual(termToString(clauses[0].head, new Env(), true), 'p(<https://example.org/alice>)', 'head');
+        assertEqual(termToString(clauses[0].head, new Env(), true), "p('https://example.org/alice')", 'head');
       },
     },
     {
@@ -713,9 +713,9 @@ function whiteBoxCases() {
     {
       name: 'variantTerms recognizes alpha-equivalent goals',
       run: () => {
-        const left = parseGoalText('edge(?x, ?y)');
-        const right = parseGoalText('edge(?a, ?b)');
-        const nonVariant = parseGoalText('edge(?a, ?a)');
+        const left = parseGoalText('edge(X, Y)');
+        const right = parseGoalText('edge(A, B)');
+        const nonVariant = parseGoalText('edge(A, A)');
         assertEqual(variantTerms(left, new Env(), right, new Env()), true, 'variant');
         assertEqual(variantTerms(left, new Env(), nonVariant, new Env()), false, 'non-variant');
       },
@@ -731,18 +731,18 @@ function whiteBoxCases() {
     {
       name: 'parseProgramText returns clause objects',
       run: () => {
-        const clauses = parseProgramText('p(a).\nq(?x) :- p(?x).\n');
+        const clauses = parseProgramText('p(a).\nq(X) :- p(X).\n');
         assertEqual(clauses.length, 2, 'clause count');
-        assertEqual(termToString(clauses[1].head, new Env(), true), 'q(?x)', 'rule head');
+        assertEqual(termToString(clauses[1].head, new Env(), true), 'q(X)', 'rule head');
         assertEqual(clauses[1].body.length, 1, 'body length');
       },
     },
     {
       name: 'clause candidate selection uses scalar indexes with fallback',
       run: () => {
-        const program = Program.parse('edge(a, b).\nedge(c, d).\nedge(?x, z).\n');
+        const program = Program.parse('edge(a, b).\nedge(c, d).\nedge(X, z).\n');
         const group = program.findGroup('edge', 2);
-        const goal = parseGoalText('edge(a, ?y)');
+        const goal = parseGoalText('edge(a, Y)');
         const candidates = selectClauseCandidates(group, goal, new Env());
         assertEqual(candidates.primary.length, 1, 'primary bucket length');
         assertEqual(candidates.fallback.length, 1, 'fallback length');
@@ -752,7 +752,7 @@ function whiteBoxCases() {
     {
       name: 'table declaration marks predicate group tabled',
       run: () => {
-        const program = Program.parse('table(path, 2).\nedge(a, b).\npath(?x, ?y) :- edge(?x, ?y).\n');
+        const program = Program.parse('table(path, 2).\nedge(a, b).\npath(X, Y) :- edge(X, Y).\n');
         const group = program.findGroup('path', 2);
         assertEqual(Boolean(group), true, 'path/2 group exists');
         assertEqual(group.tabled, true, 'path/2 tabled through table/2');
@@ -761,7 +761,7 @@ function whiteBoxCases() {
     {
       name: 'memoize fact does not table predicates',
       run: () => {
-        const program = Program.parse('memoize(path, 2).\nedge(a, b).\npath(?x, ?y) :- edge(?x, ?y).\n');
+        const program = Program.parse('memoize(path, 2).\nedge(a, b).\npath(X, Y) :- edge(X, Y).\n');
         const group = program.findGroup('path', 2);
         assertEqual(Boolean(group), true, 'path/2 group exists');
         assertEqual(group.tabled, false, 'memoize/2 is not a table declaration');
@@ -770,7 +770,7 @@ function whiteBoxCases() {
     {
       name: 'mode and determinism declarations annotate predicate groups',
       run: () => {
-        const program = Program.parse('mode(path, 2, [in, out]).\ndet(path, 2).\nedge(a, b).\npath(?x, ?y) :- edge(?x, ?y).\n');
+        const program = Program.parse('mode(path, 2, [in, out]).\ndet(path, 2).\nedge(a, b).\npath(X, Y) :- edge(X, Y).\n');
         const group = program.findGroup('path', 2);
         assertEqual(Boolean(group), true, 'path/2 group exists');
         assertEqual(group.mode.join(','), 'in,out', 'path/2 mode');
@@ -790,20 +790,20 @@ function whiteBoxCases() {
       name: 'challenging examples keep dynamic-programming predicates tabled',
       run: () => {
         const checks = [
-          ['binomial-vandermonde.eye', 'choose_step', 5, true],
-          ['catalan-convolution.eye', 'catalan', 2, false],
-          ['chart-parser.eye', 'span', 4, true],
-          ['continued-fraction-sqrt2.eye', 'conv', 3, true],
-          ['critical-path-schedule.eye', 'earliest_start', 2, false],
-          ['critical-path-schedule.eye', 'finish_time', 2, false],
-          ['integer-partitions.eye', 'partitions', 3, true],
-          ['matrix-chain-order.eye', 'cost', 3, false],
-          ['modular-exponentiation.eye', 'pow_mod', 4, true],
-          ['pell-equation.eye', 'pell', 3, true],
-          ['stirling-bell-numbers.eye', 'stirling2', 3, false],
-          ['totient-summatory.eye', 'gcd', 3, true],
-          ['totient-summatory.eye', 'totient', 2, false],
-          ['weighted-interval-scheduling.eye', 'best_from', 2, true],
+          ['binomial-vandermonde.pl', 'choose_step', 5, true],
+          ['catalan-convolution.pl', 'catalan', 2, false],
+          ['chart-parser.pl', 'span', 4, true],
+          ['continued-fraction-sqrt2.pl', 'conv', 3, true],
+          ['critical-path-schedule.pl', 'earliest_start', 2, false],
+          ['critical-path-schedule.pl', 'finish_time', 2, false],
+          ['integer-partitions.pl', 'partitions', 3, true],
+          ['matrix-chain-order.pl', 'cost', 3, false],
+          ['modular-exponentiation.pl', 'pow_mod', 4, true],
+          ['pell-equation.pl', 'pell', 3, true],
+          ['stirling-bell-numbers.pl', 'stirling2', 3, false],
+          ['totient-summatory.pl', 'gcd', 3, true],
+          ['totient-summatory.pl', 'totient', 2, false],
+          ['weighted-interval-scheduling.pl', 'best_from', 2, true],
         ];
         for (const [filename, name, arity, recursive] of checks) {
           const text = fs.readFileSync(path.join(packageRoot, 'examples', filename), 'utf8');
@@ -818,8 +818,8 @@ function whiteBoxCases() {
     {
       name: 'n-queens example keeps diagonal checks tabled',
       run: () => {
-        const text = fs.readFileSync(path.join(packageRoot, 'examples', 'n-queens-8.eye'), 'utf8');
-        const program = Program.parseSources([{ text, filename: 'n-queens-8.eye' }]);
+        const text = fs.readFileSync(path.join(packageRoot, 'examples', 'n-queens-8.pl'), 'utf8');
+        const program = Program.parseSources([{ text, filename: 'n-queens-8.pl' }]);
         const group = program.findGroup('no_diagonal_attack', 3);
         assertEqual(Boolean(group), true, 'no_diagonal_attack/3 group exists');
         assertEqual(group.tabled, true, 'no_diagonal_attack/3 tabled');
@@ -829,8 +829,8 @@ function whiteBoxCases() {
     {
       name: 'collatz example keeps recursive trajectory predicate tabled',
       run: () => {
-        const text = fs.readFileSync(path.join(packageRoot, 'examples', 'collatz-1000.eye'), 'utf8');
-        const program = Program.parseSources([{ text, filename: 'collatz-1000.eye' }]);
+        const text = fs.readFileSync(path.join(packageRoot, 'examples', 'collatz-1000.pl'), 'utf8');
+        const program = Program.parseSources([{ text, filename: 'collatz-1000.pl' }]);
         const group = program.findGroup('collatz', 2);
         assertEqual(Boolean(group), true, 'collatz/2 group exists');
         assertEqual(group.tabled, true, 'collatz/2 tabled');
@@ -841,7 +841,7 @@ function whiteBoxCases() {
       name: 'collatz example remains stack-safe for browser-sized stacks',
       run: () => {
         // Use a deliberately tiny stack to catch browser-worker recursion regressions.
-        const result = spawnSync(process.execPath, ['--stack-size=100', bin, 'examples/collatz-1000.eye'], {
+        const result = spawnSync(process.execPath, ['--stack-size=100', bin, 'examples/collatz-1000.pl'], {
           cwd: packageRoot,
           encoding: 'utf8',
         });
@@ -868,7 +868,7 @@ function sectionLabel(name) {
 }
 
 function runWhy({ program, goalText, expected }) {
-  const programFile = path.join(tmp, `${++tmpCounter}.eye`);
+  const programFile = path.join(tmp, `${++tmpCounter}.pl`);
   fs.writeFileSync(programFile, program);
   const goal = parseGoalText(goalText);
   fs.appendFileSync(programFile, `\nmaterialize(${goal.name}, ${goal.arity}).\n`);
@@ -887,7 +887,7 @@ function runWhy({ program, goalText, expected }) {
 }
 
 function runWhyLoose({ program, goalText }) {
-  const programFile = path.join(tmp, `${++tmpCounter}.eye`);
+  const programFile = path.join(tmp, `${++tmpCounter}.pl`);
   fs.writeFileSync(programFile, program);
   const goal = parseGoalText(goalText);
   fs.appendFileSync(programFile, `\nmaterialize(${goal.name}, ${goal.arity}).\n`);
@@ -901,8 +901,8 @@ function runWhyLoose({ program, goalText }) {
 
 function listExampleNames() {
   return fs.readdirSync(path.join(packageRoot, 'examples'))
-    .filter((name) => name.endsWith('.eye'))
-    .map((name) => name.slice(0, -4))
+    .filter((name) => name.endsWith('.pl'))
+    .map((name) => name.slice(0, -3))
     .sort();
 }
 
@@ -911,17 +911,17 @@ function guideExampleCatalogIssues() {
   const expected = listExampleNames();
   const guide = fs.readFileSync(path.join(packageRoot, 'docs', 'guide.md'), 'utf8');
   const section = between(guide, '## Example catalog', '## Golden outputs, tests, and conformance');
-  const rows = [...section.matchAll(/^\| \[`([A-Za-z0-9_-]+)\.eye`\]\(\.\.\/examples\/\1\.eye\) \|[^|]+\| \[`output\/\1\.eye`\]\(\.\.\/examples\/output\/\1\.eye\) \|$/gm)]
+  const rows = [...section.matchAll(/^\| \[`([A-Za-z0-9_-]+)\.pl`\]\(\.\.\/examples\/\1\.pl\) \|[^|]+\| \[`output\/\1\.pl`\]\(\.\.\/examples\/output\/\1\.pl\) \|$/gm)]
     .map((match) => match[1]);
-  const sourceNames = [...section.matchAll(/\.\.\/examples\/([A-Za-z0-9_-]+)\.eye/g)].map((match) => match[1]).sort();
-  const outputNames = [...section.matchAll(/\.\.\/examples\/output\/([A-Za-z0-9_-]+)\.eye/g)].map((match) => match[1]).sort();
+  const sourceNames = [...section.matchAll(/\.\.\/examples\/([A-Za-z0-9_-]+)\.pl/g)].map((match) => match[1]).sort();
+  const outputNames = [...section.matchAll(/\.\.\/examples\/output\/([A-Za-z0-9_-]+)\.pl/g)].map((match) => match[1]).sort();
   if (rows.length !== expected.length) issues.push(`expected ${expected.length} complete example rows, found ${rows.length}`);
   issues.push(...arrayDiffMessages(rows.sort(), expected, 'complete example rows'));
   issues.push(...arrayDiffMessages(sourceNames, expected, 'source links'));
   issues.push(...arrayDiffMessages(outputNames, expected, 'output links'));
   for (const name of expected) {
-    const outputPath = path.join(packageRoot, 'examples', 'output', `${name}.eye`);
-    if (!fs.existsSync(outputPath)) issues.push(`missing examples/output/${name}.eye`);
+    const outputPath = path.join(packageRoot, 'examples', 'output', `${name}.pl`);
+    if (!fs.existsSync(outputPath)) issues.push(`missing examples/output/${name}.pl`);
   }
   return issues.sort();
 }
@@ -934,8 +934,8 @@ function playgroundExampleIssues() {
   if (match == null) return ['playground EXAMPLES array not found'];
   const examples = JSON.parse(match[1]).sort();
   issues.push(...arrayDiffMessages(examples, expected, 'playground EXAMPLES'));
-  if (!html.includes('new URL(`./examples/${name}.eye`, location.href)')) {
-    issues.push('playground must load selected examples from relative ./examples/*.eye URLs');
+  if (!html.includes('new URL(`./examples/${name}.pl`, location.href)')) {
+    issues.push('playground must load selected examples from relative ./examples/*.pl URLs');
   }
   if (!html.includes("fetch(exampleUrl, { cache: 'no-store' })")) {
     issues.push('playground must fetch selected example source from its relative URL');
@@ -1114,12 +1114,12 @@ function documentationSourceStyleIssues() {
 
   const reference = fs.readFileSync(path.join(docsRoot, 'language-reference.md'), 'utf8');
   const builtins = between(reference, '## 9. Standard built-in predicates', '## 10. Implementation-specific built-ins');
-  const staleMetaVariables = /`[^`]*(?<!\?)(?:\b(?:A|B|C|D|N|T|Low|High|Start|Needle|Context|Search|Generator|Test|Goal)\b)[^`]*`/;
+  const staleQuestionVariables = /`[^`]*\?[A-Za-z_][A-Za-z0-9_]*[^`]*`|`[^`]*\?(?=[,.)\] |])[^`]*`/;
   for (const [index, line] of builtins.split('\n').entries()) {
     if (!line.trim().startsWith('|')) continue;
     if (line.includes('EYELANG_LOCAL_TIME=')) continue;
-    if (staleMetaVariables.test(line)) {
-      issues.push(`docs/language-reference.md section 9 line ${index + 1}: stale Prolog-style metavariable in built-in description: ${line.trim()}`);
+    if (staleQuestionVariables.test(line)) {
+      issues.push(`docs/language-reference.md section 9 line ${index + 1}: stale question-mark variable in built-in description: ${line.trim()}`);
     }
   }
   return issues.sort();

package/examples/abstract-interpretation.eye

@@ -1,50 +0,0 @@
-% Abstract interpretation over a tiny imperative program.
-%
-% The concrete program is:
-%
-%   x := input();
-%   if x < 0 then y := -x else y := x;
-%   z := 10 / y;
-%
-% Instead of executing the program for every integer input, this example tracks
-% only the abstract sign of each variable: neg, zero, or pos.  The analysis is
-% deliberately conservative: if the join point can see y = zero on any path, the
-% division is reported as a possible division-by-zero warning.
-
-materialize(absState, 3).
-materialize(absWarning, 2).
-materialize(absConclusion, 2).
-
-table(abs_state, 3).
-
-% The abstract domain.
-input_sign(neg).
-input_sign(zero).
-input_sign(pos).
-
-% The input statement gives x any of the three abstract signs.
-abs_state(input, x, ?sign) :- input_sign(?sign).
-
-% The branch refines the sign of x.  The negative branch only receives neg; the
-% non-negative branch receives zero or pos.
-abs_state(negative_branch, x, neg) :- abs_state(input, x, neg).
-abs_state(nonnegative_branch, x, zero) :- abs_state(input, x, zero).
-abs_state(nonnegative_branch, x, pos) :- abs_state(input, x, pos).
-
-% Transfer functions for assignments.  In the negative branch, y := -x turns a
-% negative x into a positive y.  In the non-negative branch, y := x preserves the
-% zero/positive information.
-abs_state(negative_branch, y, pos) :- abs_state(negative_branch, x, neg).
-abs_state(nonnegative_branch, y, ?sign) :- abs_state(nonnegative_branch, x, ?sign).
-
-% The join point merges abstract states from both branches.
-abs_state(join, ?var, ?sign) :- abs_state(negative_branch, ?var, ?sign).
-abs_state(join, ?var, ?sign) :- abs_state(nonnegative_branch, ?var, ?sign).
-
-% A possible zero denominator is enough to raise a conservative warning.
-possible_division_by_zero(join) :- abs_state(join, y, zero).
-
-absState(?point, ?var, sign(?sign)) :- abs_state(?point, ?var, ?sign).
-absWarning(division_by_zero, ?point) :- possible_division_by_zero(?point).
-absConclusion(case, "abstract interpretation keeps all feasible signs and warns because y may be zero") :-
-  possible_division_by_zero(join).