eyelang 1.3.2 → 1.3.3

package/docs/guide.md

@@ -579,4 +579,4 @@ For large programs, keep helper predicates selective, bind arguments early, docu
 
 ## Implementation limits
 
-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. 
+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. Arity-zero data is always written and read back as an atom, such as `nil`, never `nil()`. 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

@@ -222,7 +222,7 @@ Arity-zero data is written as an atom constant, not as a zero-arity compound:
 value(example, nil).
 ```
 
-The syntax `nil()` is intentionally rejected so eyelang source and read-back output use one representation for arity-zero data.
+The syntax `nil()` is intentionally rejected so eyelang source and read-back output use one representation for arity-zero data. Host APIs SHOULD follow the same rule: constructing a term with an atom name and an empty argument list is canonicalized to the atom constant itself.
 
 ## 5. Terms
 
@@ -473,7 +473,7 @@ Context terms are data representations of atomic formulas and comma conjunctions
 | `holds(?context, ?name, ?args)` | Enumerates context members of any arity, exposing each member as atom constant `?name` plus a proper argument list `?args`. |
 | `functor(?term, ?name, ?arity)` | Decomposes a non-variable term into its name and arity. |
 | `arg(?index, ?term, ?arg)` | Extracts the 1-based argument of a compound term. |
-| `compound_name_arguments(?term, ?name, ?args)` | Decomposes a compound term or constructs one from an atom name and proper argument list. |
+| `compound_name_arguments(?term, ?name, ?args)` | Decomposes a compound term, treats an atom as a zero-argument term, or constructs a term from an atom name and proper argument list. Empty `?args` constructs an atom. |
 
 Example:
 
@@ -483,6 +483,7 @@ holds((ready, name(alice, "Alice"), route(alice, bob, 7)), ?name, ?args).
 functor(route(alice, bob, 7), route, 3).
 arg(2, route(alice, bob, 7), bob).
 compound_name_arguments(?term, route, [alice, bob, 7]).
+compound_name_arguments(nil, nil, []).
 ```
 
 The first goal can yield `holds((name(alice, "Alice"), knows(alice, bob)), name(alice, "Alice")).` The second can yield `holds((ready, name(alice, "Alice"), route(alice, bob, 7)), ready, []).`, `holds((ready, name(alice, "Alice"), route(alice, bob, 7)), name, [alice, "Alice"]).`, and `holds((ready, name(alice, "Alice"), route(alice, bob, 7)), route, [alice, bob, 7]).`

package/index.d.ts

@@ -128,6 +128,7 @@ export function variable(name: string): Term;
 export function atom(name: string): Term;
 export function stringTerm(value: string): Term;
 export function numberTerm(value: string | number): Term;
+/** Construct a compound term; an empty argument list is canonicalized to atom(name). */
 export function compound(name: string, args?: EyelangTerm[]): Term;
 export function emptyList(): Term;
 export function cons(head: EyelangTerm, tail: EyelangTerm): Term;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyelang",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "A small Prolog-like logic programming language for rules, goals, answers, and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/builtins/terms.js

@@ -20,7 +20,7 @@ function argReady(goal, env) {
 
 function compoundNameArgumentsReady(goal, env) {
   const term = deref(goal.args[0], env);
-  if (term.type === 'compound') return true;
+  if (term.type === 'compound' || term.type === 'atom') return true;
   return term.type === 'var' && lexicalValue(goal.args[1], env) !== null && properListItems(goal.args[2], env) !== null;
 }
 
@@ -45,9 +45,10 @@ function* argBuiltin({ goal, env }) {
 
 function* compoundNameArguments({ goal, env }) {
   const term = deref(goal.args[0], env);
-  if (term.type === 'compound') {
+  if (term.type === 'compound' || term.type === 'atom') {
     const next = env.clone();
-    if (unify(goal.args[1], atom(term.name), next) && unify(goal.args[2], listFromItems(term.args), next)) yield next;
+    const args = term.type === 'compound' ? term.args : [];
+    if (unify(goal.args[1], atom(term.name), next) && unify(goal.args[2], listFromItems(args), next)) yield next;
     return;
   }
   if (term.type !== 'var') return;

package/src/term.js

@@ -21,7 +21,7 @@ export const variable = (name) => new Term(VAR, name);
 export const atom = (name) => new Term(ATOM, name);
 export const stringTerm = (value) => new Term(STRING, value);
 export const numberTerm = (value) => new Term(NUMBER, value);
-export const compound = (name, args = []) => new Term(COMPOUND, name, args);
+export const compound = (name, args = []) => args.length === 0 ? atom(name) : new Term(COMPOUND, name, args);
 export const emptyList = () => atom('[]');
 export const cons = (head, tail) => compound('.', [head, tail]);
 
@@ -113,17 +113,20 @@ export function unify(left, right, env) {
 }
 
 export function cloneTerm(term) {
+  if (term.type === COMPOUND && term.arity === 0) return atom(term.name);
   return new Term(term.type, term.name, term.args.map(cloneTerm));
 }
 
 export function freshTerm(term, suffix) {
   if (term.type === VAR) return variable(`${term.name}#${suffix}`);
+  if (term.type === COMPOUND && term.arity === 0) return atom(term.name);
   return new Term(term.type, term.name, term.args.map((arg) => freshTerm(arg, suffix)));
 }
 
 export function copyResolved(term, env) {
   const resolved = deref(term, env);
   if (resolved.type === VAR) return variable(resolved.name);
+  if (resolved.type === COMPOUND && resolved.arity === 0) return atom(resolved.name);
   return new Term(resolved.type, resolved.name, resolved.args.map((arg) => copyResolved(arg, env)));
 }
 

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

@@ -6,5 +6,6 @@ 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(compose_atom_empty_args, ?x) :- compound_name_arguments(?x, z, []).
+answer(decompose_atom_empty_args, pair(?name, ?args)) :- compound_name_arguments(z, ?name, ?args).
 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/073_term_introspection_edges.eye

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

package/test/run-regression.mjs

@@ -337,6 +337,18 @@ function apiCases() {
       },
     },
 
+    {
+      name: 'compound factory canonicalizes zero arity to atoms',
+      run: () => {
+        const nil = compound('nil', []);
+        assertEqual(nil.type, 'atom', 'type');
+        assertEqual(nil.name, 'nil', 'name');
+        assertEqual(nil.arity, 0, 'arity');
+        assertEqual(termToString(nil, new Env(), true), 'nil', 'readback');
+        assertEqual(unify(nil, atom('nil'), new Env()), true, 'unifies with atom');
+      },
+    },
+
     {
       name: 'portable hash helpers match standard vectors',
       run: () => {