squint-cljs 0.13.195 → 0.14.196

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');
+
+// @__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__
+function defclass(c) {
+  return c;
+}
+// @__NO_SIDE_EFFECTS__
+function withApply(f, applyFn) {
+  f[IApply__apply] = 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;
 }
@@ -542,8 +554,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 +838,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 +879,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 +920,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 +1016,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 +1045,7 @@ export class Cons {
     };
   }
 }
+);
 
 export function cons(x, coll) {
   return new Cons(x, coll);
@@ -1420,6 +1459,7 @@ export function constantly(x) {
 class List extends Array {
   constructor(...args) {
     super();
+    this[TYPE_TAG] = LIST_TYPE;
     this.push(...args);
   }
 }
@@ -1491,14 +1531,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 +2735,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 +2803,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 +2841,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 +2932,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 +3049,10 @@ export function persistent_BANG_(x) {
   return x;
 }
 
+const SortedSet = defclass(
 class SortedSet {
   constructor(xs) {
+    this[TYPE_TAG] = SET_TYPE;
     const isSorted = xs instanceof SortedSet;
     if (!isSorted) {
       xs = sort(xs);
@@ -3060,6 +3115,7 @@ class SortedSet {
     return this.keys();
   }
 }
+);
 
 export function sorted_set(...xs) {
   return new SortedSet(xs);
@@ -3283,7 +3339,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 +3349,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 +3401,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');
 }

package/src/squint/edn.js

@@ -0,0 +1,341 @@
+import * as core from './core.js';
+
+const DISCARD = Symbol('discard');
+const EOF = Symbol('eof');
+
+class Reader {
+  constructor(s) {
+    this.s = s;
+    this.idx = 0;
+  }
+  peek() {
+    return this.s[this.idx];
+  }
+  read() {
+    return this.s[this.idx++];
+  }
+  eof() {
+    return this.idx >= this.s.length;
+  }
+}
+
+function whitespace(c) {
+  return c === ' ' || c === '\t' || c === '\n' || c === '\r' || c === '\f' || c === ',';
+}
+
+function macroTerminating(c) {
+  return c === undefined || c === '"' || c === ';' || c === '@' || c === '^' ||
+    c === '`' || c === '~' || c === '(' || c === ')' || c === '[' || c === ']' ||
+    c === '{' || c === '}' || c === '\\';
+}
+
+function terminating(c) {
+  return whitespace(c) || macroTerminating(c);
+}
+
+function skipWhitespace(rdr) {
+  while (!rdr.eof()) {
+    const c = rdr.peek();
+    if (whitespace(c)) {
+      rdr.idx++;
+    } else if (c === ';') {
+      while (!rdr.eof() && rdr.peek() !== '\n') rdr.idx++;
+    } else {
+      break;
+    }
+  }
+}
+
+function readToken(rdr) {
+  const start = rdr.idx;
+  while (!rdr.eof() && !terminating(rdr.peek())) rdr.idx++;
+  return rdr.s.slice(start, rdr.idx);
+}
+
+// int-pattern carries a trailing `0\d+` poison branch (no capture group) so
+// leading-zero non-octals like 08 match here, yield no digits below, and are
+// rejected as invalid before the float pattern can accept them
+const intRe = /^([+-]?)(?:(0)|([1-9]\d*)|0[xX]([0-9a-fA-F]+)|0([0-7]+)|([1-9]\d?)[rR]([0-9a-zA-Z]+)|0\d+)(N)?$/;
+const floatRe = /^([+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)(M)?$/;
+
+// the radix-digit class is wider than the radix, so validate each digit
+function intFromRadix(s, radix) {
+  let n = 0;
+  for (let i = 0; i < s.length; i++) {
+    const d = parseInt(s[i], radix);
+    if (Number.isNaN(d)) return undefined;
+    n = n * radix + d;
+  }
+  return n;
+}
+
+// numbers are plain JS numbers; like CLJS the N and M suffixes are ignored
+function parseNumber(token) {
+  const m = intRe.exec(token);
+  if (m) {
+    const neg = m[1] === '-';
+    // radix digits range wider than the radix, so they never take N
+    if (m[7] !== undefined) {
+      const n = intFromRadix(m[7], parseInt(m[6], 10));
+      return n === undefined ? undefined : (neg ? -n : n);
+    }
+    let digits, radix;
+    if (m[2] !== undefined) { digits = '0'; radix = 10; }
+    else if (m[3] !== undefined) { digits = m[3]; radix = 10; }
+    else if (m[4] !== undefined) { digits = m[4]; radix = 16; }
+    else if (m[5] !== undefined) { digits = m[5]; radix = 8; }
+    else return undefined; // poison branch: leading-zero non-octal
+    const n = parseInt(digits, radix);
+    return neg ? -n : n;
+  }
+  // int matched above wins, so the float pattern never sees a leading-zero int
+  const f = floatRe.exec(token);
+  if (f) return parseFloat(f[1]);
+  return undefined;
+}
+
+function numberLiteral(c, c2) {
+  return (c >= '0' && c <= '9') || ((c === '+' || c === '-') && c2 >= '0' && c2 <= '9');
+}
+
+function parseToken(rdr) {
+  const token = readToken(rdr);
+  if (token === 'nil') return null;
+  if (token === 'true') return true;
+  if (token === 'false') return false;
+  if (numberLiteral(token[0], token[1])) {
+    const n = parseNumber(token);
+    if (n === undefined) throw new Error('Invalid number: ' + token);
+    return n;
+  }
+  return token;
+}
+
+function parseKeyword(rdr) {
+  rdr.idx++;
+  const token = readToken(rdr);
+  if (token === '') throw new Error('Invalid token: :');
+  // ::foo auto-resolved keywords are not valid edn
+  if (token[0] === ':') throw new Error('Invalid token: :' + token);
+  return token;
+}
+
+const stringEscapes = { t: '\t', r: '\r', n: '\n', '\\': '\\', '"': '"', b: '\b', f: '\f' };
+
+function parseString(rdr) {
+  rdr.idx++;
+  let out = '';
+  let runStart = rdr.idx;
+  for (;;) {
+    if (rdr.eof()) throw new Error('EOF while reading string');
+    const c = rdr.read();
+    if (c === '"') return out + rdr.s.slice(runStart, rdr.idx - 1);
+    if (c === '\\') {
+      out += rdr.s.slice(runStart, rdr.idx - 1);
+      const e = rdr.read();
+      if (e === 'u') {
+        out += String.fromCharCode(parseInt(rdr.s.substr(rdr.idx, 4), 16));
+        rdr.idx += 4;
+      } else if (e in stringEscapes) {
+        out += stringEscapes[e];
+      } else {
+        throw new Error('Unsupported escape character: \\' + e);
+      }
+      runStart = rdr.idx;
+    }
+  }
+}
+
+const symbolicValues = { Inf: Infinity, '-Inf': -Infinity, NaN: NaN };
+
+const namedChars = { newline: '\n', space: ' ', tab: '\t', return: '\r', backspace: '\b', formfeed: '\f' };
+
+function parseChar(rdr) {
+  rdr.idx++;
+  if (rdr.eof()) throw new Error('EOF while reading character');
+  const start = rdr.idx;
+  rdr.idx++; // first char is taken literally, even if a terminator
+  while (!rdr.eof() && !terminating(rdr.peek())) rdr.idx++;
+  const token = rdr.s.slice(start, rdr.idx);
+  if (token.length === 1) return token;
+  if (token in namedChars) return namedChars[token];
+  if (token[0] === 'u') return String.fromCharCode(parseInt(token.slice(1), 16));
+  if (token[0] === 'o') return String.fromCharCode(parseInt(token.slice(1), 8));
+  throw new Error('Unsupported character: \\' + token);
+}
+
+function parseToDelimiter(rdr, opts, delimiter) {
+  rdr.idx++;
+  const elements = [];
+  for (;;) {
+    skipWhitespace(rdr);
+    if (rdr.eof()) throw new Error('EOF while reading, expected ' + delimiter);
+    if (rdr.peek() === delimiter) {
+      rdr.idx++;
+      return elements;
+    }
+    const val = parseNext(rdr, opts);
+    if (val !== DISCARD) elements.push(val);
+  }
+}
+
+function duplicates(coll) {
+  const dups = [];
+  for (let i = 0; i < coll.length; i++) {
+    for (let j = 0; j < i; j++) {
+      if (core._EQ_(coll[i], coll[j])) {
+        dups.push(coll[i]);
+        break;
+      }
+    }
+  }
+  return dups;
+}
+
+function duplicateKeyError(kind, dups) {
+  return kind + ' literal contains duplicate key' + (dups.length > 1 ? 's' : '') +
+    ': ' + dups.map((x) => core.pr_str(x)).join(', ');
+}
+
+function parseSet(rdr, opts) {
+  const elements = parseToDelimiter(rdr, opts, '}');
+  const dups = duplicates(elements);
+  if (dups.length) throw new Error(duplicateKeyError('Set', dups));
+  return new Set(elements);
+}
+
+function qualifyKey(ns, k) {
+  if (typeof k !== 'string') return k;
+  const i = k.indexOf('/');
+  if (i === -1) return ns + '/' + k;
+  if (k.slice(0, i) === '_') return k.slice(i + 1);
+  return k;
+}
+
+function buildMap(elements, ns) {
+  if (elements.length % 2 !== 0) {
+    throw new Error('The map literal starting with ' + core.pr_str(elements[0]) + ' contains ' + elements.length +
+      ' form(s). Map literals must contain an even number of forms.');
+  }
+  const ks = elements.filter((_, i) => i % 2 === 0);
+  const dups = duplicates(ks);
+  if (dups.length) throw new Error(duplicateKeyError('Map', dups));
+  const obj = {};
+  for (let i = 0; i < elements.length; i += 2) {
+    obj[ns ? qualifyKey(ns, elements[i]) : elements[i]] = elements[i + 1];
+  }
+  return obj;
+}
+
+function parseMap(rdr, opts) {
+  return buildMap(parseToDelimiter(rdr, opts, '}'), null);
+}
+
+function parseMeta(rdr, opts) {
+  rdr.idx++;
+  skipWhitespace(rdr);
+  const c = rdr.peek();
+  let m;
+  if (c === '{') {
+    m = parseMap(rdr, opts);
+  } else if (c === ':') {
+    m = {};
+    m[parseKeyword(rdr)] = true;
+  } else {
+    // a symbol or string tags the value
+    m = { tag: parseNext(rdr, opts) };
+  }
+  skipWhitespace(rdr);
+  const form = parseNext(rdr, opts);
+  if (form === null || typeof form !== 'object') {
+    throw new Error('Metadata can only be applied to IMetas');
+  }
+  // stacked metadata merges, with the outer map winning
+  return core.with_meta(form, Object.assign({}, core.meta(form), m));
+}
+
+function parseNamespacedMap(rdr, opts) {
+  const token = readToken(rdr);
+  if (token === ':' || token[1] === ':') throw new Error('Invalid token: ' + token);
+  skipWhitespace(rdr);
+  if (rdr.peek() !== '{') throw new Error('Namespaced map must specify a map');
+  return buildMap(parseToDelimiter(rdr, opts, '}'), token.slice(1));
+}
+
+const defaultReaders = {
+  inst: (val) => new Date(val),
+  uuid: (val) => val,
+};
+
+function parseTagged(rdr, opts) {
+  const tag = readToken(rdr);
+  skipWhitespace(rdr);
+  const val = parseNext(rdr, opts);
+  const readers = opts && opts.readers;
+  if (readers && readers[tag]) return readers[tag](val);
+  if (defaultReaders[tag]) return defaultReaders[tag](val);
+  if (opts && opts.default) return opts.default(tag, val);
+  throw new Error('No reader function for tag ' + tag);
+}
+
+function parseDispatch(rdr, opts) {
+  rdr.idx++;
+  const c = rdr.peek();
+  if (c === '_') {
+    rdr.idx++;
+    // discard one real form; skip nested discards so #_ #_ a b drops both
+    let v = parseNext(rdr, opts);
+    while (v === DISCARD) v = parseNext(rdr, opts);
+    return DISCARD;
+  }
+  if (c === '!') {
+    while (!rdr.eof() && rdr.peek() !== '\n') rdr.idx++;
+    return DISCARD;
+  }
+  if (c === '{') return parseSet(rdr, opts);
+  if (c === ':') return parseNamespacedMap(rdr, opts);
+  if (c === '#') {
+    rdr.idx++;
+    const token = readToken(rdr);
+    if (token in symbolicValues) return symbolicValues[token];
+    throw new Error('Invalid token: ##' + token);
+  }
+  return parseTagged(rdr, opts);
+}
+
+function parseNext(rdr, opts) {
+  skipWhitespace(rdr);
+  if (rdr.eof()) return EOF;
+  const c = rdr.peek();
+  switch (c) {
+    case '(': return core.list(...parseToDelimiter(rdr, opts, ')'));
+    case '[': return parseToDelimiter(rdr, opts, ']');
+    case '{': return parseMap(rdr, opts);
+    case ')': case ']': case '}': throw new Error('Unmatched delimiter: ' + c);
+    case '"': return parseString(rdr);
+    case '\\': return parseChar(rdr);
+    case ':': return parseKeyword(rdr);
+    case '#': return parseDispatch(rdr, opts);
+    case "'": rdr.idx++; return core.list('quote', parseNext(rdr, opts));
+    case '^': return parseMeta(rdr, opts);
+    case '@': case '`': case '~': throw new Error('Invalid leading character: ' + c);
+    default: return parseToken(rdr);
+  }
+}
+
+export function read_string(a, b) {
+  let opts, s;
+  if (b === undefined) {
+    opts = null;
+    s = a;
+  } else {
+    opts = a;
+    s = b;
+  }
+  if (s == null || s === '') return opts && 'eof' in opts ? opts.eof : null;
+  const rdr = new Reader(s);
+  let val = parseNext(rdr, opts);
+  while (val === DISCARD) val = parseNext(rdr, opts);
+  if (val === EOF) return opts && 'eof' in opts ? opts.eof : null;
+  return val;
+}