eyelang 1.3.0 → 1.3.1

package/docs/guide.md

@@ -2,7 +2,7 @@
 
 This guide introduces Eyelang, a small Horn-clause language and engine whose source syntax is Prolog-like but deliberately its own compact language 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 bin/eyelang.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/2` declarations such as `materialize(answer, 2).` to focus output on selected predicates.
+Programs write relations directly, for example `ancestor(pat, emma)` or `status(case1, accepted)`. Absolute IRI atoms can be written explicitly with angle brackets, for example `<https://schema.org/name>`, when a program needs web identifiers without prefix declarations. 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/2` declarations such as `materialize(answer, 2).` to focus output on selected predicates.
 
 
 For the normative language definition, including lexical syntax, terms, clauses, goals, built-ins, `table/2`, `materialize/2`, and conformance boundaries, read the [Eyelang language reference](language-reference.md).

package/docs/language-reference.md

@@ -138,7 +138,7 @@ Each `?_` anonymous variable occurrence is fresh. A bare `_` is not a variable i
 
 ### 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 dot is not part of a plain atom; dotted web spaces such as `'be.ugent'` or `'org.schema'` MUST be quoted if they are meant as one atom constant. Names such as `a-b` or `http://example` MUST also be quoted if they are meant as one atom constant:
+A plain atom constant starts with a lowercase ASCII letter and is followed by zero or more ASCII letters, digits, or underscores. A dot is not part of a plain atom; dotted web spaces such as `'be.ugent'` or `'org.schema'` MUST be quoted if they are meant as one atom constant. Names such as `a-b` MUST also be quoted if they are meant as one atom constant:
 
 ```eyelang
 pat
@@ -148,9 +148,18 @@ case_123
 'org.schema'
 'eyereasoner.github'
 'a-b'
-'http://example'
 ```
 
+Absolute IRI atom constants MAY also be written between angle brackets. The content must be an absolute IRI-like lexical value with a scheme such as `https:` or `urn:`. Eyelang stores the content as the atom value and prints absolute IRI atoms with angle brackets on read-back:
+
+```eyelang
+<https://example.org/alice>
+<urn:example:bob>
+triple(<https://example.org/alice>, <https://schema.org/name>, "Alice").
+```
+
+Quoted absolute IRI atoms remain valid input, but read-back normalizes them to angle-bracket syntax. For example, `'https://example.org/alice'` prints as `<https://example.org/alice>`.
+
 A quoted atom constant is enclosed in single quotes. A single quote inside a quoted atom constant is represented by doubling it:
 
 ```eyelang
@@ -165,6 +174,8 @@ A graphic atom constant is one or more graphic characters from this set:
 #$&*+-/<=>?@^~\
 ```
 
+Angle-bracket IRI syntax is recognized only for absolute IRI-like contents. Graphic atoms such as `<=>`, `<`, and `>=` remain graphic atoms.
+
 ### 3.6 Strings
 
 A string is enclosed in double quotes. The implementation supports common escapes such as `\n`, `\t`, `\"`, and `\\`.
@@ -659,7 +670,7 @@ eyelang source is intended to be familiar to Prolog readers, but eyelang is not
 - no variables in functor or predicate position;
 - no occurs check in unification.
 
-Programs intended to be portable to eyelang SHOULD use `?` variables, 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'`.
+Programs intended to be portable to eyelang SHOULD use `?` variables, avoid ISO-specific syntax, and keep terms explicit. Atom names that are not plain lowercase-starting names, graphic atom tokens, or angle-bracket absolute IRI atoms SHOULD be written as quoted atoms, for example `'a-b'`.
 
 ## 16. Examples
 

package/package.json

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

package/src/parser.js

@@ -7,6 +7,22 @@ const TOK = {
   LPAREN: '(', RPAREN: ')', LBRACKET: '[', RBRACKET: ']', COMMA: ',', BAR: '|', DOT: '.', IF: ':-'
 };
 
+function isAbsoluteIriText(text) {
+  return /^[A-Za-z][A-Za-z0-9+.-]*:[^\s<>"'{}|\\^`]*$/.test(text);
+}
+
+function hasAngleIriToken(source, pos) {
+  if (source[pos] !== '<') return false;
+  let text = '';
+  for (let i = pos + 1; i < source.length; i++) {
+    const ch = source[i];
+    if (ch === '>') return text.length > 0 && isAbsoluteIriText(text);
+    if (ch === '\n' || ch === '\r' || /\s/.test(ch) || ch === '<') return false;
+    text += ch;
+  }
+  return false;
+}
+
 function isWhitespaceCode(code) {
   return code === 32 || code === 9 || code === 10 || code === 13 || code === 12 || code === 11;
 }
@@ -97,6 +113,18 @@ class Parser {
     }
     if (ch === ':') throw new Error('colon names are not supported; use name or prefix_name');
 
+    if (hasAngleIriToken(this.source, this.pos)) {
+      this.take(); // <
+      let text = '';
+      while (true) {
+        if (!this.peek()) throw new Error(`parse line ${line}: unterminated IRI`);
+        const value = this.take();
+        if (value === '>') break;
+        text += value;
+      }
+      return { type: TOK.ATOM, text, line };
+    }
+
     if (ch === '"' || ch === "'") {
       const quote = this.take();
       let text = '';

package/src/term.js

@@ -135,6 +135,14 @@ export function termIsGround(term, env = new Env()) {
 
 const graphicAtomChars = new Set('#$&*+-/<=>?@^~\\'.split(''));
 
+function isAbsoluteIriText(text) {
+  return /^[A-Za-z][A-Za-z0-9+.-]*:[^\s<>"'{}|\\^`]*$/.test(text);
+}
+
+function writeAngleIri(name) {
+  return `<${name}>`;
+}
+
 function atomNeedsQuotes(name) {
   if (!name) return true;
   if (name === '[]') return false;
@@ -156,6 +164,7 @@ function quoteAtom(name) {
 }
 
 function writeAtom(name) {
+  if (isAbsoluteIriText(name)) return writeAngleIri(name);
   return atomNeedsQuotes(name) ? quoteAtom(name) : name;
 }
 

package/test/conformance/cases/103_angle_iri_atoms.eye

@@ -0,0 +1,7 @@
+% Reference 3.5: absolute IRIs may be written as angle-bracket atom constants.
+materialize(iri_subject, 1).
+materialize(iri_object, 1).
+triple(<https://example.org/alice>, <https://schema.org/name>, "Alice").
+triple(<urn:example:bob>, <https://schema.org/knows>, <https://example.org/alice>).
+iri_subject(?iri) :- triple(?iri, ?_, ?_).
+iri_object(?iri) :- triple(?_, <https://schema.org/knows>, ?iri).

package/test/conformance/expected/103_angle_iri_atoms.eye

@@ -0,0 +1,3 @@
+iri_subject(<https://example.org/alice>).
+iri_subject(<urn:example:bob>).
+iri_object(<https://example.org/alice>).

package/test/run-regression.mjs

@@ -529,6 +529,27 @@ function whiteBoxCases() {
         assertEqual(termToString(clauses[0].head, new Env(), true), "p(web('be.ugent', josd), 'org.schema')", 'head');
       },
     },
+    {
+      name: 'parser accepts angle-bracket absolute IRI atoms',
+      run: () => {
+        const clauses = parseProgramText('p(<https://example.org/alice>, <urn:example:bob>).\n');
+        assertEqual(termToString(clauses[0].head, new Env(), true), 'p(<https://example.org/alice>, <urn:example:bob>)', 'head');
+      },
+    },
+    {
+      name: 'readback prints absolute IRI atoms with angle brackets',
+      run: () => {
+        const clauses = parseProgramText("p('https://example.org/alice').\n");
+        assertEqual(termToString(clauses[0].head, new Env(), true), 'p(<https://example.org/alice>)', 'head');
+      },
+    },
+    {
+      name: 'angle IRI syntax does not steal graphic atom syntax',
+      run: () => {
+        const clauses = parseProgramText('p(<=>).\n');
+        assertEqual(termToString(clauses[0].head, new Env(), true), 'p(<=>)', 'head');
+      },
+    },
     {
       name: 'list construction round-trips through properListItems',
       run: () => {