eyelang 0.1.3 → 0.1.5

package/README.md

@@ -4,6 +4,7 @@
 [![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.20761726-blue.svg)](https://doi.org/10.5281/zenodo.20761726)
 
 Eyelang is a small logic programming language for rules, goals, answers, and proofs.
+Its source syntax is a deliberately small subset of ordinary Prolog term and Horn-clause syntax.
 It grew out of logic-language experiments in the EYE/N3 reasoning tradition, but is packaged here as its own project.
 
 ## Install and run
@@ -33,26 +34,6 @@ console.log(result.stdout);
 - [Guide](docs/guide.md)
 - [Language reference](docs/language-reference.md)
 
-### Eyelang built-ins
-
-The Eyelang engine has its own built-in registry under `src/builtins/`. Built-ins are called as ordinary Eyelang predicates. See the [Eyelang language reference](docs/language-reference.md#9-standard-built-in-predicates) for the portable profile. The bundled implementation currently registers 80 name/arity entries across 78 predicate names:
-
-| Family | Count | Built-ins |
-|---|---:|---|
-| Core and host | 4 | `eq/2`, `neq/2`, `local_time/1`, `difference/3` |
-| Arithmetic, comparison, and generators | 29 | `neg/2`, `abs/2`, `sin/2`, `cos/2`, `tan/2`, `asin/2`, `acos/2`, `sqrt/2`, `floor/2`, `ceiling/2`, `trunc/2`, `rounded/2`, `exp/2`, `log/2`, `add/3`, `sub/3`, `mul/3`, `div/3`, `mod/3`, `min/3`, `max/3`, `pow/3`, `atan2/3`, `lt/2`, `gt/2`, `le/2`, `ge/2`, `between/3`, `smallest_divisor_from/3` |
-| Strings and conversions | 15 | `str_concat/3`, `contains/2`, `matches/2`, `matches/3`, `not_matches/2`, `split/3`, `join/3`, `substring/4`, `replace/4`, `lowercase/2`, `uppercase/2`, `trim/2`, `number_string/2`, `atom_string/2`, `term_string/2` |
-| Lists | 19 | `append/3`, `nth0/3`, `set_nth0/4`, `head/2`, `rest/2`, `last/2`, `take/3`, `drop/3`, `slice/4`, `member/2`, `select/3`, `not_member/2`, `reverse/2`, `length/2`, `sum_list/2`, `min_list/2`, `max_list/2`, `list_to_set/2`, `sort/2` |
-| Aggregation | 5 | `findall/3`, `countall/2`, `sumall/3`, `aggregate_min/5`, `aggregate_max/5` |
-| Control | 3 | `not/1`, `once/1`, `forall/2` |
-| Context and terms | 5 | `holds/2`, `holds/3`, `functor/3`, `arg/3`, `compound_name_arguments/3` |
-| **Total** | **80** |  |
-
-
-## Custom built-ins
-
-Custom built-ins can be supplied by creating a `BuiltinRegistry` and passing it to the solver or `run` API.
-
 ## Tests
 
 ```bash

package/docs/guide.md

@@ -1,6 +1,6 @@
 # Eyelang Guide
 
-This guide introduces Eyelang, a small Prolog-style Horn-clause language and engine for rules, goals, answers, and proofs. Eyelang works over ordinary terms, lists, arithmetic, strings, and finite search. Run it with the `eyelang` CLI, or use `node src/bin.js` when working directly from a source checkout.
+This guide introduces Eyelang, a small Horn-clause language and engine whose source syntax is a deliberate subset of ordinary Prolog syntax for rules, goals, answers, and proofs. Eyelang works over ordinary terms, lists, arithmetic, strings, and finite search. Run it with the `eyelang` CLI, or use `node src/bin.js` when working directly from a source checkout.
 
 Programs write relations directly, for example `ancestor(pat, emma)` or `status(case1, accepted)`. Eyelang output is ordinary Eyelang syntax: by default, the CLI materializes selected answer facts and prints those facts only. Pass `--proof` (or `-p`) when you also want each answer followed by a `why/2` explanation fact that records the proof. Programs may add `materialize(Name, Arity).` declarations to focus output on selected predicates.
 
@@ -238,9 +238,19 @@ The playground has matching `--stats` and `--proof` checkboxes, so browser runs
 
 ### Builtins
 
-Eyelang builtins are registered by name and arity in small modules under [`src/builtins`](../src/builtins). This keeps the runtime portable to Node.js and the browser while giving each builtin family a clear boundary. Builtins are enabled by normal predicate calls.
+Eyelang builtins are registered by name and arity in small modules under [`src/builtins`](../src/builtins). This keeps the runtime portable to Node.js and the browser while giving each builtin family a clear boundary. Built-ins are called as ordinary Eyelang predicates. See the [Eyelang language reference](docs/language-reference.md#9-standard-built-in-predicates) for the portable profile. The bundled implementation currently registers 80 name/arity entries across 78 predicate names:
+
+| Family | Count | Built-ins |
+|---|---:|---|
+| Core and host | 4 | `eq/2`, `neq/2`, `local_time/1`, `difference/3` |
+| Arithmetic, comparison, and generators | 29 | `neg/2`, `abs/2`, `sin/2`, `cos/2`, `tan/2`, `asin/2`, `acos/2`, `sqrt/2`, `floor/2`, `ceiling/2`, `trunc/2`, `rounded/2`, `exp/2`, `log/2`, `add/3`, `sub/3`, `mul/3`, `div/3`, `mod/3`, `min/3`, `max/3`, `pow/3`, `atan2/3`, `lt/2`, `gt/2`, `le/2`, `ge/2`, `between/3`, `smallest_divisor_from/3` |
+| Strings and conversions | 15 | `str_concat/3`, `contains/2`, `matches/2`, `matches/3`, `not_matches/2`, `split/3`, `join/3`, `substring/4`, `replace/4`, `lowercase/2`, `uppercase/2`, `trim/2`, `number_string/2`, `atom_string/2`, `term_string/2` |
+| Lists | 19 | `append/3`, `nth0/3`, `set_nth0/4`, `head/2`, `rest/2`, `last/2`, `take/3`, `drop/3`, `slice/4`, `member/2`, `select/3`, `not_member/2`, `reverse/2`, `length/2`, `sum_list/2`, `min_list/2`, `max_list/2`, `list_to_set/2`, `sort/2` |
+| Aggregation | 5 | `findall/3`, `countall/2`, `sumall/3`, `aggregate_min/5`, `aggregate_max/5` |
+| Control | 3 | `not/1`, `once/1`, `forall/2` |
+| Context and terms | 5 | `holds/2`, `holds/3`, `functor/3`, `arg/3`, `compound_name_arguments/3` |
+| **Total** | **80** |  |
 
-The builtin families cover unification, arithmetic, comparison, dates, strings, lists, aggregation, context terms, term inspection, and search control. Domain-specific number-theory and matrix helper modules were removed from the default registry because those predicates were examples/accelerators rather than a reusable portable surface. New reusable helpers cover common numeric functions, list slicing and summaries, string normalization/conversion, term inspection/construction, and `forall/2`. The complete bundled implementation list is kept in the top-level [README built-ins section](../README.md#built-ins-1), and the regression suite checks that table against the actual runtime registry.
 
 To add a builtin, create or extend a module with `register(registry)` and call `registry.add(name, arity, handler, options)`. The default registry is assembled in [`src/builtins/registry.js`](../src/builtins/registry.js). Builtins that are only safe for specific argument modes should provide a `ready` predicate and `fallbackWhenNotReady: true`, so user-defined clauses remain visible until the builtin is applicable.
 
@@ -522,4 +532,4 @@ For large programs, keep helper predicates selective, bind arguments early, and
 
 ## Implementation limits
 
-Eyelang is intentionally smaller than ISO Prolog. It has no operators, cut, modules, dynamic database updates, DCGs, or complete ISO library. Negation is negation-as-failure through `not/1`. Search is goal-directed and expected to be finite for the selected output goals. Output explanations are non-normative proof printouts and do not change answer semantics. 
+Eyelang is intentionally smaller than ISO Prolog. It has no operators, zero-arity compound syntax, cut, modules, dynamic database updates, DCGs, or complete ISO library. Negation is negation-as-failure through `not/1`. Search is goal-directed and expected to be finite for the selected output goals. Output explanations are non-normative proof printouts and do not change answer semantics. 

package/docs/language-reference.md

@@ -62,9 +62,9 @@
 
 ## Abstract
 
-Eyelang is a compact Prolog-like definite-clause language for rule-based programs over ordinary terms, lists, arithmetic, strings, and finite search. A Eyelang program is a finite sequence of facts and Horn clauses. The underlying declarative semantics of the pure language is **Herbrand semantics**: constants, compound terms, and lists denote themselves, and predicates denote sets of ground atomic formulas over those terms. Evaluation is goal-directed: goals are solved by unification against facts, rules, and a fixed set of built-in predicates.
+Eyelang is a compact definite-clause language whose surface syntax is a deliberately small subset of ordinary Prolog term and clause syntax for rule-based programs over ordinary terms, lists, arithmetic, strings, and finite search. A Eyelang program is a finite sequence of facts and Horn clauses. The underlying declarative semantics of the pure language is **Herbrand semantics**: constants, compound terms, and lists denote themselves, and predicates denote sets of ground atomic formulas over those terms. Evaluation is goal-directed: goals are solved by unification against facts, rules, and a fixed set of built-in predicates.
 
-Eyelang is intentionally smaller than ISO Prolog. It supports enough Prolog syntax to express Horn-clause reasoning, list processing, arithmetic examples, finite search, and context data, without operators, cut, modules, dynamic predicates, DCGs, or a complete ISO standard library.
+Eyelang is intentionally smaller than ISO Prolog. It supports a Prolog-syntax subset sufficient to express Horn-clause reasoning, list processing, arithmetic examples, finite search, and context data, without operators, cut, modules, dynamic predicates, DCGs, zero-arity compound syntax, or a complete ISO standard library.
 
 ## 1. Terminology and normative language
 
@@ -138,12 +138,14 @@ Each `_` anonymous variable occurrence is fresh.
 
 ### 3.5 Atom constants
 
-A plain atom constant starts with a lowercase ASCII letter and is followed by zero or more ASCII letters, digits, or underscores:
+A plain atom constant starts with a lowercase ASCII letter and is followed by zero or more ASCII letters, digits, or underscores. This follows the usual Prolog unquoted-atom shape; names such as `a-b` or `http://example` MUST be quoted if they are meant as one atom constant:
 
 ```prolog
 pat
 type
 case_123
+'a-b'
+'http://example'
 ```
 
 A quoted atom constant is enclosed in single quotes. A single quote inside a quoted atom constant is represented by doubling it:
@@ -190,23 +192,24 @@ term         ::= variable
               | atom_constant
               | string
               | number
-              | atom_constant "(" [term ("," term)*] ")"
+              | atom_constant "(" term ("," term)* ")"
               | "[" [list_items] "]"
               | "(" term ("," term)+ ")"
 list_items   ::= term ("," term)* ["|" term]
 ```
 
-Here `atom_constant` is a lexical class for symbolic scalar terms, not an atomic formula. Atomic formulas are represented by the grammar alternative `atom_constant "(" ... ")"` when such a compound appears in a clause head, rule body, or selected goal.
+Here `atom_constant` is a lexical class for symbolic scalar terms, not an atomic formula. Atomic formulas are represented by the grammar alternative `atom_constant "(" ... ")"` when such a compound appears in a clause head, rule body, or selected goal. Compound syntax always has at least one argument.
 
 A clause head SHOULD be a compound term. Non-compound heads are parsed but are not useful in the current predicate index.
 
-Zero-arity compounds are written with parentheses:
+Arity-zero data is written as an atom constant, not as a zero-arity compound:
 
 ```prolog
-nil().
-value(example, nil()).
+value(example, nil).
 ```
 
+The syntax `nil()` is intentionally rejected so eyelang source and read-back output remain inside the Prolog syntax subset used by this language.
+
 ## 5. Terms
 
 ### 5.1 Variables
@@ -642,9 +645,10 @@ Conformance cases live in the repository under `test/conformance/`. They are run
 
 ## 15. Relationship to ISO Prolog
 
-eyelang borrows familiar Prolog syntax and Horn-clause execution but is not ISO Prolog. Notable differences include:
+eyelang source is intended to be a subset of familiar Prolog term and Horn-clause syntax, but eyelang is not ISO Prolog. Notable differences include:
 
 - no operators or operator declarations;
+- no zero-arity compound syntax such as `nil()`;
 - no cut;
 - no modules;
 - no dynamic database update;
@@ -653,7 +657,7 @@ eyelang borrows familiar Prolog syntax and Horn-clause execution but is not ISO
 - no variables in functor or predicate position;
 - no occurs check in unification.
 
-Programs intended to be portable to eyelang SHOULD avoid ISO-specific syntax and keep terms explicit.
+Programs intended to be portable to eyelang SHOULD avoid ISO-specific syntax and keep terms explicit. Atom names that are not plain lowercase-starting names or graphic atom tokens SHOULD be written as quoted atoms, for example `'a-b'`.
 
 ## 16. Examples
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eyelang",
-  "version": "0.1.3",
-  "description": "A small logic programming language for rules, goals, answers, and proofs.",
+  "version": "0.1.5",
+  "description": "A small Prolog-syntax-subset logic programming language for rules, goals, answers, and proofs.",
   "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",

package/src/builtins/terms.js

@@ -56,7 +56,8 @@ function* compoundNameArguments({ goal, env }) {
   const args = properListItems(goal.args[2], env);
   if (name == null || !args) return;
   const next = env.clone();
-  if (unify(goal.args[0], compound(name, args), next)) yield next;
+  const built = args.length === 0 ? atom(name) : compound(name, args);
+  if (unify(goal.args[0], built, next)) yield next;
 }
 
 function scalarNameTerm(term) {

package/src/parser.js

@@ -15,18 +15,27 @@ function isDigitCode(code) {
   return code >= 48 && code <= 57;
 }
 
+function isAsciiLetterCode(code) {
+  return (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+}
+
+function isNameContinueCode(code) {
+  return code === 95 || isAsciiLetterCode(code) || isDigitCode(code);
+}
+
 function isVariableStart(text) {
   const code = text.charCodeAt(0);
   return code === 95 || (code >= 65 && code <= 90);
 }
 
-function isAtomCharCode(code) {
-  // Stop at whitespace and the punctuation tokens that have syntactic meaning.
-  return code > 0 &&
-    !isWhitespaceCode(code) &&
-    code !== 40 && code !== 41 && code !== 91 && code !== 93 &&
-    code !== 44 && code !== 124 && code !== 46 &&
-    code !== 39 && code !== 34 && code !== 58;
+function isPlainAtomStartCode(code) {
+  return code >= 97 && code <= 122;
+}
+
+const graphicAtomChars = '#$&*+-/<=>?@^~\\';
+
+function isGraphicAtomCode(code) {
+  return graphicAtomChars.includes(String.fromCharCode(code));
 }
 
 class Parser {
@@ -130,13 +139,30 @@ class Parser {
       return { type: TOK.NUMBER, text: this.source.slice(start, this.pos), line };
     }
 
-    const start = this.pos;
-    while (this.pos < this.source.length && isAtomCharCode(this.source.charCodeAt(this.pos))) this.pos++;
-    if (this.pos === start) throw new Error(`parse line ${line}: bad character ${JSON.stringify(ch)}`);
-    let text = this.source.slice(start, this.pos);
-    let type = isVariableStart(text) ? TOK.VAR : TOK.ATOM;
-    if (type === TOK.VAR && text === '_') text = `__anon${this.anonymous++}`;
-    return { type, text, line };
+    if (isVariableStart(ch)) {
+      const start = this.pos;
+      this.take();
+      while (isNameContinueCode(this.peek().charCodeAt(0))) this.take();
+      let text = this.source.slice(start, this.pos);
+      if (text === '_') text = `__anon${this.anonymous++}`;
+      return { type: TOK.VAR, text, line };
+    }
+
+    if (isPlainAtomStartCode(ch.charCodeAt(0))) {
+      const start = this.pos;
+      this.take();
+      while (isNameContinueCode(this.peek().charCodeAt(0))) this.take();
+      return { type: TOK.ATOM, text: this.source.slice(start, this.pos), line };
+    }
+
+    if (isGraphicAtomCode(ch.charCodeAt(0))) {
+      const start = this.pos;
+      this.take();
+      while (isGraphicAtomCode(this.peek().charCodeAt(0))) this.take();
+      return { type: TOK.ATOM, text: this.source.slice(start, this.pos), line };
+    }
+
+    throw new Error(`parse line ${line}: bad character ${JSON.stringify(ch)}`);
   }
   advance() {
     this.token = this.nextToken();
@@ -220,15 +246,16 @@ class Parser {
       if (this.token.type === TOK.LPAREN) {
         this.advance();
         const args = [];
-        if (this.token.type !== TOK.RPAREN) {
-          while (true) {
-            args.push(this.parseTerm());
-            if (this.token.type === TOK.COMMA) {
-              this.advance();
-              continue;
-            }
-            break;
+        if (this.token.type === TOK.RPAREN) {
+          throw new Error(`parse line ${this.token.line}: zero-arity compound syntax is not supported; use atom ${JSON.stringify(name)} for arity zero data`);
+        }
+        while (true) {
+          args.push(this.parseTerm());
+          if (this.token.type === TOK.COMMA) {
+            this.advance();
+            continue;
           }
+          break;
         }
         this.expect(TOK.RPAREN, ')');
         this.advance();
@@ -286,9 +313,11 @@ function isSimpleName(text) {
 }
 
 const SIMPLE_NUMBER = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
-const SIMPLE_ARG_FORBIDDEN = /[\s()[\]|"']/;
 const FAST_BINARY_FACT = /^([a-z][A-Za-z0-9_]*)\(\s*([^,\s()[\]|"']+)\s*,\s*([^,\s()[\]|"']+)\s*\)\.$/;
 const FAST_BINARY_RULE = /^([a-z][A-Za-z0-9_]*)\(\s*([^,\s()[\]|"']+)\s*,\s*([^,\s()[\]|"']+)\s*\)\s*:-\s*([a-z][A-Za-z0-9_]*)\(\s*([^,\s()[\]|"']+)\s*,\s*([^,\s()[\]|"']+)\s*\)\.$/;
+const SIMPLE_VARIABLE = /^[_A-Z][A-Za-z0-9_]*$/;
+const SIMPLE_ATOM = /^[a-z][A-Za-z0-9_]*$/;
+const GRAPHIC_ATOM = /^[#$&*+\-\/<=>?@^~\\]+$/;
 
 function parseClausesFastNoSource(source) {
   source = String(source ?? '');
@@ -306,11 +335,12 @@ function parseClausesFastNoSource(source) {
     cache.set(key, value);
     return value;
   };
+  const isFastScalarToken = (text) => SIMPLE_VARIABLE.test(text) || SIMPLE_ATOM.test(text) || GRAPHIC_ATOM.test(text) || SIMPLE_NUMBER.test(text);
   const scalarOrVariableFast = (text) => {
-    if (!text) throw new Error('empty simple term');
+    if (!text || !isFastScalarToken(text)) throw new Error('bad simple term');
     const first = text.charCodeAt(0);
     if (text === '_') return variable(`__anon${anonymous++}`);
-    if (first === 95 || (first >= 65 && first <= 90)) {
+    if (SIMPLE_VARIABLE.test(text)) {
       const existing = variableCache.get(text);
       if (existing) return existing;
       const value = variable(text);
@@ -318,7 +348,6 @@ function parseClausesFastNoSource(source) {
       return value;
     }
     if ((first === 45 || isDigitCode(first)) && SIMPLE_NUMBER.test(text)) return cached(numberCache, text, numberTerm);
-    if (first === 34 && text.endsWith('"')) return cached(stringCache, text.slice(1, -1), stringTerm);
     return atom(text);
   };
   const scalarOrVariable = (text) => scalarOrVariableFast(text.trim());
@@ -334,13 +363,15 @@ function parseClausesFastNoSource(source) {
     if (comma < 0 || inner.indexOf(',', comma + 1) >= 0) return null;
     const left = inner.slice(0, comma).trim();
     const right = inner.slice(comma + 1).trim();
-    if (!left || !right || SIMPLE_ARG_FORBIDDEN.test(left) || SIMPLE_ARG_FORBIDDEN.test(right)) return null;
+    if (!isFastScalarToken(left) || !isFastScalarToken(right)) return null;
     return compound(name, [scalarOrVariable(left), scalarOrVariable(right)]);
   };
   const parseFastBinaryMatch = (match) => {
+    if (!isFastScalarToken(match[2]) || !isFastScalarToken(match[3])) return null;
     return compound(match[1], [scalarOrVariableFast(match[2]), scalarOrVariableFast(match[3])]);
   };
   const parseFastBinaryRuleMatch = (match) => {
+    if (!isFastScalarToken(match[2]) || !isFastScalarToken(match[3]) || !isFastScalarToken(match[5]) || !isFastScalarToken(match[6])) return null;
     return {
       head: compound(match[1], [scalarOrVariableFast(match[2]), scalarOrVariableFast(match[3])]),
       body: [compound(match[4], [scalarOrVariableFast(match[5]), scalarOrVariableFast(match[6])])],
@@ -349,9 +380,15 @@ function parseClausesFastNoSource(source) {
   const parseFastLine = (text) => {
     if (!text.endsWith('.')) return null;
     const ruleMatch = FAST_BINARY_RULE.exec(text);
-    if (ruleMatch) return parseFastBinaryRuleMatch(ruleMatch);
+    if (ruleMatch) {
+      const parsed = parseFastBinaryRuleMatch(ruleMatch);
+      if (parsed) return parsed;
+    }
     const factMatch = FAST_BINARY_FACT.exec(text);
-    if (factMatch) return { head: parseFastBinaryMatch(factMatch), body: [] };
+    if (factMatch) {
+      const head = parseFastBinaryMatch(factMatch);
+      if (head) return { head, body: [] };
+    }
     return null;
   };
   const parseSimple = (text) => {

package/src/term.js

@@ -192,6 +192,7 @@ export function termToString(term, env = new Env(), quoteStrings = true) {
   if (resolved.type === STRING) return writeString(resolved.name, quoteStrings);
   if (resolved.type === ATOM) return writeAtom(resolved.name);
   if (resolved.type === NUMBER) return resolved.name;
+  if (resolved.type === COMPOUND && resolved.arity === 0) return writeAtom(resolved.name);
   if (isConjunction(resolved)) {
     const parts = [];
     let cursor = resolved;

package/test/conformance/cases/003_terms_and_readback.pl

@@ -9,7 +9,7 @@ raw_value(integer, -42).
 raw_value(decimal, 0.25).
 raw_value(scientific, 1.25e-3).
 raw_value(compound, pair(3, nested(atom, [x, y]))).
-raw_value(zero_arity, nil()).
+raw_value(arity_zero_atom, nil).
 raw_value(empty_list, []).
 raw_value(proper_list, [a, b, c]).
 raw_value(improper_list, [a, b | tail]).

package/test/conformance/cases/016_arity_zero_atom.pl

@@ -0,0 +1,4 @@
+% Reference 4, 5.3: arity-zero data is written as an atom constant.
+status(nil, ok).
+answer(value, X) :- status(X, ok).
+materialize(answer, 2).

package/test/conformance/cases/073_term_introspection_edges.pl

@@ -1,10 +1,10 @@
-% Reference 9.1: term-inspection built-ins expose scalars, nested arguments, and zero arity compounds.
+% Reference 9.1: term-inspection built-ins expose scalars, nested arguments, and atom construction from an empty argument list.
 materialize(answer, 2).
 answer(functor_atom, pair(Name, Arity)) :- functor(alpha, Name, Arity).
 answer(functor_number, pair(Name, Arity)) :- functor(42, Name, Arity).
 answer(functor_string, pair(Name, Arity)) :- functor("hi", Name, Arity).
 answer(arg_nested, X) :- arg(1, path(edge(a, b), c), X).
 answer(compose_nested, X) :- compound_name_arguments(X, outer, [inner(a), [b, c]]).
-answer(decompose_zero, pair(Name, Args)) :- compound_name_arguments(z(), Name, Args).
+answer(compose_atom_empty_args, X) :- compound_name_arguments(X, z, []).
 answer(arg_zero_rejected, ok) :- not(arg(0, edge(a, b), X)).
 answer(arg_too_large_rejected, ok) :- not(arg(3, edge(a, b), X)).

package/test/conformance/expected/003_terms_and_readback.pl

@@ -7,7 +7,7 @@ value(integer, -42).
 value(decimal, 0.25).
 value(scientific, 1.25e-3).
 value(compound, pair(3, nested(atom, [x, y]))).
-value(zero_arity, nil()).
+value(arity_zero_atom, nil).
 value(empty_list, []).
 value(proper_list, [a, b, c]).
 value(improper_list, [a, b | tail]).

package/test/conformance/expected/016_arity_zero_atom.pl

@@ -0,0 +1 @@
+answer(value, nil).

package/test/conformance/expected/073_term_introspection_edges.pl

@@ -3,6 +3,6 @@ answer(functor_number, pair(42, 0)).
 answer(functor_string, pair("hi", 0)).
 answer(arg_nested, edge(a, b)).
 answer(compose_nested, outer(inner(a), [b, c])).
-answer(decompose_zero, pair(z, [])).
+answer(compose_atom_empty_args, z).
 answer(arg_zero_rejected, ok).
 answer(arg_too_large_rejected, ok).

package/test/run-regression.mjs

@@ -188,26 +188,6 @@ why(
         assertEqual(result.stderr, '', 'stderr');
       },
     },
-    {
-      name: 'README covers every mirrored example',
-      run: () => {
-        const examples = listExampleNames();
-        const readmeExamples = readmeCatalogExampleNames();
-        assertEqual(readmeExamples.join('\n'), examples.join('\n'), 'README example catalog');
-      },
-    },
-    {
-      name: 'README mirrors the Eyelang builtin registry',
-      run: () => {
-        const actual = registeredBuiltinNames();
-        const documented = readmeBuiltinNames();
-        assertEqual(documented.join('\n'), actual.join('\n'), 'README builtin catalog');
-
-        const { entries, names } = readmeBuiltinSummary();
-        assertEqual(entries, actual.length, 'README builtin entry count');
-        assertEqual(names, new Set(actual.map((item) => item.split('/')[0])).size, 'README builtin name count');
-      },
-    },
     {
       name: 'stdin input is accepted',
       run: () => {
@@ -393,6 +373,23 @@ function whiteBoxCases() {
         assertEqual(termIsGround(resolved), true, 'ground after copy');
       },
     },
+
+    {
+      name: 'parser rejects non-Prolog unquoted atom spelling',
+      run: () => {
+        let threw = false;
+        try { parseProgramText('value(a-b, ok).\n'); } catch (_) { threw = true; }
+        assertEqual(threw, true, 'a-b must be quoted');
+      },
+    },
+    {
+      name: 'parser rejects zero-arity compound syntax',
+      run: () => {
+        let threw = false;
+        try { parseProgramText('value(nil(), ok).\n'); } catch (_) { threw = true; }
+        assertEqual(threw, true, 'zero-arity compound rejection');
+      },
+    },
     {
       name: 'parser preserves list syntax readback',
       run: () => {

package/test/conformance/cases/016_zero_arity_compound.pl

@@ -1,4 +0,0 @@
-% Reference 4, 5.3: zero-arity compounds are written and matched with parentheses.
-status(nil(), ok).
-answer(value, X) :- status(X, ok).
-materialize(answer, 2).

package/test/conformance/cases/016_zero_arity_compound.query

@@ -1 +0,0 @@
-answer(K, V)

package/test/conformance/expected/016_zero_arity_compound.pl

@@ -1 +0,0 @@
-answer(value, nil()).