eyeprolog 1.5.11 → 1.5.12

package/package.json

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

package/src/execute.js

@@ -51,6 +51,7 @@ export function executeGoals(program, solver, goals, { onAnswer = () => {} } = {
 function currentWriteOptions(program, solver) {
   return {
     doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+    doubleBar: !solver.isoStrict,
     operators: [...program.operators.values()],
     quoted: true,
   };

package/src/iso.js

@@ -1988,6 +1988,7 @@ function writeBuiltin(mode) {
       generateVariableNames: true,
       variableNameState: solver.writeVariableState,
       operators: solver.program.operators.values(),
+      doubleBar: !solver.isoStrict,
     }));
     yield env;
   };
@@ -2019,6 +2020,7 @@ function* writeTermBuiltin({ solver, goal, env }) {
     generateVariableNames: true,
     variableNameState: solver.writeVariableState,
     operators: solver.program.operators.values(),
+    doubleBar: !solver.isoStrict,
   }));
   yield env;
 }

package/src/parser.js

@@ -937,9 +937,37 @@ class Parser {
         this.parserFlagState.doubleQuotes === 'chars'
           ? atom(character)
           : numberTerm(character.codePointAt(0)));
-      let list = emptyList();
-      for (let i = items.length - 1; i >= 0; i--) list = cons(items[i], list);
-      return list;
+      let tail = emptyList();
+
+      // Trealla-compatible double-bar right splice (issue #88): in normal
+      // mode, a double-quoted chars/codes prefix may be followed by `||Tail`.
+      // It is equivalent to the corresponding list prefix with Tail as its
+      // final list tail, e.g. "ab"||T is [a,b|T] with double_quotes(chars).
+      // The extension binds at priority 1 (tighter than ordinary operators)
+      // and is deliberately absent from the strict ISO profile.
+      if (!this.strictIso && this.token.type === TOK.BAR) {
+        const state = {
+          pos: this.pos,
+          line: this.line,
+          previousToken: this.previousToken,
+          token: this.token,
+        };
+        this.advance();
+        if (this.token.type === TOK.BAR) {
+          this.advance();
+          tail = this.parseTerm(operatorStrength(1), false, allowBar, false);
+        } else {
+          // A single bar remains ordinary bar syntax. We had to advance once
+          // to distinguish it from `||`, so restore the tokenizer state.
+          this.pos = state.pos;
+          this.line = state.line;
+          this.previousToken = state.previousToken;
+          this.token = state.token;
+        }
+      }
+
+      for (let i = items.length - 1; i >= 0; i--) tail = cons(items[i], tail);
+      return tail;
     }
     if (this.token.type === TOK.NUMBER) {
       const value = this.token.text;

package/src/repl.js

@@ -746,6 +746,7 @@ function formatAnswer(engine, state, variables, env) {
     operatorAtomsAsArgs: true,
     dottedGraphicAtoms: true,
     doubleQuotes: state.solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+    doubleBar: !state.strictIso,
   };
   let generated = 0;
 
@@ -844,6 +845,7 @@ function formatError(engine, state, error) {
       quoted: true,
       operators: [...state.program.operators.values()],
       variableNames,
+      doubleBar: !state.strictIso,
     })}.`;
   }
   const message = error?.message ?? String(error);

package/src/term.js

@@ -1067,14 +1067,18 @@ function writeString(value, quoteStrings) {
   return out + '"';
 }
 
-function quotedListText(term, env, doubleQuotes) {
+function quotedListSplice(term, env, doubleQuotes) {
   if (doubleQuotes !== 'chars' && doubleQuotes !== 'codes') return null;
   const characters = [];
   let cursor = term;
   while (true) {
     cursor = deref(cursor, env);
-    if (isEmptyList(cursor)) return characters.length === 0 ? null : characters.join('');
-    if (!isCons(cursor)) return null;
+    if (isEmptyList(cursor)) {
+      return characters.length === 0 ? null : { text: characters.join(''), tail: null };
+    }
+    if (!isCons(cursor)) {
+      return characters.length === 0 ? null : { text: characters.join(''), tail: cursor };
+    }
     const item = deref(cursor.args[0], env);
     if (doubleQuotes === 'chars') {
       if (item.type !== ATOM || Array.from(item.name).length !== 1) return null;
@@ -1090,8 +1094,12 @@ function quotedListText(term, env, doubleQuotes) {
 }
 
 function writeList(term, env, options) {
-  const quotedText = quotedListText(term, env, options.doubleQuotes);
-  if (quotedText != null) return writeString(quotedText, true);
+  const quotedSplice = quotedListSplice(term, env, options.doubleQuotes);
+  if (quotedSplice != null && (quotedSplice.tail == null || options.doubleBar === true)) {
+    const prefix = writeString(quotedSplice.text, true);
+    if (quotedSplice.tail == null) return prefix;
+    return `${prefix}||${termToString(quotedSplice.tail, env, true, options)}`;
+  }
   const parts = [];
   let cursor = term;
   while (true) {
@@ -1110,6 +1118,10 @@ export function termToString(term, env = new Env(), quoteStrings = true, options
   options = {
     ...options,
     doubleQuotes: options.doubleQuotes ?? 'chars',
+    // termToString is also used for context-free processor-error messages.
+    // Keep the normal-profile `||` extension opt-in here so strict errors do
+    // not accidentally emit syntax that the strict parser rejects.
+    doubleBar: options.doubleBar === true,
     readVariableNames: options.readVariableNames instanceof Map ? options.readVariableNames : new Map(),
     usedReadVariableNames: options.usedReadVariableNames instanceof Set ? options.usedReadVariableNames : new Set(),
   };

package/src/write.js

@@ -152,14 +152,18 @@ function writeString(value) {
   return out + '"';
 }
 
-function quotedListText(term, env, doubleQuotes) {
+function quotedListSplice(term, env, doubleQuotes) {
   if (doubleQuotes !== 'chars' && doubleQuotes !== 'codes') return null;
   const characters = [];
   let cursor = term;
   while (true) {
     cursor = deref(cursor, env);
-    if (isEmptyList(cursor)) return characters.length === 0 ? null : characters.join('');
-    if (!isCons(cursor)) return null;
+    if (isEmptyList(cursor)) {
+      return characters.length === 0 ? null : { text: characters.join(''), tail: null };
+    }
+    if (!isCons(cursor)) {
+      return characters.length === 0 ? null : { text: characters.join(''), tail: cursor };
+    }
     const item = deref(cursor.args[0], env);
     if (doubleQuotes === 'chars') {
       if (item.type !== ATOM || Array.from(item.name).length !== 1) return null;
@@ -331,8 +335,15 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
   }
 
   if (!options.ignoreOps && isCons(resolved)) {
-    const quotedText = quotedListText(resolved, env, options.doubleQuotes);
-    if (quotedText != null) return writeString(quotedText);
+    const quotedSplice = quotedListSplice(resolved, env, options.doubleQuotes);
+    if (quotedSplice != null && (quotedSplice.tail == null || options.doubleBar)) {
+      const prefix = writeString(quotedSplice.text);
+      if (quotedSplice.tail == null) return prefix;
+      // `||` is a normal-profile syntax extension with priority 1, so a
+      // looser operator in the right operand must be parenthesized to keep the
+      // emitted text readable as the same term.
+      return `${prefix}||${format(quotedSplice.tail, env, options, table, 1, 'term')}`;
+    }
     const parts = [];
     let cursor = resolved;
     while (true) {
@@ -442,6 +453,9 @@ export function formatTermForWrite(term, env = new Env(), options = {}) {
     ignoreOps: options.ignoreOps === true,
     numbervars: options.numbervars !== false,
     doubleQuotes: options.doubleQuotes,
+    // `||` is a normal-profile syntax extension. Public normal-mode writers
+    // enable it by default; strict callers explicitly turn it off.
+    doubleBar: options.doubleBar !== false,
     variableNames: options.generateVariableNames === true
       ? printableGeneratedVariableNames(term, env, explicitVariableNames, options.variableNameState)
       : printableReadVariableNames(term, env, explicitVariableNames),

package/test/conformance/ISO-IMPLEMENTATION-DEFINED.md

@@ -113,7 +113,7 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 
 | Part 1 extension hook | EyeProlog normal-profile feature | Strict-core disposition |
 | --- | --- | --- |
-| 5.5.1 Syntax | Part 2 modules, Part 3 grammar-rule expansion, and embedded quad syntax | Module directives are rejected; grammar rules remain ordinary `-->/2` terms rather than being expanded; quad syntax is rejected. Unicode PCS membership/classification is implementation defined and therefore shared with normal mode rather than treated as an extension. |
+| 5.5.1 Syntax | Part 2 modules, Part 3 grammar-rule expansion, embedded quad syntax, and Trealla-compatible `"text"||Tail` right-splicing for double-quoted `chars`/`codes` lists | Module directives are rejected; grammar rules remain ordinary `-->/2` terms rather than being expanded; quad syntax and double-bar right-splicing are rejected. Unicode PCS membership/classification is implementation defined and therefore shared with normal mode rather than treated as an extension. |
 | 5.5.2 Predefined operators | Part 3 `|` and EyeProlog's labelable infix `(?-)/2`; CLP(Z) operators when that library is imported | Only the Part 1 operator table is predefined; a conforming `op/3` may still add permitted operators. |
 | 5.5.3 Character-conversion mapping | No non-identity initial `Convc` extension | Identity initial mapping. |
 | 5.5.4 Types | The normal JavaScript API exposes an implementation-specific string term `stringTerm(Text)`. It is disjoint from the five Part 1 term types; normal term order places it after atoms and before compound terms, and normal `atomic/1` treats it as atomic. It has no Prolog source token syntax (double-quoted source still follows `double_quotes`), is non-callable for term-to-clause conversion, is not evaluable as an arithmetic expression, and writes as a double-quoted host string. | Strict mode rejects a programmatic string term at program/goal entry with `representation_error(term)`, so the additional type cannot enter the Part 1 execution domain. **defined** — `src/term.js`, `src/program.js`, `src/solver.js`; strict API-boundary regression. |

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

@@ -1,4 +1,4 @@
 scryer_escapes(ok).
 scryer_numbers(-1, 1, 1, 1, 1).
 scryer_comments(7, 7).
-scryer_terms({1}, "a", [a, b | c], []).
+scryer_terms({1}, "a", "ab"||c, []).

package/test/conformance/expected/lists/extra_append_to_improper_tail.pl

@@ -1 +1 @@
-answer(append_to_improper_tail, [a, b | tail]).
+answer(append_to_improper_tail, "ab"||tail).

package/test/conformance/expected/lists/improper_list_readback.pl

@@ -1 +1 @@
-answer([a, b | tail]).
+answer("ab"||tail).

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

@@ -10,4 +10,4 @@ value(compound, pair(3, nested(atom, "xy"))).
 value(arity_zero_atom, nil).
 value(empty_list, []).
 value(proper_list, "abc").
-value(improper_list, [a, b | tail]).
+value(improper_list, "ab"||tail).

package/test/run-regression.mjs

@@ -2441,7 +2441,7 @@ c4 ?- call((!;1)).
           '?-    Xs = [].\n' +
           '?-    true.\n' +
           '?-    true.\n' +
-          '?-    Xs0 = [a | Xs].\n' +
+          '?-    Xs0 = "a"||Xs.\n' +
           '?- ',
           'stdout');
         assertEqual(result.stderr, '', 'stderr');
@@ -6947,6 +6947,44 @@ function whiteBoxCases() {
         assertEqual(`${quotedAtom.type}:${quotedAtom.name}`, 'atom:aλ', 'atom');
       },
     },
+    {
+      name: 'double-bar syntax splices double-quoted list prefixes (issue #88)',
+      run: () => {
+        const chars = parseGoalText('p("ab"||Tail)').args[0];
+        assertEqual(chars.args[0].name, 'a', 'chars first element');
+        assertEqual(chars.args[1].args[0].name, 'b', 'chars second element');
+        assertEqual(chars.args[1].args[1].type, 'var', 'chars partial tail type');
+        assertEqual(chars.args[1].args[1].name, 'Tail', 'chars partial tail name');
+        assertEqual(termToString(chars, new Env(), true, { doubleBar: true }), '"ab"||Tail', 'chars readback');
+
+        const codes = parseGoalText('p("aλ" || Tail)', { doubleQuotes: 'codes' }).args[0];
+        assertEqual(codes.args[0].name, '97', 'codes first element');
+        assertEqual(codes.args[1].args[0].name, '955', 'codes second element');
+        assertEqual(termToString(codes, new Env(), true, { doubleQuotes: 'codes', doubleBar: true }), '"aλ"||Tail', 'codes readback');
+
+        const nested = parseGoalText('p(["ab"|Tail])');
+        assertEqual(termToString(nested), 'p(["ab" | Tail])', 'single bar remains list syntax');
+
+        for (const options of [{ isoStrict: true }, { doubleQuotes: 'atom' }]) {
+          let threw = false;
+          try { parseGoalText('p("ab"||Tail)', options); } catch (_) { threw = true; }
+          assertEqual(threw, true, `double-bar rejected for ${JSON.stringify(options)}`);
+        }
+      },
+    },
+    {
+      name: 'REPL prints partial character lists with double-bar syntax (issue #88)',
+      run: () => {
+        const result = runCli([], {
+          input: 'phrase("Think of this text, and much more.", S0,S).\nhalt.\n',
+        });
+        assertEqual(result.status, 0, 'REPL exit status');
+        assertIncludes(result.stdout,
+          'S0 = "Think of this text, and much more."||S.',
+          'Trealla-compatible partial string answer');
+        assertNotIncludes(result.stdout, "S0 = ['T'", 'legacy expanded list answer');
+      },
+    },
     {
       name: 'double_quotes directives affect subsequent source text',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -474,6 +474,12 @@ Prolog programs accepted by EyeProlog are built from terms:
 - compound terms: `point(3, 4)`, `reading(temp, 91)`;
 - lists: `[]`, `[red, green, blue]`, `[Head | Tail]`.
 
+In normal mode, double-quoted character/code lists also support Trealla's
+right-splice notation. With `double_quotes(chars)`, `"ab"||Tail` is shorthand
+for `[a,b|Tail]`; with `double_quotes(codes)`, it denotes `[97,98|Tail]`. The
+splice is not available when `double_quotes(atom)` is active, and
+`--iso-strict` rejects it as an implementation-specific syntax extension.
+
 Plain atom constants begin with a lowercase ASCII letter. Variables begin with
 an uppercase letter or underscore. The bare `_` is anonymous and every
 occurrence is fresh. `_Name` is a named variable; repeated occurrences refer to
@@ -5492,8 +5498,10 @@ still retained where adjacent graphic tokens would otherwise merge, as in
 `write_term/2-3` supports `quoted/1`, `ignore_ops/1`, `numbervars/1`, and
 `variable_names/1`. Normal mode additionally accepts the EyeProlog extension
 `double_quotes(true|false)`: `true` lets eligible character/code lists use the
-current `double_quotes` representation, while strict ISO mode rejects this
-implementation-specific write option. Normal mode also accepts the
+current `double_quotes` representation. Proper lists can therefore be written
+as `"text"`, while a partial list such as `[a,b|Tail]` is written as
+`"ab"||Tail`. Strict ISO mode rejects this implementation-specific write
+option. Normal mode also accepts the
 implementation-specific boolean `spacing(true|false)` option: `false` emits
 only separators required to avoid lexical ambiguity, while `true` adds
 conventional layout around operators. For example,
@@ -5588,6 +5596,8 @@ lowercase ASCII letter. Variables begin with uppercase or underscore. The bare
 `_` is fresh each time. Single quotes delimit quoted atoms; double quotes use
 ISO double-quoted-list notation. Integers, decimals, scientific notation,
 binary/octal/hexadecimal integers, and character-code constants are accepted.
+Normal mode additionally accepts the Trealla-compatible `"text"||Tail`
+right-splice for double-quoted `chars`/`codes` lists; strict ISO mode does not.
 
 The processor character set is shared by normal and `--iso-strict` modes because
 Part 1 makes it implementation defined rather than an extension boundary.
@@ -8017,7 +8027,9 @@ Notable implementation boundaries are:
 - module and ISO/IEC TS 13211-3-oriented DCG compatibility profiles are supported in normal mode, without a complete Part 2/Part 3 certification claim;
 - 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`;
+  matches Trealla and Scryer and may be changed to `codes` or `atom`; normal
+  mode additionally accepts Trealla-compatible `"text"||Tail` right-splicing
+  for the `chars` and `codes` values, while strict mode rejects that syntax;
 - `write_term/2-3` implements the Part 1 plus Corrigendum 3 `quoted/1`,
   `ignore_ops/1`, `numbervars/1`, and `variable_names/1` option surface,
   including option validation and traversal rules; normal mode also offers