eyeprolog 1.5.18 → 1.5.19

package/package.json

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

package/src/charsio-host.js

@@ -188,6 +188,11 @@ function writeOptions(term, env, solver) {
     else if (option.name === 'double_quotes' && !solver.isoStrict) result.doubleQuotes = optionBoolean(option.args[0], env, option);
     else throw new PrologError('domain_error(write_option)', copyResolved(option, env));
   }
+  if (result.doubleQuotes === true) {
+    result.doubleQuotes = solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars';
+  } else {
+    result.doubleQuotes = null;
+  }
   return result;
 }
 

package/src/write.js

@@ -334,7 +334,11 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
     }
   }
 
-  if (!options.ignoreOps && isCons(resolved)) {
+  if (isCons(resolved)) {
+    // double_quotes/1 selects a character-list representation independently
+    // of operator notation. In normal mode, `||` is fixed list-splice syntax
+    // rather than an op/3 declaration, so ignore_ops(true) does not suppress
+    // an explicitly requested double-quoted proper or partial character list.
     const quotedSplice = quotedListSplice(resolved, env, options.doubleQuotes);
     if (quotedSplice != null && (quotedSplice.tail == null || options.doubleBar)) {
       const prefix = writeString(quotedSplice.text);
@@ -344,18 +348,21 @@ function format(term, env, options, table, maxPriority = 1200, context = 'term')
       // emitted text readable as the same term.
       return `${prefix}||${format(quotedSplice.tail, env, options, table, 1, 'term')}`;
     }
-    const parts = [];
-    let cursor = resolved;
-    while (true) {
-      cursor = deref(cursor, env);
-      const separator = options.compact ? ',' : ', ';
-      if (isEmptyList(cursor)) return `[${parts.join(separator)}]`;
-      if (!isCons(cursor)) {
-        const tailSeparator = options.compact ? '|' : ' | ';
-        return `[${parts.join(separator)}${tailSeparator}${format(cursor, env, options, table, 999, 'argument')}]`;
+
+    if (!options.ignoreOps) {
+      const parts = [];
+      let cursor = resolved;
+      while (true) {
+        cursor = deref(cursor, env);
+        const separator = options.compact ? ',' : ', ';
+        if (isEmptyList(cursor)) return `[${parts.join(separator)}]`;
+        if (!isCons(cursor)) {
+          const tailSeparator = options.compact ? '|' : ' | ';
+          return `[${parts.join(separator)}${tailSeparator}${format(cursor, env, options, table, 999, 'argument')}]`;
+        }
+        parts.push(format(cursor.args[0], env, options, table, 999, 'argument'));
+        cursor = cursor.args[1];
       }
-      parts.push(format(cursor.args[0], env, options, table, 999, 'argument'));
-      cursor = cursor.args[1];
     }
   }
 

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

@@ -124,7 +124,7 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 | 5.5.9 Built-in predicates | EyeProlog libraries, CLP(Z), statistics, Part 3 `phrase/2-3`, and bundled-library autoloaded predicates | Strict registry contains only the Part 1 + Corrigenda core registry. |
 | 5.5.10 Evaluable functors | Normal mode additionally accepts the EyeProlog evaluable atom `e`; the remaining arithmetic functors accepted by strict mode are the Part 1 + Corrigenda set. | Strict mode rejects `e/0` as non-evaluable and retains the Corrigendum arithmetic additions. **covered** — strict extension-boundary regression plus `src/iso-arithmetic.js`. |
 | 5.5.11 Reserved atoms | None | None. |
-| Cor.3 5.5.12 Options | Extra library/host options may exist outside core option lists | Normal mode additionally accepts the EyeProlog `write_term/2-3` options `double_quotes(true|false)` and `spacing(true|false)`. `spacing(false)` emits only lexically required separators; `spacing(true)` adds conventional layout around operators. Strict core excludes these implementation-specific extensions and accepts only the Part 1 plus Corrigendum 3 write-option surface; unknown extension options raise `domain_error(write_option,...)`. |
+| Cor.3 5.5.12 Options | Extra library/host options may exist outside core option lists | Normal mode additionally accepts the EyeProlog `write_term/2-3` options `double_quotes(true|false)` and `spacing(true|false)`. `double_quotes(true)` is orthogonal to `ignore_ops(true)`: eligible character/code lists retain double-quoted notation while operator terms use functional notation, and the order of those distinct options does not affect the result. `spacing(false)` emits only lexically required separators; `spacing(true)` adds conventional layout around operators. Strict core excludes these implementation-specific extensions and accepts only the Part 1 plus Corrigendum 3 write-option surface; unknown extension options raise `domain_error(write_option,...)`. |
 
 Normal mode provides documented module and DCG compatibility profiles whose
 features overlap standardized Part 2 and Part 3 facilities. They are extensions

package/test/run-regression.mjs

@@ -7097,6 +7097,51 @@ function whiteBoxCases() {
         }
       },
     },
+    {
+      name: 'double_quotes(true) remains effective with ignore_ops(true) in either option order (issue #88 follow-up)',
+      run: () => {
+        const source = [
+          'emit :-',
+          `  write_term(f("ab",a+b), [double_quotes(true),ignore_ops(true),quoted(true)]), put_char('|'),`,
+          `  write_term(f("ab",a+b), [ignore_ops(true),double_quotes(true),quoted(true)]), put_char('|'),`,
+          `  write_term("ab"||tail, [double_quotes(true),ignore_ops(true)]), put_char('|'),`,
+          `  write_term("ab"||tail, [ignore_ops(true),double_quotes(true)]), put_char('|'),`,
+          '  write_term("ab", [double_quotes(false),ignore_ops(true)]).',
+          '',
+        ].join('\n');
+        assertEqual(
+          run(source, { goal: 'emit' }).stdout,
+          'f("ab",+(a,b))|f("ab",+(a,b))|"ab"||tail|"ab"||tail|.(a,.(b,[]))emit.\n',
+          'write_term option composition',
+        );
+
+        const codesSource = [
+          'emit_codes :-',
+          '  set_prolog_flag(double_quotes, codes),',
+          '  write_term([97,955], [ignore_ops(true),double_quotes(true)]).',
+          '',
+        ].join('\n');
+        assertEqual(run(codesSource, { goal: 'emit_codes' }).stdout, '"aλ"emit_codes.\n',
+          'double_quotes(codes) representation');
+      },
+    },
+    {
+      name: 'charsio write_term_to_chars composes double_quotes with ignore_ops',
+      run: () => {
+        const source = [
+          ':- use_module(library(charsio)).',
+          'answer(A,B) :-',
+          '  write_term_to_chars(f("ab",a+b), [double_quotes(true),ignore_ops(true)], A),',
+          '  write_term_to_chars("ab"||tail, [ignore_ops(true),double_quotes(true)], B).',
+          '',
+        ].join('\n');
+        assertEqual(
+          run(source, { goal: 'answer(A,B)' }).stdout,
+          'answer("f(\\"ab\\",+(a,b))", "\\"ab\\"||tail").\n',
+          'charsio output',
+        );
+      },
+    },
     {
       name: 'REPL prints partial character lists with double-bar syntax (issue #88)',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5482,8 +5482,12 @@ still retained where adjacent graphic tokens would otherwise merge, as in
 `double_quotes(true|false)`: `true` lets eligible character/code lists use 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
+`"ab"||Tail`. This representation choice is independent of `ignore_ops/1`: with
+`ignore_ops(true)`, operator terms use functional notation while an explicitly
+requested character/code list remains double quoted. Thus
+`write_term(f("ab",a+b),[quoted(true),ignore_ops(true),double_quotes(true)])`
+emits `f("ab",+(a,b))`. Reversing the two options has the same effect. 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,
@@ -6175,7 +6179,7 @@ the beginning. A peek does not mark the stream as past-end.
 - **`write(+Term)`, `write(+Stream,+Term)`** — Writes readable operator notation without quoting atoms merely because quoting would be required for reparsing. Number variables are enabled.
 - **`writeq(+Term)`, `writeq(+Stream,+Term)`** — Like `write`, but quotes atoms when required for unambiguous input syntax.
 - **`write_canonical(+Term)`, `write_canonical(+Stream,+Term)`** — Writes quoted canonical functor notation while ignoring operators and without interpreting *$VAR/1*.
-- **`write_term(+Term,+Options)`, `write_term(+Stream,+Term,+Options)`** — Writes with *quoted(true or false)*, *ignore_ops(true or false)*, *numbervars(true or false)*, and *variable_names([Name=Variable,...])*. Normal mode also supports *double_quotes(true or false)* and *spacing(true or false)*.
+- **`write_term(+Term,+Options)`, `write_term(+Stream,+Term,+Options)`** — Writes with *quoted(true or false)*, *ignore_ops(true or false)*, *numbervars(true or false)*, and *variable_names([Name=Variable,...])*. Normal mode also supports *double_quotes(true or false)* and *spacing(true or false)*. `double_quotes(true)` remains effective with `ignore_ops(true)`: operator terms are written functionally while eligible character/code lists retain double-quoted notation, independently of option order.
 
 Term input uses the program's current operator table and the same ISO quoted-character
 syntax as source text, including backslash-terminated octal and hexadecimal