squint-cljs 0.5.86 → 0.6.87

package/src/squint/core.js

@@ -26,7 +26,7 @@ function walkArray(arr, comp) {
 }
 
 export function _EQ_(...xs) {
-  return walkArray(xs, (x,y) => x === y);
+  return walkArray(xs, (x, y) => x === y);
 }
 
 export function _GT_(...xs) {
@@ -605,7 +605,7 @@ export function reduced_QMARK_(x) {
 export function reduce(f, arg1, arg2) {
   f = toFn(f);
   let coll, val;
-  if (arg2 === undefined) {
+  if (arguments.length === 2) {
     // (reduce f coll)
     const iter = iterable(arg1)[Symbol.iterator]();
     const vd = iter.next();
@@ -659,7 +659,7 @@ function* _reductions3(f, init, coll) {
 
 export function reductions(f, arg1, arg2) {
   f = toFn(f);
-  if (arg2 === undefined) {
+  if (arguments.length === 2) {
     return lazy(function* () {
       yield* _reductions2(f, iterable(arg1)[Symbol.iterator]());
     });
@@ -785,7 +785,7 @@ function filter1(pred) {
 }
 
 export function filter(pred, coll) {
-  if (coll === undefined) {
+  if (arguments.length === 1) {
     return filter1(pred);
   }
   pred = toFn(pred);
@@ -806,8 +806,24 @@ export function remove(pred, coll) {
   return filter(complement(pred), coll);
 }
 
+function map_indexed1(f) {
+  return (rf) => {
+    let i = -1;
+    return (...args) => {
+      switch (args.length) {
+        case 0: return rf();
+        case 1: return rf(args[0]);
+        case 2: return rf(args[0], f((i = i + 1, i), args[1]));
+      }
+    };
+  };
+}
+
 export function map_indexed(f, coll) {
   f = toFn(f);
+  if (arguments.length === 1) {
+    return map_indexed1(f);
+  }
   const ret = [];
   let i = 0;
   for (const x of iterable(coll)) {
@@ -834,25 +850,30 @@ function keep_indexed2(f, coll) {
 function keep_indexed1(f) {
   return (rf) => {
     let ia = -1;
-    return (result, input) => {
-      if (result === undefined) {
+    return (...args) => {
+      const al = args.length;
+      if (al === 0) {
         return rf();
       }
-      if (input === undefined) {
-        return rf(result);
+      if (al === 1) {
+        return rf(args[0]);
       }
-      ia++;
-      const v = f(ia, input);
-      if (v == null) {
-        return result;
+      if (al === 2) {
+        const result = args[0];
+        const input = args[1];
+        ia++;
+        const v = f(ia, input);
+        if (v == null) {
+          return result;
+        }
+        return rf(result, v);
       }
-      return rf(result, v);
     };
   };
 }
 
 export function keep_indexed(f, coll) {
-  if (coll === undefined) {
+  if (arguments.length === 1) {
     return keep_indexed1(f);
   } else {
     return keep_indexed2(f, coll);
@@ -900,30 +921,32 @@ export function prn(...xs) {
   println(pr_str(...xs));
 }
 
-export function Atom(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);
+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];
-  };
+      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) {
@@ -1126,7 +1149,33 @@ export function interleave(...colls) {
   });
 }
 
+function interpose1(sep) {
+  return (rf) => {
+    let started = false;
+    return (...args) => {
+      switch (args.length) {
+        case 0: return rf();
+        case 1: return rf(args[0]);
+        case 2: {
+          if (started) {
+            const sepr = rf(args[0], sep);
+            if (reduced_QMARK_(sepr)) {
+              return sepr;
+            } else {
+              return rf(sepr, args[1]);
+            }
+          } else {
+            started = true;
+            return rf(args[0], args[1]);
+          }
+        }
+      }
+    };
+  };
+}
+
 export function interpose(sep, coll) {
+  if (arguments.length === 1) return interpose1(sep);
   return drop(1, interleave(repeat(sep), coll));
 }
 
@@ -1143,7 +1192,50 @@ export function select_keys(o, ks) {
   return ret;
 }
 
+export function unreduced(x) {
+  if (reduced_QMARK_(x)) {
+    return deref(x);
+  } else {
+    return x;
+  }
+}
+
+function partition_all1(n) {
+  return (rf) => {
+    let a = [];
+    return (...args) => {
+      let result, v;
+      switch (args.length) {
+        case 0: return rf();
+        case 1: {
+          result = args[0];
+          if (a.length !== 0) {
+            v = [...a];
+            a = [];
+            result = unreduced(rf(result, v));
+          }
+          return rf(result);
+        }
+        case 2: {
+          result = args[0];
+          a.push(args[1]);
+          if (n === a.length) {
+            v = [...a];
+            a = [];
+            return rf(result, v);
+          } else {
+            return result;
+          }
+        }
+      }
+    };
+  };
+}
+
 export function partition_all(n, ...args) {
+  if (arguments.length === 1) {
+    return partition_all1(n);
+  }
   let step = n,
     coll = args[0];
 
@@ -1195,8 +1287,54 @@ function partitionInternal(n, step, pad, coll, all) {
   });
 }
 
+function partition_by1(f) {
+  return (rf) => {
+    let a = [];
+    const none = {};
+    let pa = none;
+    return (...args) => {
+      const l = args.length;
+      let v;
+      if (l === 0) {
+        return rf();
+      }
+      if (l === 1) {
+        let result = args[0];
+        if (a.length !== 0) {
+          const v = [...a];
+          a = [];
+          result = unreduced(rf(result, v));
+        }
+        return rf(result);
+      }
+      if (l === 2) {
+        const result = args[0];
+        const input = args[1];
+        const pval = pa;
+        const val = f(input);
+        pa = val;
+        if (pval === none || val === pval) {
+          a.push(input);
+          return result;
+        } else {
+          const v = [...a];
+          a = [];
+          const ret = rf(result, v);
+          if (!reduced_QMARK_(ret)) {
+            a.push(input);
+          }
+          return ret;
+        }
+      }
+    };
+  };
+}
+
 export function partition_by(f, coll) {
   f = toFn(f);
+  if (arguments.length === 1) {
+    return partition_by1(f);
+  }
   return lazy(function* () {
     const iter = es6_iterator(coll);
     const _fst = iter.next();
@@ -1339,7 +1477,49 @@ export function repeat(...args) {
   };
 }
 
+export function ensure_reduced(x) {
+  if (reduced_QMARK_(x)) {
+    return x;
+  } else {
+    return reduced(x);
+  }
+}
+
+function take1(n) {
+  return (rf) => {
+    let na = n;
+    return (...args) => {
+      const al = args.length;
+      if (al === 0) {
+        return rf();
+      }
+      if (al === 1) {
+        const result = args[0];
+        return rf(result);
+      }
+      if (al === 2) {
+        let result = args[0];
+        const input = args[1];
+        const n = na;
+        const nn = (na = na - 1, na);
+        if (n > 0) {
+          result = rf(result, input);
+        }
+        if (!(nn > 0)) {
+          return ensure_reduced(result);
+        }
+        else {
+          return result;
+        }
+      }
+    };
+  };
+}
+
 export function take(n, coll) {
+  if (arguments.length === 1) {
+    return take1(n);
+  }
   return lazy(function* () {
     let i = n - 1;
     for (const x of iterable(coll)) {
@@ -1353,8 +1533,30 @@ export function take(n, coll) {
   });
 }
 
+function take_while1(pred) {
+  return (rf) => {
+    return (...args) => {
+      const al = args.length;
+      if (al === 0) return rf();
+      if (al === 1) return rf(args[0]);
+      if (al === 2) {
+        const result = args[0];
+        const input = args[1];
+        if (truth_(pred(input))) {
+          return rf(result, input);
+        } else {
+          return reduced(result);
+        }
+      }
+    };
+  };
+}
+
 export function take_while(pred, coll) {
   pred = toFn(pred);
+  if (arguments.length === 1) {
+    return take_while1(pred);
+  }
   return lazy(function* () {
     for (const o of iterable(coll)) {
       if (truth_(pred(o))) yield o;
@@ -1363,7 +1565,28 @@ export function take_while(pred, coll) {
   });
 }
 
+function take_nth1(n) {
+  return (rf) => {
+    let ia = -1;
+    return (...args) => {
+      const al = args.length;
+      if (al === 0) return rf();
+      if (al === 1) return rf(args[0]);
+      if (al === 2) {
+        const result = args[0];
+        const input = args[1];
+        ia++;
+        const i = ia;
+        if (rem(i, n) === 0) {
+          return rf(result, input);
+        } else return result;
+      }
+    };
+  };
+}
+
 export function take_nth(n, coll) {
+  if (arguments.length === 1) return take_nth1(n);
   if (n <= 0) {
     return repeat(first(coll));
   }
@@ -1392,7 +1615,32 @@ export function cycle(coll) {
   });
 }
 
+function drop1(n) {
+  return (rf) => {
+    let na = n;
+    return (...args) => {
+      const al = args.length;
+      if (al === 0) {
+        return rf();
+      }
+      if (al === 1) {
+        return rf(args[0]);
+      }
+      if (al === 2) {
+        const result = args[0];
+        const input = args[1];
+        const n = na;
+        na--;
+        if (n > 0) {
+          return result;
+        } else return rf(result, input);
+      }
+    };
+  };
+}
+
 export function drop(n, xs) {
+  if (arguments.length === 1) return drop1(n);
   return lazy(function* () {
     const iter = _iterator(iterable(xs));
     for (let x = 0; x < n; x++) {
@@ -1402,8 +1650,35 @@ export function drop(n, xs) {
   });
 }
 
+function drop_while1(pred) {
+  return (rf) => {
+    let da = true;
+    return (...args) => {
+      const al = args.length;
+      if (al === 0) {
+        return rf();
+      }
+      if (al === 1) {
+        return rf(args[0]);
+      }
+      if (al === 2) {
+        const isDrop = da;
+        const result = args[0];
+        const input = args[1];
+        if (isDrop && truth_(pred(input))) {
+          return result;
+        } else {
+          da = null;
+          return rf(result, input);
+        }
+      }
+    };
+  };
+}
+
 export function drop_while(pred, xs) {
   pred = toFn(pred);
+  if (arguments.length === 1) return drop_while1(pred);
   return lazy(function* () {
     const iter = _iterator(iterable(xs));
     while (true) {
@@ -1421,7 +1696,26 @@ export function drop_while(pred, xs) {
   });
 }
 
+function distinct1() {
+  return (rf) => {
+    const seen = new Set();
+    return (...args) => {
+      const al = args.length;
+      if (al === 0) return rf();
+      if (al === 1) return rf(args[0]);
+      if (al === 2) {
+        const result = args[0];
+        const input = args[1];
+        if (seen.has(input)) return result;
+        seen.add(input);
+        return rf(result, input);
+      }
+    };
+  };
+}
+
 export function distinct(coll) {
+  if (arguments.length === 0) return distinct1();
   return lazy(function* () {
     const seen = new Set();
     for (const x of iterable(coll)) {
@@ -1474,8 +1768,26 @@ export function not_every_QMARK_(pred, coll) {
   return !every_QMARK_(pred, coll);
 }
 
+function keep1(pred) {
+  return (rf) => {
+    return (...args) => {
+      const al = args.length;
+      if (al === 0) return rf();
+      if (al === 1) return rf(args[0]);
+      if (al === 2) {
+        const result = args[0];
+        const input = args[1];
+        const v = pred(input);
+        if (v == null) return result;
+        return rf(result, v);
+      }
+    };
+  };
+}
+
 export function keep(pred, coll) {
   pred = toFn(pred);
+  if (arguments.length === 1) return keep1(pred);
   return lazy(function* () {
     for (const o of iterable(coll)) {
       const res = pred(o);
@@ -1490,7 +1802,7 @@ export function reverse(coll) {
 }
 
 export function sort(f, coll) {
-  if (coll === undefined) {
+  if (arguments.length === 1) {
     coll = f;
     f = undefined;
   }
@@ -1522,7 +1834,7 @@ function fnToComparator(f) {
 }
 
 export function sort_by(keyfn, comp, coll) {
-  if (coll === undefined) {
+  if (arguments.length === 2) {
     coll = comp;
     comp = compare;
   }
@@ -1588,7 +1900,7 @@ function _repeatedly(f) {
 }
 
 export function repeatedly(n, f) {
-  if (f === undefined) {
+  if (arguments.length === 1) {
     f = n;
     n = undefined;
   }
@@ -2364,7 +2676,7 @@ export function pop(vec) {
 export function update_keys(m, f) {
   const m2 = empty(m);
   const assocFn = getAssocMut(m) || assoc_BANG_;
-  reduce_kv( (acc, k, v) => {
+  reduce_kv((acc, k, v) => {
     return assocFn(acc, f(k), v);
   }, m2, m);
   return m2;
@@ -2373,7 +2685,7 @@ export function update_keys(m, f) {
 export function update_vals(m, f) {
   const m2 = empty(m);
   const assocFn = getAssocMut(m) || assoc_BANG_;
-  reduce_kv( (acc, k, v) => {
+  reduce_kv((acc, k, v) => {
     return assocFn(acc, k, f(v));
   }, m2, m);
   return m2;