eyeprolog 1.3.67 → 1.3.69

package/README.md

@@ -159,13 +159,17 @@ variable representatives and ordinary Prolog backtracking, and the REPL projects
 module `attribute_goals//1` hooks as residual goals. See
 [`examples/attributed-variables.pl`](examples/attributed-variables.pl).
 
-This is the first migration stage toward reusing Markus Triska's MIT-licensed
+The next two migration stages toward reusing Markus Triska's MIT-licensed
 [Scryer `library(clpz)`](https://github.com/mthom/scryer-prolog/blob/master/src/lib/clpz.pl)
-instead of maintaining a separate constraint solver in `src/clpz.js`. The
-current CLP(Z) implementation remains active while compatibility gaps such as
-Scryer's compile-time term/goal expansion and supporting libraries are closed.
-The staged plan and exact compatibility boundary are documented in
-[`src/CLPZ-MIGRATION.md`](src/CLPZ-MIGRATION.md).
+are now in place as well. Normal-profile loading supports user-defined
+`term_expansion/2` and `goal_expansion/2`, clause-list generation, and
+`expand_term/2` for processor DCG lowering. EyeProlog also ships the support
+modules used by Scryer's CLP(Z) source (`assoc`, `pairs`, `between`, `dcgs`,
+`terms`, `error`, `si`, `freeze`, `arithmetic`, `debug`, and `format`) together
+with generic backtrackable blackboard primitives. The current CLP(Z) engine
+remains active while the upstream solver itself is integrated and checked for
+behavioral and performance parity. The staged plan and exact compatibility
+boundary are documented in [`src/CLPZ-MIGRATION.md`](src/CLPZ-MIGRATION.md).
 
 Recursion through negation is explicit. EyeProlog provides `tnot/1` for
 well-founded negation over finite, range-restricted, function-free Datalog

package/package.json

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

package/src/ARCHITECTURE.md

@@ -7,8 +7,8 @@ higher-level frontends.
 
 1. **Kernel representation and syntax** — `term.js`, `number-value.js`,
    `syntax-scan.js`, `parser.js`, `write.js`, `errors.js`.
-2. **Program preparation** — `program.js` plus `program-analysis.js` and
-   `program-indexing.js`. Static recursion/Datalog/WFS classification lives in
+2. **Program preparation** — `program.js`, `source-expansion.js`, plus
+   `program-analysis.js` and `program-indexing.js`. Static recursion/Datalog/WFS classification lives in
    `program-analysis.js`; compact clauses and candidate indexes live in
    `program-indexing.js`.
 3. **Execution** — `solver.js`, `cleanup.js`, `io.js`, `datalog.js`, `wfs.js`,
@@ -48,6 +48,23 @@ needed by Scryer's `library(atts)` and `library(clpz)`. The current CLP(Z)-speci
 `Env._clpz` store remains transitional until the Scryer Prolog implementation can
 replace it without losing test or performance parity; see `src/CLPZ-MIGRATION.md`.
 
+`Env` also owns the small generic backtrackable blackboard used by Scryer-style
+libraries. Blackboard maps are shared by clones and copied only on write, so
+`bb_b_put/2` follows ordinary Prolog backtracking without any CLP(Z)-specific
+state in the VM. `scryer-compat.js` exposes the private host bridge used by
+`library(debug)`; the rest of the Stage 3 compatibility surface lives as Prolog
+modules under `src/lib/`.
+
+`source-expansion.js` is the explicit compile-time execution boundary. When an
+already-loaded `term_expansion/2` or `goal_expansion/2` hook exists, program
+preparation invokes it with a fresh bounded `Solver` against the partially built
+program. `solver.js` therefore imports clause-selection primitives directly from
+`program-indexing.js` rather than importing the `program.js` facade. This is the
+one deliberate preparation-to-execution service edge and keeps the JavaScript
+import graph acyclic while avoiding a second meta-interpreter solely for source
+expansion. `expansion-builtins.js` provides the lower-level `expand_term/2` DCG
+service without depending on `Solver`.
+
 The JavaScript runtime stays flat directly under `src/`; the existing `src/lib/`
 contains Prolog library sources rather than JavaScript runtime modules. The architecture
 test rejects JavaScript import cycles under `src/`. Cleanup lifecycle hooks are

package/src/CLPZ-MIGRATION.md

@@ -32,20 +32,58 @@ attributes, post-binding goals, backtracking, `term_attributed_variables/2`, and
 REPL projection through the conventional module `attribute_goals//1` hook.
 `examples/attributed-variables.pl` is the runnable source-level example.
 
-## What still prevents a drop-in Scryer `clpz.pl`
+## Stage 2: source expansion substrate
 
-The upstream solver is not only an attributed-variable client. It also relies on
-compile-time facilities that EyeProlog does not yet provide generically:
+This stage is implemented. Normal-profile source loading now invokes already
+loaded module-local and `user` `term_expansion/2` and `goal_expansion/2` hooks
+left-to-right. A term expansion may yield one clause or a list of clauses, and
+`expand_term/2` exposes the processor's DCG lowering so a hook can generate the
+ordinary clauses used by Scryer's CLP(Z) parser generators. Goal expansion is
+recursive across control constructs and preserves sharing with variables in the
+surrounding clause.
 
-- user-defined `term_expansion/2` and `goal_expansion/2` during module loading;
-- the generated predicates at the end of Scryer's `clpz.pl` and its custom Duo
-  DCG `++>` expansion;
-- the supporting Scryer library surface (`assoc`, `pairs`, `between`, `dcgs`,
-  `terms`, `error`, `si`, `freeze`, `arithmetic`, `debug`, and `format`) at the
-  interfaces expected by that source;
+Module-qualified hook clauses such as `user:goal_expansion/2` are also compiled
+with the correct split between procedure ownership and lexical body context. A
+hook defined from a library module therefore lives in `user` while its
+unqualified helper calls still resolve in the defining library. The compiler
+executes hooks with a fresh bounded solver against the partially built program;
+`solver.js` imports clause-selection helpers directly from `program-indexing.js`,
+so this compile-time service remains acyclic. Strict ISO Part 1 mode does not run
+these extension hooks.
 
-These are compatibility gaps, not reasons to add more CLP(Z)-specific code to
-`term.js` or `solver.js`.
+The regression corpus covers clause-list generation, variable-sharing goal
+expansion, qualified hook lexical context, and the Scryer pattern where a
+`term_expansion/2` hook calls `expand_term/2` to generate a DCG predicate.
+
+## Stage 3: Scryer support-library surface
+
+This stage is implemented. EyeProlog now registers the library names imported by
+Scryer's current `clpz.pl`: `assoc`, `pairs`, `between`, `dcgs`, `terms`,
+`error`, `si`, `freeze`, `arithmetic`, `debug`, and `format`. The implementations
+are deliberately small compatibility layers where CLP(Z) needs only a subset of
+the upstream module, while observable predicate contracts stay at the Prolog
+library boundary. In particular, `library(freeze)` is implemented with the same
+attributed-variable `verify_attributes/3` protocol introduced in Stage 1.
+
+Two remaining Scryer runtime facilities are generic rather than constraint
+specific. `Env` now carries a copy-on-write backtrackable blackboard, exposed to
+Prolog through `bb_get/2` and `bb_b_put/2` compatibility wrappers, and
+`library(terms)` provides `copy_term_nat/2` using EyeProlog's attribute-free
+logical copy semantics. Regression coverage exercises the support modules,
+blackboard rollback, attribute-free copying, and the exact import/attribute
+prelude used by upstream CLP(Z).
+
+## What still prevents replacing `src/clpz.js`
+
+The VM/compiler and named support-library blockers are now closed. The remaining
+work is direct upstream-source integration: vendor a pinned Scryer `clpz.pl`,
+apply only the small compatibility patches exposed by loading the complete file,
+and run it side-by-side against EyeProlog's existing CLP(Z) corpus plus selected
+Scryer regressions. Only after behavioral and performance parity should the
+`eyeprolog__clpz_*` adapters and `Env._clpz` store be removed.
+
+This boundary is intentional: Stage 3 does not claim that the complete upstream
+solver is active merely because its dependency prelude loads.
 
 ## Migration rule
 

package/src/expansion-builtins.js

@@ -0,0 +1,99 @@
+// Generic source-expansion helpers exposed to Prolog code.
+//
+// expand_term/2 provides the system part of source expansion that libraries
+// such as Scryer's CLP(Z) use while generating predicates. User-defined
+// term_expansion/2 and goal_expansion/2 are invoked by program preparation in
+// source-expansion.js; keeping this builtin independent of Solver avoids an
+// import cycle through the standard-library registry.
+
+import {
+  ATOM, COMPOUND, Env, atom, compound, deref, flattenConjunction, unify,
+} from './term.js';
+import { expandDcgRuleClause } from './dcg.js';
+import { PrologError } from './errors.js';
+
+function conjunctionFromGoals(goals) {
+  if (goals.length === 0) return atom('true');
+  let body = goals[goals.length - 1];
+  for (let index = goals.length - 2; index >= 0; index--) {
+    body = compound(',', [goals[index], body]);
+  }
+  return body;
+}
+
+export function clauseToSourceTerm(clause) {
+  if (clause == null || clause.kind === 'quad') return null;
+  if (!Array.isArray(clause.body) || clause.body.length === 0) return clause.head;
+  return compound(':-', [clause.head, conjunctionFromGoals(clause.body)]);
+}
+
+export function sourceTermToClauses(term, env = new Env()) {
+  term = deref(term, env);
+  const list = sourceTermList(term, env);
+  if (list != null) {
+    const clauses = [];
+    for (const item of list) clauses.push(...sourceTermToClauses(item, env));
+    return clauses;
+  }
+  if (term.type === COMPOUND && term.name === ':-' && term.arity === 2) {
+    const head = deref(term.args[0], env);
+    const body = deref(term.args[1], env);
+    return [{ head, body: body.type === ATOM && body.name === 'true' ? [] : flattenConjunction(body) }];
+  }
+  if (term.type === COMPOUND && term.name === ':-' && term.arity === 1) {
+    return [{ head: term, body: [] }];
+  }
+  if (term.type === COMPOUND && term.name === '?-' && term.arity >= 1) {
+    return [{ head: term, body: [] }];
+  }
+  if (term.type !== ATOM && term.type !== COMPOUND) {
+    throw new PrologError('type_error(callable)', term);
+  }
+  return [{ head: term, body: [] }];
+}
+
+function sourceTermList(term, env) {
+  const items = [];
+  const seen = new Set();
+  let cursor = deref(term, env);
+  while (cursor.type === COMPOUND && cursor.name === '.' && cursor.arity === 2) {
+    if (seen.has(cursor)) throw new PrologError('type_error(list)', term);
+    seen.add(cursor);
+    items.push(deref(cursor.args[0], env));
+    cursor = deref(cursor.args[1], env);
+  }
+  if (cursor.type === ATOM && cursor.name === '[]') return items;
+  return null;
+}
+
+export function systemExpandTerm(term, module = 'user') {
+  const resolved = deref(term, new Env());
+  if (resolved.type === COMPOUND && resolved.name === '-->' && resolved.arity === 2) {
+    const expanded = expandDcgRuleClause({ head: resolved, body: [] }, module);
+    if (expanded == null) return resolved;
+    return clauseToSourceTerm(expanded);
+  }
+  return resolved;
+}
+
+function* expandTermBuiltin({ goal, env }) {
+  const input = deref(goal.args[0], env);
+  if (input.type === 'var') throw new PrologError('instantiation_error');
+  const expanded = systemExpandTerm(input, goal.module ?? 'user');
+  const next = env.clone();
+  if (unify(goal.args[1], expanded, next)) yield next;
+}
+
+function* expandGoalBuiltin({ goal, env }) {
+  const input = deref(goal.args[0], env);
+  if (input.type === 'var') throw new PrologError('instantiation_error');
+  const next = env.clone();
+  if (unify(goal.args[1], input, next)) yield next;
+}
+
+export const expansionBuiltins = {
+  register(registry) {
+    registry.add('expand_term', 2, expandTermBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('expand_goal', 2, expandGoalBuiltin, { deterministic: true, eyePrologLibrary: true });
+  },
+};

package/src/lib/arithmetic.pl

@@ -0,0 +1,36 @@
+/** Integer arithmetic helpers used by Scryer's CLP(Z) source. */
+
+:- module(arithmetic, [lsb/2, msb/2, popcount/2]).
+
+:- use_module(library(error), [must_be/2, domain_error/3]).
+
+lsb(X, N) :-
+    must_be(integer, X),
+    ( X < 1 -> domain_error(not_less_than_one, X, lsb/2)
+    ; Low is X /\ (-X), arithmetic__msb(Low, -1, N)
+    ).
+
+msb(X, N) :-
+    must_be(integer, X),
+    ( X < 1 -> domain_error(not_less_than_one, X, msb/2)
+    ; Shifted is X >> 1, arithmetic__msb(Shifted, 0, N)
+    ).
+
+arithmetic__msb(0, N, N) :- !.
+arithmetic__msb(X, N0, N) :-
+    X1 is X >> 1,
+    N1 is N0 + 1,
+    arithmetic__msb(X1, N1, N).
+
+popcount(X, Count) :-
+    must_be(integer, X),
+    ( X < 0 -> domain_error(not_less_than_zero, X, popcount/2)
+    ; arithmetic__popcount(X, 0, Count)
+    ).
+
+arithmetic__popcount(0, Count, Count) :- !.
+arithmetic__popcount(X, Count0, Count) :-
+    Bit is X /\ 1,
+    Count1 is Count0 + Bit,
+    X1 is X >> 1,
+    arithmetic__popcount(X1, Count1, Count).

package/src/lib/assoc.pl

@@ -0,0 +1,42 @@
+/** Minimal Scryer-compatible association maps.
+
+    The public operations used by library(clpz) are represented as a sorted
+    list wrapped in assoc/1.  The representation is intentionally private: the
+    predicates preserve the observable assoc contracts while keeping the
+    compatibility layer small and declarative.
+*/
+
+:- module(assoc, [
+    empty_assoc/1,
+    assoc_to_list/2,
+    get_assoc/3,
+    put_assoc/4
+]).
+
+empty_assoc(assoc([])).
+
+assoc_to_list(assoc(Pairs), Pairs).
+
+get_assoc(Key, assoc(Pairs), Value) :-
+    assoc__get(Pairs, Key, Value).
+
+assoc__get([K-V|Pairs], Key, Value) :-
+    compare(Order, Key, K),
+    assoc__get(Order, Key, Value, V, Pairs).
+
+assoc__get(=, _, Value, Value, _).
+assoc__get(>, Key, Value, _, Pairs) :-
+    assoc__get(Pairs, Key, Value).
+
+put_assoc(Key, assoc(Pairs0), Value, assoc(Pairs)) :-
+    assoc__put(Pairs0, Key, Value, Pairs).
+
+assoc__put([], Key, Value, [Key-Value]).
+assoc__put([K-V|Pairs0], Key, Value, Pairs) :-
+    compare(Order, Key, K),
+    assoc__put(Order, Key, Value, K, V, Pairs0, Pairs).
+
+assoc__put(=, Key, Value, _, _, Pairs, [Key-Value|Pairs]).
+assoc__put(<, Key, Value, K, V, Pairs, [Key-Value,K-V|Pairs]).
+assoc__put(>, Key, Value, K, V, Pairs0, [K-V|Pairs]) :-
+    assoc__put(Pairs0, Key, Value, Pairs).

package/src/lib/between.pl

@@ -0,0 +1,54 @@
+/** Scryer-compatible integer generators needed by CLP(Z). */
+
+:- module(between, [between/3, gen_int/1, gen_nat/1, numlist/2, numlist/3, repeat/1]).
+
+:- use_module(library(error), [must_be/2, can_be/2]).
+
+between(Lower, Upper, X) :-
+    must_be(integer, Lower),
+    must_be(integer, Upper),
+    can_be(integer, X),
+    ( nonvar(X) -> Lower =< X, X =< Upper
+    ; Lower =< Upper, between__from(Lower, Upper, X)
+    ).
+
+between__from(Lower, Upper, Lower).
+between__from(Lower, Upper, X) :-
+    Lower < Upper,
+    Next is Lower + 1,
+    between__from(Next, Upper, X).
+
+gen_nat(N) :-
+    can_be(integer, N),
+    ( var(N) -> between__nats(0, N) ; N >= 0 ).
+
+between__nats(N, N).
+between__nats(N0, N) :- N1 is N0 + 1, between__nats(N1, N).
+
+gen_int(N) :-
+    can_be(integer, N),
+    ( var(N) -> between__ints(0, N) ; true ).
+
+between__ints(0, 0).
+between__ints(I, I) :- I > 0.
+between__ints(I, N) :- I > 0, N is -I.
+between__ints(I0, N) :- I1 is I0 + 1, between__ints(I1, N).
+
+repeat(N) :-
+    must_be(integer, N), N > 0,
+    between__repeat(N).
+between__repeat(_).
+between__repeat(N0) :- N0 > 1, N is N0 - 1, between__repeat(N).
+
+numlist(Upper, List) :- numlist(1, Upper, List).
+
+numlist(Lower, Upper, List) :-
+    must_be(integer, Lower),
+    must_be(integer, Upper),
+    between__numlist(Lower, Upper, List).
+
+between__numlist(Lower, Upper, []) :- Lower > Upper, !.
+between__numlist(Lower, Upper, [Lower|Rest]) :-
+    Lower =< Upper,
+    Next is Lower + 1,
+    between__numlist(Next, Upper, Rest).

package/src/lib/dcgs.pl

@@ -0,0 +1,23 @@
+/** Scryer-compatible DCG helpers.
+
+    EyeProlog already provides phrase/2-3 and ISO-style grammar expansion in the
+    runtime.  This module supplies the sequence combinators used by Scryer's
+    declarative libraries and exports the built-in phrase predicates under the
+    expected module name.
+*/
+
+:- module(dcgs, [
+    phrase/2,
+    phrase/3,
+    seq//1,
+    seqq//1
+]).
+
+seq([]) --> [].
+seq([Element|Elements]) --> [Element], seq(Elements).
+
+seqq([]) --> [].
+seqq([Elements|Sequences]) --> seq(Elements), seqq(Sequences).
+
+'...' --> [].
+'...' --> [_], '...'.

package/src/lib/debug.pl

@@ -0,0 +1,17 @@
+/** Compatibility hooks for Scryer libraries.
+
+    CLP(Z) only needs the backtrackable blackboard operations; the debugging
+    predicates are deliberately harmless no-ops unless EyeProlog grows a debug
+    topic UI later.
+*/
+
+:- module(debug, [debug/1, debug/3, nodebug/1, bb_get/2, bb_b_put/2]).
+
+:- meta_predicate(debug(+, +, +)).
+
+debug(_).
+debug(_, _, _).
+nodebug(_).
+
+bb_get(Key, Value) :- eyeprolog__bb_get(Key, Value).
+bb_b_put(Key, Value) :- eyeprolog__bb_b_put(Key, Value).

package/src/lib/error.pl

@@ -0,0 +1,123 @@
+/** Small Scryer-compatible error/type layer used by reusable libraries. */
+
+:- module(error, [
+    must_be/2,
+    can_be/2,
+    instantiation_error/0,
+    instantiation_error/1,
+    domain_error/2,
+    domain_error/3,
+    type_error/2,
+    type_error/3,
+    representation_error/1,
+    resource_error/1,
+    call_with_error_context/2
+]).
+
+:- meta_predicate(call_with_error_context(0, +)).
+
+must_be(Type, Term) :-
+    ( var(Type) -> instantiation_error(must_be/2)
+    ; error__must_be(Type, Term)
+    ).
+
+error__must_be(integer, Term) :- !,
+    ( var(Term) -> instantiation_error(must_be/2)
+    ; integer(Term) -> true
+    ; type_error(integer, Term, must_be/2)
+    ).
+error__must_be(atom, Term) :- !,
+    ( var(Term) -> instantiation_error(must_be/2)
+    ; atom(Term) -> true
+    ; type_error(atom, Term, must_be/2)
+    ).
+error__must_be(number, Term) :- !,
+    ( var(Term) -> instantiation_error(must_be/2)
+    ; number(Term) -> true
+    ; type_error(number, Term, must_be/2)
+    ).
+error__must_be(var, Term) :- !,
+    ( var(Term) -> true
+    ; throw(error(uninstantiation_error(Term), must_be/2))
+    ).
+error__must_be(ground, Term) :- !,
+    ( ground(Term) -> true ; instantiation_error(must_be/2) ).
+error__must_be(acyclic, Term) :- !,
+    ( acyclic_term(Term) -> true ; type_error(acyclic_term, Term, must_be/2) ).
+error__must_be(list, Term) :- !,
+    error__proper_list(Term).
+error__must_be(list(Type), Term) :- !,
+    error__proper_list_of(Term, Type).
+error__must_be(pair, Term) :- !,
+    ( var(Term) -> instantiation_error(must_be/2)
+    ; Term = _-_ -> true
+    ; type_error(pair, Term, must_be/2)
+    ).
+error__must_be(not_less_than_zero, Term) :- !,
+    must_be(integer, Term),
+    ( Term >= 0 -> true ; domain_error(not_less_than_zero, Term, must_be/2) ).
+error__must_be(Type, Term) :-
+    ( var(Term) -> instantiation_error(must_be/2)
+    ; type_error(Type, Term, must_be/2)
+    ).
+
+error__proper_list([]).
+error__proper_list([_|Tail]) :- !, error__proper_list(Tail).
+error__proper_list(Term) :-
+    ( var(Term) -> instantiation_error(must_be/2)
+    ; type_error(list, Term, must_be/2)
+    ).
+
+error__proper_list_of([], _).
+error__proper_list_of([Head|Tail], Type) :- !,
+    must_be(Type, Head),
+    error__proper_list_of(Tail, Type).
+error__proper_list_of(Term, _) :-
+    ( var(Term) -> instantiation_error(must_be/2)
+    ; type_error(list, Term, must_be/2)
+    ).
+
+can_be(Type, Term) :-
+    ( var(Type) -> instantiation_error(can_be/2)
+    ; var(Term) -> true
+    ; error__can_be(Type, Term)
+    ).
+
+error__can_be(integer, Term) :- !,
+    ( integer(Term) -> true ; type_error(integer, Term, can_be/2) ).
+error__can_be(atom, Term) :- !,
+    ( atom(Term) -> true ; type_error(atom, Term, can_be/2) ).
+error__can_be(number, Term) :- !,
+    ( number(Term) -> true ; type_error(number, Term, can_be/2) ).
+error__can_be(list, Term) :- !, error__partial_list(Term).
+error__can_be(list(Type), Term) :- !, error__partial_list_of(Term, Type).
+error__can_be(not_less_than_zero, Term) :- !,
+    ( integer(Term) ->
+        ( Term >= 0 -> true ; domain_error(not_less_than_zero, Term, can_be/2) )
+    ; type_error(integer, Term, can_be/2)
+    ).
+error__can_be(Type, Term) :- error__must_be(Type, Term).
+
+error__partial_list(Term) :- var(Term), !.
+error__partial_list([]) :- !.
+error__partial_list([_|Tail]) :- !, error__partial_list(Tail).
+error__partial_list(Term) :- type_error(list, Term, can_be/2).
+
+error__partial_list_of(Term, _) :- var(Term), !.
+error__partial_list_of([], _) :- !.
+error__partial_list_of([Head|Tail], Type) :- !,
+    can_be(Type, Head),
+    error__partial_list_of(Tail, Type).
+error__partial_list_of(Term, _) :- type_error(list, Term, can_be/2).
+
+instantiation_error :- throw(error(instantiation_error, [])).
+instantiation_error(Context) :- throw(error(instantiation_error, Context)).
+domain_error(Type, Term) :- throw(error(domain_error(Type, Term), [])).
+domain_error(Type, Term, Context) :- throw(error(domain_error(Type, Term), Context)).
+type_error(Type, Term) :- throw(error(type_error(Type, Term), [])).
+type_error(Type, Term, Context) :- throw(error(type_error(Type, Term), Context)).
+representation_error(Flag) :- throw(error(representation_error(Flag), [])).
+resource_error(Resource) :- throw(error(resource_error(Resource), [])).
+
+call_with_error_context(Goal, Pair) :-
+    catch(Goal, error(Error, Context), throw(error(Error, [Pair|Context]))).

package/src/lib/format.pl

@@ -0,0 +1,35 @@
+/** Small format/2 compatibility layer covering the controls used by CLP(Z). */
+
+:- module(format, [format/2]).
+
+format(Template, Arguments) :-
+    format__chars(Template, Chars),
+    format__emit(Chars, Arguments).
+
+format__chars(Template, Chars) :-
+    atom(Template), !,
+    atom_chars(Template, Chars).
+format__chars(Chars, Chars).
+
+format__emit([], []).
+format__emit(['~','~'|Chars], Args) :- !,
+    put_char('~'),
+    format__emit(Chars, Args).
+format__emit(['~',n|Chars], Args) :- !,
+    nl,
+    format__emit(Chars, Args).
+format__emit(['~',w|Chars], [Arg|Args]) :- !,
+    write(Arg),
+    format__emit(Chars, Args).
+format__emit(['~',q|Chars], [Arg|Args]) :- !,
+    writeq(Arg),
+    format__emit(Chars, Args).
+format__emit(['~',a|Chars], [Arg|Args]) :- !,
+    write(Arg),
+    format__emit(Chars, Args).
+format__emit(['~',d|Chars], [Arg|Args]) :- !,
+    write(Arg),
+    format__emit(Chars, Args).
+format__emit([Char|Chars], Args) :-
+    put_char(Char),
+    format__emit(Chars, Args).

package/src/lib/freeze.pl

@@ -0,0 +1,28 @@
+/** Attributed-variable implementation of Scryer-compatible freeze/2. */
+
+:- module(freeze, [freeze/2]).
+
+:- use_module(library(atts)).
+:- meta_predicate(freeze(-, 0)).
+:- attribute frozen/1.
+
+verify_attributes(Var, Other, Goals) :-
+    get_atts(Var, frozen(FrozenA)), !,
+    ( var(Other) ->
+        ( get_atts(Other, frozen(FrozenB)) ->
+            put_atts(Other, frozen((FrozenB,FrozenA)))
+        ; put_atts(Other, frozen(FrozenA))
+        ),
+        Goals = []
+    ; Goals = [FrozenA]
+    ).
+verify_attributes(_, _, []).
+
+freeze(X, Goal) :-
+    put_atts(Fresh, frozen(Goal)),
+    Fresh = X.
+
+attribute_goals(Var) -->
+    { get_atts(Var, frozen(Goals)),
+      put_atts(Var, -frozen(_)) },
+    [freeze:freeze(Var, Goals)].

package/src/lib/pairs.pl

@@ -0,0 +1,36 @@
+/** Scryer-compatible pair helpers used by CLP(Z). */
+
+:- module(pairs, [
+    pairs_keys_values/3,
+    pairs_keys/2,
+    pairs_values/2,
+    group_pairs_by_key/2,
+    map_list_to_pairs/3
+]).
+
+:- meta_predicate(map_list_to_pairs(2, ?, ?)).
+
+pairs_keys_values([], [], []).
+pairs_keys_values([A-B|ABs], [A|As], [B|Bs]) :-
+    pairs_keys_values(ABs, As, Bs).
+
+pairs_keys(Pairs, Keys) :- pairs_keys_values(Pairs, Keys, _).
+pairs_values(Pairs, Values) :- pairs_keys_values(Pairs, _, Values).
+
+map_list_to_pairs(Pred, List, Pairs) :-
+    pairs__map_list_to_pairs(List, Pred, Pairs).
+
+pairs__map_list_to_pairs([], _, []).
+pairs__map_list_to_pairs([Head|Tail0], Pred, [Key-Head|Tail]) :-
+    call(Pred, Head, Key),
+    pairs__map_list_to_pairs(Tail0, Pred, Tail).
+
+group_pairs_by_key([], []).
+group_pairs_by_key([K-V|Pairs0], [K-[V|Values]|Pairs]) :-
+    pairs__same_key(K, Pairs0, Values, Pairs1),
+    group_pairs_by_key(Pairs1, Pairs).
+
+pairs__same_key(K0, [K1-V|Pairs0], [V|Values], Pairs) :-
+    K0 == K1, !,
+    pairs__same_key(K0, Pairs0, Values, Pairs).
+pairs__same_key(_, Pairs, [], Pairs).