1145 lines
22 KiB
JavaScript
1145 lines
22 KiB
JavaScript
'use strict';
|
|
|
|
var Curry = require("./curry.js");
|
|
var Caml_option = require("./caml_option.js");
|
|
var Belt_SortArray = require("./belt_SortArray.js");
|
|
|
|
function treeHeight(n) {
|
|
if (n !== undefined) {
|
|
return n.h;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
function copy(n) {
|
|
if (n !== undefined) {
|
|
return {
|
|
k: n.k,
|
|
v: n.v,
|
|
h: n.h,
|
|
l: copy(n.l),
|
|
r: copy(n.r)
|
|
};
|
|
} else {
|
|
return n;
|
|
}
|
|
}
|
|
|
|
function create(l, x, d, r) {
|
|
var hl = treeHeight(l);
|
|
var hr = treeHeight(r);
|
|
return {
|
|
k: x,
|
|
v: d,
|
|
h: hl >= hr ? hl + 1 | 0 : hr + 1 | 0,
|
|
l: l,
|
|
r: r
|
|
};
|
|
}
|
|
|
|
function singleton(x, d) {
|
|
return {
|
|
k: x,
|
|
v: d,
|
|
h: 1,
|
|
l: undefined,
|
|
r: undefined
|
|
};
|
|
}
|
|
|
|
function heightGe(l, r) {
|
|
if (r !== undefined) {
|
|
if (l !== undefined) {
|
|
return l.h >= r.h;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
function updateValue(n, newValue) {
|
|
if (n.v === newValue) {
|
|
return n;
|
|
} else {
|
|
return {
|
|
k: n.k,
|
|
v: newValue,
|
|
h: n.h,
|
|
l: n.l,
|
|
r: n.r
|
|
};
|
|
}
|
|
}
|
|
|
|
function bal(l, x, d, r) {
|
|
var hl = l !== undefined ? l.h : 0;
|
|
var hr = r !== undefined ? r.h : 0;
|
|
if (hl > (hr + 2 | 0)) {
|
|
var ll = l.l;
|
|
var lr = l.r;
|
|
if (treeHeight(ll) >= treeHeight(lr)) {
|
|
return create(ll, l.k, l.v, create(lr, x, d, r));
|
|
} else {
|
|
return create(create(ll, l.k, l.v, lr.l), lr.k, lr.v, create(lr.r, x, d, r));
|
|
}
|
|
}
|
|
if (hr <= (hl + 2 | 0)) {
|
|
return {
|
|
k: x,
|
|
v: d,
|
|
h: hl >= hr ? hl + 1 | 0 : hr + 1 | 0,
|
|
l: l,
|
|
r: r
|
|
};
|
|
}
|
|
var rl = r.l;
|
|
var rr = r.r;
|
|
if (treeHeight(rr) >= treeHeight(rl)) {
|
|
return create(create(l, x, d, rl), r.k, r.v, rr);
|
|
} else {
|
|
return create(create(l, x, d, rl.l), rl.k, rl.v, create(rl.r, r.k, r.v, rr));
|
|
}
|
|
}
|
|
|
|
function minKey0Aux(_n) {
|
|
while(true) {
|
|
var n = _n;
|
|
var n$1 = n.l;
|
|
if (n$1 === undefined) {
|
|
return n.k;
|
|
}
|
|
_n = n$1;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function minKey(n) {
|
|
if (n !== undefined) {
|
|
return Caml_option.some(minKey0Aux(n));
|
|
}
|
|
|
|
}
|
|
|
|
function minKeyUndefined(n) {
|
|
if (n !== undefined) {
|
|
return minKey0Aux(n);
|
|
}
|
|
|
|
}
|
|
|
|
function maxKey0Aux(_n) {
|
|
while(true) {
|
|
var n = _n;
|
|
var n$1 = n.r;
|
|
if (n$1 === undefined) {
|
|
return n.k;
|
|
}
|
|
_n = n$1;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function maxKey(n) {
|
|
if (n !== undefined) {
|
|
return Caml_option.some(maxKey0Aux(n));
|
|
}
|
|
|
|
}
|
|
|
|
function maxKeyUndefined(n) {
|
|
if (n !== undefined) {
|
|
return maxKey0Aux(n);
|
|
}
|
|
|
|
}
|
|
|
|
function minKV0Aux(_n) {
|
|
while(true) {
|
|
var n = _n;
|
|
var n$1 = n.l;
|
|
if (n$1 === undefined) {
|
|
return [
|
|
n.k,
|
|
n.v
|
|
];
|
|
}
|
|
_n = n$1;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function minimum(n) {
|
|
if (n !== undefined) {
|
|
return minKV0Aux(n);
|
|
}
|
|
|
|
}
|
|
|
|
function minUndefined(n) {
|
|
if (n !== undefined) {
|
|
return minKV0Aux(n);
|
|
}
|
|
|
|
}
|
|
|
|
function maxKV0Aux(_n) {
|
|
while(true) {
|
|
var n = _n;
|
|
var n$1 = n.r;
|
|
if (n$1 === undefined) {
|
|
return [
|
|
n.k,
|
|
n.v
|
|
];
|
|
}
|
|
_n = n$1;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function maximum(n) {
|
|
if (n !== undefined) {
|
|
return maxKV0Aux(n);
|
|
}
|
|
|
|
}
|
|
|
|
function maxUndefined(n) {
|
|
if (n !== undefined) {
|
|
return maxKV0Aux(n);
|
|
}
|
|
|
|
}
|
|
|
|
function removeMinAuxWithRef(n, kr, vr) {
|
|
var ln = n.l;
|
|
if (ln !== undefined) {
|
|
return bal(removeMinAuxWithRef(ln, kr, vr), n.k, n.v, n.r);
|
|
} else {
|
|
kr.contents = n.k;
|
|
vr.contents = n.v;
|
|
return n.r;
|
|
}
|
|
}
|
|
|
|
function isEmpty(x) {
|
|
return x === undefined;
|
|
}
|
|
|
|
function stackAllLeft(_v, _s) {
|
|
while(true) {
|
|
var s = _s;
|
|
var v = _v;
|
|
if (v === undefined) {
|
|
return s;
|
|
}
|
|
_s = {
|
|
hd: v,
|
|
tl: s
|
|
};
|
|
_v = v.l;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function findFirstByU(n, p) {
|
|
if (n === undefined) {
|
|
return ;
|
|
}
|
|
var left = findFirstByU(n.l, p);
|
|
if (left !== undefined) {
|
|
return left;
|
|
}
|
|
var v = n.k;
|
|
var d = n.v;
|
|
var pvd = p(v, d);
|
|
if (pvd) {
|
|
return [
|
|
v,
|
|
d
|
|
];
|
|
}
|
|
var right = findFirstByU(n.r, p);
|
|
if (right !== undefined) {
|
|
return right;
|
|
}
|
|
|
|
}
|
|
|
|
function findFirstBy(n, p) {
|
|
return findFirstByU(n, Curry.__2(p));
|
|
}
|
|
|
|
function forEachU(_n, f) {
|
|
while(true) {
|
|
var n = _n;
|
|
if (n === undefined) {
|
|
return ;
|
|
}
|
|
forEachU(n.l, f);
|
|
f(n.k, n.v);
|
|
_n = n.r;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function forEach(n, f) {
|
|
forEachU(n, Curry.__2(f));
|
|
}
|
|
|
|
function mapU(n, f) {
|
|
if (n === undefined) {
|
|
return ;
|
|
}
|
|
var newLeft = mapU(n.l, f);
|
|
var newD = f(n.v);
|
|
var newRight = mapU(n.r, f);
|
|
return {
|
|
k: n.k,
|
|
v: newD,
|
|
h: n.h,
|
|
l: newLeft,
|
|
r: newRight
|
|
};
|
|
}
|
|
|
|
function map(n, f) {
|
|
return mapU(n, Curry.__1(f));
|
|
}
|
|
|
|
function mapWithKeyU(n, f) {
|
|
if (n === undefined) {
|
|
return ;
|
|
}
|
|
var key = n.k;
|
|
var newLeft = mapWithKeyU(n.l, f);
|
|
var newD = f(key, n.v);
|
|
var newRight = mapWithKeyU(n.r, f);
|
|
return {
|
|
k: key,
|
|
v: newD,
|
|
h: n.h,
|
|
l: newLeft,
|
|
r: newRight
|
|
};
|
|
}
|
|
|
|
function mapWithKey(n, f) {
|
|
return mapWithKeyU(n, Curry.__2(f));
|
|
}
|
|
|
|
function reduceU(_m, _accu, f) {
|
|
while(true) {
|
|
var accu = _accu;
|
|
var m = _m;
|
|
if (m === undefined) {
|
|
return accu;
|
|
}
|
|
var v = m.k;
|
|
var d = m.v;
|
|
var l = m.l;
|
|
var r = m.r;
|
|
_accu = f(reduceU(l, accu, f), v, d);
|
|
_m = r;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function reduce(m, accu, f) {
|
|
return reduceU(m, accu, Curry.__3(f));
|
|
}
|
|
|
|
function everyU(_n, p) {
|
|
while(true) {
|
|
var n = _n;
|
|
if (n === undefined) {
|
|
return true;
|
|
}
|
|
if (!p(n.k, n.v)) {
|
|
return false;
|
|
}
|
|
if (!everyU(n.l, p)) {
|
|
return false;
|
|
}
|
|
_n = n.r;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function every(n, p) {
|
|
return everyU(n, Curry.__2(p));
|
|
}
|
|
|
|
function someU(_n, p) {
|
|
while(true) {
|
|
var n = _n;
|
|
if (n === undefined) {
|
|
return false;
|
|
}
|
|
if (p(n.k, n.v)) {
|
|
return true;
|
|
}
|
|
if (someU(n.l, p)) {
|
|
return true;
|
|
}
|
|
_n = n.r;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function some(n, p) {
|
|
return someU(n, Curry.__2(p));
|
|
}
|
|
|
|
function addMinElement(n, k, v) {
|
|
if (n !== undefined) {
|
|
return bal(addMinElement(n.l, k, v), n.k, n.v, n.r);
|
|
} else {
|
|
return singleton(k, v);
|
|
}
|
|
}
|
|
|
|
function addMaxElement(n, k, v) {
|
|
if (n !== undefined) {
|
|
return bal(n.l, n.k, n.v, addMaxElement(n.r, k, v));
|
|
} else {
|
|
return singleton(k, v);
|
|
}
|
|
}
|
|
|
|
function join(ln, v, d, rn) {
|
|
if (ln === undefined) {
|
|
return addMinElement(rn, v, d);
|
|
}
|
|
if (rn === undefined) {
|
|
return addMaxElement(ln, v, d);
|
|
}
|
|
var lv = ln.k;
|
|
var ld = ln.v;
|
|
var lh = ln.h;
|
|
var ll = ln.l;
|
|
var lr = ln.r;
|
|
var rv = rn.k;
|
|
var rd = rn.v;
|
|
var rh = rn.h;
|
|
var rl = rn.l;
|
|
var rr = rn.r;
|
|
if (lh > (rh + 2 | 0)) {
|
|
return bal(ll, lv, ld, join(lr, v, d, rn));
|
|
} else if (rh > (lh + 2 | 0)) {
|
|
return bal(join(ln, v, d, rl), rv, rd, rr);
|
|
} else {
|
|
return create(ln, v, d, rn);
|
|
}
|
|
}
|
|
|
|
function concat(t1, t2) {
|
|
if (t1 === undefined) {
|
|
return t2;
|
|
}
|
|
if (t2 === undefined) {
|
|
return t1;
|
|
}
|
|
var kr = {
|
|
contents: t2.k
|
|
};
|
|
var vr = {
|
|
contents: t2.v
|
|
};
|
|
var t2r = removeMinAuxWithRef(t2, kr, vr);
|
|
return join(t1, kr.contents, vr.contents, t2r);
|
|
}
|
|
|
|
function concatOrJoin(t1, v, d, t2) {
|
|
if (d !== undefined) {
|
|
return join(t1, v, Caml_option.valFromOption(d), t2);
|
|
} else {
|
|
return concat(t1, t2);
|
|
}
|
|
}
|
|
|
|
function keepSharedU(n, p) {
|
|
if (n === undefined) {
|
|
return ;
|
|
}
|
|
var v = n.k;
|
|
var d = n.v;
|
|
var newLeft = keepSharedU(n.l, p);
|
|
var pvd = p(v, d);
|
|
var newRight = keepSharedU(n.r, p);
|
|
if (pvd) {
|
|
return join(newLeft, v, d, newRight);
|
|
} else {
|
|
return concat(newLeft, newRight);
|
|
}
|
|
}
|
|
|
|
function keepShared(n, p) {
|
|
return keepSharedU(n, Curry.__2(p));
|
|
}
|
|
|
|
function keepMapU(n, p) {
|
|
if (n === undefined) {
|
|
return ;
|
|
}
|
|
var v = n.k;
|
|
var d = n.v;
|
|
var newLeft = keepMapU(n.l, p);
|
|
var pvd = p(v, d);
|
|
var newRight = keepMapU(n.r, p);
|
|
if (pvd !== undefined) {
|
|
return join(newLeft, v, Caml_option.valFromOption(pvd), newRight);
|
|
} else {
|
|
return concat(newLeft, newRight);
|
|
}
|
|
}
|
|
|
|
function keepMap(n, p) {
|
|
return keepMapU(n, Curry.__2(p));
|
|
}
|
|
|
|
function partitionSharedU(n, p) {
|
|
if (n === undefined) {
|
|
return [
|
|
undefined,
|
|
undefined
|
|
];
|
|
}
|
|
var key = n.k;
|
|
var value = n.v;
|
|
var match = partitionSharedU(n.l, p);
|
|
var lf = match[1];
|
|
var lt = match[0];
|
|
var pvd = p(key, value);
|
|
var match$1 = partitionSharedU(n.r, p);
|
|
var rf = match$1[1];
|
|
var rt = match$1[0];
|
|
if (pvd) {
|
|
return [
|
|
join(lt, key, value, rt),
|
|
concat(lf, rf)
|
|
];
|
|
} else {
|
|
return [
|
|
concat(lt, rt),
|
|
join(lf, key, value, rf)
|
|
];
|
|
}
|
|
}
|
|
|
|
function partitionShared(n, p) {
|
|
return partitionSharedU(n, Curry.__2(p));
|
|
}
|
|
|
|
function lengthNode(n) {
|
|
var l = n.l;
|
|
var r = n.r;
|
|
var sizeL = l !== undefined ? lengthNode(l) : 0;
|
|
var sizeR = r !== undefined ? lengthNode(r) : 0;
|
|
return (1 + sizeL | 0) + sizeR | 0;
|
|
}
|
|
|
|
function size(n) {
|
|
if (n !== undefined) {
|
|
return lengthNode(n);
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
function toListAux(_n, _accu) {
|
|
while(true) {
|
|
var accu = _accu;
|
|
var n = _n;
|
|
if (n === undefined) {
|
|
return accu;
|
|
}
|
|
var k = n.k;
|
|
var v = n.v;
|
|
var l = n.l;
|
|
var r = n.r;
|
|
_accu = {
|
|
hd: [
|
|
k,
|
|
v
|
|
],
|
|
tl: toListAux(r, accu)
|
|
};
|
|
_n = l;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function toList(s) {
|
|
return toListAux(s, /* [] */0);
|
|
}
|
|
|
|
function checkInvariantInternal(_v) {
|
|
while(true) {
|
|
var v = _v;
|
|
if (v === undefined) {
|
|
return ;
|
|
}
|
|
var l = v.l;
|
|
var r = v.r;
|
|
var diff = treeHeight(l) - treeHeight(r) | 0;
|
|
if (!(diff <= 2 && diff >= -2)) {
|
|
throw {
|
|
RE_EXN_ID: "Assert_failure",
|
|
_1: [
|
|
"belt_internalAVLtree.ml",
|
|
373,
|
|
4
|
|
],
|
|
Error: new Error()
|
|
};
|
|
}
|
|
checkInvariantInternal(l);
|
|
_v = r;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function fillArrayKey(_n, _i, arr) {
|
|
while(true) {
|
|
var i = _i;
|
|
var n = _n;
|
|
var v = n.k;
|
|
var l = n.l;
|
|
var r = n.r;
|
|
var next = l !== undefined ? fillArrayKey(l, i, arr) : i;
|
|
arr[next] = v;
|
|
var rnext = next + 1 | 0;
|
|
if (r === undefined) {
|
|
return rnext;
|
|
}
|
|
_i = rnext;
|
|
_n = r;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function fillArrayValue(_n, _i, arr) {
|
|
while(true) {
|
|
var i = _i;
|
|
var n = _n;
|
|
var l = n.l;
|
|
var r = n.r;
|
|
var next = l !== undefined ? fillArrayValue(l, i, arr) : i;
|
|
arr[next] = n.v;
|
|
var rnext = next + 1 | 0;
|
|
if (r === undefined) {
|
|
return rnext;
|
|
}
|
|
_i = rnext;
|
|
_n = r;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function fillArray(_n, _i, arr) {
|
|
while(true) {
|
|
var i = _i;
|
|
var n = _n;
|
|
var l = n.l;
|
|
var v = n.k;
|
|
var r = n.r;
|
|
var next = l !== undefined ? fillArray(l, i, arr) : i;
|
|
arr[next] = [
|
|
v,
|
|
n.v
|
|
];
|
|
var rnext = next + 1 | 0;
|
|
if (r === undefined) {
|
|
return rnext;
|
|
}
|
|
_i = rnext;
|
|
_n = r;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function toArray(n) {
|
|
if (n === undefined) {
|
|
return [];
|
|
}
|
|
var size = lengthNode(n);
|
|
var v = new Array(size);
|
|
fillArray(n, 0, v);
|
|
return v;
|
|
}
|
|
|
|
function keysToArray(n) {
|
|
if (n === undefined) {
|
|
return [];
|
|
}
|
|
var size = lengthNode(n);
|
|
var v = new Array(size);
|
|
fillArrayKey(n, 0, v);
|
|
return v;
|
|
}
|
|
|
|
function valuesToArray(n) {
|
|
if (n === undefined) {
|
|
return [];
|
|
}
|
|
var size = lengthNode(n);
|
|
var v = new Array(size);
|
|
fillArrayValue(n, 0, v);
|
|
return v;
|
|
}
|
|
|
|
function fromSortedArrayRevAux(arr, off, len) {
|
|
switch (len) {
|
|
case 0 :
|
|
return ;
|
|
case 1 :
|
|
var match = arr[off];
|
|
return singleton(match[0], match[1]);
|
|
case 2 :
|
|
var match_0 = arr[off];
|
|
var match_1 = arr[off - 1 | 0];
|
|
var match$1 = match_1;
|
|
var match$2 = match_0;
|
|
return {
|
|
k: match$1[0],
|
|
v: match$1[1],
|
|
h: 2,
|
|
l: singleton(match$2[0], match$2[1]),
|
|
r: undefined
|
|
};
|
|
case 3 :
|
|
var match_0$1 = arr[off];
|
|
var match_1$1 = arr[off - 1 | 0];
|
|
var match_2 = arr[off - 2 | 0];
|
|
var match$3 = match_2;
|
|
var match$4 = match_1$1;
|
|
var match$5 = match_0$1;
|
|
return {
|
|
k: match$4[0],
|
|
v: match$4[1],
|
|
h: 2,
|
|
l: singleton(match$5[0], match$5[1]),
|
|
r: singleton(match$3[0], match$3[1])
|
|
};
|
|
default:
|
|
var nl = len / 2 | 0;
|
|
var left = fromSortedArrayRevAux(arr, off, nl);
|
|
var match$6 = arr[off - nl | 0];
|
|
var right = fromSortedArrayRevAux(arr, (off - nl | 0) - 1 | 0, (len - nl | 0) - 1 | 0);
|
|
return create(left, match$6[0], match$6[1], right);
|
|
}
|
|
}
|
|
|
|
function fromSortedArrayAux(arr, off, len) {
|
|
switch (len) {
|
|
case 0 :
|
|
return ;
|
|
case 1 :
|
|
var match = arr[off];
|
|
return singleton(match[0], match[1]);
|
|
case 2 :
|
|
var match_0 = arr[off];
|
|
var match_1 = arr[off + 1 | 0];
|
|
var match$1 = match_1;
|
|
var match$2 = match_0;
|
|
return {
|
|
k: match$1[0],
|
|
v: match$1[1],
|
|
h: 2,
|
|
l: singleton(match$2[0], match$2[1]),
|
|
r: undefined
|
|
};
|
|
case 3 :
|
|
var match_0$1 = arr[off];
|
|
var match_1$1 = arr[off + 1 | 0];
|
|
var match_2 = arr[off + 2 | 0];
|
|
var match$3 = match_2;
|
|
var match$4 = match_1$1;
|
|
var match$5 = match_0$1;
|
|
return {
|
|
k: match$4[0],
|
|
v: match$4[1],
|
|
h: 2,
|
|
l: singleton(match$5[0], match$5[1]),
|
|
r: singleton(match$3[0], match$3[1])
|
|
};
|
|
default:
|
|
var nl = len / 2 | 0;
|
|
var left = fromSortedArrayAux(arr, off, nl);
|
|
var match$6 = arr[off + nl | 0];
|
|
var right = fromSortedArrayAux(arr, (off + nl | 0) + 1 | 0, (len - nl | 0) - 1 | 0);
|
|
return create(left, match$6[0], match$6[1], right);
|
|
}
|
|
}
|
|
|
|
function fromSortedArrayUnsafe(arr) {
|
|
return fromSortedArrayAux(arr, 0, arr.length);
|
|
}
|
|
|
|
function cmpU(s1, s2, kcmp, vcmp) {
|
|
var len1 = size(s1);
|
|
var len2 = size(s2);
|
|
if (len1 === len2) {
|
|
var _e1 = stackAllLeft(s1, /* [] */0);
|
|
var _e2 = stackAllLeft(s2, /* [] */0);
|
|
while(true) {
|
|
var e2 = _e2;
|
|
var e1 = _e1;
|
|
if (!e1) {
|
|
return 0;
|
|
}
|
|
if (!e2) {
|
|
return 0;
|
|
}
|
|
var h2 = e2.hd;
|
|
var h1 = e1.hd;
|
|
var c = kcmp(h1.k, h2.k);
|
|
if (c !== 0) {
|
|
return c;
|
|
}
|
|
var cx = vcmp(h1.v, h2.v);
|
|
if (cx !== 0) {
|
|
return cx;
|
|
}
|
|
_e2 = stackAllLeft(h2.r, e2.tl);
|
|
_e1 = stackAllLeft(h1.r, e1.tl);
|
|
continue ;
|
|
};
|
|
} else if (len1 < len2) {
|
|
return -1;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
function cmp(s1, s2, kcmp, vcmp) {
|
|
return cmpU(s1, s2, kcmp, Curry.__2(vcmp));
|
|
}
|
|
|
|
function eqU(s1, s2, kcmp, veq) {
|
|
var len1 = size(s1);
|
|
var len2 = size(s2);
|
|
if (len1 === len2) {
|
|
var _e1 = stackAllLeft(s1, /* [] */0);
|
|
var _e2 = stackAllLeft(s2, /* [] */0);
|
|
while(true) {
|
|
var e2 = _e2;
|
|
var e1 = _e1;
|
|
if (!e1) {
|
|
return true;
|
|
}
|
|
if (!e2) {
|
|
return true;
|
|
}
|
|
var h2 = e2.hd;
|
|
var h1 = e1.hd;
|
|
if (!(kcmp(h1.k, h2.k) === 0 && veq(h1.v, h2.v))) {
|
|
return false;
|
|
}
|
|
_e2 = stackAllLeft(h2.r, e2.tl);
|
|
_e1 = stackAllLeft(h1.r, e1.tl);
|
|
continue ;
|
|
};
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function eq(s1, s2, kcmp, veq) {
|
|
return eqU(s1, s2, kcmp, Curry.__2(veq));
|
|
}
|
|
|
|
function get(_n, x, cmp) {
|
|
while(true) {
|
|
var n = _n;
|
|
if (n === undefined) {
|
|
return ;
|
|
}
|
|
var v = n.k;
|
|
var c = cmp(x, v);
|
|
if (c === 0) {
|
|
return Caml_option.some(n.v);
|
|
}
|
|
_n = c < 0 ? n.l : n.r;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function getUndefined(_n, x, cmp) {
|
|
while(true) {
|
|
var n = _n;
|
|
if (n === undefined) {
|
|
return ;
|
|
}
|
|
var v = n.k;
|
|
var c = cmp(x, v);
|
|
if (c === 0) {
|
|
return n.v;
|
|
}
|
|
_n = c < 0 ? n.l : n.r;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function getExn(_n, x, cmp) {
|
|
while(true) {
|
|
var n = _n;
|
|
if (n !== undefined) {
|
|
var v = n.k;
|
|
var c = cmp(x, v);
|
|
if (c === 0) {
|
|
return n.v;
|
|
}
|
|
_n = c < 0 ? n.l : n.r;
|
|
continue ;
|
|
}
|
|
throw {
|
|
RE_EXN_ID: "Not_found",
|
|
Error: new Error()
|
|
};
|
|
};
|
|
}
|
|
|
|
function getWithDefault(_n, x, def, cmp) {
|
|
while(true) {
|
|
var n = _n;
|
|
if (n === undefined) {
|
|
return def;
|
|
}
|
|
var v = n.k;
|
|
var c = cmp(x, v);
|
|
if (c === 0) {
|
|
return n.v;
|
|
}
|
|
_n = c < 0 ? n.l : n.r;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function has(_n, x, cmp) {
|
|
while(true) {
|
|
var n = _n;
|
|
if (n === undefined) {
|
|
return false;
|
|
}
|
|
var v = n.k;
|
|
var c = cmp(x, v);
|
|
if (c === 0) {
|
|
return true;
|
|
}
|
|
_n = c < 0 ? n.l : n.r;
|
|
continue ;
|
|
};
|
|
}
|
|
|
|
function rotateWithLeftChild(k2) {
|
|
var k1 = k2.l;
|
|
k2.l = k1.r;
|
|
k1.r = k2;
|
|
var hlk2 = treeHeight(k2.l);
|
|
var hrk2 = treeHeight(k2.r);
|
|
k2.h = (
|
|
hlk2 > hrk2 ? hlk2 : hrk2
|
|
) + 1 | 0;
|
|
var hlk1 = treeHeight(k1.l);
|
|
var hk2 = k2.h;
|
|
k1.h = (
|
|
hlk1 > hk2 ? hlk1 : hk2
|
|
) + 1 | 0;
|
|
return k1;
|
|
}
|
|
|
|
function rotateWithRightChild(k1) {
|
|
var k2 = k1.r;
|
|
k1.r = k2.l;
|
|
k2.l = k1;
|
|
var hlk1 = treeHeight(k1.l);
|
|
var hrk1 = treeHeight(k1.r);
|
|
k1.h = (
|
|
hlk1 > hrk1 ? hlk1 : hrk1
|
|
) + 1 | 0;
|
|
var hrk2 = treeHeight(k2.r);
|
|
var hk1 = k1.h;
|
|
k2.h = (
|
|
hrk2 > hk1 ? hrk2 : hk1
|
|
) + 1 | 0;
|
|
return k2;
|
|
}
|
|
|
|
function doubleWithLeftChild(k3) {
|
|
var x = k3.l;
|
|
var v = rotateWithRightChild(x);
|
|
k3.l = v;
|
|
return rotateWithLeftChild(k3);
|
|
}
|
|
|
|
function doubleWithRightChild(k2) {
|
|
var x = k2.r;
|
|
var v = rotateWithLeftChild(x);
|
|
k2.r = v;
|
|
return rotateWithRightChild(k2);
|
|
}
|
|
|
|
function heightUpdateMutate(t) {
|
|
var hlt = treeHeight(t.l);
|
|
var hrt = treeHeight(t.r);
|
|
t.h = (
|
|
hlt > hrt ? hlt : hrt
|
|
) + 1 | 0;
|
|
return t;
|
|
}
|
|
|
|
function balMutate(nt) {
|
|
var l = nt.l;
|
|
var r = nt.r;
|
|
var hl = treeHeight(l);
|
|
var hr = treeHeight(r);
|
|
if (hl > (2 + hr | 0)) {
|
|
var ll = l.l;
|
|
var lr = l.r;
|
|
if (heightGe(ll, lr)) {
|
|
return heightUpdateMutate(rotateWithLeftChild(nt));
|
|
} else {
|
|
return heightUpdateMutate(doubleWithLeftChild(nt));
|
|
}
|
|
}
|
|
if (hr > (2 + hl | 0)) {
|
|
var rl = r.l;
|
|
var rr = r.r;
|
|
if (heightGe(rr, rl)) {
|
|
return heightUpdateMutate(rotateWithRightChild(nt));
|
|
} else {
|
|
return heightUpdateMutate(doubleWithRightChild(nt));
|
|
}
|
|
}
|
|
nt.h = (
|
|
hl > hr ? hl : hr
|
|
) + 1 | 0;
|
|
return nt;
|
|
}
|
|
|
|
function updateMutate(t, x, data, cmp) {
|
|
if (t === undefined) {
|
|
return singleton(x, data);
|
|
}
|
|
var k = t.k;
|
|
var c = cmp(x, k);
|
|
if (c === 0) {
|
|
t.v = data;
|
|
return t;
|
|
}
|
|
var l = t.l;
|
|
var r = t.r;
|
|
if (c < 0) {
|
|
var ll = updateMutate(l, x, data, cmp);
|
|
t.l = ll;
|
|
} else {
|
|
t.r = updateMutate(r, x, data, cmp);
|
|
}
|
|
return balMutate(t);
|
|
}
|
|
|
|
function fromArray(xs, cmp) {
|
|
var len = xs.length;
|
|
if (len === 0) {
|
|
return ;
|
|
}
|
|
var next = Belt_SortArray.strictlySortedLengthU(xs, (function (param, param$1) {
|
|
return cmp(param[0], param$1[0]) < 0;
|
|
}));
|
|
var result;
|
|
if (next >= 0) {
|
|
result = fromSortedArrayAux(xs, 0, next);
|
|
} else {
|
|
next = -next | 0;
|
|
result = fromSortedArrayRevAux(xs, next - 1 | 0, next);
|
|
}
|
|
for(var i = next; i < len; ++i){
|
|
var match = xs[i];
|
|
result = updateMutate(result, match[0], match[1], cmp);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function removeMinAuxWithRootMutate(nt, n) {
|
|
var rn = n.r;
|
|
var ln = n.l;
|
|
if (ln !== undefined) {
|
|
n.l = removeMinAuxWithRootMutate(nt, ln);
|
|
return balMutate(n);
|
|
} else {
|
|
nt.k = n.k;
|
|
nt.v = n.v;
|
|
return rn;
|
|
}
|
|
}
|
|
|
|
exports.copy = copy;
|
|
exports.create = create;
|
|
exports.bal = bal;
|
|
exports.singleton = singleton;
|
|
exports.updateValue = updateValue;
|
|
exports.minKey = minKey;
|
|
exports.minKeyUndefined = minKeyUndefined;
|
|
exports.maxKey = maxKey;
|
|
exports.maxKeyUndefined = maxKeyUndefined;
|
|
exports.minimum = minimum;
|
|
exports.minUndefined = minUndefined;
|
|
exports.maximum = maximum;
|
|
exports.maxUndefined = maxUndefined;
|
|
exports.removeMinAuxWithRef = removeMinAuxWithRef;
|
|
exports.isEmpty = isEmpty;
|
|
exports.stackAllLeft = stackAllLeft;
|
|
exports.findFirstByU = findFirstByU;
|
|
exports.findFirstBy = findFirstBy;
|
|
exports.forEachU = forEachU;
|
|
exports.forEach = forEach;
|
|
exports.mapU = mapU;
|
|
exports.map = map;
|
|
exports.mapWithKeyU = mapWithKeyU;
|
|
exports.mapWithKey = mapWithKey;
|
|
exports.reduceU = reduceU;
|
|
exports.reduce = reduce;
|
|
exports.everyU = everyU;
|
|
exports.every = every;
|
|
exports.someU = someU;
|
|
exports.some = some;
|
|
exports.join = join;
|
|
exports.concat = concat;
|
|
exports.concatOrJoin = concatOrJoin;
|
|
exports.keepSharedU = keepSharedU;
|
|
exports.keepShared = keepShared;
|
|
exports.keepMapU = keepMapU;
|
|
exports.keepMap = keepMap;
|
|
exports.partitionSharedU = partitionSharedU;
|
|
exports.partitionShared = partitionShared;
|
|
exports.lengthNode = lengthNode;
|
|
exports.size = size;
|
|
exports.toList = toList;
|
|
exports.checkInvariantInternal = checkInvariantInternal;
|
|
exports.fillArray = fillArray;
|
|
exports.toArray = toArray;
|
|
exports.keysToArray = keysToArray;
|
|
exports.valuesToArray = valuesToArray;
|
|
exports.fromSortedArrayAux = fromSortedArrayAux;
|
|
exports.fromSortedArrayRevAux = fromSortedArrayRevAux;
|
|
exports.fromSortedArrayUnsafe = fromSortedArrayUnsafe;
|
|
exports.cmpU = cmpU;
|
|
exports.cmp = cmp;
|
|
exports.eqU = eqU;
|
|
exports.eq = eq;
|
|
exports.get = get;
|
|
exports.getUndefined = getUndefined;
|
|
exports.getWithDefault = getWithDefault;
|
|
exports.getExn = getExn;
|
|
exports.has = has;
|
|
exports.fromArray = fromArray;
|
|
exports.updateMutate = updateMutate;
|
|
exports.balMutate = balMutate;
|
|
exports.removeMinAuxWithRootMutate = removeMinAuxWithRootMutate;
|
|
/* No side effect */
|