eyeprolog 1.3.65 → 1.3.67

package/README.md

@@ -130,6 +130,43 @@ local/global variable stack. `phrase/2` likewise supplies its fixed `[]`
 remainder directly to the grammar; `phrase/3` retains its delayed final output
 unification for steadfastness.
 
+### Delayed disequality with `dif/2`
+
+The normal EyeProlog runtime provides `dif/2` as a conforming extension;
+`--iso-strict` remains limited to ISO/IEC 13211-1 and does not expose it.
+Unlike `\=/2`, which only tests whether two terms are non-unifiable *now*,
+`dif/2` can succeed with a residual disequality constraint and reject a later
+binding that would make the terms identical. For example,
+`dif(X, Y), X = Y` fails, while `dif(X-Y, 1-2), X = Y, Y = 1` succeeds once
+the structural constraint becomes provably satisfied.
+
+The implementation uses backtracking-safe annotated variables in `Env`. A
+pending constraint is indexed by every currently unbound variable it mentions;
+variable aliasing and later bindings reindex the annotation, entailed constraints
+are removed, and violated constraints make unification fail. The interactive
+top level includes pending `dif/2` goals in residual answers. See
+[`examples/dif-constraints.pl`](examples/dif-constraints.pl).
+
+### Attributed variables and the CLP(Z) migration
+
+`library(atts)` now exposes Scryer-style attributed-variable operations on the
+same persistent `Env` machinery introduced for `dif/2`: `put_atts/2`,
+`get_atts/2`, `put_attr/3`, `get_attr/3`, `del_attr/2`, and
+`term_attributed_variables/2`. `:- attribute ...` declarations are accepted,
+`verify_attributes/3` is invoked before an attributed binding is committed, and
+the hook's returned goals run after that binding. Attribute state follows
+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
+[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).
+
 Recursion through negation is explicit. EyeProlog provides `tnot/1` for
 well-founded negation over finite, range-restricted, function-free Datalog
 components. Ordinary `\+/1` remains negation-as-failure and is not silently
@@ -258,13 +295,14 @@ be continued without rebuilding a full clause-resolution frame for every
 suffix.  Open and remainder-producing uses still retain the ordinary DCG
 solutions and backtracking behavior.
 
-EyeProlog also adds 128 public library predicate indicators to its 129-entry ISO
-profile. **88 are implemented entirely as ordinary Prolog clauses** in focused
-modules under `src/lib/`; the remaining control predicates and finite-domain
-`library(clpz)` kernel use backtrackable host support.
+EyeProlog also adds 135 public library predicate indicators to its 129-entry ISO
+profile. **89 are implemented entirely as ordinary Prolog clauses** in focused
+modules under `src/lib/`; the remaining control predicates, attributed-variable
+primitives, and the transitional finite-domain `library(clpz)` kernel use
+backtrackable host support.
 They are ordinary Prolog modules using EyeProlog's documented module compatibility surface, loaded explicitly by purpose, such as
-`library(lists)`, `library(lambda)`, `library(strings)`, `library(aggregate)`, or
-`library(clpz)`.
+`library(lists)`, `library(lambda)`, `library(strings)`, `library(aggregate)`,
+`library(atts)`, or `library(clpz)`.
 Portable text
 predicates use ISO atoms or character lists. The old catch-all
 `library(eyeprolog)` module is no longer needed.

package/examples/attributed-variables.pl

@@ -0,0 +1,40 @@
+% Scryer-style attributed variables on EyeProlog's annotated-variable runtime.
+%
+% The attribute declaration is intentionally the same shape used by
+% library(atts) clients such as Scryer's CLP(Z). verify_attributes/3 runs before
+% an attributed variable is bound; goals it returns run after the binding.
+
+:- use_module(library(atts)).
+:- attribute required/1.
+
+%% goal: accepts_required_value(ok)
+%% goal: alias_preserves_attribute(ok)
+
+attach_required(Variable, Value) :-
+    put_atts(Variable, required(Value)).
+
+verify_attributes(Variable, Other, Goals) :-
+    ( get_atts(Variable, required(Value)) ->
+        ( var(Other) ->
+            put_atts(Other, required(Value)),
+            Goals = []
+        ; Goals = [required_value(Other, Value)] )
+    ; Goals = [] ).
+
+required_value(Value, Value).
+
+accepts_required_value(ok) :-
+    attach_required(X, 7),
+    X = 7.
+
+alias_preserves_attribute(ok) :-
+    attach_required(X, ready),
+    X = Y,
+    get_atts(Y, required(ready)),
+    Y = ready.
+
+% The REPL uses the conventional attribute_goals//1 hook to project remaining
+% attributes as residual goals.
+attribute_goals(X) -->
+    { get_atts(X, required(Value)) },
+    [required(X, Value)].

package/examples/dif-constraints.pl

@@ -0,0 +1,19 @@
+% Delayed disequality constraints with dif/2.
+%
+% Unlike \=/2, dif/2 records a constraint when its arguments are still
+% unifiable and rechecks that constraint after later bindings.
+
+%% goal: allowed_pair(X, Y)
+%% goal: specialization(X, Y)
+
+allowed_pair(X, Y) :-
+    dif(X, Y),
+    X = left,
+    Y = right.
+
+% The structural constraint remains pending after X=Y. Binding both to 1
+% then proves X-Y and 1-2 different, so the constraint is discharged.
+specialization(X, Y) :-
+    dif(X-Y, 1-2),
+    X = Y,
+    Y = 1.

package/examples/output/attributed-variables.pl

@@ -0,0 +1,2 @@
+accepts_required_value(ok).
+alias_preserves_attribute(ok).

package/examples/output/dif-constraints.pl

@@ -0,0 +1,2 @@
+allowed_pair(left, right).
+specialization(1, 1).

package/package.json

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

package/playground.html

@@ -446,6 +446,7 @@
           "ancestor",
           "animal",
           "annotation",
+          "attributed-variables",
           "auroracare",
           "backward",
           "basic-monadic",
@@ -495,6 +496,7 @@
           "derived-backward-rule",
           "derived-rule",
           "diamond-property",
+          "dif-constraints",
           "dijkstra",
           "dijkstra-findall-sort",
           "dijkstra-risk-path",

package/src/ARCHITECTURE.md

@@ -15,7 +15,7 @@ higher-level frontends.
    `clpz.js`. `cleanup.js` owns lifecycle-aware disposal of protected builtin
    iterators and registers the normal-profile cleanup controls without making
    `solver.js` depend back on the language registry.
-4. **Language services** — `iso.js`, `iso-arithmetic.js`, `dcg.js`,
+4. **Language services** — `iso.js`, `iso-arithmetic.js`, `dcg.js`, `atts.js`,
    `standard-library.js`, and `src/lib/`.
 5. **Frontends/tools** — `execute.js`, `repl.js`, `cli.js`, `quads.js`,
    `explain.js`, and the playground worker.
@@ -31,6 +31,23 @@ kernel component into the ISO registry or a frontend.  In particular,
 report processor errors without importing `iso.js` and creating an
 `iso.js <-> dcg.js` cycle.
 
+`term.js` also owns the generic annotated-variable storage carried by `Env`.
+Annotations are persistent across `Env.clone()` and therefore backtrack with the
+substitution. Language services may attach immutable constraint descriptors,
+but the unconstrained unification hot path only performs a null check; descriptor
+validation and reindexing run only in environments that actually contain
+annotations. `dif/2` is the first descriptor-based user of this mechanism.
+
+`atts.js` layers Prolog-visible attributed variables over that same persistent
+environment. Per-module attributes follow the current variable representative.
+When an attributed variable is about to be bound, the solver runs that module's
+`verify_attributes/3` against the still-unbound representative; only a successful
+hook permits the binding, and any goals returned in the third argument are queued
+immediately after it. This pre-bind/post-bind split is the compatibility boundary
+needed by Scryer's `library(atts)` and `library(clpz)`. The current CLP(Z)-specific
+`Env._clpz` store remains transitional until the Scryer Prolog implementation can
+replace it without losing test or performance parity; see `src/CLPZ-MIGRATION.md`.
+
 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

@@ -0,0 +1,61 @@
+# CLP(Z) migration toward Scryer's Prolog implementation
+
+EyeProlog's current `library(clpz)` has a Prolog API in `src/lib/clpz.pl` and a
+CLP(Z)-specific propagation store in `src/clpz.js`. The long-term target is to
+reuse Markus Triska's MIT-licensed [`clpz.pl` from Scryer
+Prolog](https://github.com/mthom/scryer-prolog/blob/master/src/lib/clpz.pl) and
+keep the JavaScript runtime responsible for generic Prolog VM facilities rather
+than a second finite-domain solver.
+
+## Stage 1: attributed-variable substrate
+
+This stage is implemented. `Env` carries persistent per-module Prolog
+attributes in addition to the generic constraint descriptors introduced for
+`dif/2`. `src/atts.js` and `library(atts)` expose the operations required by the
+Scryer style: `put_atts/2`, `get_atts/2`, `put_attr/3`, `get_attr/3`,
+`del_attr/2`, and `term_attributed_variables/2`. The parser accepts the
+`attribute` declaration operator, Scryer-style comma-separated
+`:- attribute a/1, b/0.` directives, and `op/3` entries in module export lists.
+
+The important unification protocol is also implemented. Before an attributed
+variable is bound to a nonvariable, or before two variables carrying attributes
+for the same owner module are aliased, the solver invokes the owner's
+`verify_attributes/3`. A failed hook rejects the unification. Goals returned in
+the third argument are queued only after the binding succeeds. Aliasing an
+attributed variable with a plain variable transfers the persistent attribute map
+to the surviving representative, which is equivalent to Scryer's CLP(Z)
+`verify_attributes/3` transfer branch and avoids a recursive hook call while
+entering the hook itself.
+
+The substrate is covered by regressions for lookup, alias transfer, conflicting
+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`
+
+The upstream solver is not only an attributed-variable client. It also relies on
+compile-time facilities that EyeProlog does not yet provide generically:
+
+- 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;
+
+These are compatibility gaps, not reasons to add more CLP(Z)-specific code to
+`term.js` or `solver.js`.
+
+## Migration rule
+
+`src/clpz.js` remains the active implementation until an upstream-based Prolog
+solver passes the existing EyeProlog CLP(Z) corpus and the selected Scryer CLP(Z)
+regressions. During the transition it is the behavioral reference, not the
+architecture to extend. New generic VM work should go into attributed variables,
+term/goal expansion, or reusable library support where possible.
+
+Once the upstream source loads and reaches parity, remove the corresponding
+`eyeprolog__clpz_*` adapters and the `_clpz` store in one or more reviewable
+steps. Keep the upstream copyright and MIT license notice intact and keep local
+patches small enough that future Scryer updates can be diffed mechanically.

package/src/atts.js

@@ -0,0 +1,224 @@
+// Generic attributed-variable bridge for Prolog libraries.
+//
+// The storage is owned by Env so attributes backtrack with substitutions. This
+// module exposes the small atts interface used by Scryer libraries. Attribute
+// verification itself is scheduled by term.js and executed by Solver before a
+// binding is committed; goals returned by verify_attributes/3 run immediately
+// after the binding.
+
+import {
+  ATOM, COMPOUND, VAR, atom, compound, deref, listFromItems,
+  properListItems, unify, variable,
+} from './term.js';
+import { PrologError } from './errors.js';
+
+function callerModule(goal) {
+  return goal.module ?? 'user';
+}
+
+function attributeSignature(term) {
+  if (term.type === ATOM) return { name: term.name, arity: 0 };
+  if (term.type === COMPOUND) return { name: term.name, arity: term.arity };
+  return null;
+}
+
+function normalizedAttribute(term, env) {
+  let resolved = deref(term, env);
+  let mode = 'put';
+  if (resolved.type === COMPOUND && resolved.arity === 1 && (resolved.name === '+' || resolved.name === '-')) {
+    mode = resolved.name === '-' ? 'delete' : 'put';
+    resolved = deref(resolved.args[0], env);
+  }
+  if (resolved.type === VAR) throw new PrologError('instantiation_error');
+  const signature = attributeSignature(resolved);
+  if (signature == null) throw new PrologError('type_error(callable)', resolved);
+  return { mode, attribute: resolved, ...signature };
+}
+
+function putOne(next, variableTerm, owner, attributeTerm) {
+  const variableValue = deref(variableTerm, next);
+  if (variableValue.type !== VAR) throw new PrologError('uninstantiation_error', variableValue);
+  const normalized = normalizedAttribute(attributeTerm, next);
+  if (normalized.mode === 'delete') {
+    next.deletePrologAttribute(variableValue.name, owner, normalized.name, normalized.arity);
+    return;
+  }
+  next.putPrologAttribute(variableValue.name, owner, normalized.attribute);
+}
+
+function* putAttsBuiltin({ goal, env }) {
+  const next = env.clone();
+  const owner = callerModule(goal);
+  const variableTerm = deref(goal.args[0], next);
+  if (variableTerm.type !== VAR) throw new PrologError('uninstantiation_error', variableTerm);
+  const list = properListItems(goal.args[1], next);
+  if (list != null) {
+    for (const attribute of list) putOne(next, variableTerm, owner, attribute);
+  } else {
+    putOne(next, variableTerm, owner, goal.args[1]);
+  }
+  yield next;
+}
+
+function* getAttsBuiltin({ goal, env }) {
+  const variableTerm = deref(goal.args[0], env);
+  if (variableTerm.type !== VAR) throw new PrologError('uninstantiation_error', variableTerm);
+  const owner = callerModule(goal);
+  const pattern = deref(goal.args[1], env);
+  const attributes = env.prologAttributes(variableTerm.name, owner);
+  if (pattern.type === VAR) {
+    if (attributes.length === 0) return;
+    const next = env.clone();
+    if (unify(goal.args[1], listFromItems(attributes), next)) yield next;
+    return;
+  }
+
+  let mode = 'present';
+  let inner = pattern;
+  if (pattern.type === COMPOUND && pattern.arity === 1 && (pattern.name === '+' || pattern.name === '-')) {
+    mode = pattern.name === '-' ? 'absent' : 'present';
+    inner = deref(pattern.args[0], env);
+  }
+  if (inner.type === VAR) throw new PrologError('instantiation_error');
+  const signature = attributeSignature(inner);
+  if (signature == null) throw new PrologError('type_error(callable)', inner);
+  const stored = env.getPrologAttribute(variableTerm.name, owner, signature.name, signature.arity);
+  if (mode === 'absent') {
+    if (stored == null) yield env.clone();
+    return;
+  }
+  if (stored == null) return;
+  const next = env.clone();
+  if (unify(inner, stored, next, { skipVariableConstraints: true })) yield next;
+}
+
+function attributeName(term, env) {
+  const resolved = deref(term, env);
+  if (resolved.type === VAR) throw new PrologError('instantiation_error');
+  if (resolved.type !== ATOM) throw new PrologError('type_error(atom)', resolved);
+  return resolved.name;
+}
+
+function* putAttrBuiltin({ goal, env }) {
+  const next = env.clone();
+  const owner = callerModule(goal);
+  const variableTerm = deref(goal.args[0], next);
+  if (variableTerm.type !== VAR) throw new PrologError('uninstantiation_error', variableTerm);
+  const name = attributeName(goal.args[1], next);
+  next.putPrologAttribute(variableTerm.name, owner, compound(name, [goal.args[2]]));
+  yield next;
+}
+
+function* getAttrBuiltin({ goal, env }) {
+  const variableTerm = deref(goal.args[0], env);
+  if (variableTerm.type !== VAR) return;
+  const owner = callerModule(goal);
+  const name = attributeName(goal.args[1], env);
+  const stored = env.getPrologAttribute(variableTerm.name, owner, name, 1);
+  if (stored == null) return;
+  const next = env.clone();
+  if (unify(goal.args[2], stored.args[0], next, { skipVariableConstraints: true })) yield next;
+}
+
+function* delAttrBuiltin({ goal, env }) {
+  const next = env.clone();
+  const variableTerm = deref(goal.args[0], next);
+  if (variableTerm.type !== VAR) { yield next; return; }
+  const owner = callerModule(goal);
+  const name = attributeName(goal.args[1], next);
+  next.deletePrologAttribute(variableTerm.name, owner, name, null);
+  yield next;
+}
+
+function collectTermVariables(term, env) {
+  const result = [];
+  const seen = new Set();
+  const stack = [term];
+  while (stack.length) {
+    const current = deref(stack.pop(), env);
+    if (current.type === VAR) {
+      if (!seen.has(current.name)) {
+        seen.add(current.name);
+        result.push(current);
+      }
+      continue;
+    }
+    if (current.type === COMPOUND) {
+      for (let i = current.arity - 1; i >= 0; i--) stack.push(current.args[i]);
+    }
+  }
+  return result;
+}
+
+function* termAttributedVariablesBuiltin({ goal, env }) {
+  const variables = collectTermVariables(goal.args[0], env).filter((term) => env.hasPrologAttributes(term.name));
+  const next = env.clone();
+  if (unify(goal.args[1], listFromItems(variables), next)) yield next;
+}
+
+function* getAttrListBuiltin({ goal, env }) {
+  const variableTerm = deref(goal.args[0], env);
+  if (variableTerm.type !== VAR) return;
+  const entries = env.prologAttributes(variableTerm.name);
+  if (entries.length === 0) return;
+  const encoded = entries.map(({ module, attribute }) => compound(':', [atom(module), attribute]));
+  const next = env.clone();
+  if (unify(goal.args[1], listFromItems(encoded), next)) yield next;
+}
+
+function* getFromAttrListBuiltin({ goal, env }) {
+  const variableTerm = deref(goal.args[0], env);
+  if (variableTerm.type !== VAR) return;
+  const moduleTerm = deref(goal.args[1], env);
+  if (moduleTerm.type === VAR) throw new PrologError('instantiation_error');
+  if (moduleTerm.type !== ATOM) throw new PrologError('type_error(atom)', moduleTerm);
+  const pattern = deref(goal.args[2], env);
+  if (pattern.type === VAR) throw new PrologError('instantiation_error');
+  const signature = attributeSignature(pattern);
+  if (signature == null) throw new PrologError('type_error(callable)', pattern);
+  const stored = env.getPrologAttribute(variableTerm.name, moduleTerm.name, signature.name, signature.arity);
+  if (stored == null) return;
+  const next = env.clone();
+  if (unify(pattern, stored, next, { skipVariableConstraints: true })) yield next;
+}
+
+function* putToAttrListBuiltin({ goal, env }) {
+  const next = env.clone();
+  const variableTerm = deref(goal.args[0], next);
+  if (variableTerm.type !== VAR) throw new PrologError('uninstantiation_error', variableTerm);
+  const moduleTerm = deref(goal.args[1], next);
+  if (moduleTerm.type === VAR) throw new PrologError('instantiation_error');
+  if (moduleTerm.type !== ATOM) throw new PrologError('type_error(atom)', moduleTerm);
+  const normalized = normalizedAttribute(goal.args[2], next);
+  next.putPrologAttribute(variableTerm.name, moduleTerm.name, normalized.attribute);
+  yield next;
+}
+
+function* delFromAttrListBuiltin({ goal, env }) {
+  const next = env.clone();
+  const variableTerm = deref(goal.args[0], next);
+  if (variableTerm.type !== VAR) { yield next; return; }
+  const moduleTerm = deref(goal.args[1], next);
+  if (moduleTerm.type === VAR) throw new PrologError('instantiation_error');
+  if (moduleTerm.type !== ATOM) throw new PrologError('type_error(atom)', moduleTerm);
+  const normalized = normalizedAttribute(goal.args[2], next);
+  next.deletePrologAttribute(variableTerm.name, moduleTerm.name, normalized.name, normalized.arity);
+  yield next;
+}
+
+export const attsBuiltins = {
+  register(registry) {
+    registry.add('put_atts', 2, putAttsBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('get_atts', 2, getAttsBuiltin, { deterministic: true, eyePrologLibrary: true });
+    // Scryer's CLP(Z) sources use these through goal expansion. EyeProlog
+    // provides them directly so the source does not depend on goal_expansion/2.
+    registry.add('put_attr', 3, putAttrBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('get_attr', 3, getAttrBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('del_attr', 2, delAttrBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('$term_attributed_variables', 2, termAttributedVariablesBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('$get_attr_list', 2, getAttrListBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('$get_from_attr_list', 3, getFromAttrListBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('$put_to_attr_list', 3, putToAttrListBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('$del_from_attr_list', 3, delFromAttrListBuiltin, { deterministic: true, eyePrologLibrary: true });
+  },
+};

package/src/iso.js

@@ -167,6 +167,7 @@ export const eyePrologLibraryBuiltins = {
     registry.add('eyeprolog__call_nth', 2, callNthBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__countall', 2, countAllBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__freeze', 2, freezeBuiltin, { eyePrologLibrary: true });
+    registry.add('dif', 2, difBuiltin, { deterministic: true, eyePrologLibrary: true });
     registry.add('time', 1, timeBuiltin, { eyePrologLibrary: true });
     registry.add('eyeprolog__time', 1, timeBuiltin, { eyePrologLibrary: true });
   },
@@ -189,6 +190,43 @@ function* nonUnification({ goal, env }) {
   if (!unify(goal.args[0], goal.args[1], env.clone())) yield env;
 }
 
+function difConstraint(left, right) {
+  return Object.freeze({
+    kind: 'dif',
+    left,
+    right,
+    variables(env) {
+      return new Set([...termVariableNames(left, env), ...termVariableNames(right, env)]);
+    },
+    status(env) {
+      if (identical(left, right, env)) return 'violated';
+      const probe = env.clone();
+      return unify(left, right, probe, { skipVariableConstraints: true }) ? 'pending' : 'entailed';
+    },
+    residualGoal() {
+      return compound('dif', [left, right]);
+    },
+  });
+}
+
+function* difBuiltin({ goal, env }) {
+  const left = goal.args[0];
+  const right = goal.args[1];
+  if (identical(left, right, env)) return;
+
+  // In EyeProlog's finite-tree model, terms that cannot unify are already
+  // provably different and need no residual constraint. Otherwise attach a
+  // disequality constraint to every currently unbound variable it mentions.
+  const probe = env.clone();
+  if (!unify(left, right, probe, { skipVariableConstraints: true })) {
+    yield env;
+    return;
+  }
+  const next = env.clone();
+  next.addVariableConstraint(difConstraint(left, right));
+  yield next;
+}
+
 function termVariableNames(term, env, names = new Set(), seen = new Set()) {
   term = deref(term, env);
   if (term.type === VAR) {
@@ -1646,7 +1684,7 @@ function writeOptionBoolean(value, env, option) {
   value = deref(value, env);
   if (value.type === VAR) throw new PrologError('instantiation_error');
   if (value.type !== ATOM || !['true', 'false'].includes(value.name)) {
-    throw new PrologError('domain_error(write_option)', option);
+    throw new PrologError('domain_error(write_option)', copyResolved(option, env));
   }
   return value.name === 'true';
 }
@@ -1657,19 +1695,20 @@ function writeVariableNames(value, env, option) {
   const items = properListItems(value, env);
   if (items == null) {
     if (isPartialList(value, env)) throw new PrologError('instantiation_error');
-    throw new PrologError('domain_error(write_option)', option);
+    throw new PrologError('domain_error(write_option)', copyResolved(option, env));
   }
   const names = new Map();
   for (const item of items) {
     const pair = deref(item, env);
+    if (pair.type === VAR) throw new PrologError('instantiation_error');
     if (pair.type !== COMPOUND || pair.name !== '=' || pair.arity !== 2) {
-      throw new PrologError('domain_error(write_option)', option);
+      throw new PrologError('domain_error(write_option)', copyResolved(option, env));
     }
     const name = deref(pair.args[0], env);
     const target = deref(pair.args[1], env);
     if (name.type === VAR) throw new PrologError('instantiation_error');
     if (name.type !== ATOM) {
-      throw new PrologError('domain_error(write_option)', option);
+      throw new PrologError('domain_error(write_option)', copyResolved(option, env));
     }
     // Corrigendum 3 permits any term on the right. Only variables can name a
     // variable being written; retain the leftmost applicable entry.
@@ -1682,7 +1721,7 @@ function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = n
   const result = defaultTermWriteOptions(mode);
   for (const option of options) {
     if (option.type !== COMPOUND || option.arity !== 1) {
-      throw new PrologError('domain_error(write_option)', option);
+      throw new PrologError('domain_error(write_option)', copyResolved(option, env));
     }
     if (option.name === 'quoted') result.quoted = writeOptionBoolean(option.args[0], env, option);
     else if (option.name === 'ignore_ops') result.ignoreOps = writeOptionBoolean(option.args[0], env, option);
@@ -1691,7 +1730,7 @@ function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = n
     else if (option.name === 'double_quotes' && !solver?.isoStrict) {
       result.doubleQuotes = writeOptionBoolean(option.args[0], env, option);
     } else {
-      throw new PrologError('domain_error(write_option)', option);
+      throw new PrologError('domain_error(write_option)', copyResolved(option, env));
     }
   }
   return result;

package/src/lib/atts.pl

@@ -0,0 +1,20 @@
+/*  Attributed variables compatibility layer.
+
+    The public surface follows Scryer Prolog library(atts). EyeProlog keeps the
+    actual attribute store and verify_attributes/3 scheduling in the generic
+    annotated-variable runtime, so libraries can use put_atts/2 and get_atts/2
+    without code-generation term expansion.
+*/
+
+:- module(atts, [
+    put_atts/2,
+    get_atts/2,
+    put_attr/3,
+    get_attr/3,
+    del_attr/2,
+    term_attributed_variables/2
+]).
+:- op(1199, fx, attribute).
+
+term_attributed_variables(Term, Variables) :-
+    '$term_attributed_variables'(Term, Variables).

package/src/parser.js

@@ -372,9 +372,15 @@ class Parser {
     if (directive.type !== COMPOUND || directive.name !== 'use_module' || ![1, 2].includes(directive.arity)) return;
     const designation = directive.args[0];
     if (designation?.type !== COMPOUND || designation.name !== 'library' || designation.arity !== 1 ||
-        designation.args[0]?.type !== ATOM || designation.args[0].name !== 'clpz') return;
-    for (const [priority, specifier, name] of CLPZ_OPERATOR_DEFINITIONS) {
-      this.defineOperator(priority, specifier, name);
+        designation.args[0]?.type !== ATOM) return;
+    if (designation.args[0].name === 'clpz') {
+      for (const [priority, specifier, name] of CLPZ_OPERATOR_DEFINITIONS) {
+        this.defineOperator(priority, specifier, name);
+      }
+    } else if (designation.args[0].name === 'atts') {
+      // Scryer library(atts) exports this declaration operator. EyeProlog
+      // handles the directive directly instead of relying on term expansion.
+      this.defineOperator(1199, 'fx', 'attribute');
     }
   }
   operatorTokenName(token = this.token) {
@@ -1020,13 +1026,22 @@ class Parser {
       }
       if (this.token.type === TOK.IF) {
         this.advance();
-        const directive = this.parseTerm();
+        const attributeSequence = !this.strictIso && this.operatorTokenName() === 'attribute';
+        let directive = this.parseTerm(0, attributeSequence);
+        // Scryer's library(atts) convention permits declarations such as
+        // `:- attribute a/1, b/0.` without parentheses. At program level the
+        // comma would otherwise sit outside the prefix term; fold it back into
+        // the single attribute/1 directive before directive classification.
+        if (attributeSequence && directive.type === COMPOUND && directive.name === ',' && directive.arity === 2 &&
+            directive.args[0].type === COMPOUND && directive.args[0].name === 'attribute' && directive.args[0].arity === 1) {
+          directive = compound('attribute', [compound(',', [directive.args[0].args[0], directive.args[1]])]);
+        }
         const coreDirective = directive.type === 'compound' && (
           (['dynamic', 'multifile', 'discontiguous', 'initialization', 'include', 'ensure_loaded'].includes(directive.name) && directive.arity === 1) ||
           (['char_conversion', 'set_prolog_flag'].includes(directive.name) && directive.arity === 2)
         );
         const extensionDirective = directive.type === 'compound' && (
-          (['use_module', 'meta_predicate'].includes(directive.name) && directive.arity === 1) ||
+          (['use_module', 'meta_predicate', 'attribute'].includes(directive.name) && directive.arity === 1) ||
           (['module', 'use_module'].includes(directive.name) && directive.arity === 2)
         );
         if (this.strictIso && extensionDirective) {
@@ -1044,7 +1059,7 @@ class Parser {
         // Module loading declarations describe the compilation unit rather
         // than an executable source clause, so they do not shift proof clause
         // numbers in the importing file.
-        if (!['module', 'use_module', 'meta_predicate'].includes(directive.name)) clauseNumber++;
+        if (!['module', 'use_module', 'meta_predicate', 'attribute'].includes(directive.name)) clauseNumber++;
         if (this.sourceMetadata) clause.source = { filename: this.filename, line, clause: clauseNumber };
         accept(clause);
         continue;