time-to-botec/squiggle/node_modules/@rescript/std/lib/es6/belt_MutableSetString.js

502 lines
10 KiB
JavaScript
Raw Normal View History

import * as Curry from "./curry.js";
import * as Belt_internalAVLset from "./belt_internalAVLset.js";
import * as Belt_SortArrayString from "./belt_SortArrayString.js";
import * as Belt_internalSetString from "./belt_internalSetString.js";
function remove0(nt, x) {
var k = nt.v;
if (x === k) {
var l = nt.l;
var r = nt.r;
if (l !== undefined) {
if (r !== undefined) {
nt.r = Belt_internalAVLset.removeMinAuxWithRootMutate(nt, r);
return Belt_internalAVLset.balMutate(nt);
} else {
return l;
}
} else {
return r;
}
}
if (x < k) {
var l$1 = nt.l;
if (l$1 !== undefined) {
nt.l = remove0(l$1, x);
return Belt_internalAVLset.balMutate(nt);
} else {
return nt;
}
}
var r$1 = nt.r;
if (r$1 !== undefined) {
nt.r = remove0(r$1, x);
return Belt_internalAVLset.balMutate(nt);
} else {
return nt;
}
}
function remove(d, v) {
var oldRoot = d.data;
if (oldRoot === undefined) {
return ;
}
var newRoot = remove0(oldRoot, v);
if (newRoot !== oldRoot) {
d.data = newRoot;
return ;
}
}
function removeMany0(_t, xs, _i, len) {
while(true) {
var i = _i;
var t = _t;
if (i >= len) {
return t;
}
var ele = xs[i];
var u = remove0(t, ele);
if (u === undefined) {
return ;
}
_i = i + 1 | 0;
_t = u;
continue ;
};
}
function removeMany(d, xs) {
var oldRoot = d.data;
if (oldRoot === undefined) {
return ;
}
var len = xs.length;
d.data = removeMany0(oldRoot, xs, 0, len);
}
function removeCheck0(nt, x, removed) {
var k = nt.v;
if (x === k) {
removed.contents = true;
var l = nt.l;
var r = nt.r;
if (l !== undefined) {
if (r !== undefined) {
nt.r = Belt_internalAVLset.removeMinAuxWithRootMutate(nt, r);
return Belt_internalAVLset.balMutate(nt);
} else {
return l;
}
} else {
return r;
}
}
if (x < k) {
var l$1 = nt.l;
if (l$1 !== undefined) {
nt.l = removeCheck0(l$1, x, removed);
return Belt_internalAVLset.balMutate(nt);
} else {
return nt;
}
}
var r$1 = nt.r;
if (r$1 !== undefined) {
nt.r = removeCheck0(r$1, x, removed);
return Belt_internalAVLset.balMutate(nt);
} else {
return nt;
}
}
function removeCheck(d, v) {
var oldRoot = d.data;
if (oldRoot === undefined) {
return false;
}
var removed = {
contents: false
};
var newRoot = removeCheck0(oldRoot, v, removed);
if (newRoot !== oldRoot) {
d.data = newRoot;
}
return removed.contents;
}
function addCheck0(t, x, added) {
if (t !== undefined) {
var k = t.v;
if (x === k) {
return t;
}
var l = t.l;
var r = t.r;
if (x < k) {
var ll = addCheck0(l, x, added);
t.l = ll;
} else {
t.r = addCheck0(r, x, added);
}
return Belt_internalAVLset.balMutate(t);
}
added.contents = true;
return Belt_internalAVLset.singleton(x);
}
function addCheck(m, e) {
var oldRoot = m.data;
var added = {
contents: false
};
var newRoot = addCheck0(oldRoot, e, added);
if (newRoot !== oldRoot) {
m.data = newRoot;
}
return added.contents;
}
function add(d, k) {
var oldRoot = d.data;
var v = Belt_internalSetString.addMutate(oldRoot, k);
if (v !== oldRoot) {
d.data = v;
return ;
}
}
function addArrayMutate(t, xs) {
var v = t;
for(var i = 0 ,i_finish = xs.length; i < i_finish; ++i){
v = Belt_internalSetString.addMutate(v, xs[i]);
}
return v;
}
function mergeMany(d, arr) {
d.data = addArrayMutate(d.data, arr);
}
function make(param) {
return {
data: undefined
};
}
function isEmpty(d) {
var n = d.data;
return n === undefined;
}
function minimum(d) {
return Belt_internalAVLset.minimum(d.data);
}
function minUndefined(d) {
return Belt_internalAVLset.minUndefined(d.data);
}
function maximum(d) {
return Belt_internalAVLset.maximum(d.data);
}
function maxUndefined(d) {
return Belt_internalAVLset.maxUndefined(d.data);
}
function forEachU(d, f) {
Belt_internalAVLset.forEachU(d.data, f);
}
function forEach(d, f) {
Belt_internalAVLset.forEachU(d.data, Curry.__1(f));
}
function reduceU(d, acc, cb) {
return Belt_internalAVLset.reduceU(d.data, acc, cb);
}
function reduce(d, acc, cb) {
return reduceU(d, acc, Curry.__2(cb));
}
function everyU(d, p) {
return Belt_internalAVLset.everyU(d.data, p);
}
function every(d, p) {
return Belt_internalAVLset.everyU(d.data, Curry.__1(p));
}
function someU(d, p) {
return Belt_internalAVLset.someU(d.data, p);
}
function some(d, p) {
return Belt_internalAVLset.someU(d.data, Curry.__1(p));
}
function size(d) {
return Belt_internalAVLset.size(d.data);
}
function toList(d) {
return Belt_internalAVLset.toList(d.data);
}
function toArray(d) {
return Belt_internalAVLset.toArray(d.data);
}
function fromSortedArrayUnsafe(xs) {
return {
data: Belt_internalAVLset.fromSortedArrayUnsafe(xs)
};
}
function checkInvariantInternal(d) {
Belt_internalAVLset.checkInvariantInternal(d.data);
}
function fromArray(xs) {
return {
data: Belt_internalSetString.fromArray(xs)
};
}
function cmp(d0, d1) {
return Belt_internalSetString.cmp(d0.data, d1.data);
}
function eq(d0, d1) {
return Belt_internalSetString.eq(d0.data, d1.data);
}
function get(d, x) {
return Belt_internalSetString.get(d.data, x);
}
function getUndefined(d, x) {
return Belt_internalSetString.getUndefined(d.data, x);
}
function getExn(d, x) {
return Belt_internalSetString.getExn(d.data, x);
}
function split(d, key) {
var arr = Belt_internalAVLset.toArray(d.data);
var i = Belt_SortArrayString.binarySearch(arr, key);
var len = arr.length;
if (i >= 0) {
return [
[
{
data: Belt_internalAVLset.fromSortedArrayAux(arr, 0, i)
},
{
data: Belt_internalAVLset.fromSortedArrayAux(arr, i + 1 | 0, (len - i | 0) - 1 | 0)
}
],
true
];
}
var next = (-i | 0) - 1 | 0;
return [
[
{
data: Belt_internalAVLset.fromSortedArrayAux(arr, 0, next)
},
{
data: Belt_internalAVLset.fromSortedArrayAux(arr, next, len - next | 0)
}
],
false
];
}
function keepU(d, p) {
return {
data: Belt_internalAVLset.keepCopyU(d.data, p)
};
}
function keep(d, p) {
return keepU(d, Curry.__1(p));
}
function partitionU(d, p) {
var match = Belt_internalAVLset.partitionCopyU(d.data, p);
return [
{
data: match[0]
},
{
data: match[1]
}
];
}
function partition(d, p) {
return partitionU(d, Curry.__1(p));
}
function subset(a, b) {
return Belt_internalSetString.subset(a.data, b.data);
}
function intersect(dataa, datab) {
var dataa$1 = dataa.data;
var datab$1 = datab.data;
if (dataa$1 === undefined) {
return {
data: undefined
};
}
if (datab$1 === undefined) {
return {
data: undefined
};
}
var sizea = Belt_internalAVLset.lengthNode(dataa$1);
var sizeb = Belt_internalAVLset.lengthNode(datab$1);
var totalSize = sizea + sizeb | 0;
var tmp = new Array(totalSize);
Belt_internalAVLset.fillArray(dataa$1, 0, tmp);
Belt_internalAVLset.fillArray(datab$1, sizea, tmp);
if (tmp[sizea - 1 | 0] < tmp[sizea] || tmp[totalSize - 1 | 0] < tmp[0]) {
return {
data: undefined
};
}
var tmp2 = new Array(sizea < sizeb ? sizea : sizeb);
var k = Belt_SortArrayString.intersect(tmp, 0, sizea, tmp, sizea, sizeb, tmp2, 0);
return {
data: Belt_internalAVLset.fromSortedArrayAux(tmp2, 0, k)
};
}
function diff(dataa, datab) {
var dataa$1 = dataa.data;
var datab$1 = datab.data;
if (dataa$1 === undefined) {
return {
data: undefined
};
}
if (datab$1 === undefined) {
return {
data: Belt_internalAVLset.copy(dataa$1)
};
}
var sizea = Belt_internalAVLset.lengthNode(dataa$1);
var sizeb = Belt_internalAVLset.lengthNode(datab$1);
var totalSize = sizea + sizeb | 0;
var tmp = new Array(totalSize);
Belt_internalAVLset.fillArray(dataa$1, 0, tmp);
Belt_internalAVLset.fillArray(datab$1, sizea, tmp);
if (tmp[sizea - 1 | 0] < tmp[sizea] || tmp[totalSize - 1 | 0] < tmp[0]) {
return {
data: Belt_internalAVLset.copy(dataa$1)
};
}
var tmp2 = new Array(sizea);
var k = Belt_SortArrayString.diff(tmp, 0, sizea, tmp, sizea, sizeb, tmp2, 0);
return {
data: Belt_internalAVLset.fromSortedArrayAux(tmp2, 0, k)
};
}
function union(dataa, datab) {
var dataa$1 = dataa.data;
var datab$1 = datab.data;
if (dataa$1 === undefined) {
return {
data: Belt_internalAVLset.copy(datab$1)
};
}
if (datab$1 === undefined) {
return {
data: Belt_internalAVLset.copy(dataa$1)
};
}
var sizea = Belt_internalAVLset.lengthNode(dataa$1);
var sizeb = Belt_internalAVLset.lengthNode(datab$1);
var totalSize = sizea + sizeb | 0;
var tmp = new Array(totalSize);
Belt_internalAVLset.fillArray(dataa$1, 0, tmp);
Belt_internalAVLset.fillArray(datab$1, sizea, tmp);
if (tmp[sizea - 1 | 0] < tmp[sizea]) {
return {
data: Belt_internalAVLset.fromSortedArrayAux(tmp, 0, totalSize)
};
}
var tmp2 = new Array(totalSize);
var k = Belt_SortArrayString.union(tmp, 0, sizea, tmp, sizea, sizeb, tmp2, 0);
return {
data: Belt_internalAVLset.fromSortedArrayAux(tmp2, 0, k)
};
}
function has(d, x) {
return Belt_internalSetString.has(d.data, x);
}
function copy(d) {
return {
data: Belt_internalAVLset.copy(d.data)
};
}
export {
make ,
fromArray ,
fromSortedArrayUnsafe ,
copy ,
isEmpty ,
has ,
add ,
addCheck ,
mergeMany ,
remove ,
removeCheck ,
removeMany ,
union ,
intersect ,
diff ,
subset ,
cmp ,
eq ,
forEachU ,
forEach ,
reduceU ,
reduce ,
everyU ,
every ,
someU ,
some ,
keepU ,
keep ,
partitionU ,
partition ,
size ,
toList ,
toArray ,
minimum ,
minUndefined ,
maximum ,
maxUndefined ,
get ,
getUndefined ,
getExn ,
split ,
checkInvariantInternal ,
}
/* No side effect */