eyeprolog 1.1.1 → 1.1.3

package/README.md

@@ -25,6 +25,18 @@ EyeProlog requires Node.js 18 or newer.
 
 ```sh
 npm install --global eyeprolog
+eyeprolog
+?- use_module(library(lists)).
+   true.
+?- member(X, [prolog, logic]).
+   X = prolog
+;  X = logic.
+?- halt.
+```
+
+For a non-interactive run:
+
+```sh
 printf 'human(socrates).\nmortal(X) :- human(X).\n' |
   eyeprolog --proof --goal 'mortal(socrates)' -
 ```

package/conformance-report.md

@@ -11,7 +11,7 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | builtins | 11 | 0 | 0 | 0 | 11 |
 | context | 11 | 0 | 0 | 0 | 11 |
 | control | 15 | 0 | 0 | 0 | 15 |
-| iso | 135 | 178 | 0 | 0 | 313 |
+| iso | 164 | 209 | 0 | 0 | 373 |
 | lists | 52 | 3 | 0 | 0 | 55 |
 | modules | 2 | 0 | 0 | 0 | 2 |
 | negation | 8 | 0 | 19 | 0 | 27 |
@@ -23,4 +23,4 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | terms | 26 | 3 | 0 | 0 | 29 |
 | unification | 18 | 0 | 0 | 0 | 18 |
 | variables | 16 | 9 | 0 | 0 | 25 |
-| **Total** | **450** | **229** | **19** | **21** | **719** |
+| **Total** | **479** | **260** | **19** | **21** | **779** |

package/package.json

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

package/src/cli.js

@@ -10,7 +10,14 @@ let explanationModule = null;
 
 export async function main(argv) {
   if (argv.length === 0) {
-    await usage(process.stdout);
+    const engine = await loadEngine();
+    const { runRepl } = await import('./repl.js');
+    const exitCode = await runRepl(engine, {
+      input: process.stdin,
+      output: process.stdout,
+      errorOutput: process.stderr,
+    });
+    if (exitCode !== 0) process.exitCode = exitCode;
     return;
   }
 
@@ -109,15 +116,16 @@ export async function main(argv) {
 
 async function loadEngine() {
   if (engineModule == null) {
-    const [term, parser, program, solver, iso, library] = await Promise.all([
+    const [term, parser, program, solver, iso, library, write] = await Promise.all([
       import('./term.js'),
       import('./parser.js'),
       import('./program.js'),
       import('./solver.js'),
       import('./iso.js'),
       import('./standard-library.js'),
+      import('./write.js'),
     ]);
-    engineModule = { ...term, ...parser, ...program, ...solver, ...iso, ...library };
+    engineModule = { ...term, ...parser, ...program, ...solver, ...iso, ...library, ...write };
   }
   return engineModule;
 }
@@ -186,8 +194,12 @@ async function usage(stream) {
   stream.write(`eyeprolog ${await packageVersion()}
 
 Usage:
+  eyeprolog
   eyeprolog [options] [file-or-url.pl|- ...]
 
+Interactive:
+  With no arguments, start a Prolog REPL. Use eyeprolog -h for help.
+
 Input:
   file-or-url.pl        Read an EyeProlog program from a local file or http(s) URL.
   -                     Read an EyeProlog program from standard input.

package/src/dcg.js

@@ -96,6 +96,10 @@ export function expandDcgBody(body, input, output, options = {}) {
     return goal;
   }
 
+  // Empty braces are the empty embedded-goal sequence. Like {true}, they
+  // consume no terminals and leave the grammar state unchanged.
+  if (body.type === ATOM && body.name === '{}') return equality(input, output);
+
   if (isTerminalSequence(body)) return terminalsGoal(body, input, output, env);
 
   if (body.type === COMPOUND && body.name === ',' && body.arity === 2) {

package/src/repl.js

@@ -0,0 +1,412 @@
+// Interactive top level for the eyeprolog command.
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createInterface } from 'node:readline';
+
+const ANSWER_HELP = `
+SPACE, "n" or ";": next solution, if any
+RETURN or ".": stop enumeration
+"a": enumerate all solutions
+"f": enumerate the next 5 solutions
+"h": display this help message
+"w": write terms without depth limit
+"p": print terms with depth limit
+`;
+
+export async function runRepl(engine, options = {}) {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const errorOutput = options.errorOutput ?? process.stderr;
+  const reader = new LineReader(input, output);
+  const sources = [];
+  let state = makeState(engine, sources, output);
+  let exitCode = 0;
+
+  try {
+    state.solver.runInitializations();
+    while (true) {
+      const text = await readQuery(reader);
+      if (text == null) break;
+      if (!text.trim()) continue;
+
+      try {
+        const goal = parseGoal(engine, state, text);
+        if (isUseModuleGoal(goal)) {
+          sources.push({ text: `:- ${text}.\n`, filename: '<repl>' });
+          state = makeState(engine, sources, output);
+          state.solver.runInitializations();
+          output.write('   true.\n');
+          continue;
+        }
+        const consultFiles = consultDesignations(engine, goal);
+        if (consultFiles != null) {
+          for (const filename of consultFiles) sources.push(await readSource(filename));
+          state = makeState(engine, sources, output);
+          state.solver.runInitializations();
+          output.write('   true.\n');
+          continue;
+        }
+
+        const result = await solveQuery(engine, state, goal, reader, output);
+        if (result?.halted) {
+          exitCode = result.code;
+          break;
+        }
+      } catch (error) {
+        if (error?.name === 'HaltSignal') {
+          exitCode = error.code;
+          break;
+        }
+        output.write(`   ${formatError(error)}\n`);
+      }
+    }
+  } catch (error) {
+    errorOutput.write(`eyeprolog: ${error?.message ?? String(error)}\n`);
+    exitCode = 1;
+  } finally {
+    reader.close();
+  }
+
+  return exitCode;
+}
+
+class LineReader {
+  constructor(input, output) {
+    this.input = input;
+    this.output = output;
+    this.terminal = Boolean(input.isTTY && output.isTTY && typeof input.setRawMode === 'function');
+    this.history = [];
+    this.currentPrompt = '?- ';
+    this.open();
+  }
+
+  open() {
+    this.readline = createInterface({
+      input: this.input,
+      output: this.output,
+      terminal: Boolean(this.input.isTTY && this.output.isTTY),
+      prompt: this.currentPrompt,
+    });
+    if (this.terminal && this.history.length > 0) {
+      this.readline.history.push(...this.history);
+    }
+    this.lines = this.readline[Symbol.asyncIterator]();
+  }
+
+  async read(prompt) {
+    this.currentPrompt = prompt;
+    this.readline.setPrompt(prompt);
+    this.output.write(prompt);
+    const result = await this.lines.next();
+    return result.done ? null : result.value;
+  }
+
+  async readControl(prompt) {
+    if (!this.terminal) return this.read(prompt);
+    this.output.write(prompt);
+    this.history = [...this.readline.history];
+    this.currentPrompt = '?- ';
+    this.readline.close();
+    this.readline = null;
+    this.lines = null;
+    this.input.setRawMode(true);
+    this.input.resume();
+
+    const control = await new Promise((resolve, reject) => {
+      const cleanup = () => {
+        this.input.off('data', onData);
+        this.input.off('error', onError);
+      };
+      const onData = (data) => {
+        cleanup();
+        const text = String(data);
+        resolve(text === '\x04' ? null : text[0] ?? null);
+      };
+      const onError = (error) => {
+        cleanup();
+        reject(error);
+      };
+      this.input.once('data', onData);
+      this.input.once('error', onError);
+    });
+
+    this.input.setRawMode(false);
+    this.open();
+    return control;
+  }
+
+  close() {
+    if (this.input.isRaw) this.input.setRawMode(false);
+    this.readline?.close();
+  }
+}
+
+function makeState(engine, sources, output) {
+  const program = engine.Program.parseSources(sources);
+  const solver = new engine.Solver(program, {
+    registry: engine.getEyePrologRegistry(),
+    ioOptions: { write: (text) => output.write(String(text)) },
+  });
+  return { program: solver.program, solver };
+}
+
+async function readQuery(reader) {
+  let source = '';
+  let prompt = '?- ';
+  while (true) {
+    const line = await reader.read(prompt);
+    if (line == null) return source.trim() ? source : null;
+    source += `${line}\n`;
+    const end = terminalFullStop(source);
+    if (end >= 0) return source.slice(0, end);
+    prompt = '|    ';
+  }
+}
+
+function terminalFullStop(source) {
+  let quote = null;
+  let lineComment = false;
+  let blockComment = false;
+  let escaped = false;
+  let depth = 0;
+
+  for (let i = 0; i < source.length; i++) {
+    const ch = source[i];
+    const next = source[i + 1];
+    if (lineComment) {
+      if (ch === '\n') lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (ch === '*' && next === '/') {
+        blockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (quote != null) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === '\\') {
+        escaped = true;
+      } else if (ch === quote) {
+        if (next === quote) i++;
+        else quote = null;
+      }
+      continue;
+    }
+    if (ch === '%') {
+      lineComment = true;
+      continue;
+    }
+    if (ch === '/' && next === '*') {
+      blockComment = true;
+      i++;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === '`') {
+      quote = ch;
+      continue;
+    }
+    if ('([{'.includes(ch)) depth++;
+    else if (')]}'.includes(ch)) depth = Math.max(0, depth - 1);
+    else if (ch === '.' && depth === 0 && onlyLayoutAndComments(source.slice(i + 1))) return i;
+  }
+  return -1;
+}
+
+function onlyLayoutAndComments(source) {
+  return source.replace(/\s|%[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\//g, '').length === 0;
+}
+
+function parseGoal(engine, state, text) {
+  const goal = engine.parseGoalText(text, {
+    doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+    operatorDefinitions: [...state.program.operators.values()],
+  });
+  if (goal.type === 'var') throw new engine.PrologError('instantiation_error');
+  if (goal.type !== 'atom' && goal.type !== 'compound') {
+    throw new engine.PrologError('type_error(callable)', goal);
+  }
+  return goal;
+}
+
+function isUseModuleGoal(goal) {
+  return goal.type === 'compound' && goal.name === 'use_module' && [1, 2].includes(goal.arity);
+}
+
+function consultDesignations(engine, goal) {
+  if (goal.type === 'atom' && goal.name === '[]') return [];
+  if (goal.type !== 'compound' || goal.name !== '.' || goal.arity !== 2) return null;
+  const items = engine.properListItems(goal, new engine.Env());
+  if (items == null) return null;
+  return items.map((item) => {
+    if (item.type === 'var') throw new engine.PrologError('instantiation_error');
+    if (item.type !== 'atom') throw new engine.PrologError('type_error(atom)', item);
+    return item.name;
+  });
+}
+
+async function readSource(designation) {
+  let filename = path.resolve(designation);
+  try {
+    await fs.access(filename);
+  } catch (error) {
+    if (path.extname(filename)) throw error;
+    filename += '.pl';
+  }
+  return {
+    text: await fs.readFile(filename, 'utf8'),
+    filename: path.basename(filename),
+    baseDir: path.dirname(filename),
+  };
+}
+
+async function solveQuery(engine, state, goal, reader, output) {
+  const variables = queryVariables(goal);
+  const solver = state.solver;
+  solver.solutionsSeen = 0;
+  const solutions = solver.solve([goal], new engine.Env(), 0);
+  let current = pullSolution(solver, solutions);
+  if (current.error) {
+    if (current.error?.name === 'HaltSignal') return { halted: true, code: current.error.code };
+    throw current.error;
+  }
+
+  if (current.result.done) {
+    output.write('   false.\n');
+    return null;
+  }
+
+  let automatic = 0;
+  let firstAnswer = true;
+  while (!current.result.done) {
+    const next = pullSolution(solver, solutions);
+    output.write(current.output);
+    output.write(`${firstAnswer ? '   ' : ''}${formatAnswer(engine, state, variables, current.result.value)}`);
+    firstAnswer = false;
+    if (!next.error && next.result.done) {
+      output.write('.\n');
+      return null;
+    }
+
+    if (automatic > 0 || automatic === Infinity) {
+      if (automatic !== Infinity) automatic--;
+      output.write('\n;  ');
+    } else {
+      while (true) {
+        const controlLine = await reader.readControl('\n;  ');
+        if (controlLine == null || controlLine === '' || controlLine === '\r' || controlLine === '\n' ||
+            controlLine.trimStart().startsWith('.')) {
+          if (typeof solutions.return === 'function') solutions.return();
+          output.write('... .\n');
+          return null;
+        }
+        const control = controlLine === ' ' ? ' ' : controlLine.trimStart()[0];
+        if (control === ';' || control === 'n' || control === ' ') break;
+        if (control === 'a') {
+          automatic = Infinity;
+          break;
+        }
+        if (control === 'f') {
+          automatic = 4;
+          break;
+        }
+        if (control === 'w' || control === 'p') {
+          output.write(`${formatAnswer(engine, state, variables, current.result.value)}`);
+          continue;
+        }
+        if (control === 'h') {
+          output.write(ANSWER_HELP);
+          continue;
+        }
+        output.write('Action? ');
+      }
+    }
+
+    if (next.error) {
+      output.write(next.output);
+      if (next.error?.name === 'HaltSignal') return { halted: true, code: next.error.code };
+      throw next.error;
+    }
+    current = next;
+  }
+  return null;
+}
+
+function pullSolution(solver, solutions) {
+  const stream = solver.io.resolve('user_output');
+  const originalWrite = stream?.write;
+  let captured = '';
+  if (stream) stream.write = (text) => { captured += String(text); };
+  try {
+    return { result: solutions.next(), output: captured };
+  } catch (error) {
+    return { error, output: captured };
+  } finally {
+    if (stream) stream.write = originalWrite;
+  }
+}
+
+function queryVariables(goal) {
+  const variables = [];
+  const seen = new Set();
+  const stack = [goal];
+  while (stack.length) {
+    const term = stack.pop();
+    if (term.type === 'var') {
+      if (!term.name.startsWith('__anon') && !seen.has(term.name)) {
+        seen.add(term.name);
+        variables.push(term);
+      }
+    } else {
+      for (let i = term.args.length - 1; i >= 0; i--) stack.push(term.args[i]);
+    }
+  }
+  return variables;
+}
+
+function formatAnswer(engine, state, variables, env) {
+  const bindings = [];
+  const names = new Map(variables.map((variable) => [variable.name, variable.name]));
+  let generated = 0;
+
+  for (const variable of variables) collectUnboundVariables(engine, variable, env, names, () => `_${letterName(generated++)}`);
+  for (const variable of variables) {
+    const value = engine.deref(variable, env);
+    if (value.type === 'var' && value.name === variable.name) continue;
+    bindings.push(`${variable.name} = ${engine.formatTermForWrite(value, env, {
+      quoted: true,
+      operators: [...state.program.operators.values()],
+      variableNames: names,
+    })}`);
+  }
+  return bindings.length === 0 ? 'true' : bindings.join(', ');
+}
+
+function collectUnboundVariables(engine, term, env, names, nextName) {
+  const stack = [term];
+  const seen = new Set();
+  while (stack.length) {
+    const current = engine.deref(stack.pop(), env);
+    if (current.type === 'var') {
+      if (!seen.has(current.name)) {
+        seen.add(current.name);
+        if (!names.has(current.name)) names.set(current.name, nextName());
+      }
+    } else {
+      for (let i = current.args.length - 1; i >= 0; i--) stack.push(current.args[i]);
+    }
+  }
+}
+
+function letterName(index) {
+  const letter = String.fromCharCode(65 + (index % 26));
+  const suffix = Math.floor(index / 26);
+  return suffix === 0 ? letter : `${letter}${suffix}`;
+}
+
+function formatError(error) {
+  const message = error?.message ?? String(error);
+  return message.endsWith('.') ? message : `${message}.`;
+}

package/test/conformance/ISO-MATRIX.md

@@ -19,7 +19,7 @@ case totals.
 | 8.17 flags and hooks | required flags, mutation permissions, halt and character conversion | `exceptions_and_flags`, `remaining_builtins_and_directives`, flag error cases |
 | Clause 9 evaluable functors | integer, float, rounding, transcendental and bitwise operations | `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power` |
 | ISO/IEC 13211-2 modules | module declarations, exports, imports, qualification, meta-predicate context | `modules/qualified_call`, `modules/selective_library_import`, `dcg_module_nonterminal_indicator` |
-| ISO/IEC TS 13211-3 grammar rules | `-->`, terminal sequences, grammar control constructs, semicontexts, nonterminal indicators, `phrase/2-3` | `dcg_terminals_and_remainder`, `dcg_control_constructs`, `dcg_call_phrase_semicontext`, DCG error cases |
+| ISO/IEC TS 13211-3 grammar rules | `-->`, terminal and partial sequences, grammar control constructs, semicontexts, nonterminal indicators, modules, `phrase/2-3`, steadfastness and errors | `dcg_terminals_and_remainder`, `dcg_control_constructs`, `dcg_partial_sequences`, `dcg_phrase_steadfastness`, `dcg_dynamic_nonterminal_indicator`, `logtalk_dcg_phrase_identity`, `logtalk_dcg_semicontexts`, DCG error and precedence cases |
 
 Corrigendum-specific coverage includes double-quoted atom operator priority
 (Cor.1); the added predicates and evaluable functors, bar-operator rules,

package/test/conformance/README.md

@@ -90,11 +90,11 @@ ISO/IEC 13211-1 clauses 7 and 8. In particular, isolated negative cases keep
 instantiation, type, domain, permission, representation, and evaluation errors
 independently observable.
 
-Selected cases are adapted from the ISO and standard-core suites of Scryer
-Prolog, Trealla Prolog, and SWI-Prolog. Their upstream identifiers and licenses
+Selected cases are adapted from the ISO and standard-core suites of Logtalk,
+Scryer Prolog, Trealla Prolog, and SWI-Prolog. Their upstream identifiers and licenses
 are recorded in [THIRD_PARTY.md](THIRD_PARTY.md).
 
-The corpus has 313 cases in `iso/` and 719 file-based conformance cases in
+The corpus has 373 cases in `iso/` and 779 file-based conformance cases in
 total. The generated `conformance-report.md` is the authoritative source for
 current category totals. Together with regression, documentation-sync, API,
 example, and book-example checks, `npm test` is the release gate.

package/test/conformance/THIRD_PARTY.md

@@ -9,6 +9,13 @@ identifies its upstream test names. The cases were rewritten for EyeProlog's
 file-based query and exact-output harness and are therefore modified from the
 upstream files.
 
+Part 3 grammar cases are additionally adapted from Logtalk's
+`tests/logtalk/methods/phrase_2_3/tests.lgt` and
+`tests/logtalk/dcgs/tests.lgt` suites. Object and unit-test scaffolding was
+removed, translator-only assertions were converted to executable grammar
+behavior where possible, and expected list errors follow the Part 3
+`terminal_sequence` terminology used by EyeProlog.
+
 Copyright 1998-2026 Paulo Moura <pmoura@logtalk.org>
 
 Licensed under the Apache License, Version 2.0 (the "License"); you may not use

package/test/conformance/cases/iso/dcg_ambiguous_alternatives.pl

@@ -0,0 +1,8 @@
+% Ambiguous grammars retain every distinct semantic result.
+%% goal: ambiguity(X0)
+
+reading(first) --> [token].
+reading(second) --> [token].
+
+ambiguity(Readings) :-
+    findall(Reading, phrase(reading(Reading), [token]), Readings).

package/test/conformance/cases/iso/dcg_declaration_nonterminal_indicators.pl

@@ -0,0 +1,7 @@
+% Source organization directives accept Part 3 nonterminal indicators.
+:- multifile(shared//0).
+:- discontiguous(shared//0).
+
+shared --> [x].
+
+%% goal: phrase(shared, [x])

package/test/conformance/cases/iso/dcg_double_quotes_atom.pl

@@ -0,0 +1,7 @@
+% In atom mode, a double-quoted grammar body names a nonterminal.
+:- set_prolog_flag(double_quotes, atom).
+
+ab --> [recognized].
+uses_atom_body --> "ab".
+
+%% goal: phrase(uses_atom_body, Tokens)

package/test/conformance/cases/iso/dcg_double_quotes_codes.pl

@@ -0,0 +1,6 @@
+% Double-quoted terminal sequences honor the active Part 1 flag.
+:- set_prolog_flag(double_quotes, codes).
+
+codes --> "ab".
+
+%% goal: phrase(codes, Tokens)

package/test/conformance/cases/iso/dcg_dynamic_body_control.pl

@@ -0,0 +1,15 @@
+% phrase/2 expands dynamically constructed grammar bodies using static semantics.
+%% goal: dynamic_body(X0, X1)
+
+dynamic_body(sequence, Tokens) :-
+    Body = ([a], [b]),
+    phrase(Body, Tokens).
+dynamic_body(choice, Tokens) :-
+    Body = ([a]; [b]),
+    phrase(Body, Tokens).
+dynamic_body(embedded, Tokens) :-
+    Body = ({true}, [ok]),
+    phrase(Body, Tokens).
+dynamic_body(conditional, Tokens) :-
+    Body = ([x] -> [yes]; [no]),
+    phrase(Body, Tokens).

package/test/conformance/cases/iso/dcg_dynamic_nonterminal_indicator.pl

@@ -0,0 +1,7 @@
+% dynamic/1 accepts Part 3 nonterminal indicators and maps them to arity + 2.
+:- dynamic(token//1).
+
+%% goal: dynamic_nonterminal(X0)
+dynamic_nonterminal(asserted) :-
+    assertz(token(x, [x], [])),
+    phrase(token(x), [x]).

package/test/conformance/cases/iso/dcg_explicit_qualified_head.pl

@@ -0,0 +1,6 @@
+% An explicitly qualified grammar-rule head defines the expanded predicate
+% in the named module even without a surrounding module declaration.
+
+dcg_explicit:word --> [x].
+
+%% goal: phrase(dcg_explicit:word, [x])

package/test/conformance/cases/iso/dcg_nested_phrase_call.pl

@@ -0,0 +1,6 @@
+% phrase//1 and call//1 compose nested grammar invocations.
+
+inner --> [i].
+outer --> phrase(inner), call(inner), [o].
+
+%% goal: phrase(outer, Tokens)

package/test/conformance/cases/iso/dcg_operator_table.pl

@@ -0,0 +1,5 @@
+% Part 3 installs the grammar-rule and alternative operators.
+%% goal: dcg_operator(X0, X1, X2)
+
+dcg_operator('-->', 1200, xfx) :- current_op(1200, xfx, '-->').
+dcg_operator('|', 1105, xfy) :- current_op(1105, xfy, '|').

package/test/conformance/cases/iso/dcg_partial_sequences.pl

@@ -0,0 +1,12 @@
+% Part 3 phrase/3 accepts partial terminal sequences and preserves their tail.
+%% goal: partial_sequence(X0)
+
+partial_sequence(one) :-
+    phrase([a], [a|Tail], Tail),
+    Tail = [rest].
+partial_sequence(two) :-
+    phrase([a, b], [a, b|Tail], Tail),
+    Tail = [rest].
+partial_sequence(empty) :-
+    phrase([], Tail, Tail),
+    Tail = [rest].

package/test/conformance/cases/iso/dcg_phrase_steadfastness.pl

@@ -0,0 +1,14 @@
+% phrase/3 is steadfast in its third argument.
+%% goal: steadfast(X0)
+
+steadfast(bound_before) :-
+    Rest = [b],
+    phrase([a], [a, b], Rest).
+steadfast(bound_after) :-
+    phrase([a], [a, b], Rest),
+    Rest = [b].
+steadfast(selects_matching_alternative) :-
+    phrase(([a]; [a, b]), [a, b], [b]).
+steadfast(shared_sequence) :-
+    phrase([], Sequence, Sequence),
+    Sequence = [same].

package/test/conformance/cases/iso/dcg_qualified_chain.pl

@@ -0,0 +1,10 @@
+% Qualified nonterminals retain module context through nested phrase//1 calls.
+:- module(dcg_chain, [leaf//0, branch//0, wrapper//0, answer/1]).
+
+leaf --> [x].
+branch --> dcg_chain:leaf.
+wrapper --> phrase(dcg_chain:branch).
+answer(Tokens) :- phrase(wrapper, Tokens).
+
+%% goal: dcg_chain:answer(Tokens)
+%% goal: phrase(dcg_chain:wrapper, Tokens)