squint-cljs 0.13.195 → 0.14.197

package/src/squint/core.js

@@ -70,7 +70,7 @@ function dequal(foo, bar) {
 
     // LazyIterable falls through to the sequential-equality path below; it is an
     // object but must compare element-wise, not by enumerable properties
-    if ((!ctor || typeof foo === 'object') && !(foo instanceof LazyIterable)) {
+    if ((!ctor || typeof foo === 'object') && foo[TYPE_TAG] !== LAZY_ITERABLE_TYPE) {
       len = 0;
       for (const k in foo) {
         if (has.call(foo, k) && ++len && !has.call(bar, k)) return false;
@@ -86,12 +86,12 @@ function dequal(foo, bar) {
   // collections keep their fast paths.
   if (
     foo && bar &&
-    (Array.isArray(foo) || foo instanceof LazyIterable) &&
-    (Array.isArray(bar) || bar instanceof LazyIterable)
+    (Array.isArray(foo) || foo[TYPE_TAG] === LAZY_ITERABLE_TYPE) &&
+    (Array.isArray(bar) || bar[TYPE_TAG] === LAZY_ITERABLE_TYPE)
   ) {
     const fi = foo[Symbol.iterator]();
     const bi = bar[Symbol.iterator]();
-    while (true) {
+    for (;;) {
       const a = fi.next();
       const b = bi.next();
       if (a.done || b.done) return !!(a.done && b.done);
@@ -249,6 +249,21 @@ const LIST_TYPE = 4;
 const SET_TYPE = 5;
 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 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.squint$lang$variadic = applyFn;
+  return f;
+}
+
 function emptyOfType(type) {
   switch (type) {
     case MAP_TYPE:
@@ -274,7 +289,7 @@ function isObj(coll) {
 }
 
 function isVectorArray(x) {
-  return Array.isArray(x) && !(x instanceof List);
+  return Array.isArray(x) && x[TYPE_TAG] !== LIST_TYPE;
 }
 
 export function object_QMARK_(coll) {
@@ -291,13 +306,10 @@ function typeConst(obj) {
   }
   if (obj instanceof Map) return MAP_TYPE;
   if (obj instanceof Set) return SET_TYPE;
-  if (obj instanceof List) return LIST_TYPE;
+  // brand, not instanceof, so dispatch does not reference the classes
+  const tag = obj[TYPE_TAG];
+  if (tag !== undefined) return tag;
   if (isVectorArray(obj)) return ARRAY_TYPE;
-  if (obj instanceof LazyIterable) return LAZY_ITERABLE_TYPE;
-  if (obj instanceof SortedSet) return SET_TYPE;
-
-  // everything more specific than Object should go before this
-  if (obj instanceof Object) return OBJECT_TYPE;
 
   return undefined;
 }
@@ -380,17 +392,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);
@@ -440,7 +466,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 {
@@ -518,19 +545,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;
 }
 
@@ -542,8 +569,21 @@ export function dec(n) {
   return n - 1;
 }
 
+export const _STAR_print_newline_STAR_ = { val: false };
+export const _STAR_print_fn_STAR_ = { val: (s) => console.log(s) };
+export const _STAR_print_err_fn_STAR_ = { val: (s) => console.error(s) };
+
+export function print(...args) {
+  _STAR_print_fn_STAR_.val(args.map((v) => toEDN(v, undefined, false)).join(' '));
+}
+
 export function println(...args) {
-  console.log(...args);
+  print(...args);
+  if (_STAR_print_newline_STAR_.val) _STAR_print_fn_STAR_.val('\n');
+}
+
+export function pr(...xs) {
+  _STAR_print_fn_STAR_.val(pr_str(...xs));
 }
 
 export function nth(coll, idx, orElse) {
@@ -813,8 +853,8 @@ function* _reductions2(f, s) {
 }
 
 function* _reductions3(f, init, coll) {
-  let i = init,
-    rst = coll;
+  let i = init;
+  const rst = coll;
   while (true) {
     if (reduced_QMARK_(i)) {
       yield i.value;
@@ -854,8 +894,11 @@ const CHUNK_SIZE = 32;
 
 // One cell of a self-caching chunked seq. `step` is a thunk returning
 // [nonEmptyChunkArray, nextStep] or null at the end. See doc/dev/lazy-seqs.md.
+const LazyIterable = defclass(
 class LazyIterable {
   constructor(step) {
+    this[TYPE_TAG] = LAZY_ITERABLE_TYPE;
+    this[IIterable] = true; // Closure compatibility
     this.step = step;
     this.realized = false;
     this.chunk = null; // array, or null when this is the terminal (empty) cell
@@ -892,9 +935,18 @@ 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.
+  indexOf(x, fromIndex = 0) {
+    let i = 0;
+    for (const v of this) {
+      if (i >= fromIndex && dequal(v, x)) return i;
+      i++;
+    }
+    return -1;
+  }
 }
-
-LazyIterable.prototype[IIterable] = true; // Closure compatibility
+);
 
 // One-element chunks: an unchunked seq, realized one element at a time.
 function unchunkedSteps(iter) {
@@ -979,7 +1031,8 @@ function mapChunks(coll, xf) {
   return new LazyIterable(step(src, 0));
 }
 
-export class Cons {
+export const Cons = defclass(
+class Cons {
   constructor(x, coll) {
     this.x = x;
     this.coll = coll;
@@ -1007,6 +1060,7 @@ export class Cons {
     };
   }
 }
+);
 
 export function cons(x, coll) {
   return new Cons(x, coll);
@@ -1387,17 +1441,33 @@ 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) {
@@ -1420,6 +1490,7 @@ export function constantly(x) {
 class List extends Array {
   constructor(...args) {
     super();
+    this[TYPE_TAG] = LIST_TYPE;
     this.push(...args);
   }
 }
@@ -1491,14 +1562,10 @@ function concat1(colls) {
   return new LazyIterable(step(null));
 }
 
-export function concat(...colls) {
-  return concat1(colls);
-}
-
-// lazy seqable argument
-concat[IApply__apply] = (colls) => {
-  return concat1(colls);
-};
+export const concat = withApply(
+  (...colls) => concat1(colls),
+  (colls) => concat1(colls), // lazy seqable argument
+);
 
 export function mapcat(f, ...colls) {
   if (colls.length === 0) {
@@ -2699,6 +2766,13 @@ export function keyword(arg1, arg2) {
   return arg1;
 }
 
+export function symbol(arg1, arg2) {
+  if (arg2 !== undefined) {
+    return (arg1 != null ? arg1 + '/' : '') + arg2;
+  }
+  return arg1;
+}
+
 export function keyword_QMARK_(x) {
   return typeof x === 'string';
 }
@@ -2760,6 +2834,10 @@ export function int_QMARK_(x) {
   return Number.isInteger(x);
 }
 
+export function double_QMARK_(x) {
+  return typeof x === 'number';
+}
+
 export const integer_QMARK_ = int_QMARK_;
 
 export function pos_int_QMARK_(x) {
@@ -2794,6 +2872,10 @@ export function with_meta(x, m) {
   return ret;
 }
 
+export function vary_meta(x, f, ...args) {
+  return with_meta(x, f(meta(x), ...args));
+}
+
 export function boolean_QMARK_(x) {
   return x === true || x === false;
 }
@@ -2881,9 +2963,11 @@ export function parse_long(s) {
 
 export function parse_double(s) {
   if (string_QMARK_(s)) {
+    // eslint-disable-next-line no-control-regex -- \x00-\x20 mirrors Java trim
     if (/^[\x00-\x20]*[+-]?NaN[\x00-\x20]*$/.test(s)) {
       return NaN;
     } else if (
+      // eslint-disable-next-line no-control-regex -- \x00-\x20 mirrors Java trim
       /^[\x00-\x20]*[+-]?(Infinity|((\d+\.?\d*|\.\d+)([eE][+-]?\d+)?)[dDfF]?)[\x00-\x20]*$/.test(
         s
       )
@@ -2996,8 +3080,11 @@ export function persistent_BANG_(x) {
   return x;
 }
 
+const SortedSet = defclass(
 class SortedSet {
   constructor(xs) {
+    this[TYPE_TAG] = SET_TYPE;
+    this[SORTED_TAG] = true;
     const isSorted = xs instanceof SortedSet;
     if (!isSorted) {
       xs = sort(xs);
@@ -3060,6 +3147,7 @@ class SortedSet {
     return this.keys();
   }
 }
+);
 
 export function sorted_set(...xs) {
   return new SortedSet(xs);
@@ -3283,7 +3371,8 @@ export function vreset_BANG_(vol, v) {
   return v;
 }
 
-function toEDN(value, seen = new WeakSet()) {
+// readably false: strings unquoted
+function toEDN(value, seen = new WeakSet(), readably = true) {
   if (value == null) return 'nil';
   if (typeof value === 'number') {
     if (value === Infinity) return '##Inf';
@@ -3292,39 +3381,48 @@ function toEDN(value, seen = new WeakSet()) {
     return String(value);
   }
   if (typeof value === 'boolean') return String(value);
-  if (typeof value === 'string') return JSON.stringify(value);
+  if (typeof value === 'string') return readably ? JSON.stringify(value) : value;
   if (typeof value === 'bigint') return `${value}N`;
 
   if (typeof value === 'object') {
+    // 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]';
     seen.add(value);
     const T = typeConst(value);
-    let keys;
+    let keys, result;
     switch (T) {
       case ARRAY_TYPE:
-        return `[${value.map((v) => toEDN(v, seen)).join(' ')}]`;
+        result = `[${value.map((v) => toEDN(v, seen, readably)).join(' ')}]`;
+        break;
       case SET_TYPE:
-        return `#{${Array.from(value)
-          .map((v) => toEDN(v, seen))
+        result = `#{${Array.from(value)
+          .map((v) => toEDN(v, seen, readably))
           .join(' ')}}`;
+        break;
       case MAP_TYPE:
-        return `#js/Map {${Array.from(value.entries())
-          .map(([k, v]) => `${toEDN(k, seen)} ${toEDN(v, seen)}`)
+        result = `#js/Map {${Array.from(value.entries())
+          .map(([k, v]) => `${toEDN(k, seen, readably)} ${toEDN(v, seen, readably)}`)
           .join(', ')}}`;
+        break;
       case LAZY_ITERABLE_TYPE:
       case LIST_TYPE:
-        return `(${mapv((v) => `${toEDN(v, seen)}`, value).join(', ')})`;
+        result = `(${mapv((v) => `${toEDN(v, seen, readably)}`, value).join(', ')})`;
+        break;
       default:
         // 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
         // Promise).
         if (value.constructor && value.constructor !== Object) {
+          seen.delete(value);
           return `#<${value.constructor.name}>`;
         }
         keys = Object.keys(value);
-        return `{${keys.map((k) => `:${k} ${toEDN(value[k], seen)}`).join(', ')}}`;
+        result = `{${keys.map((k) => `:${k} ${toEDN(value[k], seen, readably)}`).join(', ')}}`;
     }
+    seen.delete(value);
+    return result;
   }
 
   return `#object[${value.constructor.name}]`;
@@ -3335,5 +3433,6 @@ export function pr_str(...xs) {
 }
 
 export function prn(...xs) {
-  return console.log(pr_str(...xs));
+  _STAR_print_fn_STAR_.val(pr_str(...xs));
+  if (_STAR_print_newline_STAR_.val) _STAR_print_fn_STAR_.val('\n');
 }