squint-cljs 0.14.199 → 0.14.201

package/src/squint/core.js

@@ -23,6 +23,9 @@ function findKey(iter, tar, key) {
 function isSortedMap(m) {
   return m != null && m[SORTED_TAG] === true && m[TYPE_TAG] === MAP_TYPE;
 }
+function isSetLike(s) {
+  return s != null && (s instanceof Set || s[TYPE_TAG] === SET_TYPE);
+}
 function isMapLike(m) {
   return (
     m != null &&
@@ -62,8 +65,33 @@ function dequal(foo, bar) {
     return true;
   }
 
+  // A plain object and a js/Map are both map reps; compare by entries.
+  // Same-type pairs skip this and keep their fast paths below.
+  if (isMapLike(foo) && isMapLike(bar) && foo.constructor !== bar.constructor) {
+    if (mapCount(foo) !== mapCount(bar)) return false;
+    for (const k of foo instanceof Map ? foo.keys() : Object.keys(foo)) {
+      if (!mapHas(bar, k) || !dequal(mapGet(foo, k), mapGet(bar, k))) return false;
+    }
+    return true;
+  }
+
+  // Sets (hash or sorted) compare by elements, across concrete types.
+  if (isSetLike(foo) || isSetLike(bar)) {
+    if (!isSetLike(foo) || !isSetLike(bar) || foo.size !== bar.size) return false;
+    for (let e of foo) {
+      if (e && typeof e === 'object') {
+        e = findKey(bar, e);
+        if (!e) return false;
+      }
+      if (!bar.has(e)) return false;
+    }
+    return true;
+  }
+
   if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
     if (ctor === Date) return foo.getTime() === bar.getTime();
+    // regexes only compare by identity, like CLJS
+    if (ctor === RegExp) return false;
 
     if (ctor === Array) {
       if ((len = foo.length) === bar.length) {
@@ -72,21 +100,6 @@ function dequal(foo, bar) {
       return len === -1;
     }
 
-    if (ctor === Set) {
-      if (foo.size !== bar.size) {
-        return false;
-      }
-      for (const elt of foo) {
-        tmp = elt;
-        if (tmp && typeof tmp === 'object') {
-          tmp = findKey(bar, tmp);
-          if (!tmp) return false;
-        }
-        if (!bar.has(tmp)) return false;
-      }
-      return true;
-    }
-
     if (ctor === Map) {
       if (foo.size !== bar.size) {
         return false;
@@ -271,9 +284,24 @@ function copy(o) {
 }
 
 export function assoc(o, k, v, ...kvs) {
-  if (!o) {
+  // only nil puns to an empty map; assoc on false throws, like CLJS
+  if (o == null) {
     o = {};
   }
+  if (isVectorArray(o)) {
+    // like CLJS: a vector key is an index in [0, count], count appends
+    let len = o.length;
+    for (let i = 0; i < kvs.length + 2; i += 2) {
+      const key = i === 0 ? k : kvs[i - 2];
+      if (!Number.isInteger(key)) {
+        throw new Error("Vector's key for assoc must be a number.");
+      }
+      if (key < 0 || key > len) {
+        throw new Error(`Index ${key} out of bounds [0,${len}]`);
+      }
+      if (key === len) len++;
+    }
+  }
   const ret = copy(o);
   assoc_BANG_(ret, k, v, ...kvs);
   return ret;
@@ -282,6 +310,9 @@ export function assoc(o, k, v, ...kvs) {
 // 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 {};
+  if (kvs.length % 2 !== 0) {
+    throw new Error('No value supplied for key: ' + kvs[kvs.length - 1]);
+  }
   return assoc({}, ...kvs);
 }
 
@@ -355,6 +386,8 @@ function typeConst(obj) {
   const tag = obj[TYPE_TAG];
   if (tag !== undefined) return tag;
   if (isVectorArray(obj)) return ARRAY_TYPE;
+  // any remaining object (class instance, null-proto) is associative
+  if (typeof obj === 'object') return OBJECT_TYPE;
 
   return undefined;
 }
@@ -441,6 +474,10 @@ export function conj_BANG_(...xs) {
   if (n === 0) {
     return vector();
   }
+  // single arg: return the coll unchanged, including nil, like CLJS
+  if (n === 1) {
+    return xs[0];
+  }
 
   let o = xs[0];
   if (o === null || o === undefined) {
@@ -474,17 +511,14 @@ export function conj_BANG_(...xs) {
       break;
     case MAP_TYPE:
       for (const x of rest) {
-        if (!Array.isArray(x))
-          iterable(x).forEach((kv) => {
-            o.set(kv[0], kv[1]);
-          });
-        else o.set(x[0], x[1]);
+        if (isVectorArray(x)) { asMapEntry(x); o.set(x[0], x[1]); }
+        else for (const kv of mapEntriesOf(x)) o.set(kv[0], kv[1]);
       }
       break;
     case OBJECT_TYPE:
       for (const x of rest) {
-        if (!Array.isArray(x)) Object.assign(o, x);
-        else o[x[0]] = x[1];
+        if (isVectorArray(x)) { asMapEntry(x); o[x[0]] = x[1]; }
+        else for (const kv of mapEntriesOf(x)) o[kv[0]] = kv[1];
       }
       break;
     default:
@@ -496,6 +530,28 @@ export function conj_BANG_(...xs) {
   return o;
 }
 
+// entries carried by a non-entry conj arg onto a map: a map merges, a
+// seqable must contain entry vectors, like CLJS
+function* mapEntriesOf(x) {
+  if (isMapLike(x)) {
+    yield* iterable(x);
+    return;
+  }
+  for (const kv of iterable(x)) {
+    if (!isVectorArray(kv)) {
+      throw new Error('conj on a map takes map entries or seqables of map entries');
+    }
+    yield kv;
+  }
+}
+
+function asMapEntry(x) {
+  if (x.length < 2) {
+    throw new Error('Vector arg to map conj must be a pair');
+  }
+  return x;
+}
+
 export function conj(...xs) {
   if (xs.length === 0) {
     return vector();
@@ -527,11 +583,8 @@ export function conj(...xs) {
     case MAP_TYPE:
       m = new Map(o);
       for (const x of rest) {
-        if (!Array.isArray(x))
-          iterable(x).forEach((kv) => {
-            m.set(kv[0], kv[1]);
-          });
-        else m.set(x[0], x[1]);
+        if (isVectorArray(x)) { asMapEntry(x); m.set(x[0], x[1]); }
+        else for (const kv of mapEntriesOf(x)) m.set(kv[0], kv[1]);
       }
 
       return copyMeta(o, m);
@@ -544,8 +597,8 @@ export function conj(...xs) {
       o2 = { ...o };
 
       for (const x of rest) {
-        if (!Array.isArray(x)) Object.assign(o2, x);
-        else o2[x[0]] = x[1];
+        if (isVectorArray(x)) { asMapEntry(x); o2[x[0]] = x[1]; }
+        else for (const kv of mapEntriesOf(x)) o2[kv[0]] = kv[1];
       }
 
       return copyMeta(o, o2);
@@ -567,7 +620,7 @@ export function disj(s, ...xs) {
   if (s == null) return s;
   // pass s itself (not a spread) so a SortedSet keeps its comparator
   const s1 = new s.constructor(s);
-  return disj_BANG_(s1, ...xs);
+  return copyMeta(s, disj_BANG_(s1, ...xs));
 }
 
 export function contains_QMARK_(coll, v) {
@@ -596,7 +649,11 @@ 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) {
+  const tc = typeConst(m);
+  if (tc !== MAP_TYPE && tc !== OBJECT_TYPE) {
+    throw new Error('dissoc expects a map, got: ' + typeof m);
+  }
+  if (tc === MAP_TYPE) {
     let present = false;
     for (const k of ks) if (m.has(k)) { present = true; break; }
     if (!present) return m;
@@ -638,6 +695,9 @@ export function pr(...xs) {
 }
 
 export function nth(coll, idx, orElse) {
+  if (typeof idx !== 'number') {
+    throw new Error('Index argument to nth must be a number');
+  }
   const hasDefault = arguments.length > 2;
   // nil coll puns to nil, like Clojure
   if (coll == null) return hasDefault ? orElse : null;
@@ -724,7 +784,8 @@ export function seqable_QMARK_(x) {
     object_QMARK_(x) ||
     // we used to check instanceof Object but this returns false for TC39 Records
     // also we used to write `Symbol.iterator in` but this does not work for strings and some other types
-    !!x[Symbol.iterator]
+    !!x[Symbol.iterator] ||
+    !!x[ISEQABLE_SYM]
   );
 }
 
@@ -754,6 +815,8 @@ export function iterable(x) {
   if (x[Symbol.iterator]) {
     return x;
   }
+  // a type extended to ISeqable seqs through its -seq method
+  if (x[ISeqable__seq] !== undefined) return iterable(x[ISeqable__seq](x));
   if (x instanceof Object) return Object.entries(x).map(tagMapEntry);
   throw new TypeError(`${x} is not iterable`);
 }
@@ -770,6 +833,7 @@ export const es6_iterator = _iterator;
 
 export function seq(x) {
   if (x == null) return x;
+  if (!seqable_QMARK_(x)) throw new TypeError(x + ' is not ISeqable');
   // a string seqs into its characters, like CLJS.
   if (typeof x === 'string') return x.length ? [...x] : null;
   const iter = iterable(x);
@@ -830,13 +894,13 @@ export function rest(coll) {
   return cell._rest; // first chunk had one element; the next cell is the rest
 }
 
+const REDUCED_DEREF = (self) => self.value;
+
 class Reduced {
   value;
   constructor(x) {
     this.value = x;
-  }
-  _deref() {
-    return this.value;
+    this[IDeref__deref] = REDUCED_DEREF;
   }
 }
 
@@ -996,12 +1060,12 @@ class LazyIterable {
       },
     };
   }
-  // CLJS supports (.indexOf coll x) on seqs; mirror it so lazy seqs work like
-  // arrays. Uses value equality, like cljs.core, and returns -1 when absent.
+  // Mirrors Array.prototype.indexOf so lazy seqs support (.indexOf coll x):
+  // reference equality, returns -1 when absent. Unlike cljs.core, not by value.
   indexOf(x, fromIndex = 0) {
     let i = 0;
     for (const v of this) {
-      if (i >= fromIndex && dequal(v, x)) return i;
+      if (i >= fromIndex && v === x) return i;
       i++;
     }
     return -1;
@@ -1125,6 +1189,8 @@ class Cons {
 );
 
 export function cons(x, coll) {
+  // like CLJS cons, which seqs a non-ISeq tail
+  if (!seqable_QMARK_(coll)) throw new TypeError(coll + ' is not ISeqable');
   return new Cons(x, coll);
 }
 
@@ -1288,48 +1354,167 @@ export function nil_QMARK_(v) {
 
 export const PROTOCOL_SENTINEL = {};
 
+// marker protocols so (satisfies? IAtom x) works, like CLJS. Marked in the
+// constructor, not on the prototype, so no top-level mutation pins Atom
+// into bundles that do not use it.
+const IATOM_SYM = Symbol('squint.core.IAtom');
+const IDEREF_SYM = Symbol('squint.core.IDeref');
+const ISEQABLE_SYM = Symbol('squint.core.ISeqable');
+export const IAtom = { __sym: IATOM_SYM };
+export const IDeref = { __sym: IDEREF_SYM };
+// method slot for (-deref x), named like the defprotocol emission so
+// (extend-type T IDeref (-deref [x] ...)) fills it
+export const IDeref__deref = Symbol('IDeref_-deref');
+export function _deref(o) {
+  if (o != null && o[IDeref__deref] !== undefined) return o[IDeref__deref](o);
+  return nilImpl(_deref, 'IDeref.-deref', o)(o);
+}
+export const ISeqable = { __sym: ISEQABLE_SYM };
+export const ISeqable__seq = Symbol('ISeqable_-seq');
+export function _seq(o) {
+  if (o != null && o[ISeqable__seq] !== undefined) return o[ISeqable__seq](o);
+  return nilImpl(_seq, 'ISeqable.-seq', o)(o);
+}
+
+// an extend-type on nil stores the impl on the dispatch fn under null,
+// the same convention the generated protocol dispatch fns use
+function nilImpl(dispatchFn, protoMethod, o) {
+  const f = dispatchFn[null];
+  if (f === undefined) throw missing_protocol(protoMethod, o);
+  return f;
+}
+export const IReset = { __sym: Symbol('squint.core.IReset') };
+export const IReset__reset_BANG_ = Symbol('IReset_-reset!');
+export function _reset_BANG_(o, v) {
+  if (o != null && o[IReset__reset_BANG_] !== undefined) return o[IReset__reset_BANG_](o, v);
+  return nilImpl(_reset_BANG_, 'IReset.-reset!', o)(o, v);
+}
+export const ISwap = { __sym: Symbol('squint.core.ISwap') };
+export const ISwap__swap_BANG_ = Symbol('ISwap_-swap!');
+export function _swap_BANG_(o, f, ...args) {
+  if (o != null && o[ISwap__swap_BANG_] !== undefined) return o[ISwap__swap_BANG_](o, f, ...args);
+  return nilImpl(_swap_BANG_, 'ISwap.-swap!', o)(o, f, ...args);
+}
+export const IWatchable = { __sym: Symbol('squint.core.IWatchable') };
+export const IWatchable__add_watch = Symbol('IWatchable_-add-watch');
+export const IWatchable__remove_watch = Symbol('IWatchable_-remove-watch');
+export const IWatchable__notify_watches = Symbol('IWatchable_-notify-watches');
+export function _add_watch(o, k, f) {
+  if (o != null && o[IWatchable__add_watch] !== undefined) return o[IWatchable__add_watch](o, k, f);
+  return nilImpl(_add_watch, 'IWatchable.-add-watch', o)(o, k, f);
+}
+export function _remove_watch(o, k) {
+  if (o != null && o[IWatchable__remove_watch] !== undefined) return o[IWatchable__remove_watch](o, k);
+  return nilImpl(_remove_watch, 'IWatchable.-remove-watch', o)(o, k);
+}
+export function _notify_watches(o, oldv, newv) {
+  if (o != null && o[IWatchable__notify_watches] !== undefined) return o[IWatchable__notify_watches](o, oldv, newv);
+  return nilImpl(_notify_watches, 'IWatchable.-notify-watches', o)(o, oldv, newv);
+}
+
+// shared protocol impls: one fn per operation, a pointer per instance
+const ATOM_DEREF = (self) => self.val;
+const ATOM_RESET = (self, x) => {
+  if (self._validator && !truth_(self._validator(x))) {
+    throw new Error('Validator rejected reference state');
+  }
+  const old_val = self.val;
+  self.val = x;
+  if (self._hasWatches) {
+    for (const [k, f] of Object.entries(self._watches)) f(k, self, old_val, x);
+  }
+  return x;
+};
+const ATOM_SWAP = function (self, f, a, b, xs) {
+  switch (arguments.length) {
+    case 2:
+      return ATOM_RESET(self, f(self.val));
+    case 3:
+      return ATOM_RESET(self, f(self.val, a));
+    case 4:
+      return ATOM_RESET(self, f(self.val, a, b));
+    default:
+      return ATOM_RESET(self, f(self.val, a, b, ...xs));
+  }
+};
+const ATOM_ADD_WATCH = (self, k, f) => {
+  self._watches[k] = f;
+  self._hasWatches = true;
+};
+const ATOM_REMOVE_WATCH = (self, k) => {
+  delete self._watches[k];
+};
+const ATOM_NOTIFY = (self, oldv, newv) => {
+  for (const [k, f] of Object.entries(self._watches)) f(k, self, oldv, newv);
+};
+
 export class Atom {
   constructor(init) {
     this.val = init;
     this._watches = {};
-    this._deref = () => this.val;
     this._hasWatches = false;
-    this._reset_BANG_ = (x) => {
-      const old_val = this.val;
-      this.val = x;
-      if (this._hasWatches) {
-        for (const entry of Object.entries(this._watches)) {
-          const k = entry[0];
-          const f = entry[1];
-          f(k, this, old_val, x);
-        }
-      }
-      return x;
-    };
-    this._add_watch = (k, fn) => {
-      this._watches[k] = fn;
-      this._hasWatches = true;
-    };
-    this._remove_watch = (k) => {
-      delete this._watches[k];
-    };
-  }
-}
-
-export function atom(init) {
-  return new Atom(init);
+    this[IATOM_SYM] = true;
+    this[IDEREF_SYM] = true;
+    this[IDeref__deref] = ATOM_DEREF;
+    this[IReset.__sym] = true;
+    this[IReset__reset_BANG_] = ATOM_RESET;
+    this[ISwap.__sym] = true;
+    this[ISwap__swap_BANG_] = ATOM_SWAP;
+    this[IWatchable.__sym] = true;
+    this[IWatchable__add_watch] = ATOM_ADD_WATCH;
+    this[IWatchable__remove_watch] = ATOM_REMOVE_WATCH;
+    this[IWatchable__notify_watches] = ATOM_NOTIFY;
+  }
+}
+
+export function atom(init, ...opts) {
+  const a = new Atom(init);
+  for (let i = 0; i < opts.length; i += 2) {
+    if (opts[i] === 'meta') a[_metaSym] = opts[i + 1];
+    else if (opts[i] === 'validator') a._validator = opts[i + 1];
+  }
+  return a;
+}
+
+// the CLJS missing-protocol error, used by every protocol dispatch miss
+export function missing_protocol(proto, obj) {
+  let ty;
+  if (obj === null) ty = 'null';
+  else if (obj === undefined) ty = 'undefined';
+  else if (Array.isArray(obj)) ty = 'array';
+  else if (typeof obj === 'object' && obj.constructor && obj.constructor !== Object) {
+    ty = obj.constructor.name;
+  } else ty = typeof obj;
+  return new Error(
+    `No protocol method ${proto} defined for type ${ty}: ${obj ?? ''}`
+  );
 }
 
 export function deref(ref) {
-  return ref._deref();
+  if (ref?.[IDeref__deref] !== undefined) return ref[IDeref__deref](ref);
+  return nilImpl(_deref, 'IDeref.-deref', ref)(ref);
 }
 
 export function reset_BANG_(atm, v) {
-  atm._reset_BANG_(v);
+  if (atm?.[IReset__reset_BANG_] !== undefined) return atm[IReset__reset_BANG_](atm, v);
+  return nilImpl(_reset_BANG_, 'IReset.-reset!', atm)(atm, v);
 }
 
 export function swap_BANG_(atm, f, ...args) {
   f = __toFn(f);
+  if (atm?.[ISwap__swap_BANG_] !== undefined) {
+    // the CLJS -swap! contract: up to two positional args, the rest packed
+    switch (args.length) {
+      case 0:
+        return atm[ISwap__swap_BANG_](atm, f);
+      case 1:
+        return atm[ISwap__swap_BANG_](atm, f, args[0]);
+      case 2:
+        return atm[ISwap__swap_BANG_](atm, f, args[0], args[1]);
+      default:
+        return atm[ISwap__swap_BANG_](atm, f, args[0], args[1], args.slice(2));
+    }
+  }
   const v = f(deref(atm), ...args);
   reset_BANG_(atm, v);
   return v;
@@ -1339,19 +1524,19 @@ export function swap_vals_BANG_(atm, f, ...args) {
   const oldv = deref(atm);
   f = __toFn(f);
   const newv = f(oldv, ...args);
-  atm._reset_BANG_(newv);
+  reset_BANG_(atm, newv);
   return [oldv, newv];
 }
 
 export function reset_vals_BANG_(atm, newv) {
   const oldv = deref(atm);
-  atm._reset_BANG_(newv);
+  reset_BANG_(atm, newv);
   return [oldv, newv];
 }
 
 export function compare_and_set_BANG_(atm, oldv, newv) {
   if (deref(atm) === oldv) {
-    atm._reset_BANG_(newv);
+    reset_BANG_(atm, newv);
     return true;
   } else {
     return false;
@@ -1516,11 +1701,23 @@ export function set_QMARK_(x) {
   return typeConst(x) === SET_TYPE;
 }
 
+export function hash_set(...xs) {
+  return new Set(xs);
+}
+
+export function sorted_QMARK_(x) {
+  return x != null && x[SORTED_TAG] === true;
+}
+
+export function char_QMARK_(x) {
+  return typeof x === 'string' && x.length === 1;
+}
+
 export function apply(f, ...args) {
   f = __toFn(f);
   const xs = args.slice(0, args.length - 1);
   const last = args[args.length - 1];
-  // variadic impl hint; see doc/adr/0001
+  // variadic impl hint; see doc/ai/adr/0001
   const v = f.squint$lang$variadic;
   if (v) {
     // pull maxfa fixed args (bounded, lazy-safe); more left -> variadic, else fixed
@@ -1694,9 +1891,10 @@ export function interpose(sep, coll) {
 
 export function select_keys(o, ks) {
   const type = typeConst(o);
-  // ret could be object or array, but in the future, maybe we'll have an IEmpty protocol
-  const ret = emptyOfType(type) || {};
-  for (const k of ks) {
+  // always a map, like CLJS; a js/Map source keeps its rep
+  const ret = type === MAP_TYPE ? new Map() : {};
+  // iterable puns nil to no keys and a map to its entries, like CLJS seq
+  for (const k of iterable(ks)) {
     const v = get(o, k);
     if (v !== undefined) {
       assoc_BANG_(ret, k, v);
@@ -1903,6 +2101,9 @@ export function merge(...args) {
   let obj;
   if (firstArg === null || firstArg === undefined) {
     obj = {};
+  } else if (typeConst(firstArg) === undefined) {
+    // a non-collection passes through; conj! throws when maps follow, like CLJS
+    obj = firstArg;
   } else {
     obj = into(empty(firstArg), firstArg);
   }
@@ -2020,7 +2221,15 @@ function take1(n) {
   });
 }
 
+function assertNumber(n) {
+  if (typeof n !== 'number') {
+    throw new Error('Assert failed: (number? n)');
+  }
+  return n;
+}
+
 export function take(n, coll) {
+  assertNumber(n);
   if (arguments.length === 1) {
     return take1(n);
   }
@@ -2038,6 +2247,7 @@ export function take(n, coll) {
 }
 
 export function take_last(n, coll) {
+  assertNumber(n);
   if (n <= 0) {
     return null;
   }
@@ -2110,8 +2320,18 @@ export function partial(f, ...xs) {
 }
 
 export function cycle(coll) {
+  // seq the coll eagerly: nil or empty cycles to an empty seq and a
+  // non-iterable throws, like the seq call in CLJS cycle. The first lap
+  // is cached and replayed, like the retained seq in CLJS Cycle, so a
+  // one-shot iterator source cycles instead of ending after one lap.
+  const it = iterable(coll);
   return lazy(function* () {
-    while (true) yield* coll;
+    const cache = [];
+    for (const x of it) {
+      cache.push(x);
+      yield x;
+    }
+    while (cache.length) yield* cache;
   });
 }
 
@@ -2123,6 +2343,7 @@ function drop1(n) {
 }
 
 export function drop(n, xs) {
+  assertNumber(n);
   if (arguments.length === 1) return drop1(n);
   return lazyIter(xs, function* (iter) {
     for (let x = 0; x < n; x++) {
@@ -2217,7 +2438,8 @@ export function update(coll, k, f, ...args) {
 
 export function get_in(coll, path, orElse) {
   let entry = coll;
-  for (const item of path) {
+  // iterable puns a nil path to an empty path, like CLJS
+  for (const item of iterable(path)) {
     entry = get(entry, item);
   }
   if (entry === undefined) return orElse;
@@ -2282,6 +2504,18 @@ export function reverse(coll) {
   return toArray(coll).reverse();
 }
 
+export function rseq(x) {
+  // vectors and sorted maps/sets are reversible, like CLJS
+  if (isVectorArray(x)) {
+    return x.length === 0 ? null : [...x].reverse();
+  }
+  if (x != null && x[SORTED_TAG] === true) {
+    const xs = [...x].reverse();
+    return xs.length === 0 ? null : xs;
+  }
+  throw new Error('rseq not supported on: ' + typeof x);
+}
+
 export function sort(f, coll) {
   if (arguments.length === 1) {
     coll = f;
@@ -2568,8 +2802,10 @@ export function dorun(x) {
 }
 
 export function doall(x) {
-  // realize as concrete array
-  return vec(x);
+  // realize a lazy seq and return it, like CLJS; anything else is
+  // already concrete
+  if (x != null && x[TYPE_TAG] === LAZY_ITERABLE_TYPE) for (const _ of x);
+  return x;
 }
 
 export function aclone(arr) {
@@ -2577,13 +2813,53 @@ export function aclone(arr) {
   return cloned;
 }
 
+function typed_array(sizeOrSeq, initValOrSeq) {
+  if (initValOrSeq !== undefined) {
+    const a = new Array(sizeOrSeq);
+    if (typeof initValOrSeq === 'number') return a.fill(initValOrSeq);
+    let i = 0;
+    for (const x of iterable(initValOrSeq)) {
+      if (i >= sizeOrSeq) break;
+      a[i++] = x;
+    }
+    return a;
+  }
+  if (typeof sizeOrSeq === 'number') return new Array(sizeOrSeq).fill(null);
+  return [...iterable(sizeOrSeq)];
+}
+
+// like CLJS: provided for compatibility, all make a plain array
+export function int_array(sizeOrSeq, initValOrSeq) {
+  return typed_array(sizeOrSeq, initValOrSeq);
+}
+export function long_array(sizeOrSeq, initValOrSeq) {
+  return typed_array(sizeOrSeq, initValOrSeq);
+}
+export function float_array(sizeOrSeq, initValOrSeq) {
+  return typed_array(sizeOrSeq, initValOrSeq);
+}
+export function double_array(sizeOrSeq, initValOrSeq) {
+  return typed_array(sizeOrSeq, initValOrSeq);
+}
+export function object_array(sizeOrSeq, initValOrSeq) {
+  return typed_array(sizeOrSeq, initValOrSeq);
+}
+
 export function add_watch(ref, key, fn) {
-  ref._add_watch(key, fn);
+  if (ref?.[IWatchable__add_watch] !== undefined) {
+    ref[IWatchable__add_watch](ref, key, fn);
+    return ref;
+  }
+  nilImpl(_add_watch, 'IWatchable.-add-watch', ref)(ref, key, fn);
   return ref;
 }
 
 export function remove_watch(ref, key) {
-  ref._remove_watch(key);
+  if (ref?.[IWatchable__remove_watch] !== undefined) {
+    ref[IWatchable__remove_watch](ref, key);
+    return ref;
+  }
+  nilImpl(_remove_watch, 'IWatchable.-remove-watch', ref)(ref, key);
   return ref;
 }
 
@@ -2598,17 +2874,17 @@ export function reduce_kv(f, init, m) {
   return ret;
 }
 
+// CLJS reduce of (cond (NaN? x) x (NaN? y) y (> x y) x :else y): returns one of
+// the values, so nil acts like zero, and a NaN propagates. NaN? is js/isNaN.
 export function max(x, ...more) {
-  // (if (> a b) a b) reduce, like CLJS: returns one of the values, so nil acts
-  // like zero and NaN propagates, instead of Math.max coercing nil to 0.
   let m = x;
-  for (const y of more) m = m > y ? m : y;
+  for (const y of more) m = isNaN(m) ? m : isNaN(y) ? y : m > y ? m : y;
   return m;
 }
 
 export function min(x, ...more) {
   let m = x;
-  for (const y of more) m = m < y ? m : y;
+  for (const y of more) m = isNaN(m) ? m : isNaN(y) ? y : m < y ? m : y;
   return m;
 }
 
@@ -2636,15 +2912,15 @@ export function every_pred(...preds) {
 
 export function some_fn(...fns) {
   return (...args) => {
+    let res;
     for (const f of fns) {
       for (const a of args) {
-        const res = f(a);
-        if (res) {
-          return res;
-        }
+        res = f(a);
+        // truth_, not JS truthiness: 0 and "" are truthy in CLJS
+        if (truth_(res)) return res;
       }
     }
-    return undefined;
+    return res;
   };
 }
 
@@ -2788,7 +3064,8 @@ export function re_seq(re, s) {
 }
 
 export function NaN_QMARK_(x) {
-  return Number.isNaN(x);
+  // coercing, like CLJS js/isNaN: (NaN? "foo") is true
+  return isNaN(x);
 }
 
 export function number_QMARK_(x) {
@@ -2796,7 +3073,7 @@ export function number_QMARK_(x) {
 }
 
 export function keys(obj) {
-  if (obj == null) return;
+  if (obj == null) return null;
   const t = typeConst(obj);
   switch (t) {
     case OBJECT_TYPE: {
@@ -2808,6 +3085,11 @@ export function keys(obj) {
       if (obj.size) return Array.from(obj.keys());
       return;
   }
+  // not a map: nil when empty, like seq in CLJS, else throw
+  for (const _ of iterable(obj)) {
+    throw new TypeError(obj + ' is not a map');
+  }
+  return null;
 }
 
 export function js_keys(obj) {
@@ -2815,7 +3097,7 @@ export function js_keys(obj) {
 }
 
 export function vals(obj) {
-  if (obj == null) return;
+  if (obj == null) return null;
   const t = typeConst(obj);
   switch (t) {
     case OBJECT_TYPE: {
@@ -2827,6 +3109,11 @@ export function vals(obj) {
       if (obj.size) return Array.from(obj.values());
       return;
   }
+  // not a map: nil when empty, like seq in CLJS, else throw
+  for (const _ of iterable(obj)) {
+    throw new TypeError(obj + ' is not a map');
+  }
+  return null;
 }
 
 export function string_QMARK_(s) {
@@ -3021,34 +3308,22 @@ export function mod(x, y) {
 }
 
 export function min_key(k, x, ...more) {
-  if (more.length == 0) {
-    return x;
+  k = __toFn(k);
+  // pairwise (if (< (k x) (k y)) x y), like CLJS, so NaN propagates right
+  let min = x;
+  for (const y of more) {
+    if (!(k(min) < k(y))) min = y;
   }
-  var kx = k(x);
-  var min = x;
-  more.forEach((y) => {
-    var ky = k(y);
-    if (ky <= kx) {
-      kx = ky;
-      min = y;
-    }
-  });
   return min;
 }
 
 export function max_key(k, x, ...more) {
-  if (more.length == 0) {
-    return x;
+  k = __toFn(k);
+  // pairwise (if (> (k x) (k y)) x y), like CLJS, so NaN propagates right
+  let max = x;
+  for (const y of more) {
+    if (!(k(max) > k(y))) max = y;
   }
-  var kx = k(x);
-  var max = x;
-  more.forEach((y) => {
-    var ky = k(y);
-    if (ky >= kx) {
-      kx = ky;
-      max = y;
-    }
-  });
   return max;
 }
 
@@ -3202,6 +3477,7 @@ class SortedSet {
     // we don't re-use xs since xs can contain duplicates
     this._elts = [...s];
     this._set = s;
+    this.size = this._elts.length;
   }
   add(x) {
     if (this._set.has(x)) return this;
@@ -3461,6 +3737,7 @@ export function memoize(f) {
 }
 
 export function peek(vec) {
+  if (vec == null) return null;
   // 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)) {
@@ -3468,7 +3745,7 @@ export function peek(vec) {
   } else if (array_QMARK_(vec)) {
     return vec[vec.length - 1];
   } else {
-    return first(vec);
+    throw missing_protocol('IStack.-peek', vec);
   }
 }
 
@@ -3483,7 +3760,7 @@ export function pop(vec) {
     ret.pop();
     return ret;
   } else {
-    return rest(vec);
+    throw missing_protocol('IStack.-pop', vec);
   }
 }
 
@@ -3514,7 +3791,7 @@ export function update_vals(m, f) {
 }
 
 export function random_uuid() {
-  return crypto.randomUUID();
+  return new UUID(crypto.randomUUID());
 }
 
 export class UUID {
@@ -3527,20 +3804,34 @@ export class UUID {
 }
 
 export function uuid(s) {
-  return new UUID(s);
+  // lowercased, like CLJS
+  return new UUID(s.toLowerCase());
 }
 
 export function uuid_QMARK_(x) {
   return x instanceof UUID;
 }
 
+const UUID_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+
+export function parse_uuid(s) {
+  if (typeof s !== 'string') {
+    throw new Error('Expected string, got: ' + (s === null ? 'nil' : typeof s));
+  }
+  return UUID_REGEX.test(s) ? uuid(s) : null;
+}
+
 export function inst_QMARK_(x) {
   return x instanceof Date;
 }
 
+const DELAY_DEREF = (self) => self._deref();
+
 export class Delay {
   constructor(f) {
     this.f = f;
+    this[IDEREF_SYM] = true;
+    this[IDeref__deref] = DELAY_DEREF;
   }
   _deref() {
     if (this.realized) {
@@ -3560,6 +3851,10 @@ export function realized_QMARK_(x) {
   throw new Error('realized? not supported on: ' + str(x));
 }
 
+export function force(x) {
+  return x instanceof Delay ? x._deref() : x;
+}
+
 function clj__GT_js_(x, seen) {
   // we need to protect against circular objects
   if (seen.has(x)) return x;
@@ -3587,12 +3882,12 @@ export function not_EQ_(...more) {
   return not(_EQ_(...more));
 }
 
+const VOLATILE_DEREF = (self) => self.v;
+
 class Volatile {
   constructor(v) {
     this.v = v;
-  }
-  _deref() {
-    return this.v;
+    this[IDeref__deref] = VOLATILE_DEREF;
   }
 }