squint-cljs 0.14.202 → 0.14.203

package/src/squint/multi.js

@@ -218,7 +218,13 @@ function hAnd(a, b, field) {
 }
 export function parents(a, b)     { return hAnd(a, b, 'parents'); }
 export function ancestors(a, b)   { return hAnd(a, b, 'ancestors'); }
-export function descendants(a, b) { return hAnd(a, b, 'descendants'); }
+export function descendants(a, b) {
+  // like CLJS: a constructor has no derive-based descendants, JS type
+  // inheritance is not tracked
+  const tag = b === undefined ? a : b;
+  if (typeof tag === 'function') throw new Error("Can't get descendants of constructors");
+  return hAnd(a, b, 'descendants');
+}
 
 function _prefers(prefer, a, b) {
   const key = findKeyByEquiv(prefer, a);

package/src/squint/record.js

@@ -0,0 +1,103 @@
+import {
+  IRecord,
+  ILookup__lookup,
+  IAssociative__assoc,
+  IAssociative__contains_key_QMARK_,
+  IMap__dissoc,
+  ICounted__count,
+  IKVReduce__kv_reduce,
+  ICollection__conj,
+  IEquiv__equiv,
+  ISeqable__seq,
+  ISeqable,
+  _EQ_,
+  vector_QMARK_,
+  seq,
+} from './core.js';
+
+// shared defrecord implementations: every record type points its protocol
+// slots at these, so call sites stay monomorphic across record types
+function recordLookup(rec, k, nf) {
+  const v = rec[k];
+  return v === undefined ? nf : v;
+}
+function recordCopy(rec) {
+  return Object.assign(Object.create(Object.getPrototypeOf(rec)), rec);
+}
+function recordAssoc(rec, k, v) {
+  const r = recordCopy(rec);
+  r[k] = v;
+  return r;
+}
+function recordContains(rec, k) {
+  return Object.prototype.hasOwnProperty.call(rec, k);
+}
+function recordDissoc(rec, k) {
+  // removing a basis field demotes to a plain map, like CLJS
+  if (rec[IRecord.__sym].includes(k)) {
+    const m = { ...rec };
+    delete m[k];
+    return m;
+  }
+  const r = recordCopy(rec);
+  delete r[k];
+  return r;
+}
+function recordCount(rec) {
+  return Object.keys(rec).length;
+}
+function recordKvReduce(rec, f, init) {
+  let acc = init;
+  for (const k of Object.keys(rec)) acc = f(acc, k, rec[k]);
+  return acc;
+}
+function recordConj(rec, x) {
+  if (vector_QMARK_(x)) return recordAssoc(rec, x[0], x[1]);
+  let r = rec;
+  for (const e of seq(x) ?? []) r = recordAssoc(r, e[0], e[1]);
+  return r;
+}
+function recordEquiv(rec, other) {
+  if (other == null || Object.getPrototypeOf(rec) !== Object.getPrototypeOf(other)) return false;
+  const ka = Object.keys(rec);
+  if (ka.length !== Object.keys(other).length) return false;
+  for (const k of ka) {
+    if (!Object.prototype.hasOwnProperty.call(other, k) || !_EQ_(rec[k], other[k])) return false;
+  }
+  return true;
+}
+function recordSeq(rec) {
+  return seq(Object.entries(rec));
+}
+
+export function attach(proto, basis, aliases) {
+  proto[IRecord.__sym] = basis;
+  proto[ILookup__lookup] = recordLookup;
+  proto[IAssociative__assoc] = recordAssoc;
+  proto[IAssociative__contains_key_QMARK_] = recordContains;
+  proto[IMap__dissoc] = recordDissoc;
+  proto[ICounted__count] = recordCount;
+  proto[IKVReduce__kv_reduce] = recordKvReduce;
+  proto[ICollection__conj] = recordConj;
+  proto[IEquiv__equiv] = recordEquiv;
+  proto[ISeqable__seq] = recordSeq;
+  proto[ISeqable.__sym] = true;
+  proto[Symbol.iterator] = function* () {
+    for (const k of Object.keys(this)) yield [k, this[k]];
+  };
+  Object.defineProperty(proto, Symbol.toStringTag, {
+    get() { return this.constructor.name; },
+  });
+  proto[Symbol.for('nodejs.util.inspect.custom')] = function (_depth, opts, inspect) {
+    return '#' + this.constructor.name + ' ' + inspect({ ...this }, opts);
+  };
+  if (aliases !== undefined) {
+    for (const munged of Object.keys(aliases)) {
+      const field = aliases[munged];
+      Object.defineProperty(proto, munged, {
+        get() { return this[field]; },
+      });
+    }
+  }
+  return null;
+}

package/src/squint/set.js

@@ -1,43 +1,120 @@
 import * as core from './core.js';
+import {
+  ICounted__count,
+  IAssociative__contains_key_QMARK_,
+  ICollection__conj,
+  ISet__disjoin,
+  IEditableCollection__as_transient,
+  ITransientCollection__conj_BANG_,
+  ITransientCollection__persistent_BANG_,
+  ITransientSet__disjoin_BANG_,
+} from './core.js';
 
 function _bubble_max_key(k, coll) {
   const max = core.max_key(k, ...coll);
   return [max, ...coll.filter(x => x !== max)];
 }
 
+// a js/Set or set-like with reference .has/.add (SortedSet); a persistent
+// set from squint.immutable dispatches through core instead
+function jsSetLike(x) {
+  return x instanceof Set || (x != null && typeof x.has === 'function' && typeof x.add === 'function');
+}
+
+// the persistent paths dispatch through the slot symbols directly: the
+// symbols are tiny consts, where the core wrapper fns (count, conj!, ...)
+// drag their whole dispatch chains into js-Set-only bundles
+function setSize(x) {
+  return typeof x.size === 'number' ? x.size : x[ICounted__count](x);
+}
+
+function setHas(x, e) {
+  return jsSetLike(x) ? x.has(e) : x[IAssociative__contains_key_QMARK_](x, e);
+}
+
+// fold elements into a copy of target, preserving its type: js/Set mutates a
+// copy, a protocol set goes through its transient when it has one and folds
+// persistent -conj otherwise (a set type need not implement transients)
+function addAll(target, elems) {
+  if (jsSetLike(target)) {
+    const res = new Set(target);
+    for (const e of elems) res.add(e);
+    return res;
+  }
+  const es = core.iterable(elems);
+  if (target[IEditableCollection__as_transient] !== undefined) {
+    let t = target[IEditableCollection__as_transient](target);
+    for (const e of es) t = t[ITransientCollection__conj_BANG_](t, e);
+    return t[ITransientCollection__persistent_BANG_](t);
+  }
+  let res = target;
+  for (const e of es) res = res[ICollection__conj](res, e);
+  return res;
+}
+
+// remove each elem for which pred is true, preserving the set's type
+function removeWhere(xset, pred) {
+  const es = core.iterable(xset);
+  if (xset[IEditableCollection__as_transient] !== undefined) {
+    let t = xset[IEditableCollection__as_transient](xset);
+    for (const e of es) {
+      if (pred(e)) t = t[ITransientSet__disjoin_BANG_](t, e);
+    }
+    return t[ITransientCollection__persistent_BANG_](t);
+  }
+  let res = xset;
+  for (const e of es) {
+    if (pred(e)) res = res[ISet__disjoin](res, e);
+  }
+  return res;
+}
+
 function _intersection2(x, y) {
-  if (x.size > y.size) {
+  if (setSize(x) > setSize(y)) {
     const tmp = y;
     y = x;
     x = tmp;
   }
-  const res = new Set();
-  for (const elem of x) {
-    if (y.has(elem)) {
-      res.add(elem);
+  if (jsSetLike(x)) {
+    const res = new Set();
+    for (const elem of x) {
+      if (setHas(y, elem)) {
+        res.add(elem);
+      }
     }
+    return res;
   }
-  return res;
+  // protocol set: disj the non-members, keeping the type and sharing
+  return removeWhere(x, (elem) => !setHas(y, elem));
 }
 
 export function intersection(...xs) {
   switch (xs.length) {
     case 0: return null;
     case 1: return xs[0];
-    case 2: return xs[0].size > xs[1].size ?
-      _intersection2(xs[0], xs[1]) :
-      _intersection2(xs[1], xs[0]);
-    default: return _bubble_max_key((x) => 0 - x.size, xs).reduce(_intersection2);
+    case 2: return _intersection2(xs[0], xs[1]);
+    default: return _bubble_max_key((x) => 0 - setSize(x), xs).reduce(_intersection2);
   }
 }
 
 function _difference2(x, y) {
-  const res = new Set();
-  for (const elem of x) {
-    if (!y.has(elem)) {
-      res.add(elem);
+  if (jsSetLike(x)) {
+    const res = new Set();
+    for (const elem of x) {
+      if (!setHas(y, elem)) {
+        res.add(elem);
+      }
     }
+    return res;
+  }
+  const ys = core.iterable(y);
+  if (x[IEditableCollection__as_transient] !== undefined) {
+    let t = x[IEditableCollection__as_transient](x);
+    for (const elem of ys) t = t[ITransientSet__disjoin_BANG_](t, elem);
+    return t[ITransientCollection__persistent_BANG_](t);
   }
+  let res = x;
+  for (const elem of ys) res = res[ISet__disjoin](res, elem);
   return res;
 }
 
@@ -51,32 +128,31 @@ export function difference(...xs) {
 }
 
 function _union2(x, y) {
-  const res = new Set(x);
-  for (const elem of y) {
-    res.add(elem);
+  if (setSize(x) < setSize(y)) {
+    const tmp = y;
+    y = x;
+    x = tmp;
   }
-  return res;
+  return addAll(x, y);
 }
 
 export function union(...xs) {
   switch (xs.length) {
     case 0: return null;
     case 1: return xs[0];
-    case 2: return xs[0].size > xs[1].size ?
-      _union2(xs[0], xs[1]) :
-      _union2(xs[1], xs[0]);
-    default: return _bubble_max_key((x) => x.size, xs).reduce(_union2);
+    case 2: return _union2(xs[0], xs[1]);
+    default: return _bubble_max_key((x) => setSize(x), xs).reduce(_union2);
   }
 }
 
 function _subset_QMARK_2(x, y) {
-  for (const elem of x) {
-    if (!y.has(elem)) {
+  for (const elem of core.iterable(x)) {
+    if (!setHas(y, elem)) {
       return false;
     }
   }
   return true;
-} 
+}
 
 export function subset_QMARK_(x, y) {
   if (x === undefined) {
@@ -85,21 +161,12 @@ export function subset_QMARK_(x, y) {
   if (y === undefined) {
     return false;
   }
-  if (x.size > y.size) {
+  if (setSize(x) > setSize(y)) {
     return false;
   }
   return _subset_QMARK_2(x, y);
 }
 
-function _superset_QMARK_2(x, y) {
-  for (const elem of x) {
-    if (!y.has(elem)) {
-      return false;
-    }
-  }
-  return true;
-}
-
 export function superset_QMARK_(x, y) {
   if (x === undefined) {
     return true;
@@ -107,28 +174,44 @@ export function superset_QMARK_(x, y) {
   if (y === undefined) {
     return true;
   }
-  if (x.size < y.size) {
+  if (setSize(x) < setSize(y)) {
     return false;
   }
-  return _superset_QMARK_2(y, x);
+  return _subset_QMARK_2(y, x);
 }
 
 export function select(pred, xset) {
   if (xset === undefined) {
     return null;
   }
-  const res = new Set();
-  for (const elem of xset) {
-    if (core.truth_(pred(elem))) {
-      res.add(elem);
+  if (jsSetLike(xset)) {
+    const res = new Set();
+    for (const elem of xset) {
+      if (core.truth_(pred(elem))) {
+        res.add(elem);
+      }
     }
+    return res;
   }
-  return res;
+  return removeWhere(xset, (elem) => !core.truth_(pred(elem)));
+}
+
+// true when m is an immutable slot-map: mutate-in-place helpers would corrupt it
+function slotMap(m) {
+  return m != null && m[core.IAssociative__assoc] !== undefined;
 }
 
 export function rename_keys(map, kmap) {
   const ks = core.keys(kmap);
   let without = core.dissoc(map, ...ks);
+  if (slotMap(without)) {
+    return ks.reduce((m, k) => {
+      if (core.contains_QMARK_(map, k)) {
+        return core.assoc(m, core.get(kmap, k), core.get(map, k));
+      }
+      return m;
+    }, without);
+  }
   if (without === map) {
     without = {...map};
   }
@@ -142,18 +225,31 @@ export function rename_keys(map, kmap) {
 }
 
 export function rename(xrel, kmap) {
-  return core.set(core.map(x => rename_keys(x, kmap), xrel));
+  return into_set_like(xrel, core.map(x => rename_keys(x, kmap), xrel));
 }
 
 export function project(xrel, ...ks) {
-  return core.set(core.map(x => core.select_keys(x, ...ks), xrel));
+  return into_set_like(xrel, core.map(x => core.select_keys(x, ...ks), xrel));
+}
+
+// an empty set of the same kind as rel (a persistent set stays persistent),
+// filled from elems
+function into_set_like(rel, elems) {
+  const empty = rel != null && !jsSetLike(rel) && rel[ISet__disjoin] !== undefined
+    ? core.empty(rel)
+    : new Set();
+  return addAll(empty, elems);
 }
 
 export function map_invert(xmap) {
   if (xmap === undefined) {
     return {};
   }
-  return core.reduce_kv((m, k, v) => core.assoc_BANG_(m, v, k), core.empty(xmap), xmap);
+  const empty = core.empty(xmap);
+  if (slotMap(empty)) {
+    return core.reduce_kv((m, k, v) => core.assoc(m, v, k), empty, xmap);
+  }
+  return core.reduce_kv((m, k, v) => core.assoc_BANG_(m, v, k), empty, xmap);
 }
 
 export function join(xrel, yrel, kmap) {
@@ -179,4 +275,4 @@ export function join(xrel, yrel, kmap) {
       return found ? core.reduce((acc, y) => acc.add(core.merge(y, x)), ret, found) : ret;
     }, new Set(), s);
   }
-}
+}