squint-cljs 0.14.196 → 0.14.198

package/src/squint/core.js

@@ -20,6 +20,28 @@ function findKey(iter, tar, key) {
   }
 }
 
+function isSortedMap(m) {
+  return m != null && m[SORTED_TAG] === true && m[TYPE_TAG] === MAP_TYPE;
+}
+function isMapLike(m) {
+  return (
+    m != null &&
+    typeof m === 'object' &&
+    (m.constructor === Object || m instanceof Map || m[TYPE_TAG] === MAP_TYPE)
+  );
+}
+function mapHas(m, k) {
+  return m instanceof Map || m[TYPE_TAG] === MAP_TYPE ? m.has(k) : has.call(m, k);
+}
+function mapGet(m, k) {
+  return m instanceof Map || m[TYPE_TAG] === MAP_TYPE ? m.get(k) : m[k];
+}
+function mapCount(m) {
+  return m instanceof Map || m[TYPE_TAG] === MAP_TYPE
+    ? m.size
+    : Object.keys(m).length;
+}
+
 function dequal(foo, bar) {
   // supports primitives, Array, Set, Map and plain objects
   // like CLJS: does not support NaN
@@ -28,7 +50,21 @@ function dequal(foo, bar) {
   if (foo == null) return bar == null;
   var ctor, len, tmp;
 
+  // A sorted map compares by entries against any map type (object, Map, sorted).
+  const fooSorted = isSortedMap(foo);
+  if (fooSorted || isSortedMap(bar)) {
+    const sm = fooSorted ? foo : bar;
+    const other = sm === foo ? bar : foo;
+    if (!isMapLike(other) || mapCount(sm) !== mapCount(other)) return false;
+    for (const k of sm.keys()) {
+      if (!mapHas(other, k) || !dequal(sm.get(k), mapGet(other, k))) return false;
+    }
+    return true;
+  }
+
   if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+    if (ctor === Date) return foo.getTime() === bar.getTime();
+
     if (ctor === Array) {
       if ((len = foo.length) === bar.length) {
         while (len-- && dequal(foo[len], bar[len]));
@@ -219,7 +255,8 @@ function copyMeta(from, to) {
 function copy(o) {
   switch (typeConst(o)) {
     case MAP_TYPE:
-      return copyMeta(o, new Map(o));
+      // new o.constructor(o) preserves a SortedMap; for a plain Map it is new Map(o)
+      return copyMeta(o, new o.constructor(o));
     case SET_TYPE:
       return copyMeta(o, new o.constructor(o));
     case ARRAY_TYPE:
@@ -242,6 +279,14 @@ export function assoc(o, k, v, ...kvs) {
   return ret;
 }
 
+// squint has no distinct hash-map or array-map type; both build a plain object.
+export function hash_map(...kvs) {
+  if (kvs.length === 0) return {};
+  return assoc({}, ...kvs);
+}
+
+export const array_map = hash_map;
+
 const MAP_TYPE = 1;
 const ARRAY_TYPE = 2;
 const OBJECT_TYPE = 3;
@@ -251,16 +296,16 @@ const LAZY_ITERABLE_TYPE = 6;
 
 // type tag set in each collection ctor, read by typeConst (DCE: no instanceof).
 const TYPE_TAG = Symbol('squint.lang.type');
+const SORTED_TAG = Symbol('squint.lang.sorted');
 
-// @__NO_SIDE_EFFECTS__ lets bundlers drop unused calls, so a computed-key class
-// or IApply fn shakes out (neither does alone). See doc/dev/dce.md.
+// @__NO_SIDE_EFFECTS__ lets a bundler drop unused defclass/withApply calls; see doc/dev/dce.md
 // @__NO_SIDE_EFFECTS__
 function defclass(c) {
   return c;
 }
 // @__NO_SIDE_EFFECTS__
 function withApply(f, applyFn) {
-  f[IApply__apply] = applyFn;
+  f.squint$lang$variadic = applyFn;
   return f;
 }
 
@@ -392,17 +437,31 @@ function conj_BANG_set(o, rest) {
 }
 
 export function conj_BANG_(...xs) {
-  if (xs.length === 0) {
+  const n = xs.length;
+  if (n === 0) {
     return vector();
   }
 
-  const [_o, ...rest] = xs;
-
-  let o = _o;
+  let o = xs[0];
   if (o === null || o === undefined) {
     o = [];
   }
 
+  // Fast path for the common single-element conj! onto an array or set,
+  // avoiding the rest-array allocation and spread.
+  if (n === 2) {
+    switch (typeConst(o)) {
+      case ARRAY_TYPE:
+        o.push(xs[1]);
+        return o;
+      case SET_TYPE:
+        o.add(xs[1]);
+        return o;
+    }
+  }
+
+  const rest = xs.slice(1);
+
   switch (typeConst(o)) {
     case SET_TYPE:
       conj_BANG_set(o, rest);
@@ -443,6 +502,8 @@ export function conj(...xs) {
   }
 
   const [_o, ...rest] = xs;
+  // (conj coll) with nothing to add returns coll unchanged, including nil.
+  if (rest.length === 0) return _o;
 
   let o = _o;
   if (o === null || o === undefined) {
@@ -452,7 +513,8 @@ export function conj(...xs) {
 
   switch (typeConst(o)) {
     case SET_TYPE:
-      if (o instanceof SortedSet) {
+      // brand, not instanceof, so conj does not pin SortedSet
+      if (o[SORTED_TAG]) {
         // prevent re-sorting of collection
         return copyMeta(o, conj_BANG_set(new o.constructor(o), rest));
       } else {
@@ -503,11 +565,15 @@ export function disj_BANG_(s, ...xs) {
 
 export function disj(s, ...xs) {
   if (s == null) return s;
-  const s1 = new s.constructor([...s]);
+  // pass s itself (not a spread) so a SortedSet keeps its comparator
+  const s1 = new s.constructor(s);
   return disj_BANG_(s1, ...xs);
 }
 
 export function contains_QMARK_(coll, v) {
+  if (typeof coll === 'string') {
+    return int_QMARK_(v) && v >= 0 && v < coll.length;
+  }
   switch (typeConst(coll)) {
     case SET_TYPE:
     case MAP_TYPE:
@@ -530,19 +596,19 @@ export function dissoc_BANG_(m, ...ks) {
 export function dissoc(m, ...ks) {
   if (!m) return;
   if (ks.length === 0) return m;
+  if (typeConst(m) === MAP_TYPE) {
+    let present = false;
+    for (const k of ks) if (m.has(k)) { present = true; break; }
+    if (!present) return m;
+    const m2 = copy(m);
+    for (const k of ks) m2.delete(k);
+    return m2;
+  }
+  let present = false;
+  for (const k of ks) if (k in m) { present = true; break; }
+  if (!present) return m;
   const m2 = copy(m);
-  switch (typeConst(m)) {
-    case MAP_TYPE:
-      for (const k of ks) {
-        m2.delete(k);
-      }
-      break;
-    default:
-      for (const k of ks) {
-        delete m2[k];
-      }
-      break;
-  }
+  for (const k of ks) delete m2[k];
   return m2;
 }
 
@@ -643,7 +709,11 @@ export function seq_QMARK_(x) {
   return x != null && !!x[Symbol.iterator];
 }
 
-export const sequential_QMARK_ = seq_QMARK_;
+export function sequential_QMARK_(x) {
+  // vectors and lists are arrays; lazy seqs and cons carry the lazy brand.
+  // Sets, maps and strings are iterable but not sequential.
+  return Array.isArray(x) || x?.[TYPE_TAG] === LAZY_ITERABLE_TYPE;
+}
 
 export function seqable_QMARK_(x) {
   return (
@@ -700,11 +770,17 @@ export const es6_iterator = _iterator;
 
 export function seq(x) {
   if (x == null) return x;
+  // a string seqs into its characters, like CLJS.
+  if (typeof x === 'string') return x.length ? [...x] : null;
   const iter = iterable(x);
   // return nil for terminal checking
   if (iter.length === 0 || iter.size === 0) {
     return null;
   }
+  // a set is iterable but not sequential; materialize its elements.
+  if (iter instanceof Set || iter[TYPE_TAG] === SET_TYPE) {
+    return [...iter];
+  }
   const _i = iter[Symbol.iterator]();
   if (_i.next().done) return null;
   return iter;
@@ -1019,6 +1095,7 @@ function mapChunks(coll, xf) {
 export const Cons = defclass(
 class Cons {
   constructor(x, coll) {
+    this[TYPE_TAG] = LAZY_ITERABLE_TYPE;
     this.x = x;
     this.coll = coll;
   }
@@ -1351,6 +1428,19 @@ export function re_pattern(s) {
 }
 
 export function subvec(arr, start, end) {
+  if (!isVectorArray(arr)) {
+    throw new Error('subvec: argument must be a vector');
+  }
+  if (end === undefined) end = arr.length;
+  if (start == null || end == null) {
+    throw new Error('subvec: start and end must not be nil');
+  }
+  // CLJS coerces the indices with (int x) before bounds-checking.
+  start = start | 0;
+  end = end | 0;
+  if (start < 0 || end < start || end > arr.length) {
+    throw new Error('subvec: index out of bounds');
+  }
   return arr.slice(start, end);
 }
 
@@ -1426,20 +1516,39 @@ export function set_QMARK_(x) {
   return typeConst(x) === SET_TYPE;
 }
 
-const IApply__apply = Symbol('IApply__apply');
-
 export function apply(f, ...args) {
   f = __toFn(f);
   const xs = args.slice(0, args.length - 1);
-  const coll = iterable(args[args.length - 1]);
-  const af = f[IApply__apply];
-  if (af) {
-    return af(...xs, coll);
+  const last = args[args.length - 1];
+  // variadic impl hint; see doc/adr/0001
+  const v = f.squint$lang$variadic;
+  if (v) {
+    // pull maxfa fixed args (bounded, lazy-safe); more left -> variadic, else fixed
+    const maxfa = v.length - 1;
+    const fixed = [];
+    let i = 0, rest;
+    for (; i < maxfa && i < xs.length; i++) fixed.push(xs[i]);
+    if (i < maxfa) {
+      let s = seq(last);
+      for (; i < maxfa && s != null; i++) {
+        fixed.push(first(s));
+        s = next(s);
+      }
+      rest = s;
+    } else {
+      rest = i < xs.length ? concat1([xs.slice(i), last]) : last;
+    }
+    rest = rest == null ? null : seq(rest);
+    if (rest == null) return f(...fixed);
+    return v(...fixed, rest);
   }
-  return f(...xs, ...coll);
+  return f(...xs, ...iterable(last));
 }
 
 export function even_QMARK_(x) {
+  if (!Number.isInteger(x)) {
+    throw new Error(`Argument must be an integer: ${x}`);
+  }
   return x % 2 == 0;
 }
 
@@ -1465,7 +1574,7 @@ class List extends Array {
 }
 
 export function list_QMARK_(x) {
-  return typeConst(x) === LIST_TYPE;
+  return x?.[TYPE_TAG] === LIST_TYPE;
 }
 
 export function list(...args) {
@@ -1651,8 +1760,10 @@ export function partition_all(n, ...args) {
 }
 
 export function partition(n, ...args) {
+  // pad stays undefined for arity 1 and 2: only arity 4 provides a pad, which
+  // makes the final partial partition be emitted (padded when pad has elements).
   let step = n,
-    pad = [],
+    pad,
     coll = args[0];
 
   if (args.length === 2) {
@@ -1687,8 +1798,10 @@ function partitionInternal(n, step, pad, coll, all) {
     if (p.length > 0) {
       if (p.length === n || all) {
         yield p;
-      } else if (pad.length) {
-        p.push(...pad.slice(0, n - p.length));
+      } else if (pad !== undefined) {
+        if (pad != null) {
+          p.push(...[...iterable(pad)].slice(0, n - p.length));
+        }
         yield p;
       }
     }
@@ -1783,6 +1896,8 @@ export function empty(coll) {
 }
 
 export function merge(...args) {
+  // with no truthy maps, return nil like CLJS `(when (some identity maps) ...)`.
+  if (!args.some(truth_)) return null;
   // if the first arg is nil we coerce it into a map.
   const firstArg = args[0];
   let obj;
@@ -1874,20 +1989,16 @@ export function repeat(...args) {
   if (args.length == 0 || args.length > 2) {
     throw new Error(`Invalid arity: ${args.length}`);
   }
-
-  return {
-    [IIterable]: true,
-    [IIterable__iterator]:
-      args.length == 1
-        ? function* () {
-            const x = args[0];
-            while (true) yield x;
-          }
-        : function* () {
-            const [n, x] = args;
-            for (var i = 0; i < n; i++) yield x;
-          },
-  };
+  if (args.length == 1) {
+    const x = args[0];
+    return lazy(function* () {
+      while (true) yield x;
+    });
+  }
+  const [n, x] = args;
+  return lazy(function* () {
+    for (var i = 0; i < n; i++) yield x;
+  });
 }
 
 export function ensure_reduced(x) {
@@ -1939,6 +2050,8 @@ export function take_last(n, coll) {
       lastN[i % n] = x;
       i++;
     }
+    // an empty or nil coll has no last n elements; return nil like CLJS.
+    if (i === 0) return null;
     if (i % n !== 0 && i >= n) {
       return lastN.slice(i % n).concat(lastN.slice(0, i % n));
     } else {
@@ -2116,14 +2229,14 @@ export function update_in(coll, path, f, ...args) {
   return assoc_in(coll, path, f(get_in(coll, path), ...args));
 }
 
-export function fnil(f, x, ...xs) {
+export function fnil(f, ...defaults) {
   f = __toFn(f);
-  return function (a, ...args) {
-    if (!a) {
-      return f(x, ...xs, ...args);
-    } else {
-      return f(a, ...xs, ...args);
+  const n = defaults.length;
+  return function (...args) {
+    for (let i = 0; i < n; i++) {
+      if (args[i] == null) args[i] = defaults[i];
     }
+    return f(...args);
   };
 }
 
@@ -2297,7 +2410,10 @@ export function repeatedly(n, f) {
     n = undefined;
   }
   const res = _repeatedly(f);
-  if (n) {
+  if (n !== undefined) {
+    if (typeof n !== 'number') {
+      throw new Error('repeatedly: count must be a number, got: ' + str(n));
+    }
     return take(n, res);
   } else {
     return res;
@@ -2332,6 +2448,11 @@ export function frequencies(coll) {
 // The lazy-seq macro emits `new LazySeq(() => body)`: a LazyIterable whose step
 // evaluates the body thunk on first force and reads it unchunked.
 export class LazySeq extends LazyIterable {
+  // Core fns build the base LazyIterable, not this subclass, so widen
+  // instanceof to any lazy cell for `(instance? LazySeq x)` parity with CLJS.
+  static [Symbol.hasInstance](x) {
+    return x instanceof LazyIterable;
+  }
   constructor(f) {
     super(() => unchunkedSteps(es6_iterator(iterable(f())))());
   }
@@ -2383,7 +2504,7 @@ export function some_QMARK_(x) {
 }
 
 export function boolean$(x) {
-  return !!x;
+  return truth_(x);
 }
 
 export function zero_QMARK_(x) {
@@ -2457,11 +2578,13 @@ export function aclone(arr) {
 }
 
 export function add_watch(ref, key, fn) {
-  return ref._add_watch(key, fn);
+  ref._add_watch(key, fn);
+  return ref;
 }
 
 export function remove_watch(ref, key) {
-  return ref._remove_watch(key);
+  ref._remove_watch(key);
+  return ref;
 }
 
 export function reduce_kv(f, init, m) {
@@ -2493,6 +2616,7 @@ export function map_QMARK_(coll) {
   if (coll == null) return false;
   if (isObj(coll)) return true;
   if (coll instanceof Map) return true;
+  if (coll[TYPE_TAG] === MAP_TYPE) return true;
   return false;
 }
 
@@ -2675,25 +2799,33 @@ export function keys(obj) {
   if (obj == null) return;
   const t = typeConst(obj);
   switch (t) {
-    case OBJECT_TYPE:
-      return Object.keys(obj);
+    case OBJECT_TYPE: {
+      const ks = Object.keys(obj);
+      if (ks.length) return ks;
+      return;
+    }
     case MAP_TYPE:
-      return Array.from(obj.keys());
+      if (obj.size) return Array.from(obj.keys());
+      return;
   }
 }
 
 export function js_keys(obj) {
-  return keys(obj);
+  return keys(obj) ?? [];
 }
 
 export function vals(obj) {
   if (obj == null) return;
   const t = typeConst(obj);
   switch (t) {
-    case OBJECT_TYPE:
-      return Object.values(obj);
+    case OBJECT_TYPE: {
+      const vs = Object.values(obj);
+      if (vs.length) return vs;
+      return;
+    }
     case MAP_TYPE:
-      return Array.from(obj.values());
+      if (obj.size) return Array.from(obj.values());
+      return;
   }
 }
 
@@ -2836,6 +2968,13 @@ export function with_meta(x, m) {
     wrapped[_metaSym] = m;
     return wrapped;
   }
+  // A lazy seq or cons is not copied element-wise: clone the head so the new
+  // value carries its own metadata without forcing realization.
+  if (x?.[TYPE_TAG] === LAZY_ITERABLE_TYPE) {
+    const ret = Object.assign(Object.create(Object.getPrototypeOf(x)), x);
+    ret[_metaSym] = m;
+    return ret;
+  }
   const ret = copy(x);
   ret[_metaSym] = m;
   return ret;
@@ -3051,11 +3190,13 @@ export function persistent_BANG_(x) {
 
 const SortedSet = defclass(
 class SortedSet {
-  constructor(xs) {
+  constructor(xs, cmp) {
     this[TYPE_TAG] = SET_TYPE;
-    const isSorted = xs instanceof SortedSet;
+    this[SORTED_TAG] = true;
+    this._cmp = cmp ?? xs?._cmp;
+    const isSorted = xs instanceof SortedSet && xs._cmp === this._cmp;
     if (!isSorted) {
-      xs = sort(xs);
+      xs = this._cmp ? sort(this._cmp, xs) : sort(xs);
     }
     const s = new Set(xs);
     // we don't re-use xs since xs can contain duplicates
@@ -3065,9 +3206,10 @@ class SortedSet {
   add(x) {
     if (this._set.has(x)) return this;
     const xs = this._elts;
+    const cmp = this._cmp;
     let added = false;
     for (let i = 0; i < xs.length; i++) {
-      if (compare(x, xs[i]) <= 0) {
+      if ((cmp ? cmp(x, xs[i]) : compare(x, xs[i])) <= 0) {
         xs.splice(i, 0, x);
         added = true;
         break;
@@ -3121,6 +3263,85 @@ export function sorted_set(...xs) {
   return new SortedSet(xs);
 }
 
+export function sorted_set_by(cmp, ...xs) {
+  return new SortedSet(xs, fnToComparator(__toFn(cmp)));
+}
+
+// A map that keeps its keys in sorted order. Backed by a sorted key array plus
+// a plain Map for lookup, and branded MAP_TYPE so map ops dispatch normally.
+const SortedMap = defclass(
+class SortedMap {
+  constructor(entries, cmp) {
+    this[TYPE_TAG] = MAP_TYPE;
+    this[SORTED_TAG] = true;
+    this._cmp = cmp ?? entries?._cmp;
+    this._map = new Map();
+    this._keys = [];
+    this.size = 0;
+    if (entries) {
+      for (const [k, v] of entries) this.set(k, v);
+    }
+  }
+  set(k, v) {
+    if (!this._map.has(k)) {
+      const ks = this._keys;
+      const cmp = this._cmp;
+      let i = 0;
+      while (i < ks.length && (cmp ? cmp(k, ks[i]) : compare(k, ks[i])) > 0) i++;
+      ks.splice(i, 0, k);
+    }
+    this._map.set(k, v);
+    this.size = this._map.size;
+    return this;
+  }
+  get(k) {
+    return this._map.get(k);
+  }
+  has(k) {
+    return this._map.has(k);
+  }
+  delete(k) {
+    if (this._map.delete(k)) {
+      this._keys.splice(this._keys.indexOf(k), 1);
+      this.size = this._map.size;
+    }
+    return this;
+  }
+  *keys() {
+    yield* this._keys;
+  }
+  *values() {
+    for (const k of this._keys) yield this._map.get(k);
+  }
+  *entries() {
+    for (const k of this._keys) yield [k, this._map.get(k)];
+  }
+  forEach(f) {
+    for (const k of this._keys) f(this._map.get(k), k, this);
+  }
+  clear() {
+    this._map.clear();
+    this._keys = [];
+    this.size = 0;
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+}
+);
+
+export function sorted_map(...kvs) {
+  const m = new SortedMap();
+  for (let i = 0; i < kvs.length; i += 2) m.set(kvs[i], kvs[i + 1]);
+  return m;
+}
+
+export function sorted_map_by(cmp, ...kvs) {
+  const m = new SortedMap(null, fnToComparator(__toFn(cmp)));
+  for (let i = 0; i < kvs.length; i += 2) m.set(kvs[i], kvs[i + 1]);
+  return m;
+}
+
 function mkBoundFn(_sc, test, key) {
   return (e) => {
     return test(compare(e, key), 0);
@@ -3186,6 +3407,14 @@ export function long$(x) {
   return fix(x);
 }
 
+export function float$(x) {
+  return x;
+}
+
+export function double$(x) {
+  return x;
+}
+
 export function type(x) {
   return x != null && x.constructor;
 }
@@ -3200,7 +3429,7 @@ function preserving_reduced(rf) {
 }
 
 export function cat(rf) {
-  rf = preserving_reduced(rf);
+  const rrf = preserving_reduced(rf);
   return (...args) => {
     switch (args.length) {
       case 0:
@@ -3208,7 +3437,7 @@ export function cat(rf) {
       case 1:
         return rf(args[0]);
       case 2:
-        return reduce(rf, args[0], args[1]);
+        return reduce(rrf, args[0], args[1]);
     }
   };
 }
@@ -3232,7 +3461,11 @@ export function memoize(f) {
 }
 
 export function peek(vec) {
-  if (array_QMARK_(vec)) {
+  // A list peeks at its front; squint lists are array-backed, so check list
+  // before array to avoid returning the last element.
+  if (list_QMARK_(vec)) {
+    return first(vec);
+  } else if (array_QMARK_(vec)) {
     return vec[vec.length - 1];
   } else {
     return first(vec);
@@ -3240,7 +3473,12 @@ export function peek(vec) {
 }
 
 export function pop(vec) {
-  if (array_QMARK_(vec)) {
+  if (vec == null) return null;
+  if (list_QMARK_(vec)) {
+    if (vec.length === 0) throw new Error("Can't pop empty list");
+    return rest(vec);
+  } else if (array_QMARK_(vec)) {
+    if (vec.length === 0) throw new Error("Can't pop empty vector");
     const ret = [...vec];
     ret.pop();
     return ret;
@@ -3279,6 +3517,27 @@ export function random_uuid() {
   return crypto.randomUUID();
 }
 
+export class UUID {
+  constructor(uuid) {
+    this.uuid = uuid;
+  }
+  toString() {
+    return this.uuid;
+  }
+}
+
+export function uuid(s) {
+  return new UUID(s);
+}
+
+export function uuid_QMARK_(x) {
+  return x instanceof UUID;
+}
+
+export function inst_QMARK_(x) {
+  return x instanceof Date;
+}
+
 export class Delay {
   constructor(f) {
     this.f = f;
@@ -3294,6 +3553,13 @@ export class Delay {
   }
 }
 
+export function realized_QMARK_(x) {
+  if (x instanceof Delay || x instanceof LazyIterable) {
+    return x.realized === true;
+  }
+  throw new Error('realized? not supported on: ' + str(x));
+}
+
 function clj__GT_js_(x, seen) {
   // we need to protect against circular objects
   if (seen.has(x)) return x;
@@ -3353,6 +3619,7 @@ function toEDN(value, seen = new WeakSet(), readably = true) {
   if (typeof value === 'bigint') return `${value}N`;
 
   if (typeof value === 'object') {
+    if (value instanceof UUID) return readably ? `#uuid "${value.uuid}"` : value.uuid;
     // seen tracks the current ancestor path only. A shared reference that
     // appears under sibling branches is a DAG, not a cycle, so delete on exit.
     if (seen.has(value)) return '#object[circular]';