squint-cljs 0.14.202 → 0.14.203

package/src/squint/core.js

@@ -5,9 +5,19 @@
 // (e.g. multi.js). Signature and semantics may change without notice.
 export function __toFn(x) {
   if (x == null || typeof x === 'function') return x;
-  const t = typeof x;
-  if (t === 'string') return (coll, d) => get(coll, x, d);
-  if (t === 'object') return (k, d) => get(x, k, d);
+  if (typeof x === 'string') return (coll, d) => get(coll, x, d);
+  // a value is callable as a lookup only if it is a collection or a custom
+  // type implementing ILookup; a seq, list or opaque object throws when
+  // called, like a non-IFn in CLJS
+  switch (typeConst(x)) {
+    case MAP_TYPE:
+    case ARRAY_TYPE:
+    case OBJECT_TYPE:
+    case SET_TYPE:
+      return (k, d) => get(x, k, d);
+    case INSTANCE_TYPE:
+      if (x[ILookup__lookup] !== undefined) return (k, d) => get(x, k, d);
+  }
   return x;
 }
 
@@ -51,6 +61,12 @@ function dequal(foo, bar) {
   if (foo === bar) return true;
   // null and undefined are both nil in CLJS, so they compare equal
   if (foo == null) return bar == null;
+  if (bar == null) return false;
+  // -equiv dispatches on the left argument, like CLJS =
+  if (typeof foo === 'object' && foo[IEquiv__equiv] !== undefined) return !!foo[IEquiv__equiv](foo, bar);
+  // when only the right side has -equiv (the left is e.g. a plain object),
+  // dispatch on it so = stays symmetric
+  if (typeof bar === 'object' && bar[IEquiv__equiv] !== undefined) return !!bar[IEquiv__equiv](bar, foo);
   var ctor, len, tmp;
 
   // A sorted map compares by entries against any map type (object, Map, sorted).
@@ -193,6 +209,13 @@ export function _(...xs) {
   return xs.reduce((x, y) => x - y);
 }
 
+export function _SLASH_(...xs) {
+  if (xs.length === 1) {
+    return 1 / xs[0];
+  }
+  return xs.reduce((x, y) => x / y);
+}
+
 export const __protocol_satisfies = {};
 
 export function satisfies_QMARK_(protocol, x) {
@@ -219,6 +242,7 @@ function getAssocMut(m) {
       return mapAssocMut;
     case ARRAY_TYPE:
     case OBJECT_TYPE:
+    case INSTANCE_TYPE:
       return objAssocMut;
   }
 }
@@ -258,6 +282,17 @@ export function assoc_BANG_(m, k, v, ...kvs) {
         m[kvs[i]] = kvs[i + 1];
       }
       break;
+    case INSTANCE_TYPE:
+      if (m[ITransientAssociative__assoc_BANG_] !== undefined) {
+        // re-read the slot off the current value: an -assoc! impl may return a
+        // different handle
+        let ret = m[ITransientAssociative__assoc_BANG_](m, k, v);
+        for (let i = 0; i < kvs.length; i += 2) {
+          ret = ret[ITransientAssociative__assoc_BANG_](ret, kvs[i], kvs[i + 1]);
+        }
+        return ret;
+      }
+    // fall through: an instance without -assoc! keeps the object behavior
     case OBJECT_TYPE:
       m[k] = v;
 
@@ -274,16 +309,14 @@ export function assoc_BANG_(m, k, v, ...kvs) {
   return m;
 }
 
-const _metaSym = Symbol('meta');
-
-// Copies metadata from `from` onto `to` (when present) and returns `to`. Used
-// to make value-producing operations (copy, empty, conj, into) carry metadata
-// like Clojure does, instead of dropping it on the freshly built structure.
-// Kept branch-light for the hot path: reads an absent symbol property (cheap,
-// no hidden-class change) and only writes when metadata is actually present.
+// value-producing ops (copy, empty, conj, into) carry metadata by
+// forwarding the instance-level meta slots onto the fresh structure
 function copyMeta(from, to) {
-  const m = from?.[_metaSym];
-  if (m !== undefined) to[_metaSym] = m;
+  const f = from?.[IMeta__meta];
+  if (f !== undefined) {
+    to[IMeta__meta] = f;
+    to[IWithMeta__with_meta] = from[IWithMeta__with_meta];
+  }
   return to;
 }
 
@@ -296,6 +329,7 @@ function copy(o) {
       return copyMeta(o, new o.constructor(o));
     case ARRAY_TYPE:
       return copyMeta(o, [...o]);
+    case INSTANCE_TYPE:
     case OBJECT_TYPE:
       return copyMeta(o, { ...o });
     case LIST_TYPE:
@@ -313,6 +347,13 @@ export function assoc(o, k, v, ...kvs) {
   if (o == null) {
     o = {};
   }
+  if (o[IAssociative__assoc] !== undefined) {
+    let ret = o[IAssociative__assoc](o, k, v);
+    for (let i = 0; i < kvs.length; i += 2) {
+      ret = ret[IAssociative__assoc](ret, kvs[i], kvs[i + 1]);
+    }
+    return ret;
+  }
   const ret = copy(o);
   assoc_BANG_(ret, k, v, ...kvs);
   return ret;
@@ -335,6 +376,9 @@ const OBJECT_TYPE = 3;
 const LIST_TYPE = 4;
 const SET_TYPE = 5;
 const LAZY_ITERABLE_TYPE = 6;
+// a class instance or null-prototype object: the extension point for the
+// map-facing protocols. Plain objects keep the OBJECT_TYPE fast path.
+const INSTANCE_TYPE = 7;
 
 // type tag set in each collection ctor, read by typeConst (DCE: no instanceof).
 const TYPE_TAG = Symbol('squint.lang.type');
@@ -398,7 +442,7 @@ function typeConst(obj) {
   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;
+  if (typeof obj === 'object') return INSTANCE_TYPE;
 
   return undefined;
 }
@@ -407,7 +451,7 @@ function assoc_in_with(f, fname, o, keys, value) {
   keys = vec(keys);
   o = o || {}; // default nil behavior is JS object
   const baseType = typeConst(o);
-  if (baseType !== MAP_TYPE && baseType !== ARRAY_TYPE && baseType !== OBJECT_TYPE)
+  if (baseType !== MAP_TYPE && baseType !== ARRAY_TYPE && baseType !== OBJECT_TYPE && baseType !== INSTANCE_TYPE)
     throw new Error(
       `Illegal argument: ${fname} expects the first argument to be a Map, Array, or Object.`
     );
@@ -419,9 +463,12 @@ function assoc_in_with(f, fname, o, keys, value) {
     const k = keys[i];
     let chainValue;
     if (lastInChain instanceof Map) chainValue = lastInChain.get(k);
-    else chainValue = lastInChain[k];
+    else if (lastInChain != null && lastInChain[ILookup__lookup] !== undefined) {
+      chainValue = lastInChain[ILookup__lookup](lastInChain, k, undefined);
+    } else chainValue = lastInChain[k];
     if (!chainValue) {
-      chainValue = emptyOfType(baseType);
+      // an instance root has no empty-of-type: missing levels become plain maps
+      chainValue = emptyOfType(baseType) ?? {};
     }
     chain.push(chainValue);
     lastInChain = chainValue;
@@ -526,6 +573,14 @@ export function conj_BANG_(...xs) {
         else for (const kv of mapEntriesOf(x)) o.set(kv[0], kv[1]);
       }
       break;
+    case INSTANCE_TYPE:
+      if (o[ITransientCollection__conj_BANG_] !== undefined) {
+        // re-dispatch per element: a -conj! impl may return a different handle
+        let acc = o[ITransientCollection__conj_BANG_](o, rest[0]);
+        for (let i = 1; i < rest.length; i++) acc = conj_BANG_(acc, rest[i]);
+        return acc;
+      }
+    // fall through: an instance without -conj! keeps the object behavior
     case OBJECT_TYPE:
       for (const x of rest) {
         if (isVectorArray(x)) { asMapEntry(x); o[x[0]] = x[1]; }
@@ -604,6 +659,14 @@ export function conj(...xs) {
         yield* rest;
         yield* o;
       });
+    case INSTANCE_TYPE:
+      if (o[ICollection__conj] !== undefined) {
+        // re-dispatch per element: a -conj impl may return a different type
+        o2 = o[ICollection__conj](o, rest[0]);
+        for (let i = 1; i < rest.length; i++) o2 = conj(o2, rest[i]);
+        return o2;
+      }
+    // fall through: an instance without -conj keeps the object behavior
     case OBJECT_TYPE:
       o2 = { ...o };
 
@@ -621,6 +684,13 @@ export function conj(...xs) {
 }
 
 export function disj_BANG_(s, ...xs) {
+  if (s != null && s[ITransientSet__disjoin_BANG_] !== undefined) {
+    let ret = s;
+    for (const x of xs) {
+      ret = ret != null && ret[ITransientSet__disjoin_BANG_] !== undefined ? ret[ITransientSet__disjoin_BANG_](ret, x) : disj_BANG_(ret, x);
+    }
+    return ret;
+  }
   for (const x of xs) {
     s.delete(x);
   }
@@ -629,6 +699,12 @@ export function disj_BANG_(s, ...xs) {
 
 export function disj(s, ...xs) {
   if (s == null) return s;
+  if (xs.length === 0) return s;
+  if (s[ISet__disjoin] !== undefined) {
+    let ret = s[ISet__disjoin](s, xs[0]);
+    for (let i = 1; i < xs.length; i++) ret = disj(ret, xs[i]);
+    return ret;
+  }
   // pass s itself (not a spread) so a SortedSet keeps its comparator
   const s1 = new s.constructor(s);
   return copyMeta(s, disj_BANG_(s1, ...xs));
@@ -644,12 +720,22 @@ export function contains_QMARK_(coll, v) {
       return coll.has(v);
     case undefined:
       return false;
+    case INSTANCE_TYPE:
+      if (coll[IAssociative__contains_key_QMARK_] !== undefined) {
+        return coll[IAssociative__contains_key_QMARK_](coll, v);
+      }
+    // fall through
     default:
       return v in coll;
   }
 }
 
 export function dissoc_BANG_(m, ...ks) {
+  if (m != null && m[ITransientMap__dissoc_BANG_] !== undefined) {
+    let ret = m;
+    for (const k of ks) ret = ret != null && ret[ITransientMap__dissoc_BANG_] !== undefined ? ret[ITransientMap__dissoc_BANG_](ret, k) : dissoc_BANG_(ret, k);
+    return ret;
+  }
   for (const k of ks) {
     delete m[k];
   }
@@ -661,9 +747,18 @@ export function dissoc(m, ...ks) {
   if (!m) return;
   if (ks.length === 0) return m;
   const tc = typeConst(m);
-  if (tc !== MAP_TYPE && tc !== OBJECT_TYPE) {
+  if (tc !== MAP_TYPE && tc !== OBJECT_TYPE && tc !== INSTANCE_TYPE) {
     throw new Error('dissoc expects a map, got: ' + typeof m);
   }
+  if (tc === INSTANCE_TYPE && m[IMap__dissoc] !== undefined) {
+    let ret = m;
+    // re-dispatch per key: a -dissoc impl may return a different type
+    for (const k of ks) {
+      if (ret == null) return ret;
+      ret = ret[IMap__dissoc] !== undefined ? ret[IMap__dissoc](ret, k) : dissoc(ret, k);
+    }
+    return ret;
+  }
   if (tc === MAP_TYPE) {
     let present = false;
     for (const k of ks) if (m.has(k)) { present = true; break; }
@@ -701,6 +796,14 @@ export function println(...args) {
   if (_STAR_print_newline_STAR_.val) _STAR_print_fn_STAR_.val('\n');
 }
 
+export function print_str(...args) {
+  return args.map((v) => toEDN(v, undefined, false)).join(' ');
+}
+
+export function println_str(...args) {
+  return print_str(...args) + '\n';
+}
+
 export function pr(...xs) {
   _STAR_print_fn_STAR_.val(pr_str(...xs));
 }
@@ -718,6 +821,8 @@ export function nth(coll, idx, orElse) {
     if (idx >= 0 && idx < coll.length) {
       return coll[idx];
     }
+  } else if (coll[IIndexed__nth] !== undefined) {
+    return hasDefault ? coll[IIndexed__nth](coll, idx, orElse) : coll[IIndexed__nth](coll, idx);
   } else if (idx >= 0) {
     // non-array: skip whole chunks instead of counting elements (handles
     // infinite seqs since it stops once idx is reached)
@@ -760,6 +865,10 @@ export function get(coll, key, otherwise = undefined) {
       v = coll[key];
       break;
     default:
+      if (coll[ILookup__lookup] !== undefined) {
+        v = coll[ILookup__lookup](coll, key, otherwise);
+        return v === undefined ? otherwise : v;
+      }
       // we choose .get as the default implementation, e.g. fetch Headers are not Maps, but do implement a .get method
       g = coll['get'];
       if (typeof g === 'function') {
@@ -783,7 +892,7 @@ export function seq_QMARK_(x) {
 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;
+  return Array.isArray(x) || x?.[TYPE_TAG] === LAZY_ITERABLE_TYPE || (x != null && x[IVector.__sym] !== undefined);
 }
 
 export function seqable_QMARK_(x) {
@@ -828,7 +937,10 @@ export function iterable(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);
+  // only a plain object is a squint map; a class instance without a native
+  // iterator or ISeqable is not iterable, matching seqable? and CLJS, and
+  // never leaks its internal fields
+  if (isObj(x)) return Object.entries(x).map(tagMapEntry);
   throw new TypeError(`${x} is not iterable`);
 }
 
@@ -852,10 +964,19 @@ export function seq(x) {
   if (iter.length === 0 || iter.size === 0) {
     return null;
   }
-  // a set is iterable but not sequential; materialize its elements.
+  // a set or map is iterable but not a sequence; materialize its entries
+  // into a distinct seq so the result is not itself a set or map, like CLJS
   if (iter instanceof Set || iter[TYPE_TAG] === SET_TYPE) {
     return [...iter];
   }
+  if (iter instanceof Map || iter[TYPE_TAG] === MAP_TYPE) {
+    return [...iter].map(tagMapEntry);
+  }
+  // an instance with -dissoc is a map rep: same distinct entry seq
+  if (iter[IMap__dissoc] !== undefined) {
+    const entries = [...iter].map(tagMapEntry);
+    return entries.length === 0 ? null : entries;
+  }
   const _i = iter[Symbol.iterator]();
   if (_i.next().done) return null;
   return iter;
@@ -888,6 +1009,14 @@ export function ffirst(coll) {
   return first(first(coll));
 }
 
+export function fnext(coll) {
+  return first(next(coll));
+}
+
+export function nfirst(coll) {
+  return next(first(coll));
+}
+
 export function rest(coll) {
   // chunk-aware: drop the first element of the first chunk, keep the rest of
   // the chain chunked (preserves chunkedness, unlike re-iterating element-wise)
@@ -1285,6 +1414,13 @@ export function filterv(pred, coll) {
   return pushAll([], filter(pred, coll));
 }
 
+export function random_sample(prob, coll) {
+  if (arguments.length === 1) {
+    return filter((_) => rand() < prob);
+  }
+  return filter((_) => rand() < prob, coll);
+}
+
 export function remove(pred, coll) {
   if (arguments.length === 1) {
     return filter1(complement(pred));
@@ -1382,10 +1518,326 @@ export function _deref(o) {
 }
 export const ISeqable = { __sym: ISEQABLE_SYM };
 export const ISeqable__seq = Symbol('ISeqable_-seq');
+
+// map-facing protocols. Each dispatches through its slot in the extension
+// path (INSTANCE_TYPE) of the corresponding core fn, so plain objects and
+// arrays never pay for them. Slot symbols are separate consts so a bundle
+// using only e.g. conj pulls one symbol, not the whole protocol set.
+export const ILookup = { __sym: Symbol('squint.core.ILookup') };
+export const ILookup__lookup = Symbol('ILookup_-lookup');
+export const IAssociative = { __sym: Symbol('squint.core.IAssociative') };
+export const IAssociative__assoc = Symbol('IAssociative_-assoc');
+export const IAssociative__contains_key_QMARK_ = Symbol('IAssociative_-contains-key?');
+export const IMap = { __sym: Symbol('squint.core.IMap') };
+export const IMap__dissoc = Symbol('IMap_-dissoc');
+export const ICounted = { __sym: Symbol('squint.core.ICounted') };
+export const ICounted__count = Symbol('ICounted_-count');
+export const IKVReduce = { __sym: Symbol('squint.core.IKVReduce') };
+export const IKVReduce__kv_reduce = Symbol('IKVReduce_-kv-reduce');
+export const ICollection = { __sym: Symbol('squint.core.ICollection') };
+export const ICollection__conj = Symbol('ICollection_-conj');
+export const IEmptyableCollection = { __sym: Symbol('squint.core.IEmptyableCollection') };
+export const IEmptyableCollection__empty = Symbol('IEmptyableCollection_-empty');
+export const IEquiv = { __sym: Symbol('squint.core.IEquiv') };
+export const IEquiv__equiv = Symbol('IEquiv_-equiv');
+// set and transient protocols, same extension-path dispatch as the map-facing
+// protocols above
+export const ISet = { __sym: Symbol('squint.core.ISet') };
+export const ISet__disjoin = Symbol('ISet_-disjoin');
+export const IEditableCollection = { __sym: Symbol('squint.core.IEditableCollection') };
+export const IEditableCollection__as_transient = Symbol('IEditableCollection_-as-transient');
+export const ITransientCollection = { __sym: Symbol('squint.core.ITransientCollection') };
+export const ITransientCollection__conj_BANG_ = Symbol('ITransientCollection_-conj!');
+export const ITransientCollection__persistent_BANG_ = Symbol('ITransientCollection_-persistent!');
+export const ITransientAssociative = { __sym: Symbol('squint.core.ITransientAssociative') };
+export const ITransientAssociative__assoc_BANG_ = Symbol('ITransientAssociative_-assoc!');
+export const ITransientMap = { __sym: Symbol('squint.core.ITransientMap') };
+export const ITransientMap__dissoc_BANG_ = Symbol('ITransientMap_-dissoc!');
+export const ITransientSet = { __sym: Symbol('squint.core.ITransientSet') };
+export const ITransientSet__disjoin_BANG_ = Symbol('ITransientSet_-disjoin!');
+// metadata protocols, like CLJS: types implement the slots, plain values
+// get instance-level impls installed by with-meta
+export const IMeta = { __sym: Symbol('squint.core.IMeta') };
+export const IMeta__meta = Symbol('IMeta_-meta');
+export const IWithMeta = { __sym: Symbol('squint.core.IWithMeta') };
+export const IWithMeta__with_meta = Symbol('IWithMeta_-with-meta');
+// hashing (Murmur3, like CLJS). The contract: (= a b) implies (hash a) ===
+// (hash b), where = is dequal. None of this is referenced by =, so bundles
+// that only compare pay nothing.
+// Ported from ClojureScript (cljs/core.cljs), Copyright (c) Rich Hickey and
+// contributors, Eclipse Public License 1.0. MurmurHash3 by Austin Appleby
+// (public domain).
+
+// IHash: a custom type opts into value hashing
+export const IHash = { __sym: Symbol('squint.core.IHash') };
+export const IHash__hash = Symbol('IHash_-hash');
+
+// the equality hashed collections key by: identical or -equiv, never a
+// deep compare like =
+export function equiv(x, y) {
+  if (x === y) return true;
+  if (x == null) return y == null;
+  if (y == null) return false;
+  if (x[IEquiv__equiv] !== undefined) return !!x[IEquiv__equiv](x, y);
+  if (y[IEquiv__equiv] !== undefined) return !!y[IEquiv__equiv](y, x);
+  if (x instanceof Date && y instanceof Date) return x.getTime() === y.getTime();
+  return false;
+}
+
+// identity uid for reference-keyed values, like CLJS goog/getUid
+const UIDS = /* @__PURE__ */ new WeakMap();
+let uidCounter = 0;
+
+function uid(o) {
+  let id = UIDS.get(o);
+  if (id === undefined) {
+    id = ++uidCounter;
+    UIDS.set(o, id);
+  }
+  return id;
+}
+
+const imul = Math.imul;
+const M3_C1 = 0xcc9e2d51 | 0;
+const M3_C2 = 0x1b873593 | 0;
+
+function rotl(x, n) {
+  return (x << n) | (x >>> (32 - n));
+}
+
+function m3MixK1(k1) {
+  return imul(rotl(imul(k1 | 0, M3_C1), 15), M3_C2);
+}
+
+function m3MixH1(h1, k1) {
+  return (imul(rotl((h1 | 0) ^ (k1 | 0), 13), 5) + (0xe6546b64 | 0)) | 0;
+}
+
+function m3Fmix(h1, len) {
+  h1 = (h1 ^ len) | 0;
+  h1 = (h1 ^ (h1 >>> 16)) | 0;
+  h1 = imul(h1, 0x85ebca6b | 0);
+  h1 = (h1 ^ (h1 >>> 13)) | 0;
+  h1 = imul(h1, 0xc2b2ae35 | 0);
+  return (h1 ^ (h1 >>> 16)) | 0;
+}
+
+function m3HashInt(x) {
+  return x === 0 ? 0 : m3Fmix(m3MixH1(0, m3MixK1(x)), 4);
+}
+
+let stringHashCache = /* @__PURE__ */ Object.create(null);
+let stringHashCacheCount = 0;
+
+function hashStringRaw(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) h = (imul(31, h) + s.charCodeAt(i)) | 0;
+  return h;
+}
+
+function hashString(s) {
+  if (stringHashCacheCount > 8192) {
+    stringHashCache = Object.create(null);
+    stringHashCacheCount = 0;
+  }
+  let h = stringHashCache[s];
+  if (typeof h !== 'number') {
+    h = hashStringRaw(s);
+    stringHashCache[s] = h;
+    stringHashCacheCount++;
+  }
+  return h;
+}
+
+// one IIFE, not two consts: `new Int32Array(F64.buffer)` reads a property,
+// which pins F64 into bundles even under a pure annotation
+const HASH_BUF = /* @__PURE__ */ (() => {
+  const f64 = new Float64Array(1);
+  return { f64, i32: new Int32Array(f64.buffer) };
+})();
+
+function hashDouble(n) {
+  HASH_BUF.f64[0] = n;
+  return (HASH_BUF.i32[0] ^ HASH_BUF.i32[1]) | 0;
+}
+
+function mixCollectionHash(hashBasis, count) {
+  return m3Fmix(m3MixH1(0, m3MixK1(hashBasis)), count);
+}
+
+export function hash_ordered_coll(coll) {
+  let n = 0;
+  let h = 1;
+  for (const x of coll) {
+    h = (imul(31, h) + hash(x)) | 0;
+    n++;
+  }
+  return mixCollectionHash(h, n);
+}
+
+export function hash_unordered_coll(coll) {
+  let n = 0;
+  let h = 0;
+  for (const x of coll) {
+    h = (h + hash(x)) | 0;
+    n++;
+  }
+  return mixCollectionHash(h, n);
+}
+
+// a map entry hashes as (hash-ordered-coll [k v])
+function hashEntry(k, v) {
+  return mixCollectionHash((imul(31, (imul(31, 1) + hash(k)) | 0) + hash(v)) | 0, 2);
+}
+
+function hashMapEntries(entries) {
+  let n = 0;
+  let h = 0;
+  for (const [k, v] of entries) {
+    h = (h + hashEntry(k, v)) | 0;
+    n++;
+  }
+  return mixCollectionHash(h, n);
+}
+
+// (equiv a b) implies (hash a) === (hash b): plain mutable data hashes by
+// uid, a type with -equiv but no -hash gets a structural entry hash
+export function hash(o) {
+  if (o == null) return 0;
+  switch (typeof o) {
+    case 'number':
+      if (Number.isFinite(o)) {
+        return Number.isSafeInteger(o) ? o % 2147483647 | 0 : hashDouble(o);
+      }
+      if (o === Infinity) return 2146435072;
+      if (o === -Infinity) return -1048576;
+      return 2146959360; // NaN
+    case 'boolean':
+      return o ? 1231 : 1237;
+    case 'string':
+      return m3HashInt(hashString(o));
+    case 'bigint':
+      return Number(o % 2147483647n) | 0;
+    case 'function':
+      return uid(o) | 0;
+    case 'object':
+      break;
+    default:
+      // JS symbols compare by identity; a constant hash is consistent
+      return 0;
+  }
+  if (o[IHash__hash] !== undefined) return o[IHash__hash](o) | 0;
+  if (o instanceof Date) return o.valueOf() | 0;
+  if (o[IEquiv__equiv] !== undefined) return hashMapEntries(Object.entries(o));
+  return uid(o) | 0;
+}
+
+// printing protocols, like CLJS: a type prints itself through
+// (-pr-writer [obj writer opts]), writing strings via (-write writer s)
+export const IWriter = { __sym: Symbol('squint.core.IWriter') };
+export const IWriter__write = Symbol('IWriter_-write');
+export const IPrintWithWriter = { __sym: Symbol('squint.core.IPrintWithWriter') };
+export const IPrintWithWriter__pr_writer = Symbol('IPrintWithWriter_-pr-writer');
+export function _write(writer, s) {
+  if (writer != null && writer[IWriter__write] !== undefined) return writer[IWriter__write](writer, s);
+  return nilImpl(_write, 'IWriter.-write', writer)(writer, s);
+}
+export function write_all(writer, ...ss) {
+  for (const s of ss) _write(writer, s);
+}
+// vector-facing protocols, dispatched like the map-facing set above
+export const IStack = { __sym: Symbol('squint.core.IStack') };
+export const IStack__peek = Symbol('IStack_-peek');
+export const IStack__pop = Symbol('IStack_-pop');
+export const IIndexed = { __sym: Symbol('squint.core.IIndexed') };
+export const IIndexed__nth = Symbol('IIndexed_-nth');
+export const ITransientVector = { __sym: Symbol('squint.core.ITransientVector') };
+export const ITransientVector__pop_BANG_ = Symbol('ITransientVector_-pop!');
+// marker protocol: a non-array type that counts as a vector (vector?,
+// sequential?, vec, subvec route through it)
+export const IVector = { __sym: Symbol('squint.core.IVector') };
+// a type converts itself in clj->js through this slot, like CLJS IEncodeJS;
+// the impl receives (x, recur) with recur a cycle-safe clj->js
+export const IEncodeJS = { __sym: Symbol('squint.core.IEncodeJS') };
+export const IEncodeJS__clj__GT_js = Symbol('IEncodeJS_-clj->js');
+// marker protocol set by defrecord
+export const IRecord = { __sym: Symbol('squint.core.IRecord') };
+
+export function record_QMARK_(x) {
+  return x != null && x[IRecord.__sym] !== undefined;
+}
+
+// The protocol-method fns below share one shape but stay hand-written on
+// purpose: a shared factory makes V8 share type feedback across all of them,
+// turning every slot access megamorphic (measured 1.8 -> 11 ns per call).
+export function _lookup(o, k, nf) {
+  if (o != null && o[ILookup__lookup] !== undefined) return o[ILookup__lookup](o, k, nf);
+  return nilImpl(_lookup, 'ILookup.-lookup', o)(o, k, nf);
+}
+export function _assoc(o, k, v) {
+  if (o != null && o[IAssociative__assoc] !== undefined) return o[IAssociative__assoc](o, k, v);
+  return nilImpl(_assoc, 'IAssociative.-assoc', o)(o, k, v);
+}
+export function _contains_key_QMARK_(o, k) {
+  if (o != null && o[IAssociative__contains_key_QMARK_] !== undefined) return o[IAssociative__contains_key_QMARK_](o, k);
+  return nilImpl(_contains_key_QMARK_, 'IAssociative.-contains-key?', o)(o, k);
+}
+export function _dissoc(o, k) {
+  if (o != null && o[IMap__dissoc] !== undefined) return o[IMap__dissoc](o, k);
+  return nilImpl(_dissoc, 'IMap.-dissoc', o)(o, k);
+}
+export function _count(o) {
+  if (o != null && o[ICounted__count] !== undefined) return o[ICounted__count](o);
+  return nilImpl(_count, 'ICounted.-count', o)(o);
+}
+export function _kv_reduce(o, f, init) {
+  if (o != null && o[IKVReduce__kv_reduce] !== undefined) return o[IKVReduce__kv_reduce](o, f, init);
+  return nilImpl(_kv_reduce, 'IKVReduce.-kv-reduce', o)(o, f, init);
+}
+export function _conj(o, x) {
+  if (o != null && o[ICollection__conj] !== undefined) return o[ICollection__conj](o, x);
+  return nilImpl(_conj, 'ICollection.-conj', o)(o, x);
+}
+export function _empty(o) {
+  if (o != null && o[IEmptyableCollection__empty] !== undefined) return o[IEmptyableCollection__empty](o);
+  return nilImpl(_empty, 'IEmptyableCollection.-empty', o)(o);
+}
+export function _equiv(o, other) {
+  if (o != null && o[IEquiv__equiv] !== undefined) return o[IEquiv__equiv](o, other);
+  return nilImpl(_equiv, 'IEquiv.-equiv', o)(o, other);
+}
 export function _seq(o) {
   if (o != null && o[ISeqable__seq] !== undefined) return o[ISeqable__seq](o);
   return nilImpl(_seq, 'ISeqable.-seq', o)(o);
 }
+export function _disjoin(o, x) {
+  if (o != null && o[ISet__disjoin] !== undefined) return o[ISet__disjoin](o, x);
+  return nilImpl(_disjoin, 'ISet.-disjoin', o)(o, x);
+}
+export function _as_transient(o) {
+  if (o != null && o[IEditableCollection__as_transient] !== undefined) return o[IEditableCollection__as_transient](o);
+  return nilImpl(_as_transient, 'IEditableCollection.-as-transient', o)(o);
+}
+export function _conj_BANG_(o, x) {
+  if (o != null && o[ITransientCollection__conj_BANG_] !== undefined) return o[ITransientCollection__conj_BANG_](o, x);
+  return nilImpl(_conj_BANG_, 'ITransientCollection.-conj!', o)(o, x);
+}
+export function _persistent_BANG_(o) {
+  if (o != null && o[ITransientCollection__persistent_BANG_] !== undefined) return o[ITransientCollection__persistent_BANG_](o);
+  return nilImpl(_persistent_BANG_, 'ITransientCollection.-persistent!', o)(o);
+}
+export function _assoc_BANG_(o, k, v) {
+  if (o != null && o[ITransientAssociative__assoc_BANG_] !== undefined) return o[ITransientAssociative__assoc_BANG_](o, k, v);
+  return nilImpl(_assoc_BANG_, 'ITransientAssociative.-assoc!', o)(o, k, v);
+}
+export function _dissoc_BANG_(o, k) {
+  if (o != null && o[ITransientMap__dissoc_BANG_] !== undefined) return o[ITransientMap__dissoc_BANG_](o, k);
+  return nilImpl(_dissoc_BANG_, 'ITransientMap.-dissoc!', o)(o, k);
+}
+export function _disjoin_BANG_(o, x) {
+  if (o != null && o[ITransientSet__disjoin_BANG_] !== undefined) return o[ITransientSet__disjoin_BANG_](o, x);
+  return nilImpl(_disjoin_BANG_, 'ITransientSet.-disjoin!', o)(o, x);
+}
 
 // an extend-type on nil stores the impl on the dispatch fn under null,
 // the same convention the generated protocol dispatch fns use
@@ -1481,7 +1933,11 @@ export class Atom {
 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];
+    // IMeta only, like CLJS Atom: keeps with-meta's copy machinery out of atom-only bundles
+    if (opts[i] === 'meta') {
+      const mv = opts[i + 1];
+      a[IMeta__meta] = () => mv;
+    }
     else if (opts[i] === 'validator') a._validator = opts[i + 1];
   }
   return a;
@@ -1636,6 +2092,21 @@ export function re_pattern(s) {
 }
 
 export function subvec(arr, start, end) {
+  // an IVector type slices through its own slots (bounds-checked nth + conj)
+  if (arr != null && arr[IVector.__sym] !== undefined) {
+    if (end === undefined) end = _count(arr);
+    if (start == null || end == null) {
+      throw new Error('subvec: start and end must not be nil');
+    }
+    start = start | 0;
+    end = end | 0;
+    if (start < 0 || end < start || end > _count(arr)) {
+      throw new Error('subvec: index out of bounds');
+    }
+    let ret = arr[IEmptyableCollection__empty](arr);
+    for (let i = start; i < end; i++) ret = ret[ICollection__conj](ret, arr[IIndexed__nth](arr, i));
+    return ret;
+  }
   if (!isVectorArray(arr)) {
     throw new Error('subvec: argument must be a vector');
   }
@@ -1659,7 +2130,8 @@ export function vector(...args) {
 export const array = vector;
 
 export function vector_QMARK_(x) {
-  return isVectorArray(x);
+  if (x == null) return false;
+  return isVectorArray(x) || x[IVector.__sym] !== undefined;
 }
 
 export function mapv(...args) {
@@ -1713,6 +2185,7 @@ function toArray(coll) {
 
 export function vec(x) {
   if (isVectorArray(x)) return x;
+  if (x != null && x[IVector.__sym] !== undefined) return x;
   return pushAll([], x);
 }
 
@@ -1721,7 +2194,8 @@ export function set(coll) {
 }
 
 export function set_QMARK_(x) {
-  return typeConst(x) === SET_TYPE;
+  if (x == null) return false;
+  return typeConst(x) === SET_TYPE || x[ISet.__sym] !== undefined;
 }
 
 export function hash_set(...xs) {
@@ -1736,6 +2210,12 @@ export function char_QMARK_(x) {
   return typeof x === 'string' && x.length === 1;
 }
 
+export function char$(x) {
+  if (typeof x === 'string' && x.length === 1) return x;
+  if (typeof x === 'number') return String.fromCharCode(x);
+  throw new Error('Argument to char must be a character or number: ' + x);
+}
+
 export function apply(f, ...args) {
   f = __toFn(f);
   const xs = args.slice(0, args.length - 1);
@@ -2110,9 +2590,12 @@ export function partition_by(f, coll) {
 export function empty(coll) {
   const type = typeConst(coll);
   if (type != null) {
-    // a class instance is not an emptyable collection, like CLJS;
-    // a plain or null-prototype object still empties to {}
-    if (type === OBJECT_TYPE && coll.constructor !== undefined && coll.constructor !== Object) return null;
+    if (type === INSTANCE_TYPE) {
+      if (coll[IEmptyableCollection__empty] !== undefined) return coll[IEmptyableCollection__empty](coll);
+      // a null-prototype object is a map rep; any other instance is not an
+      // emptyable collection, like CLJS
+      return coll.constructor === undefined ? copyMeta(coll, {}) : null;
+    }
     return copyMeta(coll, emptyOfType(type));
   }
   // non-collections give nil, like CLJS
@@ -2130,9 +2613,22 @@ export function merge(...args) {
   } else if (typeConst(firstArg) === undefined) {
     // a non-collection passes through; conj! throws when maps follow, like CLJS
     obj = firstArg;
+  } else if (firstArg[ICollection__conj] !== undefined) {
+    // a -conj type is immutable: no defensive copy needed, and a record has
+    // no empty to rebuild from
+    obj = firstArg;
   } else {
     obj = into(empty(firstArg), firstArg);
   }
+  // an ICollection target merges through -conj instead of mutation
+  if (obj != null && obj[ICollection__conj] !== undefined) {
+    for (let i = 1; i < args.length; i++) {
+      obj = obj != null && obj[ICollection__conj] !== undefined
+        ? obj[ICollection__conj](obj, args[i])
+        : conj_BANG_(obj, args[i]);
+    }
+    return obj;
+  }
   return conj_BANG_(obj, ...args.slice(1));
 }
 
@@ -2190,17 +2686,31 @@ export function into(...args) {
       if (isVectorArray(to)) {
         return pushAll(copy(to), args[1]);
       }
+      // a type with -conj is immutable: fold through the slot instead of
+      // mutating a copy. Direct slot calls keep conj out of the bundle.
+      if (to[ICollection__conj] !== undefined) {
+        return reduce(
+          (acc, x) =>
+            acc != null && acc[ICollection__conj] !== undefined
+              ? acc[ICollection__conj](acc, x)
+              : conj_BANG_(acc, x),
+          to,
+          args[1]
+        );
+      }
       return reduce(conj_BANG_, copy(to), args[1]);
     case 3:
       to = args[0];
       xform = args[1];
       from = args[2];
-      c = copy(to);
+      c = to != null && to[ICollection__conj] !== undefined ? to : copy(to);
       rf = (coll, v) => {
         if (v === undefined) {
           return coll;
         }
-        return conj_BANG_(coll, v);
+        return coll != null && coll[ICollection__conj] !== undefined
+          ? coll[ICollection__conj](coll, v)
+          : conj_BANG_(coll, v);
       };
       return transduce(xform, rf, c, from);
     default:
@@ -2531,6 +3041,10 @@ export function reverse(coll) {
   return toArray(coll).reverse();
 }
 
+export function reversible_QMARK_(x) {
+  return isVectorArray(x) || (x != null && x[SORTED_TAG] === true);
+}
+
 export function rseq(x) {
   // vectors and sorted maps/sets are reversible, like CLJS
   if (isVectorArray(x)) {
@@ -2744,6 +3258,7 @@ export function count(coll) {
   if (typeof len === 'number') {
     return len;
   }
+  if (coll[ICounted__count] !== undefined) return coll[ICounted__count](coll);
   // sum chunk lengths instead of counting elements one by one
   const next = chunkCursor(coll);
   let ret = 0;
@@ -2768,6 +3283,15 @@ export function boolean$(x) {
   return truth_(x);
 }
 
+export function parse_boolean(s) {
+  if (typeof s !== 'string') {
+    throw new Error('Argument must be a string');
+  }
+  if (s === 'true') return true;
+  if (s === 'false') return false;
+  return null;
+}
+
 export function zero_QMARK_(x) {
   return x === 0;
 }
@@ -2894,6 +3418,7 @@ export function reduce_kv(f, init, m) {
   if (!m) {
     return init;
   }
+  if (m[IKVReduce__kv_reduce] !== undefined) return m[IKVReduce__kv_reduce](m, f, init);
   var ret = init;
   for (const o of iterable(m)) {
     ret = f(ret, o[0], o[1]);
@@ -2915,11 +3440,25 @@ export function min(x, ...more) {
   return m;
 }
 
+export function associative_QMARK_(x) {
+  switch (typeConst(x)) {
+    case MAP_TYPE:
+    case ARRAY_TYPE:
+    case OBJECT_TYPE:
+      return true;
+    case INSTANCE_TYPE:
+      return x[IAssociative__assoc] !== undefined;
+    default:
+      return false;
+  }
+}
+
 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;
+  if (coll[IMap.__sym] !== undefined) return true;
   return false;
 }
 
@@ -2994,6 +3533,24 @@ export function nnext(x) {
   return next(next(x));
 }
 
+export function nthnext(coll, n) {
+  let xs = seq(coll);
+  while (xs != null && n > 0) {
+    xs = next(xs);
+    n = n - 1;
+  }
+  return xs;
+}
+
+export function nthrest(coll, n) {
+  let xs = coll;
+  while (n > 0 && seq(xs) != null) {
+    xs = rest(xs);
+    n = n - 1;
+  }
+  return xs;
+}
+
 export function compare(x, y) {
   if (x === y) {
     return 0;
@@ -3103,6 +3660,14 @@ export function keys(obj) {
   if (obj == null) return null;
   const t = typeConst(obj);
   switch (t) {
+    case INSTANCE_TYPE:
+      // Object.keys on an instance would leak internals: go through -kv-reduce
+      if (obj[IKVReduce__kv_reduce] !== undefined) {
+        const ks = obj[IKVReduce__kv_reduce](obj, (acc, k, _) => (acc.push(k), acc), []);
+        if (ks.length) return ks;
+        return;
+      }
+    // fall through
     case OBJECT_TYPE: {
       const ks = Object.keys(obj);
       if (ks.length) return ks;
@@ -3127,6 +3692,13 @@ export function vals(obj) {
   if (obj == null) return null;
   const t = typeConst(obj);
   switch (t) {
+    case INSTANCE_TYPE:
+      if (obj[IKVReduce__kv_reduce] !== undefined) {
+        const vs = obj[IKVReduce__kv_reduce](obj, (acc, _, v) => (acc.push(v), acc), []);
+        if (vs.length) return vs;
+        return;
+      }
+    // fall through
     case OBJECT_TYPE: {
       const vs = Object.values(obj);
       if (vs.length) return vs;
@@ -3210,6 +3782,26 @@ export function qualified_keyword_QMARK_(x) {
   return typeof x === 'string' && x.includes('/');
 }
 
+export function ident_QMARK_(x) {
+  return typeof x === 'string';
+}
+
+export function simple_ident_QMARK_(x) {
+  return typeof x === 'string' && namespace(x) == null;
+}
+
+export function qualified_ident_QMARK_(x) {
+  return typeof x === 'string' && namespace(x) != null;
+}
+
+export function simple_symbol_QMARK_(x) {
+  return symbol_QMARK_(x) && namespace(x) == null;
+}
+
+export function qualified_symbol_QMARK_(x) {
+  return symbol_QMARK_(x) && namespace(x) != null;
+}
+
 export function coll_QMARK_(coll) {
   return typeConst(coll) != undefined;
 }
@@ -3253,6 +3845,11 @@ export function double_QMARK_(x) {
   return typeof x === 'number';
 }
 
+// like CLJS: every number is a float
+export function float_QMARK_(x) {
+  return double_QMARK_(x);
+}
+
 export const integer_QMARK_ = int_QMARK_;
 
 export function pos_int_QMARK_(x) {
@@ -3268,30 +3865,41 @@ export function neg_int_QMARK_(x) {
 }
 
 export function meta(x) {
-  if (x instanceof Object) {
-    return x[_metaSym];
-  } else return null;
+  if (x != null && x[IMeta__meta] !== undefined) {
+    return x[IMeta__meta](x);
+  }
+  return null;
 }
 
 export function with_meta(x, m) {
+  if (x != null && x[IWithMeta__with_meta] !== undefined) {
+    return x[IWithMeta__with_meta](x, m);
+  }
+  return with_meta_copy(x, m);
+}
+
+// instance-level impls for a plain value; the meta lives in the closure
+function installMeta(x, m) {
+  x[IMeta__meta] = () => m;
+  x[IWithMeta__with_meta] = with_meta_copy;
+  return x;
+}
+
+function with_meta_copy(x, m) {
   // For functions, wrap in a new callable that forwards to the original
   // so fn? stays true and the original isn't mutated. copy() can't handle
   // functions - a {...x} spread loses the call signature.
   if (typeof x === 'function') {
     const wrapped = function (...args) { return x.apply(this, args); };
-    wrapped[_metaSym] = m;
-    return wrapped;
+    return installMeta(wrapped, m);
   }
   // 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;
+    return installMeta(ret, m);
   }
-  const ret = copy(x);
-  ret[_metaSym] = m;
-  return ret;
+  return installMeta(copy(x), m);
 }
 
 export function vary_meta(x, f, ...args) {
@@ -3308,6 +3916,7 @@ export function counted_QMARK_(x) {
     case ARRAY_TYPE:
     case MAP_TYPE:
     case OBJECT_TYPE:
+    case INSTANCE_TYPE:
     case LIST_TYPE:
     case SET_TYPE:
       return true;
@@ -3481,10 +4090,12 @@ export function flatten(x) {
 }
 
 export function transient$(x) {
+  if (x != null && x[IEditableCollection__as_transient] !== undefined) return x[IEditableCollection__as_transient](x);
   return copy(x);
 }
 
 export function persistent_BANG_(x) {
+  if (x != null && x[ITransientCollection__persistent_BANG_] !== undefined) return x[ITransientCollection__persistent_BANG_](x);
   // no Object.freeze: persistent structures stay extensible so symbol-keyed
   // metadata can be attached
   return x;
@@ -3718,6 +4329,18 @@ export function double$(x) {
   return x;
 }
 
+export function num(x) {
+  return x;
+}
+
+export function byte$(x) {
+  return x;
+}
+
+export function short$(x) {
+  return x;
+}
+
 export function type(x) {
   return x != null && x.constructor;
 }
@@ -3771,6 +4394,8 @@ export function peek(vec) {
     return first(vec);
   } else if (array_QMARK_(vec)) {
     return vec[vec.length - 1];
+  } else if (vec[IStack__peek] !== undefined) {
+    return vec[IStack__peek](vec);
   } else {
     throw missing_protocol('IStack.-peek', vec);
   }
@@ -3786,13 +4411,30 @@ export function pop(vec) {
     const ret = [...vec];
     ret.pop();
     return ret;
+  } else if (vec[IStack__pop] !== undefined) {
+    return vec[IStack__pop](vec);
   } else {
     throw missing_protocol('IStack.-pop', vec);
   }
 }
 
+export function pop_BANG_(v) {
+  if (v != null && isVectorArray(v)) {
+    if (v.length === 0) throw new Error("Can't pop empty vector");
+    v.pop();
+    return v;
+  }
+  if (v != null && v[ITransientVector__pop_BANG_] !== undefined) {
+    return v[ITransientVector__pop_BANG_](v);
+  }
+  throw missing_protocol('ITransientVector.-pop!', v);
+}
+
 export function update_keys(m, f) {
   const m2 = empty(m);
+  if (m2 != null && m2[IAssociative__assoc] !== undefined) {
+    return reduce_kv((acc, k, v) => acc[IAssociative__assoc](acc, f(k), v), m2, m);
+  }
   const assocFn = getAssocMut(m) || assoc_BANG_;
   reduce_kv(
     (acc, k, v) => {
@@ -3806,6 +4448,9 @@ export function update_keys(m, f) {
 
 export function update_vals(m, f) {
   const m2 = empty(m);
+  if (m2 != null && m2[IAssociative__assoc] !== undefined) {
+    return reduce_kv((acc, k, v) => acc[IAssociative__assoc](acc, k, f(v)), m2, m);
+  }
   const assocFn = getAssocMut(m) || assoc_BANG_;
   reduce_kv(
     (acc, k, v) => {
@@ -3886,12 +4531,15 @@ function clj__GT_js_(x, seen) {
   // we need to protect against circular objects
   if (seen.has(x)) return x;
   seen.add(x);
+  if (x != null && x[IEncodeJS__clj__GT_js] !== undefined) {
+    return x[IEncodeJS__clj__GT_js](x, (v) => clj__GT_js_(v, seen));
+  }
   if (map_QMARK_(x)) {
     return update_vals(x, (x) => clj__GT_js_(x, seen));
   }
 
   const tc = typeConst(x);
-  if (tc && tc != OBJECT_TYPE) {
+  if (tc && tc != OBJECT_TYPE && tc != INSTANCE_TYPE) {
     return mapv((x) => clj__GT_js_(x, seen), x);
   }
   return x;
@@ -3967,6 +4615,18 @@ function toEDN(value, seen = new WeakSet(), readably = true) {
         result = `(${mapv((v) => `${toEDN(v, seen, readably)}`, value).join(', ')})`;
         break;
       default:
+        if (value[IPrintWithWriter__pr_writer] !== undefined) {
+          let buf = '';
+          const writer = { [IWriter__write]: (_w, s) => (buf += s), [IWriter.__sym]: true };
+          value[IPrintWithWriter__pr_writer](value, writer, { readably: readably });
+          result = buf;
+          break;
+        }
+        if (value[IRecord.__sym] !== undefined) {
+          keys = Object.keys(value);
+          result = `#${value.constructor.name}{${keys.map((k) => `:${k} ${toEDN(value[k], seen, readably)}`).join(', ')}}`;
+          break;
+        }
         // Non-plain objects (Promise, Error, Date, class instances, ...) have a
         // constructor other than Object. Print them as #<Name> rather than {}
         // (which is what Object.keys would yield for opaque values like a
@@ -3993,3 +4653,8 @@ export function prn(...xs) {
   _STAR_print_fn_STAR_.val(pr_str(...xs));
   if (_STAR_print_newline_STAR_.val) _STAR_print_fn_STAR_.val('\n');
 }
+
+export function prn_str(...xs) {
+  return pr_str(...xs) + '\n';
+}
+