extra-iterable
Version:
An iterable is a sequence of values.
1,290 lines (1,286 loc) • 30.5 kB
JavaScript
function IDENTITY(v) {
return v;
}
function COMPARE(a, b) {
return a < b ? -1 : (a > b ? 1 : 0);
}
function mod(x, y) {
return x - y * Math.floor(x / y);
}
const END = Number.MAX_SAFE_INTEGER;
const EMPTY = [].values();
function toSet(x, fm = null) {
if (!fm)
return new Set(x);
var a = new Set(), i = -1;
for (var v of x)
a.add(fm(v, ++i, x));
return a;
}
function is(v) {
return v != null && typeof v[Symbol.iterator] === "function";
}
function isIterator(v) {
return v != null && typeof v.next === "function";
}
function isList(v) {
return is(v) && typeof v !== "string";
}
function iterator(x) {
return x[Symbol.iterator]();
}
function* keys(x) {
var i = -1;
for (var _ of x)
yield ++i;
}
function* values(x) {
yield* x;
}
function* entries(x) {
var i = -1;
for (var v of x)
yield [++i, v];
}
function from(x) {
if (is(x))
return x;
return fromIterator(x);
}
function fromIterator(x) {
return { [Symbol.iterator]: () => x };
}
function* fromRange(v = 0, V = END, dv = 1) {
for (var n = 0, N = (V - v) / dv; n < N; ++n, v += dv)
yield v;
}
function* fromInvocation(fn, ...args) {
for (;;)
yield fn(...args);
}
function* fromApplication(fm, v) {
yield v;
for (var i = 1;; ++i)
yield v = fm(v, i, null);
}
function isOnce(x) {
return x[Symbol.iterator]() === x;
}
function isMany(x) {
return !isOnce(x);
}
function toMany(x, now = false) {
if (!isOnce(x))
return x;
return now ? Array.from(x) : toManyLate(x[Symbol.iterator](), []);
}
function toManyLate(ix, a) {
return {
[Symbol.iterator]: () => {
var i = -1;
return {
next: () => {
if (++i < a.length)
return { value: a[i], done: false };
var { value, done } = ix.next();
if (!done)
a[i] = value;
return { value, done };
}
};
}
};
}
function toInvokable(x) {
var ix = x[Symbol.iterator]();
return () => ix.next().value;
}
function isEmpty(x) {
for (var _ of x)
return false;
return true;
}
function length(x, i = 0, I = END) {
var j = -1, n = 0;
for (var _ of x)
if (++j >= i && j < I)
++n;
return n;
}
function index(x, i) {
var X = length(x);
return i >= 0 ? Math.min(i, X) : Math.max(X + i, 0);
}
function indexRange(x, i = 0, I = END) {
var X = length(x);
var i = i >= 0 ? Math.min(i, X) : Math.max(X + i, 0);
var I = I >= 0 ? Math.min(I, X) : Math.max(X + I, 0);
return [i, Math.max(i, I)];
}
function compare(x, y, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var ix = x[Symbol.iterator]();
var iy = y[Symbol.iterator]();
for (var i = 0;; ++i) {
var u = ix.next();
var v = iy.next();
if (u.done || v.done)
break;
var u1 = fm(u.value, i, x);
var v1 = fm(v.value, i, y);
var c = fc(u1, v1);
if (c !== 0)
return c;
}
return (v.done ? 1 : 0) - (u.done ? 1 : 0);
}
function isEqual(x, y, fc = null, fm = null) {
return compare(x, y, fc, fm) === 0;
}
function get(x, i) {
var j = -1;
for (var v of x)
if (++j === i)
return v;
}
function* getAll(x, is) {
var i = 0, j = -1;
var IS = is.length;
for (var v of x) {
if (is[i] !== ++j)
continue;
do {
yield v;
} while (++i < IS && is[i] === is[i - 1]);
if (i >= IS)
break;
}
for (; i < IS; ++i)
yield;
}
function getPath(x, p) {
for (var i of p)
x = is(x) ? get(x, i) : undefined;
return x;
}
function hasPath(x, p) {
return getPath(x, p) !== undefined;
}
function* set(x, i, v) {
var j = -1;
for (var u of x)
yield ++j === i ? v : u;
if (j >= i)
return;
for (; ++j < i;)
yield;
yield v;
}
function* swap(x, i, j) {
if (i === j) {
yield* x;
return;
}
var k = Math.min(i, j);
var l = Math.max(i, j);
var mid = [];
var vk, i = -1;
for (var v of x) {
if (++i < k || i > l)
yield v;
else if (i === k)
vk = v;
else if (i < l)
mid.push(v);
else {
yield v;
yield* mid;
yield vk;
mid = null;
}
}
}
function* remove(x, i) {
yield* splice(x, i, 1);
}
function count(x, ft) {
var i = -1, a = 0;
for (var v of x)
if (ft(v, ++i, x))
++a;
return a;
}
function countAs(x, fm = null) {
var fm = fm || IDENTITY;
var i = -1, a = new Map();
for (var v of x) {
var v1 = fm(v, ++i, x);
a.set(v1, (a.get(v1) || 0) + 1);
}
return a;
}
function min(x, fc = null, fm = null) {
return rangeEntries(x, fc, fm)[0][1];
}
function max(x, fc = null, fm = null) {
return rangeEntries(x, fc, fm)[1][1];
}
function range(x, fc = null, fm = null) {
var [a, b] = rangeEntries(x, fc, fm);
return [a[1], b[1]];
}
function minEntry(x, fc = null, fm = null) {
return rangeEntries(x, fc, fm)[0];
}
function maxEntry(x, fc = null, fm = null) {
return rangeEntries(x, fc, fm)[1];
}
function rangeEntries(x, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var mi = -1, mu, mv;
var ni = -1, nu, nv;
var i = -1;
for (var u of x) {
var v = fm(u, ++i, x);
if (i === 0 || fc(v, mv) < 0) {
mi = i;
mu = u;
mv = v;
}
if (i === 0 || fc(v, nv) > 0) {
ni = i;
nu = u;
nv = v;
}
}
return [[mi, mu], [ni, nu]];
}
function slice(x, i = 0, I = END) {
if (i >= 0 && I >= 0)
return slicePos(x, i, I);
else if (i >= 0 && I < 0)
return slicePosNeg(x, i, I);
else
return sliceNeg(x, i, I);
}
function* slicePos(x, i, I) {
var k = -1;
for (var v of x) {
if (++k >= I)
break;
if (k >= i)
yield v;
}
}
function* slicePosNeg(x, i, I) {
var j = 0, k = -1;
var a = [], A = -I;
for (var v of x) {
if (++k < i)
continue;
if (a.length >= A)
yield a[j];
a[j] = v;
j = (j + 1) % A;
}
}
function* sliceNeg(x, i, I) {
var j = 0, X = 0;
var a = [], A = -i;
for (var v of x) {
a[j] = v;
j = (j + 1) % A;
++X;
}
var i = Math.max(X + i, 0);
var I = I < 0 ? Math.max(X + I, 0) : Math.min(I, X);
var n = Math.max(I - i, 0);
var J = Math.max(j + n - A, 0);
yield* a.slice(j, j + n);
yield* a.slice(0, J);
}
function head(x, vd) {
for (var v of x)
return v;
return vd;
}
function last(x, vd) {
var v = vd;
for (var v of x)
;
return v;
}
function* tail(x) {
var i = -1;
for (var v of x)
if (++i > 0)
yield v;
}
function* init(x) {
var u, i = -1;
for (var v of x) {
if (++i > 0)
yield u;
u = v;
}
}
function left(x, n) {
return slice(x, 0, n);
}
function right(x, n) {
return n !== 0 ? slice(x, -n) : EMPTY;
}
function middle(x, i, n = 1) {
return slice(x, i, i + n);
}
function take(x, n = 1) {
return slice(x, 0, n);
}
function takeRight(x, n = 1) {
return n > 0 ? slice(x, -n) : EMPTY;
}
function* takeWhile(x, ft) {
var i = -1;
for (var v of x) {
if (ft(v, ++i, x))
yield v;
else
return;
}
}
function* takeWhileRight(x, ft) {
var a = [], i = -1;
for (var v of x) {
if (ft(v, ++i, x))
a.push(v);
else
a.length = 0;
}
yield* a;
}
function drop(x, n = 1) {
return slice(x, n);
}
function dropRight(x, n = 1) {
return n > 0 ? slice(x, 0, -n) : values(x);
}
function* dropWhile(x, ft) {
var c = true, i = -1;
for (var v of x) {
c = c && ft(v, ++i, x);
if (!c)
yield v;
}
}
function* dropWhileRight(x, ft) {
var a = [], i = -1;
for (var v of x) {
if (ft(v, ++i, x))
a.push(v);
else {
yield* a;
yield v;
a.length = 0;
}
}
}
function includes(x, v, i = 0) {
return hasValue(slice(x, i), v);
}
function indexOf(x, v, i = 0) {
var a = searchValue(slice(x, i), v);
return a >= 0 ? a + i : a;
}
function lastIndexOf(x, v, i = END - 1) {
return searchValueRight(slice(x, 0, i + 1), v);
}
function find(x, ft) {
var i = -1;
for (var v of x)
if (ft(v, ++i, x))
return v;
}
function findRight(x, ft) {
var i = -1, a;
for (var v of x)
if (ft(v, ++i, x))
a = v;
return a;
}
function scanWhile(x, ft) {
var i = -1;
for (var v of x)
if (!ft(v, ++i, x))
return i;
return ++i;
}
function scanWhileRight(x, ft) {
var a = -1, i = -1;
for (var v of x)
if (!ft(v, ++i, x))
a = i;
return ++a;
}
function scanUntil(x, ft) {
var i = -1;
for (var v of x)
if (ft(v, ++i, x))
return i;
return ++i;
}
function scanUntilRight(x, ft) {
var a = -1, i = -1;
for (var v of x)
if (ft(v, ++i, x))
a = i;
return ++a;
}
function search(x, ft) {
var i = -1;
for (var v of x)
if (ft(v, ++i, x))
return i;
return -1;
}
function searchRight(x, ft) {
var i = -1, a = -1;
for (var v of x)
if (ft(v, ++i, x))
a = i;
return a;
}
function* searchAll(x, ft) {
var i = -1;
for (var v of x)
if (ft(v, ++i, x))
yield i;
}
function searchValue(x, v, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var v1 = fm(v, 0, null), i = -1;
for (var u of x) {
var u1 = fm(u, ++i, x);
if (fc(u1, v1) === 0)
return i;
}
return -1;
}
function searchValueRight(x, v, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var v1 = fm(v, 0, null);
var i = -1, a = -1;
for (var u of x) {
var u1 = fm(u, ++i, x);
if (fc(u1, v1) === 0)
a = i;
}
return a;
}
function* searchValueAll(x, v, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var v1 = fm(v, 0, null), i = -1;
for (var u of x) {
var u1 = fm(u, ++i, x);
if (fc(u1, v1) === 0)
yield i;
}
}
function searchInfix(x, y, fc = null, fm = null) {
return head(searchInfixAll(x, y, fc, fm), -1);
}
function searchInfixRight(x, y, fc = null, fm = null) {
return last(searchInfixAll(x, y, fc, fm), -1);
}
function* searchInfixAll(x, y, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var y1 = [...map(y, fm)];
var Y = y1.length;
if (Y === 0) {
yield* fromRange(0, length(x));
return;
}
var m = new Array(Y).fill(false);
var i = -1, J = 0;
for (var u of x) {
var u1 = fm(u, ++i, x);
for (var j = J; j > 0; --j)
m[j] = m[j - 1] && fc(u1, y1[j]) === 0;
m[0] = fc(u1, y1[0]) === 0;
J = Math.min(J + 1, Y - 1);
if (m[Y - 1])
yield i - Y + 1;
}
}
function searchSubsequence(x, y, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var y1 = [...map(y, fm)];
var Y = y1.length;
if (Y === 0)
return 0;
var si = [], sn = [], i = -1;
for (var u of x) {
var u1 = fm(u, ++i, x);
for (var s = 0, S = si.length; s < S; ++s) {
var v1 = y1[sn[s]];
if (fc(u1, v1) !== 0)
continue;
if (++sn[s] === Y)
return si[s];
}
var v1 = y1[0];
if (fc(u1, v1) !== 0)
continue;
si.push(i);
sn.push(1);
}
return -1;
}
function hasValue(x, v, fc = null, fm = null) {
return searchValue(x, v, fc, fm) >= 0;
}
function hasPrefix(x, y, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var ix = x[Symbol.iterator](), i = -1;
for (var v of y) {
var a = ix.next();
if (a.done)
return false;
var u1 = fm(a.value, ++i, x);
var v1 = fm(v, i, y);
if (fc(u1, v1) !== 0)
return false;
}
return true;
}
function hasSuffix(x, y, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var y1 = Array.isArray(y) ? y : [...y];
var Y = y1.length;
var a = [], k = 0, n = 0;
if (Y === 0)
return true;
for (var u of x) {
a[k++ % Y] = u;
++n;
}
if (a.length < Y)
return false;
for (var i = 0, j = n - Y; i < Y; ++i, ++j) {
var u1 = fm(a[k++ % Y], j, x);
var v1 = fm(y1[i], i, y);
if (fc(u1, v1) !== 0)
return false;
}
return true;
}
function hasInfix(x, y, fc = null, fm = null) {
return searchInfix(x, y, fc, fm) >= 0;
}
function hasSubsequence(x, y, fc = null, fm = null) {
return searchSubsequence(x, y, fc, fm) >= 0;
}
function forEach(x, fp) {
var i = -1;
for (var v of x)
fp(v, ++i, x);
}
function some(x, ft = null) {
if (ft)
return someTest(x, ft);
else
return someBoolean(x);
}
function someBoolean(x) {
for (var v of x)
if (v)
return true;
return false;
}
function someTest(x, ft) {
var i = -1;
for (var v of x)
if (ft(v, ++i, x))
return true;
return false;
}
function every(x, ft = null) {
if (ft)
return everyTest(x, ft);
else
return everyBoolean(x);
}
function everyBoolean(x) {
for (var v of x)
if (!v)
return false;
return true;
}
function everyTest(x, ft) {
var i = -1;
for (var v of x)
if (!ft(v, ++i, x))
return false;
return true;
}
function* map(x, fm) {
var i = -1;
for (var v of x)
yield fm(v, ++i, x);
}
function reduce(x, fr, acc) {
var init = arguments.length <= 2, i = -1;
for (var v of x) {
if (init) {
init = false;
acc = v;
++i;
}
else
acc = fr(acc, v, ++i, x);
}
return acc;
}
function* filter(x, ft) {
var i = -1;
for (var v of x)
if (ft(v, ++i, x))
yield v;
}
function* filterAt(x, is) {
var i = -1;
for (var v of x)
if (is.includes(++i))
yield v;
}
function* reject(x, ft) {
var i = -1;
for (var v of x)
if (!ft(v, ++i, x))
yield v;
}
function* rejectAt(x, is) {
var i = -1;
for (var v of x)
if (!is.includes(++i))
yield v;
}
function* accumulate(x, fr, acc) {
var init = arguments.length <= 2, i = -1;
for (var v of x) {
if (init) {
init = false;
acc = v;
++i;
}
else
acc = fr(acc, v, ++i, x);
yield acc;
}
}
function* flat(x, n = -1, fm = null, ft = null) {
var fm = fm || IDENTITY;
var ft = ft || isList, i = -1;
for (var v of x) {
var v1 = fm(v, ++i, x);
if (n !== 0 && ft(v1, i, x))
yield* flat(v1, n - 1, fm, ft);
else
yield v1;
}
}
function* flatMap(x, fm = null, ft = null) {
var fm = fm || IDENTITY;
var ft = ft || isList, i = -1;
for (var v of x) {
var v1 = fm(v, ++i, x);
if (ft(v1, i, x))
yield* v1;
else
yield v1;
}
}
function* zip(xs, fm = null, fe = null, vd) {
var fm = fm || IDENTITY;
var fe = fe || some;
var X = xs.length;
if (X === 0)
return;
var ix = [], ds = [], vs = [];
for (var r = 0; r < X; r++)
ix[r] = xs[r][Symbol.iterator]();
for (var i = 0;; ++i) {
for (var r = 0; r < X; ++r) {
var { done, value } = ix[r].next();
ds[r] = done;
vs[r] = done ? vd : value;
}
if (fe(ds))
break;
yield fm(vs.slice(), i, null);
}
}
function* fill(x, v, i = 0, I = END) {
var j = -1;
for (var u of x) {
if (++j >= i && j < I)
yield v;
else
yield u;
}
}
function* push(x, ...vs) {
yield* x;
yield* vs;
}
function* unshift(x, ...vs) {
yield* vs;
yield* x;
}
function* copy(x, y, j = 0, i = 0, I = END) {
var k = -1, J = -1;
for (var u of x) {
if (++k === j) {
J = k;
for (var v of slice(y, i, I)) {
yield v;
++J;
}
}
if (k >= j && k < J)
continue;
else
yield u;
}
if (k < j) {
for (; ++k < j;)
yield;
yield* slice(y, i, I);
}
}
function* copyWithin(x, j = 0, i = 0, I = END) {
var x = toMany(x), n = length(x);
for (var v of copy(x, x, j, i, I)) {
if (--n < 0)
break;
yield v;
}
}
function moveWithin(x, j = 0, i = 0, I = END) {
if (j < i)
return movePart(x, j, i, I);
else if (j > I)
return movePart(x, i, I, j);
else
return values(x);
}
function* movePart(x, j, k, l) {
var p = [], i = -1;
for (var v of x) {
if (++i < j || i >= l)
yield v;
else {
p.push(v);
if (i < l - 1)
continue;
yield* p.slice(k - j);
yield* p.slice(0, k - j);
}
}
}
function* splice(x, i = 0, n = END - i, ...vs) {
var j = -1;
for (var u of x) {
if (++j < i || j >= i + n)
yield u;
else if (j === i)
yield* vs;
}
}
function* split(x, ft) {
var a = [], i = -1;
for (var v of x) {
if (!ft(v, ++i, x))
a.push(v);
else if (a.length > 0) {
yield a;
a = [];
}
}
if (a.length > 0)
yield a;
}
function* splitAt(x, is) {
var a = [], i = -1;
for (var v of x) {
if (!is.includes(++i))
a.push(v);
else if (a.length > 0) {
yield a;
a = [];
}
}
if (a.length > 0)
yield a;
}
function* cut(x, ft) {
var i = -1, a = [];
for (var v of x) {
if (ft(v, ++i, x)) {
yield a;
a = [];
}
a.push(v);
}
yield a;
}
function* cutRight(x, ft) {
var i = -1, a = [];
for (var v of x) {
a.push(v);
if (ft(v, ++i, x)) {
yield a;
a = [];
}
}
yield a;
}
function* cutAt(x, is) {
var ii = is[Symbol.iterator]();
var i = ii.next();
if (i.done)
i.value = END;
var a = [], j = -1;
for (var v of x) {
if (++j < i.value) {
a.push(v);
continue;
}
yield a;
a = [v];
var i = ii.next();
if (i.done)
i.value = END;
}
yield a;
for (; !i.done; i = ii.next())
yield [];
}
function* cutAtRight(x, is) {
yield* cutAt(x, map(is, i => i + 1));
}
function* group(x, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var a = [], u1, i = -1;
for (var v of x) {
var v1 = fm(v, ++i, x);
if (i > 0 && fc(u1, v1) !== 0) {
yield a;
a = [v];
}
else
a.push(v);
u1 = v1;
}
yield a;
}
function partition(x, ft) {
var t = [], f = [], i = -1;
for (var v of x) {
if (ft(v, ++i, x))
t.push(v);
else
f.push(v);
}
return [t, f];
}
function partitionAs(x, fm = null) {
var fm = fm || IDENTITY;
var a = new Map(), i = -1;
for (var v of x) {
var v1 = fm(v, ++i, x);
if (!a.has(v1))
a.set(v1, []);
a.get(v1).push(v);
}
return a;
}
function* chunk(x, n = 1, s = n) {
var M = Math.max(n, s);
var m = 0, a = [];
for (var v of x) {
if (m < n)
a.push(v);
if (++m < M)
continue;
do {
yield a;
} while (s <= 0);
a = a.slice(s);
m = a.length;
}
if (a.length > 0)
yield a;
}
function* cycle(x, i = 0, n = -1) {
var x = toMany(x), X = 0;
if (i < 0) {
X = length(x);
if (X === 0)
return;
i = mod(i, X);
}
while (true) {
X = 0;
for (var v of x) {
++X;
if (--i >= 0)
continue;
if (n-- === 0)
return;
yield v;
}
if (X === 0)
return;
if (i >= X)
i = mod(i, X);
}
}
function* repeat(x, n = -1) {
var x = toMany(x);
for (; n !== 0; --n)
yield* x;
}
function* reverse(x) {
var a = Array.isArray(x) ? x : [...x];
for (var i = a.length - 1; i >= 0; --i)
yield a[i];
}
function rotate(x, n = 0) {
if (n === 0)
return values(x);
else if (n > 0)
return rotateLeft(x, n);
else
return rotateRight(x, -n);
}
function* rotateLeft(x, n) {
var a = [], i = -1;
for (var v of x) {
if (++i < n)
a.push(v);
else
yield v;
}
if (++i === 0 || i >= n) {
yield* a;
return;
}
var n = n % i;
yield* a.slice(n);
yield* a.slice(0, n);
}
function* rotateRight(x, n) {
var a = Array.from(x);
if (a.length === 0)
return;
var n = n % a.length;
yield* a.slice(-n);
yield* a.slice(0, -n);
}
function* intersperse(x, v) {
var i = -1;
for (var u of x) {
if (++i > 0)
yield v;
yield u;
}
}
function* interpolate(x, fc) {
var u, i = -1;
for (var v of x) {
if (++i > 0)
yield fc(u, v);
yield (u = v);
}
}
function* intermix(x, y, m = 1, n = 1, s = m, t = n) {
var x1 = chunk(x, m, s);
var y1 = chunk(repeat(y), n, t);
var iy = y1[Symbol.iterator](), i = -1;
for (var u of x1) {
if (++i > 0)
yield* iy.next().value;
yield* u;
}
}
function* interleave(xs) {
var X = xs.length;
if (X === 0)
return;
var ix = [];
for (var i = 0; i < X; ++i)
ix[i] = xs[i][Symbol.iterator]();
for (var i = 0, n = X; n > 0; i = (i + 1) % X) {
if (ix[i] == null)
continue;
var a = ix[i].next();
if (a.done) {
ix[i] = null;
--n;
}
else
yield a.value;
}
}
function* concat(...xs) {
for (var x of xs)
yield* x;
}
function* merge(xs, fc = null, fm = null) {
var X = xs.length;
var ix = [], ax = [];
for (var i = 0, n = 0; n < X; ++n) {
ix[i] = xs[i][Symbol.iterator]();
ax[i] = ix[i].next();
if (!ax[i].done)
++i;
}
while (i > 0) {
var as = ax.map(a => a.value);
var j = minEntry(as, fc, fm)[0];
yield as[j];
ax[j] = ix[j].next();
if (!ax[j].done)
continue;
ix.splice(j, 1);
ax.splice(j, 1);
--i;
}
}
function join(x, sep = ",") {
var a = "";
for (var v of x)
a += v + sep;
return a.substring(0, a.length - sep.length);
}
function isUnique(x, fc = null, fm = null) {
if (fc)
return isUniqueDual(x, fc, fm);
else
return isUniqueMap(x, fm);
}
function isUniqueMap(x, fm = null) {
var fm = fm || IDENTITY;
var x1 = new Set(), i = -1;
for (var v of x) {
var v1 = fm(v, ++i, x);
if (x1.has(v1))
return false;
x1.add(v1);
}
return true;
}
function isUniqueDual(x, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var x1 = [...map(x, fm)];
for (var u1 of x1) {
for (var v1 of x1)
if (fc(u1, v1) === 0)
return false;
}
return true;
}
function isDisjoint(x, y, fc = null, fm = null) {
if (fc)
return isDisjointDual(x, y, fc, fm);
else
return isDisjointMap(x, y, fm);
}
function isDisjointMap(x, y, fm = null) {
var y1 = toSet(y, fm), i = -1;
var fm = fm || IDENTITY;
for (var u of x) {
var u1 = fm(u, ++i, x);
if (y1.has(u1))
return false;
}
return true;
}
function isDisjointDual(x, y, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var y1 = [...map(y, fm)], i = -1;
for (var u of x) {
var u1 = fm(u, ++i, x);
for (var v1 of y1)
if (fc(u1, v1) === 0)
return false;
}
return true;
}
function* unique(x, fc = null, fm = null) {
if (fc)
yield* uniqueDual(x, fc, fm);
else
yield* uniqueMap(x, fm);
}
function* uniqueMap(x, fm = null) {
var fm = fm || IDENTITY;
var x1 = new Set(), i = -1;
for (var v of x) {
var v1 = fm(v, ++i, x);
if (x1.has(v1))
continue;
x1.add(v1);
yield v;
}
}
function* uniqueDual(x, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var x1 = [], i = -1;
NEXTX: for (var v of x) {
var v1 = fm(v, ++i, x);
for (var u1 of x1)
if (fc(u1, v1) === 0)
continue NEXTX;
x1.push(v1);
yield v;
}
}
function* union(x, y, fc = null, fm = null) {
if (fc)
yield* unionDual(x, y, fc, fm);
else
yield* unionMap(x, y, fm);
}
function* unionMap(x, y, fm = null) {
var fm = fm || IDENTITY;
var x1 = new Set();
var i = -1, j = -1;
for (var u of x) {
var u1 = fm(u, ++i, x);
x1.add(u1);
yield u;
}
for (var v of y) {
var v1 = fm(v, ++j, y);
if (!x1.has(v1))
yield v;
}
}
function* unionDual(x, y, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var x = toMany(x);
yield* x;
var x1 = [...map(x, fm)], j = -1;
NEXTY: for (var v of y) {
var v1 = fm(v, ++j, y);
for (var u1 of x1)
if (fc(u1, v1) === 0)
continue NEXTY;
yield v;
}
}
function* intersection(x, y, fc = null, fm = null) {
if (fc)
yield* intersectionDual(x, y, fc, fm);
else
yield* intersectionMap(x, y, fm);
}
function* intersectionMap(x, y, fm = null) {
var y1 = toSet(y, fm), i = -1;
var fm = fm || IDENTITY;
for (var u of x) {
var u1 = fm(u, ++i, x);
if (y1.has(u1))
yield u;
}
}
function* intersectionDual(x, y, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var y1 = [...map(y, fm)], i = -1;
NEXTX: for (var u of x) {
var u1 = fm(u, ++i, x);
for (var v1 of y1)
if (fc(u1, v1) === 0) {
yield u;
continue NEXTX;
}
}
}
function* difference(x, y, fc = null, fm = null) {
if (fc)
yield* differenceDual(x, y, fc, fm);
else
yield* differenceMap(x, y, fm);
}
function* differenceMap(x, y, fm = null) {
var y1 = toSet(y, fm), i = -1;
var fm = fm || IDENTITY;
for (var u of x) {
var u1 = fm(u, ++i, x);
if (!y1.has(u1))
yield u;
}
}
function* differenceDual(x, y, fc = null, fm = null) {
var fc = fc || COMPARE;
var fm = fm || IDENTITY;
var y1 = [...map(y, fm)], i = -1;
NEXTX: for (var u of x) {
var u1 = fm(u, ++i, x);
for (var v1 of y1)
if (fc(u1, v1) === 0)
continue NEXTX;
yield u;
}
}
function* symmetricDifference(x, y, fc = null, fm = null) {
var x = toMany(x), y = toMany(y);
yield* difference(x, y, fc, fm);
yield* difference(y, x, fc, fm);
}
function* cartesianProduct(xs, fm = null) {
var fm = fm || IDENTITY;
var X = xs.length;
if (X === 0)
return;
var jx = [], ix = [], ax = [];
for (var i = 0; i < X; ++i) {
jx[i] = i > 0 ? toMany(xs[i]) : xs[i];
ix[i] = jx[i][Symbol.iterator]();
ax[i] = ix[i].next();
if (ax[i].done)
return;
}
for (var i = 0;; ++i) {
var vs = [];
for (var a of ax)
vs.push(a.value);
yield fm(vs, i, null);
for (var r = X - 1; r >= 0; --r) {
ax[r] = ix[r].next();
if (!ax[r].done)
break;
ix[r] = jx[r][Symbol.iterator]();
ax[r] = ix[r].next();
}
if (r < 0)
break;
}
}
export { END, accumulate, toInvokable as callable, cartesianProduct, chunk, compare, concat, copy, copyWithin, count, countAs, cut, cutAt, cutAtRight, cutRight, cycle, difference, drop, dropRight, dropWhile, dropWhileRight, entries, every, fill, filter, filterAt, find, filter as findAll, findRight, flat, flatMap, forEach, from, fromApplication, fromApplication as fromApply, fromInvocation as fromCall, fromInvocation, fromIterator, fromRange, get, getAll, getPath, group, hasInfix, hasPath, hasPrefix, hasSubsequence, hasSuffix, hasValue, head, includes, index, indexOf, indexRange, init, interleave, intermix, interpolate, intersection, intersperse, is, isDisjoint, isEmpty, isEqual, isIterator, isList, isMany, isOnce, isUnique, iterator, join, keys, last, lastIndexOf, left, length, toMany as many, map, max, maxEntry, merge, middle, min, minEntry, moveWithin, partition, partitionAs, init as pop, push, range, rangeEntries, reduce, reject, rejectAt, remove, repeat, reverse, right, rotate, scanUntil, scanUntilRight, scanWhile, scanWhileRight, search, searchAll, searchInfix, searchInfixAll, searchInfixRight, searchRight, searchSubsequence, searchValue, searchValueAll, searchValueRight, set, tail as shift, length as size, slice, some, splice, split, splitAt, swap, symmetricDifference, tail, take, takeRight, takeWhile, takeWhileRight, toInvokable as toCallable, toInvokable, toMany, values as toOnce, union, unique, unshift, values, zip };