eyeprolog 0.5.14 → 0.5.16

package/README.md

@@ -28,6 +28,8 @@ eyeprolog --goal 'type(socrates, mortal)' examples/socrates.pl
 ```
 
 Programs may declare their default queries with `%% goal:` comments.
+Double-quoted text follows the ISO `double_quotes` flag and defaults to a
+proper list of one-character atoms (`chars`), matching Trealla and Scryer.
 
 ## Portable library
 

package/conformance-report.md

@@ -11,7 +11,7 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | builtins | 11 | 0 | 0 | 0 | 11 |
 | context | 11 | 0 | 0 | 0 | 11 |
 | control | 15 | 0 | 0 | 0 | 15 |
-| iso | 120 | 159 | 0 | 0 | 279 |
+| iso | 121 | 159 | 0 | 0 | 280 |
 | lists | 52 | 3 | 0 | 0 | 55 |
 | negation | 8 | 0 | 19 | 0 | 27 |
 | proofs | 0 | 0 | 0 | 21 | 21 |
@@ -22,4 +22,4 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | terms | 26 | 3 | 0 | 0 | 29 |
 | unification | 18 | 0 | 0 | 0 | 18 |
 | variables | 16 | 9 | 0 | 0 | 25 |
-| **Total** | **433** | **212** | **19** | **21** | **685** |
+| **Total** | **434** | **212** | **19** | **21** | **686** |

package/examples/output/aliases-and-namespaces.pl

@@ -1,5 +1,5 @@
 value(nativeMath, 1.0).
 ok(nativeCompare, true).
 ok(nativeString, true).
-tail(nativeList, [b, c]).
+tail(nativeList, "bc").
 label(vocabularyExample, "vocabulary names are ordinary predicate names").

package/examples/output/dijkstra-findall-sort.pl

@@ -1,2 +1,2 @@
-shortestPath(dijkstra_findall_sort, [a, c, b, d, e, f]).
+shortestPath(dijkstra_findall_sort, "acbdef").
 cost(dijkstra_findall_sort, 13).

package/examples/output/dijkstra.pl

@@ -1,16 +1,16 @@
-edge([b, a], 4).
-edge([c, a], 2).
-edge([c, b], 1).
-edge([d, b], 5).
-edge([d, c], 8).
-edge([e, c], 10).
-edge([e, d], 2).
-edge([f, d], 6).
-edge([f, e], 3).
-path([a, f], [[a, b, d, e, f], 14]).
-path([a, f], [[a, b, d, f], 15]).
-path([a, f], [[a, c, d, e, f], 15]).
-path([a, f], [[a, c, d, f], 16]).
-path([a, f], [[a, c, e, f], 15]).
-path([a, f], [[a, c, b, d, e, f], 13]).
-path([a, f], [[a, c, b, d, f], 14]).
+edge("ba", 4).
+edge("ca", 2).
+edge("cb", 1).
+edge("db", 5).
+edge("dc", 8).
+edge("ec", 10).
+edge("ed", 2).
+edge("fd", 6).
+edge("fe", 3).
+path("af", ["abdef", 14]).
+path("af", ["abdf", 15]).
+path("af", ["acdef", 15]).
+path("af", ["acdf", 16]).
+path("af", ["acef", 15]).
+path("af", ["acbdef", 13]).
+path("af", ["acbdf", 14]).

package/examples/output/drone-corridor-planner.pl

@@ -1,17 +1,17 @@
-gps_plan(d1, plan([fly_gent_brugge, public_coastline_brugge_oostende], 2800.0, 0.012, 0.96029999999999993, 0.95039999999999991, low, none, [t, t, t, t, t])).
-gps_plan(d1, plan([fly_gent_brugge, buy_permit_brugge, public_coastline_brugge_oostende], 3250.0, 0.014, 0.94109399999999999, 0.95039999999999991, low, yes, [t, t, t, t])).
-gps_plan(d1, plan([fly_gent_brugge, buy_permit_brugge, topup_brugge, cross_corridor_brugge_oostende], 3250.0, 0.015000000000000001, 0.94984520399999994, 0.97019999999999995, mid, yes, [t, t, t])).
-gps_plan(d1, plan([fly_gent_brugge, buy_permit_brugge, topup_brugge, public_coastline_brugge_oostende], 3550.0, 0.017000000000000001, 0.94499905500000003, 0.931392, mid, yes, [t, t, t])).
-gps_plan(d1, plan([fly_gent_brugge, topup_brugge, public_coastline_brugge_oostende], 3100.0, 0.015000000000000001, 0.96428475000000002, 0.931392, mid, none, [t, t, t, t])).
-gps_plan(d1, plan([fly_gent_brugge, topup_brugge, buy_permit_brugge, cross_corridor_brugge_oostende], 3250.0, 0.015000000000000001, 0.94984520399999994, 0.97019999999999995, mid, yes, [t, t, t])).
-gps_plan(d1, plan([fly_gent_brugge, topup_brugge, buy_permit_brugge, public_coastline_brugge_oostende], 3550.0, 0.017000000000000001, 0.94499905500000003, 0.931392, mid, yes, [t, t, t])).
-gps_plan(d1, plan([train_gent_brugge, public_coastline_brugge_oostende], 2900.0, 0.018000000000000002, 0.97402500000000003, 0.95519999999999994, mid, none, [t, t, t, t, t])).
-gps_plan(d1, plan([train_gent_brugge, buy_permit_brugge, cross_corridor_brugge_oostende], 3050.0, 0.018000000000000002, 0.95943959999999995, 0.995, mid, yes, [t, t, t, t])).
-gps_plan(d1, plan([train_gent_brugge, buy_permit_brugge, public_coastline_brugge_oostende], 3350.0, 0.02, 0.95454450000000002, 0.95519999999999994, mid, yes, [t, t, t, t])).
-gps_plan(d1, plan([fly_gent_kortrijk, fly_kortrijk_brugge, buy_permit_brugge, quick_charge_brugge, cross_corridor_brugge_oostende], 5150.0, 0.024, 0.94034675195999995, 0.9506969999999999, mid, yes, [t, t])).
-gps_plan(d1, plan([fly_gent_kortrijk, fly_kortrijk_brugge, quick_charge_brugge, public_coastline_brugge_oostende], 5000.0, 0.024, 0.95464190250000003, 0.91266911999999989, mid, none, [t, t, t])).
-gps_plan(d1, plan([fly_gent_kortrijk, fly_kortrijk_brugge, quick_charge_brugge, buy_permit_brugge, cross_corridor_brugge_oostende], 5150.0, 0.024, 0.94034675195999995, 0.9506969999999999, mid, yes, [t, t])).
-gps_plan(d1, plan([fly_gent_kortrijk, get_zone_permit_kortrijk, fly_kortrijk_brugge, quick_charge_brugge, cross_corridor_brugge_oostende], 5000.0, 0.023, 0.95857796449800003, 0.9506969999999999, mid, yes, [t, t])).
-gps_plan(d1, plan([fly_gent_kortrijk, get_zone_permit_kortrijk, fly_kortrijk_brugge, quick_charge_brugge, public_coastline_brugge_oostende], 5300.0, 0.025000000000000001, 0.95368726059749998, 0.91266911999999989, mid, yes, [t, t])).
-gps_plan(d1, plan([fly_gent_kortrijk, get_zone_permit_kortrijk, emergency_charge_kortrijk, direct_corridor_kortrijk_oostende], 3500.0, 0.02, 0.94356004544999994, 0.86526000000000003, mid, yes, [t, t, t])).
-gps_plan(d1, plan([fly_gent_kortrijk, emergency_charge_kortrijk, get_zone_permit_kortrijk, direct_corridor_kortrijk_oostende], 3500.0, 0.019999999999999997, 0.94356004544999994, 0.86526000000000003, mid, yes, [t, t, t])).
+gps_plan(d1, plan([fly_gent_brugge, public_coastline_brugge_oostende], 2800.0, 0.012, 0.96029999999999993, 0.95039999999999991, low, none, "ttttt")).
+gps_plan(d1, plan([fly_gent_brugge, buy_permit_brugge, public_coastline_brugge_oostende], 3250.0, 0.014, 0.94109399999999999, 0.95039999999999991, low, yes, "tttt")).
+gps_plan(d1, plan([fly_gent_brugge, buy_permit_brugge, topup_brugge, cross_corridor_brugge_oostende], 3250.0, 0.015000000000000001, 0.94984520399999994, 0.97019999999999995, mid, yes, "ttt")).
+gps_plan(d1, plan([fly_gent_brugge, buy_permit_brugge, topup_brugge, public_coastline_brugge_oostende], 3550.0, 0.017000000000000001, 0.94499905500000003, 0.931392, mid, yes, "ttt")).
+gps_plan(d1, plan([fly_gent_brugge, topup_brugge, public_coastline_brugge_oostende], 3100.0, 0.015000000000000001, 0.96428475000000002, 0.931392, mid, none, "tttt")).
+gps_plan(d1, plan([fly_gent_brugge, topup_brugge, buy_permit_brugge, cross_corridor_brugge_oostende], 3250.0, 0.015000000000000001, 0.94984520399999994, 0.97019999999999995, mid, yes, "ttt")).
+gps_plan(d1, plan([fly_gent_brugge, topup_brugge, buy_permit_brugge, public_coastline_brugge_oostende], 3550.0, 0.017000000000000001, 0.94499905500000003, 0.931392, mid, yes, "ttt")).
+gps_plan(d1, plan([train_gent_brugge, public_coastline_brugge_oostende], 2900.0, 0.018000000000000002, 0.97402500000000003, 0.95519999999999994, mid, none, "ttttt")).
+gps_plan(d1, plan([train_gent_brugge, buy_permit_brugge, cross_corridor_brugge_oostende], 3050.0, 0.018000000000000002, 0.95943959999999995, 0.995, mid, yes, "tttt")).
+gps_plan(d1, plan([train_gent_brugge, buy_permit_brugge, public_coastline_brugge_oostende], 3350.0, 0.02, 0.95454450000000002, 0.95519999999999994, mid, yes, "tttt")).
+gps_plan(d1, plan([fly_gent_kortrijk, fly_kortrijk_brugge, buy_permit_brugge, quick_charge_brugge, cross_corridor_brugge_oostende], 5150.0, 0.024, 0.94034675195999995, 0.9506969999999999, mid, yes, "tt")).
+gps_plan(d1, plan([fly_gent_kortrijk, fly_kortrijk_brugge, quick_charge_brugge, public_coastline_brugge_oostende], 5000.0, 0.024, 0.95464190250000003, 0.91266911999999989, mid, none, "ttt")).
+gps_plan(d1, plan([fly_gent_kortrijk, fly_kortrijk_brugge, quick_charge_brugge, buy_permit_brugge, cross_corridor_brugge_oostende], 5150.0, 0.024, 0.94034675195999995, 0.9506969999999999, mid, yes, "tt")).
+gps_plan(d1, plan([fly_gent_kortrijk, get_zone_permit_kortrijk, fly_kortrijk_brugge, quick_charge_brugge, cross_corridor_brugge_oostende], 5000.0, 0.023, 0.95857796449800003, 0.9506969999999999, mid, yes, "tt")).
+gps_plan(d1, plan([fly_gent_kortrijk, get_zone_permit_kortrijk, fly_kortrijk_brugge, quick_charge_brugge, public_coastline_brugge_oostende], 5300.0, 0.025000000000000001, 0.95368726059749998, 0.91266911999999989, mid, yes, "tt")).
+gps_plan(d1, plan([fly_gent_kortrijk, get_zone_permit_kortrijk, emergency_charge_kortrijk, direct_corridor_kortrijk_oostende], 3500.0, 0.02, 0.94356004544999994, 0.86526000000000003, mid, yes, "ttt")).
+gps_plan(d1, plan([fly_gent_kortrijk, emergency_charge_kortrijk, get_zone_permit_kortrijk, direct_corridor_kortrijk_oostende], 3500.0, 0.019999999999999997, 0.94356004544999994, 0.86526000000000003, mid, yes, "ttt")).

package/examples/output/iso-atomic-conversion.pl

@@ -1,6 +1,6 @@
 report(joined, eyeprolog).
 report(prefix, eye).
-report(characters, [e, y, e]).
+report(characters, "eye").
 report(codes, [65, 90]).
 report(decoded_character, 'λ').
 report(number, 42).

package/examples/output/list-collection.pl

@@ -2,6 +2,6 @@ collectionLength(numbers, 3).
 collectionMember(numbers, 1).
 collectionMember(numbers, 2).
 collectionMember(numbers, 3).
-collectionAppend(letters, [a, b, c]).
+collectionAppend(letters, "abc").
 head(letters, a).
-tail(letters, [b]).
+tail(letters, "b").

package/examples/proof/aliases-and-namespaces.pl

@@ -44,16 +44,16 @@ why(
   )
 ).
 
-tail(nativeList, [b, c]).
+tail(nativeList, "bc").
 why(
-  tail(nativeList, [b, c]),
+  tail(nativeList, "bc"),
   proof(
-    goal(tail(nativeList, [b, c])),
+    goal(tail(nativeList, "bc")),
     by(rule("aliases-and-namespaces.pl", clause(4))),
-    bindings([binding("Tail", [b, c]), binding("_head", a)]),
+    bindings([binding("Tail", "bc"), binding("_head", a)]),
     uses([
       proof(
-        goal(=([a, b, c], [a, b, c])),
+        goal(=("abc", "abc")),
         by(builtin(=, 2))
       )
     ])

package/examples/proof/graph-reachability.pl

@@ -11,48 +11,48 @@ why(
         bindings([binding("Start", a), binding("Goal", f)]),
         uses([
           proof(
-            goal(reachable(a, f, [a])),
+            goal(reachable(a, f, "a")),
             by(rule("graph-reachability.pl", clause(9))),
-            bindings([binding("Start", a), binding("Goal", f), binding("Visited", [a]), binding("Next", b)]),
+            bindings([binding("Start", a), binding("Goal", f), binding("Visited", "a"), binding("Next", b)]),
             uses([
               proof(
                 goal(edge(a, b)),
                 by(fact("graph-reachability.pl", clause(1)))
               ),
               proof(
-                goal('\\+'(member(b, [a]))),
+                goal('\\+'(member(b, "a"))),
                 by(builtin('\\+', 1))
               ),
               proof(
-                goal(reachable(b, f, [b, a])),
+                goal(reachable(b, f, "ba")),
                 by(rule("graph-reachability.pl", clause(9))),
-                bindings([binding("Start", b), binding("Goal", f), binding("Visited", [b, a]), binding("Next", d)]),
+                bindings([binding("Start", b), binding("Goal", f), binding("Visited", "ba"), binding("Next", d)]),
                 uses([
                   proof(
                     goal(edge(b, d)),
                     by(fact("graph-reachability.pl", clause(3)))
                   ),
                   proof(
-                    goal('\\+'(member(d, [b, a]))),
+                    goal('\\+'(member(d, "ba"))),
                     by(builtin('\\+', 1))
                   ),
                   proof(
-                    goal(reachable(d, f, [d, b, a])),
+                    goal(reachable(d, f, "dba")),
                     by(rule("graph-reachability.pl", clause(9))),
-                    bindings([binding("Start", d), binding("Goal", f), binding("Visited", [d, b, a]), binding("Next", f)]),
+                    bindings([binding("Start", d), binding("Goal", f), binding("Visited", "dba"), binding("Next", f)]),
                     uses([
                       proof(
                         goal(edge(d, f)),
                         by(fact("graph-reachability.pl", clause(5)))
                       ),
                       proof(
-                        goal('\\+'(member(f, [d, b, a]))),
+                        goal('\\+'(member(f, "dba"))),
                         by(builtin('\\+', 1))
                       ),
                       proof(
-                        goal(reachable(f, f, [f, d, b, a])),
+                        goal(reachable(f, f, "fdba")),
                         by(fact("graph-reachability.pl", clause(8))),
-                        bindings([binding("Node", f), binding("_visited", [f, d, b, a])])
+                        bindings([binding("Node", f), binding("_visited", "fdba")])
                       )
                     ])
                   )
@@ -79,48 +79,48 @@ why(
         bindings([binding("Start", c), binding("Goal", g)]),
         uses([
           proof(
-            goal(reachable(c, g, [c])),
+            goal(reachable(c, g, "c")),
             by(rule("graph-reachability.pl", clause(9))),
-            bindings([binding("Start", c), binding("Goal", g), binding("Visited", [c]), binding("Next", e)]),
+            bindings([binding("Start", c), binding("Goal", g), binding("Visited", "c"), binding("Next", e)]),
             uses([
               proof(
                 goal(edge(c, e)),
                 by(fact("graph-reachability.pl", clause(4)))
               ),
               proof(
-                goal('\\+'(member(e, [c]))),
+                goal('\\+'(member(e, "c"))),
                 by(builtin('\\+', 1))
               ),
               proof(
-                goal(reachable(e, g, [e, c])),
+                goal(reachable(e, g, "ec")),
                 by(rule("graph-reachability.pl", clause(9))),
-                bindings([binding("Start", e), binding("Goal", g), binding("Visited", [e, c]), binding("Next", f)]),
+                bindings([binding("Start", e), binding("Goal", g), binding("Visited", "ec"), binding("Next", f)]),
                 uses([
                   proof(
                     goal(edge(e, f)),
                     by(fact("graph-reachability.pl", clause(6)))
                   ),
                   proof(
-                    goal('\\+'(member(f, [e, c]))),
+                    goal('\\+'(member(f, "ec"))),
                     by(builtin('\\+', 1))
                   ),
                   proof(
-                    goal(reachable(f, g, [f, e, c])),
+                    goal(reachable(f, g, "fec")),
                     by(rule("graph-reachability.pl", clause(9))),
-                    bindings([binding("Start", f), binding("Goal", g), binding("Visited", [f, e, c]), binding("Next", g)]),
+                    bindings([binding("Start", f), binding("Goal", g), binding("Visited", "fec"), binding("Next", g)]),
                     uses([
                       proof(
                         goal(edge(f, g)),
                         by(fact("graph-reachability.pl", clause(7)))
                       ),
                       proof(
-                        goal('\\+'(member(g, [f, e, c]))),
+                        goal('\\+'(member(g, "fec"))),
                         by(builtin('\\+', 1))
                       ),
                       proof(
-                        goal(reachable(g, g, [g, f, e, c])),
+                        goal(reachable(g, g, "gfec")),
                         by(fact("graph-reachability.pl", clause(8))),
-                        bindings([binding("Node", g), binding("_visited", [g, f, e, c])])
+                        bindings([binding("Node", g), binding("_visited", "gfec")])
                       )
                     ])
                   )

package/examples/proof/list-collection.pl

@@ -78,20 +78,20 @@ why(
   )
 ).
 
-collectionAppend(letters, [a, b, c]).
+collectionAppend(letters, "abc").
 why(
-  collectionAppend(letters, [a, b, c]),
+  collectionAppend(letters, "abc"),
   proof(
-    goal(collectionAppend(letters, [a, b, c])),
+    goal(collectionAppend(letters, "abc")),
     by(rule("list-collection.pl", clause(5))),
-    bindings([binding("Extended", [a, b, c]), binding("List", [a, b])]),
+    bindings([binding("Extended", "abc"), binding("List", "ab")]),
     uses([
       proof(
-        goal(collection(letters, [a, b])),
+        goal(collection(letters, "ab")),
         by(fact("list-collection.pl", clause(2)))
       ),
       proof(
-        goal(append([a, b], [c], [a, b, c])),
+        goal(append("ab", "c", "abc")),
         by(library(append, 3))
       )
     ])
@@ -104,26 +104,26 @@ why(
   proof(
     goal(head(letters, a)),
     by(rule("list-collection.pl", clause(6))),
-    bindings([binding("Head", a), binding("_tail", [b])]),
+    bindings([binding("Head", a), binding("_tail", "b")]),
     uses([
       proof(
-        goal(collection(letters, [a, b])),
+        goal(collection(letters, "ab")),
         by(fact("list-collection.pl", clause(2)))
       )
     ])
   )
 ).
 
-tail(letters, [b]).
+tail(letters, "b").
 why(
-  tail(letters, [b]),
+  tail(letters, "b"),
   proof(
-    goal(tail(letters, [b])),
+    goal(tail(letters, "b")),
     by(rule("list-collection.pl", clause(7))),
-    bindings([binding("Tail", [b]), binding("_head", a)]),
+    bindings([binding("Tail", "b"), binding("_head", a)]),
     uses([
       proof(
-        goal(collection(letters, [a, b])),
+        goal(collection(letters, "ab")),
         by(fact("list-collection.pl", clause(2)))
       )
     ])

package/examples/proof/term-tools.pl

@@ -71,7 +71,7 @@ why(
     bindings([binding("Text", 'edge(a, [b, c])')]),
     uses([
       proof(
-        goal(term_string(edge(a, [b, c]), 'edge(a, [b, c])')),
+        goal(term_string(edge(a, "bc"), 'edge(a, [b, c])')),
         by(library(term_string, 2))
       )
     ])

package/index.d.ts

@@ -16,6 +16,8 @@ export interface EyePrologRunOptions {
   sourceMetadata?: boolean;
   strictNegation?: boolean;
   analyzeNegation?: boolean;
+  /** Initial ISO interpretation of double-quoted list notation. Defaults to chars. */
+  doubleQuotes?: 'chars' | 'codes' | 'atom';
   ioOptions?: {
     input?: string;
     write?: (text: string) => void;
@@ -88,6 +90,7 @@ export class Program {
   constructor(clauses?: EyePrologClause[], options?: EyePrologRunOptions);
   clauses: EyePrologClause[];
   groups: Map<string, EyePrologPredicateGroup>;
+  doubleQuotes: 'chars' | 'codes' | 'atom';
   negationDependencies: Array<{ from: string; to: string; negative: boolean }>;
   negationStratificationErrors: Array<{ from: string; to: string }>;
   stratifiedNegation: boolean;
@@ -101,7 +104,7 @@ export class Program {
   assertStratifiedNegation(): true;
   isStratifiedNegation(): boolean;
   groupHasRule(group: EyePrologPredicateGroup): boolean;
-  sourceFactLines(predicateKeys?: Set<string> | null): Set<string>;
+  sourceFactLines(predicateKeys?: Set<string> | null, options?: { doubleQuotes?: 'chars' | 'codes' | 'atom' }): Set<string>;
 }
 
 export interface BuiltinDefinition {
@@ -181,7 +184,7 @@ export function compareNumberText(left: string, right: string): number;
 export function makeProgram(source: string, options?: EyePrologRunOptions): Program;
 export function parseClauses(source: string, options?: EyePrologRunOptions): EyePrologClause[];
 export function parseProgramText(source: string, options?: EyePrologRunOptions): EyePrologClause[];
-export function parseGoalText(source: string): EyePrologTerm;
+export function parseGoalText(source: string, options?: EyePrologRunOptions): EyePrologTerm;
 export function createDefaultRegistry(): BuiltinRegistry;
 export function createEyePrologRegistry(): BuiltinRegistry;
 export function getDefaultRegistry(): BuiltinRegistry;

package/package.json

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

package/src/cli.js

@@ -128,22 +128,27 @@ async function loadExplanation() {
 }
 
 async function runDefault(engine, program, options) {
+  const registry = engine.getEyePrologRegistry();
+  const solver = new engine.Solver(program, {
+    registry,
+    ioOptions: { write: (text) => process.stdout.write(String(text)) },
+  });
+  program = solver.program;
   const goals = options.goals.map((text) => {
-    const goal = engine.parseGoalText(text);
+    const goal = engine.parseGoalText(text, {
+      doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+    });
     if (goal.type === 'var') throw new engine.PrologError('instantiation_error');
     if (goal.type !== 'atom' && goal.type !== 'compound') throw new engine.PrologError('type_error(callable)', goal);
     return goal;
   });
   const queriedKeys = new Set(goals.map((goal) => `${goal.name}/${goal.arity}`));
-  const facts = program.sourceFactLines(queriedKeys);
+  const writeOptions = {
+    doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+  };
+  const facts = program.sourceFactLines(queriedKeys, writeOptions);
   const lines = new Set();
-  const registry = engine.getEyePrologRegistry();
   const explanation = options.proof ? await loadExplanation() : null;
-  const solver = new engine.Solver(program, {
-    registry,
-    ioOptions: { write: (text) => process.stdout.write(String(text)) },
-  });
-  program = solver.program;
   try {
     solver.runInitializations();
     for (const goal of goals) {
@@ -151,7 +156,10 @@ async function runDefault(engine, program, options) {
       for (const env of solver.solve([goal], new engine.Env(), 0)) {
         if (!engine.termIsGround(goal, env)) continue;
 
-        const line = `${engine.termToString(goal, env, true)}.\n`;
+        const currentWriteOptions = {
+          doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+        };
+        const line = `${engine.termToString(goal, env, true, currentWriteOptions)}.\n`;
         if (facts.has(line) || lines.has(line)) continue;
 
         lines.add(line);

package/src/index.js

@@ -47,9 +47,12 @@ export function run(source, options = {}) {
     },
   });
   program = solver.program;
-  const goals = normalizeGoals(options);
+  const goals = normalizeGoals(options, solver);
+  const writeOptions = {
+    doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+  };
   const queriedKeys = new Set(goals.map((goal) => `${goal.name}/${goal.arity}`));
-  const facts = program.sourceFactLines(queriedKeys);
+  const facts = program.sourceFactLines(queriedKeys, writeOptions);
   const seen = new Set();
   let haltCode = null;
   try {
@@ -59,7 +62,10 @@ export function run(source, options = {}) {
       for (const env of solver.solve([goal], new Env(), 0)) {
         const resolved = copyResolved(goal, env);
         if (!termIsGround(resolved)) continue;
-        const line = `${termToString(resolved, new Env(), true)}.\n`;
+        const currentWriteOptions = {
+          doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+        };
+        const line = `${termToString(resolved, new Env(), true, currentWriteOptions)}.\n`;
         if (facts.has(line) || seen.has(line)) continue;
         seen.add(line);
         output.push(line);
@@ -73,10 +79,14 @@ export function run(source, options = {}) {
   return { stdout: output.join(''), stats: solver.stats, haltCode };
 }
 
-function normalizeGoals(options) {
+function normalizeGoals(options, solver) {
   const requested = options.goals ?? (options.goal == null ? [] : [options.goal]);
   return requested.map((requestedGoal) => {
-    const goal = typeof requestedGoal === 'string' ? parseGoalText(requestedGoal) : requestedGoal;
+    const goal = typeof requestedGoal === 'string'
+      ? parseGoalText(requestedGoal, {
+          doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+        })
+      : requestedGoal;
     if (goal.type === VAR) throw new PrologError('instantiation_error');
     if (goal.type !== ATOM && goal.type !== COMPOUND) throw new PrologError('type_error(callable)', goal);
     return goal;

package/src/iso.js

@@ -920,6 +920,7 @@ function readTermFromStream(stream, solver) {
       const clauses = parseClauses(convertedTermText(candidate.text, solver), {
         sourceMetadata: false,
         operatorState,
+        doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
       });
       if (clauses.length !== 1 || clauses[0].body.length) throw new Error('bad term');
       stream.position = candidate.end;

package/src/parser.js

@@ -1,6 +1,6 @@
 // Tokenizer and recursive-descent parser for the EyeProlog source language.
 // It preserves the compact Prolog-like syntax while producing Term objects for the solver.
-import { atom, compound, cons, emptyList, numberTerm, stringTerm, variable } from './term.js';
+import { atom, compound, cons, emptyList, numberTerm, variable } from './term.js';
 
 const TOK = {
   EOF: 'eof', ATOM: 'atom', VAR: 'var', STRING: 'string', NUMBER: 'number',
@@ -143,6 +143,12 @@ class Parser {
     this.line = 1;
     this.anonymous = 0;
     this.sourceMetadata = options.sourceMetadata !== false;
+    this.parserFlagState = options.parserFlagState ?? {
+      doubleQuotes: options.doubleQuotes ?? 'chars',
+    };
+    if (!['chars', 'codes', 'atom'].includes(this.parserFlagState.doubleQuotes)) {
+      throw new Error(`invalid double_quotes parser flag: ${this.parserFlagState.doubleQuotes}`);
+    }
     const operatorState = options.operatorState ?? createParserOperatorState(
       options.operatorDefinitions ?? [],
       options.includeDefaultOperators !== false,
@@ -174,6 +180,14 @@ class Parser {
     for (const name of names) this.defineOperator(priority, specifierTerm.name, name);
     return true;
   }
+  applyParserFlagDirective(directive) {
+    if (directive.type !== 'compound' || directive.name !== 'set_prolog_flag' || directive.arity !== 2) return;
+    const [flag, value] = directive.args;
+    if (flag.type === 'atom' && flag.name === 'double_quotes' &&
+        value.type === 'atom' && ['chars', 'codes', 'atom'].includes(value.name)) {
+      this.parserFlagState.doubleQuotes = value.name;
+    }
+  }
   peek(offset = 0) {
     return this.source[this.pos + offset] ?? '';
   }
@@ -494,7 +508,31 @@ class Parser {
     if (this.token.type === TOK.STRING) {
       const value = this.token.text;
       this.advance();
-      return stringTerm(value);
+      if (this.parserFlagState.doubleQuotes === 'atom') {
+        if (this.token.type === TOK.LPAREN) {
+          this.advance();
+          const args = [];
+          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(value)} for arity zero data`);
+          }
+          while (true) {
+            args.push(this.parseTerm(0, false));
+            if (this.token.type !== TOK.COMMA) break;
+            this.advance();
+          }
+          this.expect(TOK.RPAREN, ')');
+          this.advance();
+          return compound(value, args);
+        }
+        return atom(value);
+      }
+      const items = Array.from(value, (character) =>
+        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;
     }
     if (this.token.type === TOK.NUMBER) {
       const value = this.token.text;
@@ -544,6 +582,7 @@ class Parser {
           throw new Error(`parse line ${line}: bad term`);
         }
         this.expect(TOK.DOT, '.');
+        this.applyParserFlagDirective(directive);
         this.advance();
         const clause = { head: compound(':-', [directive]), body: [] };
         clauseNumber++;
@@ -588,11 +627,17 @@ function listAtomNames(term) {
 
 
 export function parseClauses(source, options = {}) {
+  const ownsParserFlagState = options.parserFlagState == null;
+  const initialDoubleQuotes = options.doubleQuotes ?? 'chars';
+  const parserOptions = ownsParserFlagState
+    ? { ...options, parserFlagState: { doubleQuotes: initialDoubleQuotes } }
+    : options;
   if (options.sourceMetadata === false) {
-    const clauses = parseClausesFastNoSource(source);
+    const clauses = parseClausesFastNoSource(source, null, null, parserOptions);
     if (clauses) return clauses;
+    if (ownsParserFlagState) parserOptions.parserFlagState.doubleQuotes = initialDoubleQuotes;
   }
-  return new Parser(source, options).parseProgram();
+  return new Parser(source, parserOptions).parseProgram();
 }
 
 // Streaming parser entry points used by ProgramBuilder.  The ordinary public
@@ -602,8 +647,8 @@ export function parseClausesInto(source, options = {}, emit) {
   new Parser(source, options).parseProgram(emit);
 }
 
-export function tryParseClausesFastInto(source, emit, emitBinary = null) {
-  return parseClausesFastNoSource(source, emit, emitBinary) !== null;
+export function tryParseClausesFastInto(source, emit, emitBinary = null, options = {}) {
+  return parseClausesFastNoSource(source, emit, emitBinary, options) !== null;
 }
 
 function isSimpleName(text) {
@@ -624,7 +669,7 @@ const SIMPLE_VARIABLE = /^(?:_|[A-Z_][A-Za-z0-9_]*)$/;
 const SIMPLE_ATOM = /^[a-z][A-Za-z0-9_]*$/;
 const GRAPHIC_ATOM = /^[#$&*+\-\/<=>@^~\\]+$/;
 
-function parseClausesFastNoSource(source, emit = null, emitBinary = null) {
+function parseClausesFastNoSource(source, emit = null, emitBinary = null, options = {}) {
   source = String(source ?? '');
   const numberCache = new Map();
   const stringCache = new Map();
@@ -896,7 +941,7 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null) {
       return true;
     }
     try {
-      const parsed = new Parser(text, { sourceMetadata: false }).parseProgram();
+      const parsed = new Parser(text, { ...options, sourceMetadata: false }).parseProgram();
       for (const clause of parsed) accept(clause);
       return true;
     } catch (_) {
@@ -938,12 +983,12 @@ function parseClausesFastNoSource(source, emit = null, emitBinary = null) {
   return clauses ?? true;
 }
 
-export function parseProgramText(source) {
-  return parseClauses(source);
+export function parseProgramText(source, options = {}) {
+  return parseClauses(source, options);
 }
 
-export function parseGoalText(text) {
-  const clauses = parseClauses(`zz_goal((${text})).`);
+export function parseGoalText(text, options = {}) {
+  const clauses = parseClauses(`zz_goal((${text})).`, options);
   const head = clauses[0]?.head;
   if (clauses.length !== 1 || head?.type !== 'compound' ||
       head.name !== 'zz_goal' || head.arity !== 1 || clauses[0].body.length !== 0) {