deep6 1.1.3 → 1.2.0

package/src/unify.d.ts

@@ -0,0 +1,95 @@
+// Type definitions for deep6 unification
+// Generated from src/unify.js
+
+import {Env, Unifier, Variable} from './env.js';
+
+/**
+ * Options for unification
+ */
+export interface UnifyOptions {
+  /** Handle circular references (default: false) */
+  circular?: boolean;
+  /** Include symbol properties (default: false) */
+  symbols?: boolean;
+  /** Use loose equality for primitives (default: false) */
+  loose?: boolean;
+  /** Ignore function properties (default: false) */
+  ignoreFunctions?: boolean;
+  /** Distinguish +0 from -0 (default: false) */
+  signedZero?: boolean;
+  /** Allow extra keys on target objects (default: false) */
+  openObjects?: boolean;
+  /** Allow extra elements in target arrays (default: false) */
+  openArrays?: boolean;
+  /** Allow extra entries in target Maps (default: false) */
+  openMaps?: boolean;
+  /** Allow extra entries in target Sets (default: false) */
+  openSets?: boolean;
+}
+
+/**
+ * Core unification algorithm
+ *
+ * Attempts to unify two values, optionally binding variables.
+ * Returns an Env with bindings on success, or null on failure.
+ *
+ * @param l - Left value
+ * @param r - Right value
+ * @param env - Existing environment, options object, or null
+ * @param options - Unification options (when env is provided separately)
+ * @returns Environment with bindings, or null on failure
+ */
+export declare const unify: (l: unknown, r: unknown, env?: Env | UnifyOptions | null, options?: UnifyOptions) => Env | null;
+
+/**
+ * Flat array of type-specific unifier pairs: [Constructor, handler, Constructor, handler, ...]
+ *
+ * Use `registry.push(Type, handler)` to register a custom type handler.
+ * Handler signature: `(l, r, ls, rs, env) => boolean`
+ */
+export declare const registry: unknown[];
+
+/**
+ * Flat array of filter pairs: [predicate, handler, predicate, handler, ...]
+ *
+ * Use `filters.push(predicate, handler)` to register a custom filter.
+ */
+export declare const filters: unknown[];
+
+/**
+ * Wraps a value for open matching (target may have extra properties)
+ * @param o - Value to wrap
+ * @returns Open-wrapped value
+ */
+export declare const open: <T>(o: T) => T;
+
+/**
+ * Wraps a value for soft matching (bidirectional open, updates both sides)
+ * @param o - Value to wrap
+ * @returns Soft-wrapped value
+ */
+export declare const soft: <T>(o: T) => T;
+
+/**
+ * Checks if a value is open-wrapped
+ * @param o - Value to check
+ */
+export declare const isOpen: (o: unknown) => boolean;
+
+/**
+ * Checks if a value is soft-wrapped
+ * @param o - Value to check
+ */
+export declare const isSoft: (o: unknown) => boolean;
+
+/**
+ * Checks if a value is wrapped (open or soft)
+ * @param o - Value to check
+ */
+export declare const isWrapped: (o: unknown) => boolean;
+
+// Re-exports from env.js (value exports, usable as constructors)
+export {Env, Unifier, Variable} from './env.js';
+export {_, any, isUnifier, isVariable, variable} from './env.js';
+
+export default unify;

package/src/unify.js

@@ -24,18 +24,17 @@ class Wrap extends Unifier {
       value = isWrapped ? val.object : val;
     if (!value || typeof value != 'object' || Array.isArray(this.object) !== Array.isArray(value)) return false;
     if (Array.isArray(this.object)) {
-      if (!Array.isArray(value)) return false;
       return isWrapped
         ? unifyObjects(this.object, this.type, this, val.object, val.type, val, ls, rs, env)
         : unifyObjects(this.object, this.type, this, val, env.openArrays ? 'open' : 'exact', null, ls, rs, env);
     }
-    if (typeof Map == 'function' && this.object instanceof Map) {
+    if (this.object instanceof Map) {
       if (!(value instanceof Map)) return false;
       return isWrapped
         ? unifyMaps(this.object, this.type, this, val.object, val.type, val, ls, rs, env)
         : unifyMaps(this.object, this.type, this, val, env.openMaps ? 'open' : 'exact', null, ls, rs, env);
     }
-    if (typeof Set == 'function' && this.object instanceof Set) {
+    if (this.object instanceof Set) {
       if (!(value instanceof Set)) return false;
       return isWrapped
         ? unifySets(this.object, this.type, this, val.object, val.type, val, ls, rs, env)
@@ -61,11 +60,12 @@ const registry = [
     Date,
     (l, r) => l instanceof Date && r instanceof Date && l.getTime() == r.getTime(),
     RegExp,
-    (l, r) =>
-      l instanceof RegExp && r instanceof RegExp && l.source == r.source && l.global == r.global && l.multiline == r.multiline && l.ignoreCase == r.ignoreCase
+    (l, r) => l instanceof RegExp && r instanceof RegExp && l.source == r.source && l.flags == r.flags
   ],
   filters = [];
 
+typeof URL == 'function' && registry.push(URL, (l, r) => l instanceof URL && r instanceof URL && l.href == r.href);
+
 // possible well-known constructors
 
 const unifyTypedArrays = Type => (l, r, ls, rs, env) => {
@@ -99,9 +99,10 @@ const unifyDataView = (l, r, ls, rs, env) => {
 };
 typeof DataView == 'function' && registry.push(DataView, unifyDataView);
 
+const unifyUint8Array = unifyTypedArrays(Uint8Array);
 const unifyArrayBuffer = (l, r, ls, rs, env) => {
   if (!(l instanceof ArrayBuffer) || !(r instanceof ArrayBuffer) || l.byteLength != r.byteLength) return false;
-  return unifyTypedArrays(Uint8Array)(new Uint8Array(l), new Uint8Array(r), ls, rs, env);
+  return unifyUint8Array(new Uint8Array(l), new Uint8Array(r), ls, rs, env);
 };
 typeof ArrayBuffer == 'function' && typeof Uint8Array == 'function' && registry.push(ArrayBuffer, unifyArrayBuffer);
 
@@ -161,22 +162,28 @@ const mapOps = {
     }
   }
 };
-mapOps.exact.exact.compare = mapOps.exact.open.compare = mapOps.exact.soft.compare = (l, r, ls, rs) => {
-  for (const [key, value] of r) {
-    if (!l.has(key)) return false;
-    ls.push(l.get(key));
-    rs.push(value);
-  }
-  return true;
-};
-mapOps.open.open.compare = mapOps.open.soft.compare = mapOps.soft.soft.compare = (l, r, ls, rs) => {
-  for (const [key, value] of r) {
-    if (!l.has(key)) continue;
-    ls.push(l.get(key));
-    rs.push(value);
-  }
-  return true;
-};
+mapOps.exact.exact.compare =
+  mapOps.exact.open.compare =
+  mapOps.exact.soft.compare =
+    (l, r, ls, rs) => {
+      for (const [key, value] of r) {
+        if (!l.has(key)) return false;
+        ls.push(l.get(key));
+        rs.push(value);
+      }
+      return true;
+    };
+mapOps.open.open.compare =
+  mapOps.open.soft.compare =
+  mapOps.soft.soft.compare =
+    (l, r, ls, rs) => {
+      for (const [key, value] of r) {
+        if (!l.has(key)) continue;
+        ls.push(l.get(key));
+        rs.push(value);
+      }
+      return true;
+    };
 mapOps.exact.soft.update = mapOps.open.soft.update = function () {
   for (const [key, value] of this.l) {
     !this.r.has(key) && this.r.set(key, value);
@@ -186,7 +193,19 @@ mapOps.exact.soft.update = mapOps.open.soft.update = function () {
 const unifyMaps = (l, lt, lm, r, rt, rm, ls, rs, env) => {
   const ols = ls;
   if (lt > rt) {
-    [l, lt, lm, ls, r, rt, rm, rs] = [r, rt, rm, rs, l, lt, lm, ls];
+    let tmp;
+    tmp = l;
+    l = r;
+    r = tmp;
+    tmp = lt;
+    lt = rt;
+    rt = tmp;
+    tmp = lm;
+    lm = rm;
+    rm = tmp;
+    tmp = ls;
+    ls = rs;
+    rs = tmp;
   }
   const ops = mapOps[lt][rt];
   if (ops.precheck && !ops.precheck(l, r)) return false;
@@ -231,8 +250,13 @@ const setOps = {
     }
   }
 };
-setOps.exact.exact.compare = setOps.exact.open.compare = setOps.exact.soft.compare = setOps.open.open.compare = setOps.open.soft.compare = setOps.soft.soft.compare = () =>
-  true;
+setOps.exact.exact.compare =
+  setOps.exact.open.compare =
+  setOps.exact.soft.compare =
+  setOps.open.open.compare =
+  setOps.open.soft.compare =
+  setOps.soft.soft.compare =
+    () => true;
 setOps.exact.soft.update = setOps.open.soft.update = function () {
   for (const key of this.l) {
     this.r.add(key);
@@ -242,7 +266,19 @@ setOps.exact.soft.update = setOps.open.soft.update = function () {
 const unifySets = (l, lt, lm, r, rt, rm, ls, rs, env) => {
   const ols = ls;
   if (lt > rt) {
-    [l, lt, lm, ls, r, rt, rm, rs] = [r, rt, rm, rs, l, lt, lm, ls];
+    let tmp;
+    tmp = l;
+    l = r;
+    r = tmp;
+    tmp = lt;
+    lt = rt;
+    rt = tmp;
+    tmp = lm;
+    lm = rm;
+    rm = tmp;
+    tmp = ls;
+    ls = rs;
+    rs = tmp;
   }
   const ops = setOps[lt][rt];
   if (ops.precheck && !ops.precheck(l, r)) return false;
@@ -267,7 +303,10 @@ const objectOps = {
           rKeys = rKeys.concat(Object.getOwnPropertySymbols(r));
         }
         if (lKeys.length != rKeys.length) return false;
-        return lKeys.every(k => hasOwnProperty.call(r, k));
+        for (let i = 0; i < lKeys.length; ++i) {
+          if (!hasOwnProperty.call(r, lKeys[i])) return false;
+        }
+        return true;
       }
     },
     open: {},
@@ -298,29 +337,34 @@ const objectOps = {
     }
   }
 };
-objectOps.exact.exact.compare = objectOps.exact.open.compare = objectOps.exact.soft.compare = (l, r, ls, rs, env) => {
-  let keys = Object.keys(r);
-  if (env.symbols) keys = keys.concat(Object.getOwnPropertySymbols(r));
-  return keys.every(k => {
-    if (hasOwnProperty.call(l, k)) {
-      ls.push(l[k]);
-      rs.push(r[k]);
+objectOps.exact.exact.compare =
+  objectOps.exact.open.compare =
+  objectOps.exact.soft.compare =
+    (l, r, ls, rs, env) => {
+      let keys = Object.keys(r);
+      if (env.symbols) keys = keys.concat(Object.getOwnPropertySymbols(r));
+      for (let i = 0; i < keys.length; ++i) {
+        const k = keys[i];
+        if (!hasOwnProperty.call(l, k)) return false;
+        ls.push(l[k]);
+        rs.push(r[k]);
+      }
       return true;
-    }
-    return false;
-  });
-};
-objectOps.open.open.compare = objectOps.open.soft.compare = objectOps.soft.soft.compare = (l, r, ls, rs, env) => {
-  let keys = Object.keys(r);
-  if (env.symbols) keys = keys.concat(Object.getOwnPropertySymbols(r));
-  for (const k of keys) {
-    if (hasOwnProperty.call(l, k)) {
-      ls.push(l[k]);
-      rs.push(r[k]);
-    }
-  }
-  return true;
-};
+    };
+objectOps.open.open.compare =
+  objectOps.open.soft.compare =
+  objectOps.soft.soft.compare =
+    (l, r, ls, rs, env) => {
+      let keys = Object.keys(r);
+      if (env.symbols) keys = keys.concat(Object.getOwnPropertySymbols(r));
+      for (const k of keys) {
+        if (hasOwnProperty.call(l, k)) {
+          ls.push(l[k]);
+          rs.push(r[k]);
+        }
+      }
+      return true;
+    };
 objectOps.exact.soft.update = objectOps.open.soft.update = function () {
   let keys = Object.keys(this.l);
   if (this.e.symbols) keys = keys.concat(Object.getOwnPropertySymbols(this.l));
@@ -332,7 +376,19 @@ objectOps.exact.soft.update = objectOps.open.soft.update = function () {
 const unifyObjects = (l, lt, lm, r, rt, rm, ls, rs, env) => {
   const ols = ls;
   if (lt > rt) {
-    [l, lt, lm, ls, r, rt, rm, rs] = [r, rt, rm, rs, l, lt, lm, ls];
+    let tmp;
+    tmp = l;
+    l = r;
+    r = tmp;
+    tmp = lt;
+    lt = rt;
+    rt = tmp;
+    tmp = lm;
+    lm = rm;
+    rm = tmp;
+    tmp = ls;
+    ls = rs;
+    rs = tmp;
   }
   const ops = objectOps[lt][rt];
   if (ops.precheck && !ops.precheck(l, r, env)) return false;
@@ -354,36 +410,39 @@ const unify = (l, r, env, options) => {
   env = Object.assign(env, options);
   // options: openObjects, openArrays, openMaps, openSets, circular, loose, ignoreFunctions, signedZero, symbols.
   const ls = [l],
-    rs = [r],
-    lSeen = new Map(),
+    rs = [r];
+  let lSeen, rSeen;
+  if (env.circular) {
+    lSeen = new Map();
     rSeen = new Map();
+  }
   main: while (ls.length) {
     // perform a command, or extract a pair
     l = ls.pop();
-    if (l instanceof Command) {
+    if (typeof l == 'object' && l instanceof Command) {
       l.f();
       continue;
     }
     r = rs.pop();
     // direct equality
     if (l === r) {
-      if (env.circular && l && typeof l == 'object' && lSeen.has(l) ^ rSeen.has(r)) return null;
+      if (lSeen && l && typeof l == 'object' && lSeen.has(l) ^ rSeen.has(r)) return null;
       if (env.signedZero && l === 0 && 1 / l !== 1 / r) return null;
       continue;
     }
     // anyvar
     if (l === _ || r === _) continue;
     // process variables (variables have priority)
-    if (l instanceof Variable) {
+    if (typeof l == 'object' && l instanceof Variable) {
       if (l.unify(r, ls, rs, env)) continue;
       return null;
     }
-    if (r instanceof Variable) {
+    if (typeof r == 'object' && r instanceof Variable) {
       if (r.unify(l, ls, rs, env)) continue;
       return null;
     }
     // process circular dependencies
-    if (env.circular) {
+    if (lSeen) {
       const lIndex = lSeen.get(l);
       if (typeof lIndex == 'number') {
         if (lIndex === rSeen.get(r)) continue main;
@@ -396,11 +455,11 @@ const unify = (l, r, env, options) => {
       r && typeof r == 'object' && rSeen.set(r, rSeen.size);
     }
     // invoke custom unifiers
-    if (l instanceof Unifier) {
+    if (typeof l == 'object' && l instanceof Unifier) {
       if (l.unify(r, ls, rs, env)) continue;
       return null;
     }
-    if (r instanceof Unifier) {
+    if (typeof r == 'object' && r instanceof Unifier) {
       if (r.unify(l, ls, rs, env)) continue;
       return null;
     }
@@ -414,12 +473,17 @@ const unify = (l, r, env, options) => {
     if (typeof l == 'number' && isNaN(l) && isNaN(r)) continue;
     // cut off impossible combinations
     if (typeof l != 'object' || !l || !r) return null;
-    // process registered constructors
-    const registry = unify.registry;
-    for (let i = 0; i < registry.length; i += 2) {
-      if (l instanceof registry[i] || r instanceof registry[i]) {
-        if (registry[i + 1](l, r, ls, rs, env)) continue main;
-        return null;
+    // fast path: plain objects and arrays skip registry
+    const lp = Object.getPrototypeOf(l),
+      rp = Object.getPrototypeOf(r);
+    if (!((lp === Object.prototype || lp === null || lp === Array.prototype) && (rp === Object.prototype || rp === null || rp === Array.prototype))) {
+      // process registered constructors
+      const registry = unify.registry;
+      for (let i = 0; i < registry.length; i += 2) {
+        if (l instanceof registry[i] || r instanceof registry[i]) {
+          if (registry[i + 1](l, r, ls, rs, env)) continue main;
+          return null;
+        }
       }
     }
     // process registered filters
@@ -442,5 +506,5 @@ const unify = (l, r, env, options) => {
 unify.registry = registry;
 unify.filters = filters;
 
-export {_, Env, Unifier, isUnifier, Variable, variable, isVariable, _ as any, open, soft, isOpen, isSoft, isWrapped};
+export {_, Env, Unifier, isUnifier, Variable, variable, isVariable, _ as any, open, soft, isOpen, isSoft, isWrapped, unify};
 export default unify;

package/src/utils/replaceVars.d.ts

@@ -0,0 +1,25 @@
+// Type definitions for deep6 replaceVars utility
+// Generated from src/utils/replaceVars.js
+
+import type {Env, Variable} from '../env.js';
+
+/**
+ * Creates a tagged template function that substitutes variables from an environment
+ *
+ * Template interpolations can be Variable instances (resolved via `.get(env)`),
+ * strings/numbers/symbols (looked up in `env.values`), or other values (coerced to string).
+ *
+ * @param env - Unification environment with variable bindings
+ * @returns A tagged template literal function
+ *
+ * @example
+ * ```ts
+ * const x = variable('x');
+ * const env = unify({a: x}, {a: 42});
+ * const t = replaceVars(env);
+ * t`The answer is ${x}!`; // "The answer is 42!"
+ * ```
+ */
+export declare const replaceVars: (env: Env) => (strings: TemplateStringsArray, ...vars: unknown[]) => string;
+
+export default replaceVars;

package/src/utils/replaceVars.js

@@ -1,24 +1,28 @@
 import {isVariable} from '../env.js';
 
-const replaceVars = env => (strings, ...vars) => {
-  let buffer = strings[0];
-  for(let i = 0; i < vars.length;) {
-    const v = vars[i];
-    if (isVariable(v)) {
-      buffer += v.get(env);
-    } else switch (typeof v) {
-      case 'string':
-      case 'number':
-      case 'symbol':
-        buffer += env.values[v];
-        break;
-      default:
-        buffer += v;
-        break;
+const replaceVars =
+  env =>
+  (strings, ...vars) => {
+    let buffer = strings[0];
+    for (let i = 0; i < vars.length; ) {
+      const v = vars[i];
+      if (isVariable(v)) {
+        buffer += v.get(env);
+      } else
+        switch (typeof v) {
+          case 'string':
+          case 'number':
+          case 'symbol':
+            buffer += env.values[v];
+            break;
+          default:
+            buffer += v;
+            break;
+        }
+      buffer += strings[++i];
     }
-    buffer += strings[++i];
-  }
-  return buffer;
-};
+    return buffer;
+  };
 
+export {replaceVars};
 export default replaceVars;