eyeprolog 1.1.0 → 1.1.1

package/README.md

@@ -33,9 +33,19 @@ Programs may declare their default queries with `%% goal:` comments.
 Double-quoted text follows the ISO `double_quotes` flag and defaults to a
 proper list of one-character atoms (`chars`), matching Trealla and Scryer.
 
-## Standard library modules
+## ISO modules and definite clause grammars
 
-EyeProlog adds 44 public library predicates to its 127-entry ISO core registry.
+EyeProlog implements ISO/IEC 13211-2 modules and the grammar rules and
+`phrase/2-3` predicates of ISO/IEC TS 13211-3:2025. For example:
+
+```prolog
+sentence --> [hello], noun.
+noun --> [world] | [prolog].
+
+%% goal: phrase(sentence, Words)
+```
+
+EyeProlog also adds 44 public library predicates to its 129-entry ISO registry.
 **All 44 are ordinary Prolog clauses** in `src/lib/eyeprolog.pl` and
 `src/lib/lists.pl`. They are ISO/IEC 13211-2 modules, loaded explicitly with
 `use_module(library(eyeprolog))` or `use_module(library(lists))`, following the

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 | 130 | 174 | 0 | 0 | 304 |
+| iso | 135 | 178 | 0 | 0 | 313 |
 | 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** | **445** | **225** | **19** | **21** | **710** |
+| **Total** | **450** | **229** | **19** | **21** | **719** |

package/examples/book/README.md

@@ -127,7 +127,7 @@ npm run generate
 - [01-tree.pl](chapter-22/01-tree.pl)
 - [02-tree_member.pl](chapter-22/02-tree_member.pl)
 - [03-mirror.pl](chapter-22/03-mirror.pl) — Transforming a tree
-- [04-sentence.pl](chapter-22/04-sentence.pl) — A grammar without special syntax
+- [04-sentence.pl](chapter-22/04-sentence.pl) — A standard definite clause grammar
 - [05-evaluate.pl](chapter-22/05-evaluate.pl) — Interpreting an expression
 - [06-lookup.pl](chapter-22/06-lookup.pl)
 - [07-simplify.pl](chapter-22/07-simplify.pl) — Rewriting symbolic expressions
@@ -233,6 +233,7 @@ npm run generate
 ## Chapter 38: Language and ISO profile
 
 - [01-city.pl](chapter-38/01-city.pl)
+- [02-look_ahead.pl](chapter-38/02-look_ahead.pl) — ISO Part 3 definite clause grammars
 
 ## Chapter 39: Built-in predicates by programming role
 

package/examples/book/chapter-22/04-sentence.pl

@@ -1,19 +1,15 @@
-% From The Art of EyeProlog, Chapter 22 — A grammar without special syntax.
-sentence(Input, Rest) :-
-  noun_phrase(Input, AfterNoun),
-  verb_phrase(AfterNoun, Rest).
+% From The Art of EyeProlog, Chapter 22 — A standard definite clause grammar.
+sentence --> noun_phrase, verb_phrase.
 
-noun_phrase([the | Input], Rest) :- noun(Input, Rest).
-noun_phrase([a | Input], Rest) :- noun(Input, Rest).
+noun_phrase --> [the], noun.
+noun_phrase --> [a], noun.
 
-noun([robot | Rest], Rest).
-noun([scientist | Rest], Rest).
+noun --> [robot].
+noun --> [scientist].
 
-verb_phrase(Input, Rest) :-
-  verb(Input, AfterVerb),
-  noun_phrase(AfterVerb, Rest).
+verb_phrase --> verb, noun_phrase.
 
-verb([helps | Rest], Rest).
-verb([observes | Rest], Rest).
+verb --> [helps].
+verb --> [observes].
 
-complete_sentence(Words) :- sentence(Words, []).
+complete_sentence(Words) :- phrase(sentence, Words).

package/examples/book/chapter-38/02-look_ahead.pl

@@ -0,0 +1,2 @@
+% From The Art of EyeProlog, Chapter 38 — ISO Part 3 definite clause grammars.
+look_ahead(X), [X] --> [X].

package/examples/dcg-command-parser.pl

@@ -0,0 +1,26 @@
+% Parse and generate commands for a tiny home-automation language with a DCG.
+%
+% The grammar separates surface tokens from the structured command term used
+% by an application.  phrase/2 requires complete input, while phrase/3 leaves
+% unconsumed tokens available to a surrounding parser.
+%% goal: dcg_example(X0, X1)
+
+command(set(light(Room), State)) -->
+  [set], room(Room), [light, to], state(State).
+
+room(kitchen) --> [kitchen].
+room(hall) --> [hall].
+
+state(on) --> [on].
+state(off) --> [off].
+
+dcg_example(parsed, Command) :-
+  phrase(command(Command), [set, kitchen, light, to, on]).
+dcg_example(generated, Tokens) :-
+  phrase(command(set(light(hall), off)), Tokens).
+dcg_example(remainder, Rest) :-
+  phrase(command(set(light(kitchen), on)),
+         [set, kitchen, light, to, on, then, wait],
+         Rest).
+dcg_example(rejected, invalid_command) :-
+  \+ phrase(command(_), [set, garage, light, to, blinking]).

package/examples/output/dcg-command-parser.pl

@@ -0,0 +1,4 @@
+dcg_example(parsed, set(light(kitchen), on)).
+dcg_example(generated, [set, hall, light, to, off]).
+dcg_example(remainder, [then, wait]).
+dcg_example(rejected, invalid_command).

package/package.json

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

package/playground.html

@@ -475,6 +475,7 @@
           "control-system",
           "critical-path-schedule",
           "cyclic-path",
+          "dcg-command-parser",
           "d3-group",
           "dairy-energy-balance",
           "data-negotiation",

package/src/dcg.js

@@ -0,0 +1,241 @@
+// ISO/IEC TS 13211-3:2025 definite clause grammar expansion.
+// Grammar rules are lowered to ordinary clauses during program preparation;
+// phrase/2-3 use the same body expansion for dynamically supplied grammars.
+import {
+  ATOM, COMPOUND, VAR, Env, atom, compound, deref, emptyList,
+  flattenConjunction, variable,
+} from './term.js';
+import { PrologError } from './iso.js';
+
+let dcgFresh = 0;
+
+function freshDcgVariable(label = 'S') {
+  // NUL cannot occur in a source variable name, so generated difference-list
+  // variables cannot capture a variable written by the program.
+  return variable(`\u0000dcg${++dcgFresh}:${label}`);
+}
+
+function conjunction(first, second) {
+  return compound(',', [first, second]);
+}
+
+function equality(left, right) {
+  return compound('=', [left, right]);
+}
+
+function listWithTail(items, tail) {
+  let list = tail;
+  for (let index = items.length - 1; index >= 0; index--) {
+    list = compound('.', [items[index], list]);
+  }
+  return list;
+}
+
+function terminalItems(term, env = new Env()) {
+  const items = [];
+  const original = term;
+  const seen = new Set();
+  let cursor = deref(term, env);
+  while (cursor.type === COMPOUND && cursor.name === '.' && cursor.arity === 2) {
+    if (seen.has(cursor)) throw new PrologError('type_error(terminal_sequence)', original);
+    seen.add(cursor);
+    items.push(cursor.args[0]);
+    cursor = deref(cursor.args[1], env);
+  }
+  if (cursor.type === ATOM && cursor.name === '[]') return items;
+  if (cursor.type === VAR) throw new PrologError('instantiation_error');
+  throw new PrologError('type_error(terminal_sequence)', original);
+}
+
+function terminalsGoal(terminals, input, output, env) {
+  return equality(input, listWithTail(terminalItems(terminals, env), output));
+}
+
+function appendStateArguments(nonterminal, input, output, module) {
+  nonterminal = deref(nonterminal, new Env());
+  if (nonterminal.type === ATOM) {
+    const goal = compound(nonterminal.name, [input, output]);
+    goal.module = module;
+    return goal;
+  }
+  if (nonterminal.type !== COMPOUND) throw new PrologError('type_error(callable)', nonterminal);
+  if (nonterminal.name === ':' && nonterminal.arity === 2) {
+    const qualifier = nonterminal.args[0];
+    if (qualifier.type === VAR) throw new PrologError('instantiation_error');
+    if (qualifier.type !== ATOM) throw new PrologError('type_error(atom)', qualifier);
+    return compound(':', [qualifier, appendStateArguments(nonterminal.args[1], input, output, qualifier.name)]);
+  }
+  const goal = compound(nonterminal.name, [...nonterminal.args, input, output]);
+  goal.module = nonterminal.module ?? module;
+  return goal;
+}
+
+function markGoalModule(term, module) {
+  if (!term || (term.type !== ATOM && term.type !== COMPOUND)) return term;
+  term.module ??= module;
+  if (term.type === COMPOUND &&
+      [',', ';', '->', '\\+', 'call', 'once', 'catch', 'phrase'].includes(term.name)) {
+    for (const argument of term.args) markGoalModule(argument, module);
+  }
+  return term;
+}
+
+function isTerminalSequence(term) {
+  return (term.type === ATOM && term.name === '[]') ||
+    (term.type === COMPOUND && term.name === '.' && term.arity === 2);
+}
+
+export function expandDcgBody(body, input, output, options = {}) {
+  const env = options.env ?? new Env();
+  const module = options.module ?? 'user';
+  body = deref(body, env);
+
+  if (body.type === VAR) {
+    const goal = compound('phrase', [body, input, output]);
+    goal.module = module;
+    return goal;
+  }
+
+  if (isTerminalSequence(body)) return terminalsGoal(body, input, output, env);
+
+  if (body.type === COMPOUND && body.name === ',' && body.arity === 2) {
+    const middle = freshDcgVariable('sequence');
+    return conjunction(
+      expandDcgBody(body.args[0], input, middle, options),
+      expandDcgBody(body.args[1], middle, output, options),
+    );
+  }
+
+  if (body.type === COMPOUND && [';', '|'].includes(body.name) && body.arity === 2) {
+    const left = body.args[0];
+    if (body.name === ';' && left.type === COMPOUND && left.name === '->' && left.arity === 2) {
+      const middle = freshDcgVariable('condition');
+      return compound(';', [
+        compound('->', [
+          expandDcgBody(left.args[0], input, middle, options),
+          expandDcgBody(left.args[1], middle, output, options),
+        ]),
+        expandDcgBody(body.args[1], input, output, options),
+      ]);
+    }
+    return compound(';', [
+      expandDcgBody(left, input, output, options),
+      expandDcgBody(body.args[1], input, output, options),
+    ]);
+  }
+
+  if (body.type === COMPOUND && body.name === '{}' && body.arity === 1) {
+    return conjunction(markGoalModule(body.args[0], module), equality(input, output));
+  }
+
+  if (body.type === COMPOUND && body.name === 'call' && body.arity === 1) {
+    const closure = body.args[0];
+    if (closure.type === ATOM || closure.type === COMPOUND) closure.module ??= module;
+    const goal = compound('call', [closure, input, output]);
+    goal.module = module;
+    return goal;
+  }
+
+  if (body.type === COMPOUND && body.name === 'phrase' && body.arity === 1) {
+    const goal = compound('phrase', [body.args[0], input, output]);
+    goal.module = module;
+    return goal;
+  }
+
+  if (body.type === ATOM && body.name === '!') {
+    return conjunction(body, equality(input, output));
+  }
+
+  // TS 13211-3 leaves \+//1 and ->//2 implementation dependent.  EyeProlog
+  // uses the widespread non-consuming negation and state-threading if-then
+  // definitions and documents these choices in its conformance profile.
+  if (body.type === COMPOUND && body.name === '\\+' && body.arity === 1) {
+    const ignored = freshDcgVariable('negated');
+    return conjunction(
+      compound('\\+', [expandDcgBody(body.args[0], input, ignored, options)]),
+      equality(input, output),
+    );
+  }
+
+  if (body.type === COMPOUND && body.name === '->' && body.arity === 2) {
+    const middle = freshDcgVariable('condition');
+    return compound('->', [
+      expandDcgBody(body.args[0], input, middle, options),
+      expandDcgBody(body.args[1], middle, output, options),
+    ]);
+  }
+
+  if (body.type !== ATOM && body.type !== COMPOUND) {
+    throw new PrologError('type_error(callable)', body);
+  }
+  return appendStateArguments(body, input, output, module);
+}
+
+function splitGrammarHead(head) {
+  let terminals = null;
+  if (head.type === COMPOUND && head.name === ',' && head.arity === 2) {
+    terminals = head.args[1];
+    head = head.args[0];
+  }
+  let module = null;
+  if (head.type === COMPOUND && head.name === ':' && head.arity === 2) {
+    if (head.args[0].type === VAR) throw new PrologError('instantiation_error');
+    if (head.args[0].type !== ATOM) throw new PrologError('type_error(atom)', head.args[0]);
+    module = head.args[0].name;
+    head = head.args[1];
+  }
+  if (head.type === VAR) throw new PrologError('instantiation_error');
+  if (head.type !== ATOM && head.type !== COMPOUND) throw new PrologError('type_error(callable)', head);
+  if (isTerminalSequence(head) ||
+      (head.type === COMPOUND && [',', ';', '|', '->', '{}'].includes(head.name)) ||
+      (head.type === ATOM && ['!', '{}'].includes(head.name))) {
+    throw new PrologError('permission_error(define, grammar_rule)', head);
+  }
+  return { head, terminals, module };
+}
+
+export function expandDcgRuleClause(clause, defaultModule = 'user') {
+  if (clause?.body?.length !== 0 || clause?.head?.type !== COMPOUND ||
+      clause.head.name !== '-->' || clause.head.arity !== 2) return null;
+
+  const declaration = splitGrammarHead(clause.head.args[0]);
+  const module = declaration.module ?? defaultModule;
+  const input = freshDcgVariable('input');
+  const output = freshDcgVariable('output');
+  const expandedHead = appendStateArguments(declaration.head, input, output, module);
+  delete expandedHead.module;
+
+  let bodyOutput = output;
+  if (declaration.terminals != null) bodyOutput = freshDcgVariable('semicontext');
+  let expandedBody = expandDcgBody(clause.head.args[1], input, bodyOutput, { module });
+  if (declaration.terminals != null) {
+    expandedBody = conjunction(
+      expandedBody,
+      terminalsGoal(declaration.terminals, output, bodyOutput, new Env()),
+    );
+  }
+
+  const expanded = {
+    head: expandedHead,
+    body: flattenConjunction(expandedBody),
+    module,
+    grammarRule: clause.head,
+  };
+  if (clause.source) expanded.source = clause.source;
+  return expanded;
+}
+
+export function isListOrPartialList(term, env) {
+  const seen = new Set();
+  let cursor = deref(term, env);
+  while (cursor.type === COMPOUND && cursor.name === '.' && cursor.arity === 2) {
+    if (seen.has(cursor)) return false;
+    seen.add(cursor);
+    cursor = deref(cursor.args[1], env);
+  }
+  return cursor.type === VAR || (cursor.type === ATOM && cursor.name === '[]');
+}
+
+export function emptyTerminalSequence() {
+  return emptyList();
+}

package/src/iso.js

@@ -7,6 +7,7 @@ import {
 } from './term.js';
 import { createParserOperatorState, parseClauses } from './parser.js';
 import { formatTermForWrite } from './write.js';
+import { emptyTerminalSequence, expandDcgBody, isListOrPartialList } from './dcg.js';
 
 let isoFresh = 0;
 
@@ -150,6 +151,8 @@ export const isoBuiltins = {
     registry.add('repeat', 0, repeatBuiltin);
     registry.add(';', 2, disjunctionBuiltin);
     registry.add('->', 2, ifThenBuiltin);
+    registry.add('phrase', 2, phraseBuiltin);
+    registry.add('phrase', 3, phraseBuiltin);
 
     registry.add('is', 2, isBuiltin, { deterministic: true });
     registry.add('=:=', 2, arithmeticComparison((n) => n === 0), { deterministic: true });
@@ -1545,6 +1548,38 @@ function* callClosureBuiltin({ solver, goal, env }) {
     solver.absorbStatsFrom(child);
   }
 }
+
+function* phraseBuiltin({ solver, goal, env }) {
+  const grammarBody = deref(goal.args[0], env);
+  if (grammarBody.type === VAR) throw new PrologError('instantiation_error');
+  if (grammarBody.type !== ATOM && grammarBody.type !== COMPOUND) {
+    throw new PrologError('type_error(callable)', grammarBody);
+  }
+
+  const input = goal.args[1];
+  const requestedOutput = goal.arity === 2 ? emptyTerminalSequence() : goal.args[2];
+  if (!isListOrPartialList(input, env)) {
+    throw new PrologError('type_error(terminal_sequence)', deref(input, env));
+  }
+  if (!isListOrPartialList(requestedOutput, env)) {
+    throw new PrologError('type_error(terminal_sequence)', deref(requestedOutput, env));
+  }
+
+  // Delay the final output unification to keep phrase/3 steadfast in its
+  // third argument, as required by the Part 3 execution model.
+  const finalOutput = variable(`\u0000phrase:${++isoFresh}`);
+  const expanded = expandDcgBody(grammarBody, input, finalOutput, {
+    env,
+    module: goal.module ?? grammarBody.module ?? 'user',
+  });
+  const finish = compound('=', [finalOutput, requestedOutput]);
+  const child = solver.cloneForInnerGoal();
+  try {
+    yield* child.solve([expanded, finish], env, 0);
+  } finally {
+    solver.absorbStatsFrom(child);
+  }
+}
 function formalErrorTerm(error) {
   const parse = (text) => {
     const open = text.indexOf('(');
@@ -1625,7 +1660,14 @@ function* disjunctionBuiltin({ solver, goal, env }) {
     yield* solver.solve([callable(goal.args[1], env)], env.clone(), 0);
     return;
   }
+  const marker = solver.active[solver.active.length - 1] ?? null;
+  const markerCutEpoch = marker?.cutEpoch ?? 0;
+  const solverCutEpoch = solver.cutEpoch;
   yield* solver.solve([callable(goal.args[0], env)], env.clone(), 0);
+  const cutThisScope = marker == null
+    ? solver.cutEpoch !== solverCutEpoch
+    : (marker.cutEpoch ?? 0) !== markerCutEpoch;
+  if (cutThisScope) return;
   yield* solver.solve([callable(goal.args[1], env)], env.clone(), 0);
 }
 function* ifThenBuiltin({ solver, goal, env }) {

package/src/parser.js

@@ -39,6 +39,8 @@ const graphicAtomChars = '#$&*+-./<=>@^~\\;:';
 // canonical notation. Commas remain separators except inside parentheses.
 const INFIX_OPERATORS = new Map([
   [':-', { precedence: 2, associativity: 'none' }],
+  ['-->', { precedence: 2, associativity: 'none' }],
+  ['|', { precedence: 4, associativity: 'right' }],
   [';', { precedence: 5, associativity: 'right' }],
   ['->', { precedence: 7, associativity: 'right' }],
   [',', { precedence: 10, associativity: 'right' }],
@@ -82,7 +84,8 @@ const PREFIX_OPERATORS = new Map([
 ]);
 
 export const ISO_OPERATOR_DEFINITIONS = [
-  [1200, 'xfx', ':-'], [1200, 'fx', ':-'],
+  [1200, 'xfx', ':-'], [1200, 'fx', ':-'], [1200, 'xfx', '-->'],
+  [1105, 'xfy', '|'],
   [1100, 'xfy', ';'], [1050, 'xfy', '->'], [1000, 'xfy', ','],
   [900, 'fy', '\\+'],
   ...['=', '=..', '\\=', '==', '\\==', '@<', '@=<', '@>', '@>=', 'is',
@@ -618,7 +621,25 @@ class Parser {
         accept(clause);
         continue;
       }
-      const head = this.parseTerm(3);
+      let head = this.parseTerm(3);
+      // ISO/IEC TS 13211-3 grammar rules use -->/2 at the same top-level
+      // priority as clauses.  The left side may include an unparenthesized
+      // semicontext: NonTerminal, Terminals --> Body.
+      if (this.token.type === TOK.COMMA) {
+        this.advance();
+        head = compound(',', [head, this.parseTerm(3)]);
+      }
+      if (this.operatorTokenName() === '-->') {
+        this.advance();
+        const grammarBody = this.parseTerm(0, true);
+        this.expect(TOK.DOT, '.');
+        this.advance();
+        const clause = { head: compound('-->', [head, grammarBody]), body: [] };
+        clauseNumber++;
+        if (this.sourceMetadata) clause.source = { filename: this.filename, line, clause: clauseNumber };
+        accept(clause);
+        continue;
+      }
       const body = [];
       if (this.token.type === TOK.IF) {
         this.advance();

package/src/program.js

@@ -11,6 +11,7 @@ import {
 import { PrologError } from './iso.js';
 import { currentWorkingDirectory, fs, path } from './platform.js';
 import { standardLibrarySources } from './standard-library.js';
+import { expandDcgRuleClause } from './dcg.js';
 
 const DEFER_PROGRAM_BUILD = Symbol('deferProgramBuild');
 const FAST_PARSE_ABORT = Symbol('fastParseAbort');
@@ -663,6 +664,8 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
     batch.length = 0;
   };
   const accept = (clause) => {
+    const grammarClause = expandDcgRuleClause(clause, context.module);
+    if (grammarClause) clause = grammarClause;
     const moduleDeclaration = moduleDirective(clause);
     if (moduleDeclaration) {
       flush();
@@ -690,9 +693,9 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
     }
     const include = includeDirective(clause);
     if (!include) {
-      clause.module = context.module;
+      clause.module ??= context.module;
       if (!isDirectiveClause(clause)) {
-        for (const goal of clause.body) annotateGoalModule(goal, context.module);
+        for (const goal of clause.body) annotateGoalModule(goal, clause.module);
       }
       batch.push(clause);
       if (batch.length >= PROGRAM_BUILD_BATCH_SIZE) flush();
@@ -759,9 +762,14 @@ function moduleExportIndicators(term) {
   if (items == null) return null;
   const indicators = [];
   for (const item of items) {
-    if (item.type !== COMPOUND || item.name !== '/' || item.arity !== 2) return null;
+    if (item.type !== COMPOUND || !['/', '//'].includes(item.name) || item.arity !== 2) return null;
     const indicator = predicateIndicator(item.args[0], item.args[1]);
     if (!indicator) return null;
+    if (item.name === '//') {
+      indicator.arity += 2;
+      indicator.key = `${indicator.name}/${indicator.arity}`;
+      indicator.nonterminalArity = indicator.arity - 2;
+    }
     indicators.push(indicator);
   }
   return indicators;
@@ -844,12 +852,21 @@ function dynamicDirectiveIndicators(clause) {
   if (directive.type !== COMPOUND || directive.name !== 'dynamic' || directive.arity !== 1) return [];
   const terms = properListItems(directive.args[0], new Env()) ?? flattenDirectiveSequence(directive.args[0]);
   return terms.map((indicator) =>
-    indicator.type === COMPOUND && indicator.name === '/' && indicator.arity === 2
-      ? predicateIndicator(indicator.args[0], indicator.args[1])
+    indicator.type === COMPOUND && ['/', '//'].includes(indicator.name) && indicator.arity === 2
+      ? nonterminalOrPredicateIndicator(indicator)
       : null
   ).filter(Boolean);
 }
 
+function nonterminalOrPredicateIndicator(term) {
+  const indicator = predicateIndicator(term.args[0], term.args[1]);
+  if (!indicator || term.name !== '//') return indicator;
+  indicator.arity += 2;
+  indicator.key = `${indicator.name}/${indicator.arity}`;
+  indicator.nonterminalArity = indicator.arity - 2;
+  return indicator;
+}
+
 function flattenDirectiveSequence(term) {
   if (term.type === COMPOUND && term.name === ',' && term.arity === 2) {
     return [...flattenDirectiveSequence(term.args[0]), ...flattenDirectiveSequence(term.args[1])];

package/src/solver.js

@@ -61,6 +61,7 @@ export class Solver {
     this.io = options.io ?? new StreamManager(options.ioOptions);
     this.solveStacks = [];
     this.active = [];
+    this.cutEpoch = 0;
     this.memo = new Map();
     this.tableCoordinator = null;
     this.groundChainSuccess = new Set();
@@ -215,10 +216,12 @@ export class Solver {
         // be run early as pure filters. Stop at internal sentinels so rule-body
         // active guards are released before the caller's remaining goals are seen.
         const selectedIndex = selectReadyDeterministicBuiltin(goals, env, this.registry);
-        const goal = goals[selectedIndex];
+        const goal = deref(goals[selectedIndex], env);
         const rest = selectedIndex === 0 ? goals.slice(1) : [...goals.slice(0, selectedIndex), ...goals.slice(selectedIndex + 1)];
         if (goal.type === 'atom' && goal.name === '!' && goal.arity === 0) {
           const marker = active[active.length - 1] ?? null;
+          this.cutEpoch++;
+          if (marker) marker.cutEpoch = (marker.cutEpoch ?? 0) + 1;
           for (const solveStack of this.solveStacks) {
             for (let i = solveStack.length - 1; i >= 0; i--) {
               if (marker == null || solveStack[i].active?.includes(marker)) solveStack.splice(i, 1);
@@ -247,7 +250,9 @@ export class Solver {
           continue;
         }
 
+        if (goal.type === 'var') throw new PrologError('instantiation_error');
         const callable = goal.type === COMPOUND || goal.type === 'atom';
+        if (!callable) throw new PrologError('type_error(callable)', goal);
         const def = callable ? this.registry.get(goal.name, goal.arity) : null;
         this.active = active;
         if (def && builtinIsReadyOrAuthoritative(def, this, goal, env)) {
@@ -274,7 +279,6 @@ export class Solver {
         }
 
         this.stats.solve_one_goal_calls++;
-        if (!callable) break;
         const group = this.program.findGroup(goal.name, goal.arity, goal.module ?? 'user');
         if (!group) {
           if (this.prologFlags.get('unknown')?.value?.name === 'error') {

package/test/conformance/ISO-MATRIX.md

@@ -1,4 +1,4 @@
-# ISO/IEC 13211-1 conformance matrix
+# ISO Prolog conformance matrix
 
 The normative baseline for the `iso/` corpus is ISO/IEC 13211-1:1995 plus
 Technical Corrigenda 1:2007, 2:2012, and 3:2017. This matrix links the standard
@@ -18,6 +18,8 @@ case totals.
 | 8.16 atomic processing | atoms, characters, codes and number conversion with prescribed errors | `atomic_term_processing`, focused forward/reverse cases, Logtalk-derived error cases |
 | 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 |
 
 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

@@ -7,13 +7,15 @@ supported ISO Prolog profile, built-ins, extensions, and reasoner behavior.
 
 The suite is intentionally file-based. Exact standard output, errors, warnings,
 and proof output test the behavior of the JavaScript implementation.
-[ISO-MATRIX.md](ISO-MATRIX.md) maps normative clause families and all three
-corrigenda to representative executable cases.
+[ISO-MATRIX.md](ISO-MATRIX.md) maps Part 1 normative clause families, all three
+corrigenda, Part 2 modules, and Part 3 definite clause grammars to representative
+executable cases.
 
 “Conformance” here means conformance to EyeProlog's documented ISO compatibility
 profile and implementation extensions. The default registry covers the exact
 predicate indicators listed in Appendix B of the book across the supported
-ISO/IEC 13211-1:1995 standard families. This suite is still not an independent certification of
+ISO/IEC 13211-1:1995, ISO/IEC 13211-2:2000, and ISO/IEC TS 13211-3:2025
+standard families. This suite is still not an independent certification of
 every processor requirement, lexical edge, option combination, or prescribed
 error precedence. Cases under `iso/` identify standards-derived behavior;
 other directories cover EyeProlog host contracts and extensions.
@@ -92,7 +94,7 @@ Selected cases are adapted from the ISO and standard-core suites of Scryer
 Prolog, Trealla Prolog, and SWI-Prolog. Their upstream identifiers and licenses
 are recorded in [THIRD_PARTY.md](THIRD_PARTY.md).
 
-The corpus has 304 cases in `iso/` and 710 file-based conformance cases in
+The corpus has 313 cases in `iso/` and 719 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/cases/iso/cut_disjunction_scope.pl

@@ -0,0 +1,5 @@
+% ISO cut discards choices in its own invocation but not its caller.
+inner(X) :- (X = a, ! ; X = b).
+outer(X) :- (inner(X) ; X = c).
+
+%% goal: outer(X)

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

@@ -0,0 +1,12 @@
+% Part 3 call//1, phrase//1, variable bodies, and semicontexts.
+match(X, [X|S], S).
+
+via_call(X) --> call(match(X)).
+via_phrase --> phrase([x, y]).
+look_ahead(X), [X] --> [X].
+variable_body(Body) --> Body.
+
+%% goal: phrase(via_call(a), [a])
+%% goal: phrase(via_phrase, X)
+%% goal: phrase(look_ahead(a), [a], R)
+%% goal: phrase(variable_body([z]), X)

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

@@ -0,0 +1,12 @@
+% Part 3 alternatives, embedded goals, if-then-else, negation and cut.
+token(X) --> [X], { atom(X) }.
+choice --> [a] | [b].
+guarded --> ([a] -> [b] ; [c]).
+not_a --> \+ [a], [_].
+committed --> ([a], ! ; [b]).
+
+%% goal: phrase(token(a), [a])
+%% goal: phrase(choice, X)
+%% goal: phrase(guarded, X)
+%% goal: phrase(not_a, [b])
+%% goal: phrase(committed, X)

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

@@ -0,0 +1,8 @@
+% Part 2 module exports combined with a Part 3 nonterminal indicator.
+:- module(dcg_vocab, [word//1, answer/1]).
+
+word(X) --> [X].
+answer(X) :- phrase(word(X), [hello]).
+
+%% goal: dcg_vocab:answer(X)
+%% goal: phrase(dcg_vocab:word(hello), [hello])

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

@@ -0,0 +1,8 @@
+% ISO/IEC TS 13211-3 terminal sequences, concatenation, parsing and generation.
+sentence --> article, noun, verb.
+article --> [the].
+noun --> [cat].
+verb --> [sleeps].
+
+%% goal: phrase(sentence, X)
+%% goal: phrase(article, [the, rest], R)

package/test/conformance/errors/iso/dcg_phrase_bad_input.pl

@@ -0,0 +1 @@
+%% goal: phrase([], not_a_terminal_sequence)

package/test/conformance/errors/iso/dcg_phrase_bad_output.pl

@@ -0,0 +1 @@
+%% goal: phrase([], [], not_a_terminal_sequence)

package/test/conformance/errors/iso/dcg_phrase_noncallable.pl

@@ -0,0 +1 @@
+%% goal: phrase(42, [])

package/test/conformance/errors/iso/dcg_phrase_variable.pl

@@ -0,0 +1 @@
+%% goal: phrase(Body, [])

package/test/conformance/expected/iso/cut_disjunction_scope.pl

@@ -0,0 +1,2 @@
+outer(a).
+outer(c).

package/test/conformance/expected/iso/dcg_call_phrase_semicontext.pl

@@ -0,0 +1,4 @@
+phrase(via_call(a), "a").
+phrase(via_phrase, "xy").
+phrase(look_ahead(a), "a", "a").
+phrase(variable_body("z"), "z").

package/test/conformance/expected/iso/dcg_control_constructs.pl

@@ -0,0 +1,6 @@
+phrase(token(a), "a").
+phrase(choice, "a").
+phrase(choice, "b").
+phrase(guarded, "ab").
+phrase(not_a, "b").
+phrase(committed, "a").

package/test/conformance/expected/iso/dcg_module_nonterminal_indicator.pl

@@ -0,0 +1,2 @@
+dcg_vocab:answer(hello).
+phrase(dcg_vocab:word(hello), [hello]).

package/test/conformance/expected/iso/dcg_terminals_and_remainder.pl

@@ -0,0 +1,2 @@
+phrase(sentence, [the, cat, sleeps]).
+phrase(article, [the, rest], [rest]).

package/test/conformance/expected-errors/iso/dcg_phrase_bad_input.txt

@@ -0,0 +1 @@
+error(type_error(terminal_sequence), not_a_terminal_sequence)

package/test/conformance/expected-errors/iso/dcg_phrase_bad_output.txt

@@ -0,0 +1 @@
+error(type_error(terminal_sequence), not_a_terminal_sequence)

package/test/conformance/expected-errors/iso/dcg_phrase_noncallable.txt

@@ -0,0 +1 @@
+error(type_error(callable), 42)

package/test/conformance/expected-errors/iso/dcg_phrase_variable.txt

@@ -0,0 +1 @@
+error(instantiation_error)

package/test/run-regression.mjs

@@ -595,7 +595,7 @@ function documentationSyncCases() {
           '<a href="https://eyereasoner.github.io/eyeprolog/the-art-of-eyeprolog">\n    <img src="book-assets/title-page.svg" alt="Read The Art of EyeProlog"',
           'README cover links to the book',
         );
-        for (const filename of ['src/iso.js', 'src/standard-library.js', 'src/lib/eyeprolog.pl', 'src/lib/lists.pl', 'src/playground-worker.js']) {
+        for (const filename of ['src/iso.js', 'src/dcg.js', 'src/standard-library.js', 'src/lib/eyeprolog.pl', 'src/lib/lists.pl', 'src/playground-worker.js']) {
           assertEqual(fs.existsSync(path.join(packageRoot, filename)), true, `${filename} exists`);
           assertIncludes(book, filename, `book documents ${filename}`);
         }
@@ -1030,7 +1030,9 @@ open(X) :- candidate(X), \\+ closed(X).
         assertEqual(Boolean(registry.get('is', 2)), true, 'ISO is/2 exists');
         assertEqual(Boolean(registry.get('append', 3)), false, 'append/3 is not ISO core');
         assertEqual(library.eyePrologLibrary, true, 'complete registry marker');
-        assertEqual(library.defs.size, 127, 'EyeProlog registry contains only ISO host definitions');
+        assertEqual(library.defs.size, 129, 'EyeProlog registry contains only ISO host definitions');
+        assertEqual(Boolean(registry.get('phrase', 2)), true, 'Part 3 phrase/2 exists');
+        assertEqual(Boolean(registry.get('phrase', 3)), true, 'Part 3 phrase/3 exists');
         assertEqual(registeredNativeEyePrologLibraryNames().length, 0, 'public native EyeProlog builtin count');
         assertEqual(eyePrologPortableLibraryIndicators.length, 44, 'portable Prolog library count');
         assertEqual(eyePrologNativeLibraryIndicators.length, 0, 'native host library count');
@@ -1111,6 +1113,26 @@ portable_check(A, B, C) :- lowercase('HELLO', A), replace('banana', 'na', 'NA',
           'answer(blue, user_local).\nqualified(ok).\n', 'module execution');
       },
     },
+    {
+      name: 'Part 3 nonterminal indicators import through Part 2 modules',
+      run: () => {
+        const directory = path.join(tmp, `dcg-modules-${++tmpCounter}`);
+        fs.mkdirSync(directory);
+        fs.writeFileSync(path.join(directory, 'vocabulary.pl'), [
+          ':- module(vocabulary, [word//1]).',
+          'word(hello) --> [hello].',
+          '',
+        ].join('\n'));
+        const source = [
+          ":- use_module('vocabulary.pl', [word//1]).",
+          'answer(X) :- phrase(word(X), [hello]).',
+          '',
+        ].join('\n');
+        const program = Program.parseSources([{ text: source, filename: 'main.pl', baseDir: directory }]);
+        assertEqual(program.findGroup('word', 3)?.module, 'vocabulary', 'word//1 imports expanded word/3');
+        assertEqual(run(program, { goal: 'answer(X)' }).stdout, 'answer(hello).\n', 'imported grammar execution');
+      },
+    },
     {
       name: 'EyeProlog library preserves relational and arithmetic behavior',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -1758,7 +1758,8 @@ truncate search; it does not prove that no further answer exists.
 ### Implementation boundary
 
 The source layout mirrors the language boundary. `src/iso.js` contains the
-isolated ISO processor predicates and registry. `src/lib/eyeprolog.pl` contains
+isolated ISO processor predicates and registry. `src/dcg.js` implements the
+shared ISO Part 3 grammar-rule and dynamic-body expansion. `src/lib/eyeprolog.pl` contains
 collision-free portable extensions, while `src/lib/lists.pl` supplies common
 list relations. Both are ordinary ISO/IEC 13211-2 modules, organized like
 Scryer's `src/lib` and registered for `library(Name)` by
@@ -2594,40 +2595,37 @@ and exchanges left and right at every level. It also suggests a structural
 induction. The empty tree is its own mirror; if both recursive calls are
 correct, the constructed parent is correct.
 
-### A grammar without special syntax
+### A standard definite clause grammar
 
-A recognizer can relate an input list to its unconsumed suffix. The pair of
-arguments makes sequencing explicit:
+ISO/IEC TS 13211-3 definite clause grammar rules describe a sequence while the
+processor supplies the pair of difference-list arguments used for execution:
 
 ```eyeprolog
-sentence(Input, Rest) :-
-  noun_phrase(Input, AfterNoun),
-  verb_phrase(AfterNoun, Rest).
+sentence --> noun_phrase, verb_phrase.
 
-noun_phrase([the | Input], Rest) :- noun(Input, Rest).
-noun_phrase([a | Input], Rest) :- noun(Input, Rest).
+noun_phrase --> [the], noun.
+noun_phrase --> [a], noun.
 
-noun([robot | Rest], Rest).
-noun([scientist | Rest], Rest).
+noun --> [robot].
+noun --> [scientist].
 
-verb_phrase(Input, Rest) :-
-  verb(Input, AfterVerb),
-  noun_phrase(AfterVerb, Rest).
+verb_phrase --> verb, noun_phrase.
 
-verb([helps | Rest], Rest).
-verb([observes | Rest], Rest).
+verb --> [helps].
+verb --> [observes].
 
-complete_sentence(Words) :- sentence(Words, []).
+complete_sentence(Words) :- phrase(sentence, Words).
 ```
 
 ```sh
 eyeprolog --goal 'complete_sentence([the, robot, helps, a, scientist])' program.pl
 ```
 
-The first argument is the list before a phrase and the second is the suffix
-after it. Composition is variable sharing: the suffix returned by
-`noun_phrase/2` becomes the input of `verb_phrase/2`. This is the central idea
-behind difference-list grammars, expressed without dedicated notation.
+The expansion of `sentence//0` is an ordinary `sentence/2` relation: its first
+extra argument is the sequence before parsing and its second is the suffix.
+Composition shares the suffix from `noun_phrase//0` with the input to
+`verb_phrase//0`. `phrase/2` requires complete consumption; `phrase/3` exposes
+the remaining sequence.
 
 The same relation can be a bounded generator when vocabulary and output length
 are constrained by surrounding relations. An unconstrained
@@ -5178,7 +5176,8 @@ The long catalogs are meant to be entered locally, not memorized linearly.
 
 The standards baseline is ISO/IEC 13211-1:1995, as corrected by Technical
 Corrigenda 1:2007, 2:2012, and 3:2017, together with the module facilities of
-ISO/IEC 13211-2. EyeProlog implements the compatibility profile documented
+ISO/IEC 13211-2 and definite clause grammars from ISO/IEC TS 13211-3:2025.
+EyeProlog implements the compatibility profile documented
 here; it does not claim certification as a complete conforming processor.
 
 Prolog source accepted by EyeProlog is UTF-8. `%` starts a line comment and
@@ -5244,6 +5243,7 @@ lowered to ordinary compound terms:
 
 - prefix: `\+`, unary `+`, unary `-`, and `\`;
 - control: `,`, `;`, and `->`;
+- grammar rules: `-->` and the Part 3 alternative `|`;
 - unification and comparison: `=`, `\=`, `==`, `\==`, `@<`, `@=<`, `@>`,
   `@>=`, `is`, `=:=`, `=\=`, `<`, `=<`, `>`, and `>=`;
 - arithmetic: `+`, `-`, `*`, `/`, `//`, `div`, `mod`, `rem`, `/\`, `\/`,
@@ -5278,8 +5278,8 @@ negation.
 
 EyeProlog supports cut, operator declarations, dynamic database updates, grouped
 solutions, exceptions, flags, initialization and inclusion directives, and
-standard stream and term I/O. ISO Part 2 modules complement this Part 1 core;
-DCG notation remains outside the profile.
+standard stream and term I/O. ISO Part 2 modules and Part 3 definite clause
+grammars complement this Part 1 core.
 
 ### ISO Part 2 modules
 
@@ -5316,6 +5316,38 @@ an empty list when only qualified calls are wanted. `Module:Goal` selects a
 module explicitly. Repeated module loads are idempotent, while conflicting
 imports and requests for predicates that a module does not export are errors.
 
+### ISO Part 3 definite clause grammars
+
+A grammar rule `Head --> Body.` is prepared as an ordinary predicate with two
+additional difference-list arguments. Parameterized nonterminals retain their
+written arguments, so `token(Type)//1` is implemented by `token/3`.
+Nonterminal indicators can be exported and imported through modules:
+
+```text
+:- module(vocabulary, [word//1]).
+
+word(noun) --> [robot] | [scientist].
+```
+
+The required grammar constructs are terminal lists, `[]`, sequencing with
+comma, alternatives with `;` or `|`, if-then-else, embedded goals `{Goal}`,
+`call//1`, `phrase//1`, and `!//0`. Semicontexts provide look-ahead by restoring
+terminals to the remaining sequence:
+
+```eyeprolog
+look_ahead(X), [X] --> [X].
+```
+
+`phrase(+Body,?Sequence)` accepts or generates a complete sequence.
+`phrase(+Body,?Sequence,?Rest)` leaves `Rest` unconsumed and is steadfast in
+that argument. A variable body raises `instantiation_error`; a non-callable
+body raises `type_error(callable)`. EyeProlog performs the optional Part 3
+terminal-sequence checks and reports `type_error(terminal_sequence)`.
+
+Part 3 leaves `\+//1` and standalone `->//2` implementation dependent.
+EyeProlog uses non-consuming negation (`\+ Body` tests from the current state)
+and threads the state produced by the condition into the then-grammar.
+
 ### Directives and protected built-ins
 
 `false/0` is the ISO always-failing built-in. It is protected as a static
@@ -5379,7 +5411,7 @@ profile. Where a predicate is defined by ISO/IEC 13211-1:1995, EyeProlog uses it
 standard predicate indicator; the registry also includes a few later or common
 compatibility predicates identified below. Arithmetic is expressed through
 `is/2` rather than output arguments on arithmetic predicates. The registry
-contains 127 name/arity entries across 99 names.
+contains 129 name/arity entries across 100 names.
 
 | Role | Registered predicate indicators |
 | --- | --- |
@@ -5389,6 +5421,7 @@ contains 127 name/arity entries across 99 names.
 | Term order | `compare/3`, `@</2`, `@=</2`, `@>/2`, `@>=/2`, `sort/2`, `keysort/2` |
 | Term inspection | `functor/3`, `arg/3`, `=../2`, `copy_term/2`, `term_variables/2` |
 | Collection | `findall/3`, `bagof/3`, `setof/3` |
+| Grammar processing | `phrase/2`, `phrase/3` |
 | Database and information | `clause/2`, `asserta/1`, `assertz/1`, `retract/1`, `retractall/1`, `abolish/1`, `current_predicate/1` |
 | Operators, conversion, and flags | `op/3`, `current_op/3`, `char_conversion/2`, `current_char_conversion/2`, `current_prolog_flag/2`, `set_prolog_flag/2` |
 | Atomic terms | `atom_length/2`, `atom_concat/3`, `sub_atom/5`, `atom_chars/2`, `atom_codes/2`, `char_code/2`, `number_chars/2`, `number_codes/2` |
@@ -5442,6 +5475,19 @@ if-then-else commitment described above. Cuts and committed conditions are
 operational controls; use ordinary relations when all alternatives should
 remain observable.
 
+### Definite clause grammar processing
+
+| Predicate and principal call | Behavior |
+| --- | --- |
+| `phrase(+Body,?Sequence)` | Parses or generates `Sequence` with a Part 3 grammar body and requires complete consumption. |
+| `phrase(+Body,?Sequence,?Rest)` | Parses or generates a prefix described by `Body` and unifies `Rest` with the unconsumed terminal sequence. The final unification is delayed so the third argument is steadfast. |
+
+Grammar rules are expanded during program preparation and therefore appear to
+the solver as ordinary predicates with two extra arguments. Dynamic grammar
+bodies passed to `phrase/2-3` use the same expansion rules. This includes
+module qualification and the caller module used by embedded or meta-called
+nonterminals.
+
 ### Unification, type tests, and term order
 
 | Predicate and principal call | Behavior |
@@ -5689,12 +5735,12 @@ so side effects occur in Prolog execution order.
 
 ### The EyeProlog library
 
-EyeProlog exposes **44 library predicate indicators** in addition to the 127
+EyeProlog exposes **44 library predicate indicators** in addition to the 129
 indicators in its isolated ISO profile. **All 44 are ordinary Prolog clauses**
 across `src/lib/eyeprolog.pl` and `src/lib/lists.pl`; none
 is a native host predicate. The resulting
-normal EyeProlog language surface is therefore **171 public predicate
-indicators**. Internally, the runtime registry contains only the 127 ISO
+normal EyeProlog language surface is therefore **173 public predicate
+indicators**. Internally, the runtime registry contains only the 129 ISO
 definitions; the EyeProlog relations are module source clauses.
 
 The two Prolog files declare `eyeprolog` and `lists` with `module/2`. A program
@@ -6141,7 +6187,7 @@ Review questions:
 </figure>
 
 The [examples directory](https://github.com/eyereasoner/eyeprolog/tree/main/examples/) is the book's executable companion. The
-top-level directory contains **188 self-contained runnable programs**. Every
+top-level directory contains **189 self-contained runnable programs**. Every
 source program has an exact answer file under
 [examples/output](https://github.com/eyereasoner/eyeprolog/tree/main/examples/output/), and **60 selected programs** have a checked
 explanation under [examples/proof](https://github.com/eyereasoner/eyeprolog/tree/main/examples/proof/). The thematic tables below link every top-level program and open the program
@@ -6193,6 +6239,7 @@ mode at a time.
 | [Floating Point](https://github.com/eyereasoner/eyeprolog/blob/main/examples/floating-point.pl) | Floating-point arithmetic and comparisons. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/floating-point.pl) · [proof](https://github.com/eyereasoner/eyeprolog/blob/main/examples/proof/floating-point.pl) |
 | [Atomic conversion](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-atomic-conversion.pl) | Atom splitting, character atoms, Unicode codes, and numeric parsing. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/iso-atomic-conversion.pl) |
 | [Control and errors](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-control-and-errors.pl) | `call/1`, `once/1`, cut, if-then-else, `throw/1`, and `catch/3`. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/iso-control-and-errors.pl) |
+| [DCG command parser](https://github.com/eyereasoner/eyeprolog/blob/main/examples/dcg-command-parser.pl) | A Part 3 grammar parses token lists into application terms, generates tokens, preserves a remainder, and rejects malformed input. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/dcg-command-parser.pl) |
 | [Dynamic database](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-dynamic-database.pl) | Initialization and ordered updates to a declared dynamic procedure. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/iso-dynamic-database.pl) · [proof](https://github.com/eyereasoner/eyeprolog/blob/main/examples/proof/iso-dynamic-database.pl) |
 | [Grouped solutions](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-grouped-solutions.pl) | `findall/3`, `bagof/3`, `setof/3`, existential qualification, and `clause/2`. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/iso-grouped-solutions.pl) |
 | [Integer arithmetic](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-integer-arithmetic.pl) | Integer quotient/remainder choices plus bit operations. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/iso-integer-arithmetic.pl) |
@@ -6511,7 +6558,7 @@ hand.
 
 #### Running and extending the corpus
 
-Run all 188 normal answer goldens and the 60 selected proof goldens with:
+Run all 189 normal answer goldens and the 60 selected proof goldens with:
 
 ```sh
 npm run test:examples
@@ -6559,9 +6606,10 @@ node test/run-conformance-report.mjs
 ```
 
 The complete suite must pass before release. The file-based conformance corpus
-contains 710 cases, including 304 focused ISO
+contains 719 cases, including 313 focused ISO
 cases derived from the success, failure, mode, and error behavior in
-ISO/IEC 13211-1 clauses 7 and 8. Separate exact-output suites check 188 normal
+ISO/IEC 13211-1 clauses 7 and 8, Part 2 modules, and Part 3 grammar rules.
+Separate exact-output suites check 189 normal
 examples and 60 proof examples; all extracted book programs are parsed and
 their declared goals are executed. The seven-case
 playground contract suite imports the production worker, sends real reasoning
@@ -6590,18 +6638,20 @@ Run the browser contract independently with:
 npm run test:playground
 ```
 
-### Supported ISO Prolog profile
+### Supported ISO Prolog implementation
 
-EyeProlog executes a documented and tested **ISO compatibility profile** based on
-ISO/IEC 13211-1:1995 and its three technical corrigenda. The exact supported
-predicate indicators—not a claim about the standard's complete processor
-environment—are listed in Chapter 39. The profile includes control and
+EyeProlog executes a documented and tested ISO Prolog implementation based on
+ISO/IEC 13211-1:1995 and its three technical corrigenda, ISO/IEC 13211-2:2000,
+and ISO/IEC TS 13211-3:2025. The exact supported predicate indicators are
+listed in Chapter 39. The implementation includes control and
 exceptions, term operations, arithmetic, grouped solutions, dynamic clauses,
 operators, atomic-term processing, flags, character conversion, streams,
 character/byte and term I/O, initialization, source inclusion, and
 termination. Corrigendum 2 additions—including `subsumes_term/2`,
 `acyclic_term/1`, `sort/2`, `keysort/2`, `term_variables/2`, `retractall/1`,
-and `call/2-8`—are part of that baseline rather than extensions.
+and `call/2-8`—are part of that baseline rather than extensions. Part 2 module
+identity and imports and Part 3 grammar expansion and `phrase/2-3` are likewise
+standard language facilities.
 
 This breadth is not a formal certification of every processor requirement.
 The executable examples are EyeProlog-profile programs using host-supplied goals,
@@ -6610,7 +6660,7 @@ The remaining qualifications are:
 
 - zero-arity compound syntax such as `ready()` is represented by the atom
   `ready`;
-- ISO Part 2 modules are supported; DCG notation remains outside the profile;
+- ISO Part 2 modules and ISO/IEC TS 13211-3 definite clause grammars are supported;
 - variables cannot occupy functor or predicate position;
 - double-quoted text follows `double_quotes` exactly; the default `chars` value
   matches Trealla and Scryer and may be changed to `codes` or `atom`;

package/tools/extract-book-examples.mjs

@@ -41,7 +41,7 @@ for (const match of book.matchAll(/^(## \d+\. ([^\n]+)|# ([^\n]+)|```eyeprolog\n
     .split('\n')
     .map((line) => line.trim())
     .find((line) => line && !line.startsWith('%') && !line.startsWith(':-'));
-  const predicate = firstClause?.match(/^([a-z][a-z0-9_]*)\s*(?:\(|\.)/)?.[1] ?? 'program';
+  const predicate = firstClause?.match(/^([a-z][a-z0-9_]*)\s*(?:\(|\.|-->)/)?.[1] ?? 'program';
   const section = [...preceding.matchAll(/^### ([^\n]+)$/gm)].at(-1)?.[1] ?? '';
   chapter.examples.push({ predicate, section, source });
 }

package/why-eyeprolog.md

@@ -18,7 +18,8 @@ language gives programs recognizable semantics without inventing another rule
 syntax.
 
 EyeProlog implements the Part 1 core together with Technical Corrigenda 1, 2,
-and 3. Its executable conformance matrix and tests document the supported
+and 3, Part 2 modules, and the Part 3 definite clause grammar specification.
+Its executable conformance matrix and tests document the supported
 behavior. This is extensive implementation evidence, not certification by an
 independent standards body.
 
@@ -31,6 +32,7 @@ keeps a narrow architecture:
 - one solver with automatic tabling for eligible positive recursion;
 - the ISO built-in registry;
 - lean portable ISO Part 2 library modules;
+- ISO Part 3 definite clause grammars and `phrase/2-3`;
 - optional proof explanations; and
 - the same implementation in Node.js and the browser.
 
@@ -79,5 +81,7 @@ visible enough to understand.
 ## References
 
 - [ISO/IEC 13211-1:1995 — Prolog, Part 1: General core](https://www.iso.org/standard/21413.html)
+- [ISO/IEC 13211-2:2000 — Prolog, Part 2: Modules](https://www.iso.org/standard/20775.html)
+- [ISO/IEC TS 13211-3:2025 — Prolog, Part 3: Definite clause grammar rules](https://www.iso.org/standard/83635.html)
 - [The Art of EyeProlog](the-art-of-eyeprolog.md)
 - [EyeProlog README](README.md)