@tellahq/rescript 10.1.0-alpha.1

package/lib/js/belt_internalMapString.js

@@ -0,0 +1,363 @@
+'use strict';
+
+var Caml = require("./caml.js");
+var Curry = require("./curry.js");
+var Caml_option = require("./caml_option.js");
+var Belt_SortArray = require("./belt_SortArray.js");
+var Belt_internalAVLtree = require("./belt_internalAVLtree.js");
+
+function add(t, x, data) {
+  if (t === undefined) {
+    return Belt_internalAVLtree.singleton(x, data);
+  }
+  var k = t.k;
+  if (x === k) {
+    return Belt_internalAVLtree.updateValue(t, data);
+  }
+  var v = t.v;
+  if (x < k) {
+    return Belt_internalAVLtree.bal(add(t.l, x, data), k, v, t.r);
+  } else {
+    return Belt_internalAVLtree.bal(t.l, k, v, add(t.r, x, data));
+  }
+}
+
+function get(_n, x) {
+  while(true) {
+    var n = _n;
+    if (n === undefined) {
+      return ;
+    }
+    var v = n.k;
+    if (x === v) {
+      return Caml_option.some(n.v);
+    }
+    _n = x < v ? n.l : n.r;
+    continue ;
+  };
+}
+
+function getUndefined(_n, x) {
+  while(true) {
+    var n = _n;
+    if (n === undefined) {
+      return ;
+    }
+    var v = n.k;
+    if (x === v) {
+      return n.v;
+    }
+    _n = x < v ? n.l : n.r;
+    continue ;
+  };
+}
+
+function getExn(_n, x) {
+  while(true) {
+    var n = _n;
+    if (n !== undefined) {
+      var v = n.k;
+      if (x === v) {
+        return n.v;
+      }
+      _n = x < v ? n.l : n.r;
+      continue ;
+    }
+    throw {
+          RE_EXN_ID: "Not_found",
+          Error: new Error()
+        };
+  };
+}
+
+function getWithDefault(_n, x, def) {
+  while(true) {
+    var n = _n;
+    if (n === undefined) {
+      return def;
+    }
+    var v = n.k;
+    if (x === v) {
+      return n.v;
+    }
+    _n = x < v ? n.l : n.r;
+    continue ;
+  };
+}
+
+function has(_n, x) {
+  while(true) {
+    var n = _n;
+    if (n === undefined) {
+      return false;
+    }
+    var v = n.k;
+    if (x === v) {
+      return true;
+    }
+    _n = x < v ? n.l : n.r;
+    continue ;
+  };
+}
+
+function remove(n, x) {
+  if (n === undefined) {
+    return n;
+  }
+  var v = n.k;
+  var l = n.l;
+  var r = n.r;
+  if (x !== v) {
+    if (x < v) {
+      return Belt_internalAVLtree.bal(remove(l, x), v, n.v, r);
+    } else {
+      return Belt_internalAVLtree.bal(l, v, n.v, remove(r, x));
+    }
+  }
+  if (l === undefined) {
+    return r;
+  }
+  if (r === undefined) {
+    return l;
+  }
+  var kr = {
+    contents: r.k
+  };
+  var vr = {
+    contents: r.v
+  };
+  var r$1 = Belt_internalAVLtree.removeMinAuxWithRef(r, kr, vr);
+  return Belt_internalAVLtree.bal(l, kr.contents, vr.contents, r$1);
+}
+
+function splitAux(x, n) {
+  var v = n.k;
+  var d = n.v;
+  var l = n.l;
+  var r = n.r;
+  if (x === v) {
+    return [
+            l,
+            Caml_option.some(d),
+            r
+          ];
+  }
+  if (x < v) {
+    if (l === undefined) {
+      return [
+              undefined,
+              undefined,
+              n
+            ];
+    }
+    var match = splitAux(x, l);
+    return [
+            match[0],
+            match[1],
+            Belt_internalAVLtree.join(match[2], v, d, r)
+          ];
+  }
+  if (r === undefined) {
+    return [
+            n,
+            undefined,
+            undefined
+          ];
+  }
+  var match$1 = splitAux(x, r);
+  return [
+          Belt_internalAVLtree.join(l, v, d, match$1[0]),
+          match$1[1],
+          match$1[2]
+        ];
+}
+
+function split(x, n) {
+  if (n !== undefined) {
+    return splitAux(x, n);
+  } else {
+    return [
+            undefined,
+            undefined,
+            undefined
+          ];
+  }
+}
+
+function mergeU(s1, s2, f) {
+  if (s1 !== undefined) {
+    if (s1.h >= (
+        s2 !== undefined ? s2.h : 0
+      )) {
+      var v1 = s1.k;
+      var d1 = s1.v;
+      var l1 = s1.l;
+      var r1 = s1.r;
+      var match = split(v1, s2);
+      return Belt_internalAVLtree.concatOrJoin(mergeU(l1, match[0], f), v1, f(v1, Caml_option.some(d1), match[1]), mergeU(r1, match[2], f));
+    }
+    
+  } else if (s2 === undefined) {
+    return ;
+  }
+  var v2 = s2.k;
+  var d2 = s2.v;
+  var l2 = s2.l;
+  var r2 = s2.r;
+  var match$1 = split(v2, s1);
+  return Belt_internalAVLtree.concatOrJoin(mergeU(match$1[0], l2, f), v2, f(v2, match$1[1], Caml_option.some(d2)), mergeU(match$1[2], r2, f));
+}
+
+function merge(s1, s2, f) {
+  return mergeU(s1, s2, Curry.__3(f));
+}
+
+function compareAux(_e1, _e2, vcmp) {
+  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 = Caml.string_compare(h1.k, h2.k);
+    if (c !== 0) {
+      return c;
+    }
+    var cx = vcmp(h1.v, h2.v);
+    if (cx !== 0) {
+      return cx;
+    }
+    _e2 = Belt_internalAVLtree.stackAllLeft(h2.r, e2.tl);
+    _e1 = Belt_internalAVLtree.stackAllLeft(h1.r, e1.tl);
+    continue ;
+  };
+}
+
+function cmpU(s1, s2, cmp) {
+  var len1 = Belt_internalAVLtree.size(s1);
+  var len2 = Belt_internalAVLtree.size(s2);
+  if (len1 === len2) {
+    return compareAux(Belt_internalAVLtree.stackAllLeft(s1, /* [] */0), Belt_internalAVLtree.stackAllLeft(s2, /* [] */0), cmp);
+  } else if (len1 < len2) {
+    return -1;
+  } else {
+    return 1;
+  }
+}
+
+function cmp(s1, s2, f) {
+  return cmpU(s1, s2, Curry.__2(f));
+}
+
+function eqAux(_e1, _e2, eq) {
+  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 (!(h1.k === h2.k && eq(h1.v, h2.v))) {
+      return false;
+    }
+    _e2 = Belt_internalAVLtree.stackAllLeft(h2.r, e2.tl);
+    _e1 = Belt_internalAVLtree.stackAllLeft(h1.r, e1.tl);
+    continue ;
+  };
+}
+
+function eqU(s1, s2, eq) {
+  var len1 = Belt_internalAVLtree.size(s1);
+  var len2 = Belt_internalAVLtree.size(s2);
+  if (len1 === len2) {
+    return eqAux(Belt_internalAVLtree.stackAllLeft(s1, /* [] */0), Belt_internalAVLtree.stackAllLeft(s2, /* [] */0), eq);
+  } else {
+    return false;
+  }
+}
+
+function eq(s1, s2, f) {
+  return eqU(s1, s2, Curry.__2(f));
+}
+
+function addMutate(t, x, data) {
+  if (t === undefined) {
+    return Belt_internalAVLtree.singleton(x, data);
+  }
+  var k = t.k;
+  if (x === k) {
+    t.k = x;
+    t.v = data;
+    return t;
+  }
+  var l = t.l;
+  var r = t.r;
+  if (x < k) {
+    var ll = addMutate(l, x, data);
+    t.l = ll;
+  } else {
+    t.r = addMutate(r, x, data);
+  }
+  return Belt_internalAVLtree.balMutate(t);
+}
+
+function fromArray(xs) {
+  var len = xs.length;
+  if (len === 0) {
+    return ;
+  }
+  var next = Belt_SortArray.strictlySortedLengthU(xs, (function (param, param$1) {
+          return param[0] < param$1[0];
+        }));
+  var result;
+  if (next >= 0) {
+    result = Belt_internalAVLtree.fromSortedArrayAux(xs, 0, next);
+  } else {
+    next = -next | 0;
+    result = Belt_internalAVLtree.fromSortedArrayRevAux(xs, next - 1 | 0, next);
+  }
+  for(var i = next; i < len; ++i){
+    var match = xs[i];
+    result = addMutate(result, match[0], match[1]);
+  }
+  return result;
+}
+
+var N;
+
+var A;
+
+var S;
+
+exports.N = N;
+exports.A = A;
+exports.S = S;
+exports.add = add;
+exports.get = get;
+exports.getUndefined = getUndefined;
+exports.getExn = getExn;
+exports.getWithDefault = getWithDefault;
+exports.has = has;
+exports.remove = remove;
+exports.splitAux = splitAux;
+exports.split = split;
+exports.mergeU = mergeU;
+exports.merge = merge;
+exports.compareAux = compareAux;
+exports.cmpU = cmpU;
+exports.cmp = cmp;
+exports.eqAux = eqAux;
+exports.eqU = eqU;
+exports.eq = eq;
+exports.addMutate = addMutate;
+exports.fromArray = fromArray;
+/* No side effect */

package/lib/js/belt_internalSetBuckets.js

@@ -0,0 +1,189 @@
+'use strict';
+
+var Curry = require("./curry.js");
+var Belt_Array = require("./belt_Array.js");
+
+function copyAuxCont(_c, _prec) {
+  while(true) {
+    var prec = _prec;
+    var c = _c;
+    if (c === undefined) {
+      return ;
+    }
+    var ncopy = {
+      key: c.key,
+      next: undefined
+    };
+    prec.next = ncopy;
+    _prec = ncopy;
+    _c = c.next;
+    continue ;
+  };
+}
+
+function copyBucket(c) {
+  if (c === undefined) {
+    return c;
+  }
+  var head = {
+    key: c.key,
+    next: undefined
+  };
+  copyAuxCont(c.next, head);
+  return head;
+}
+
+function copyBuckets(buckets) {
+  var len = buckets.length;
+  var newBuckets = new Array(len);
+  for(var i = 0; i < len; ++i){
+    newBuckets[i] = copyBucket(buckets[i]);
+  }
+  return newBuckets;
+}
+
+function copy(x) {
+  return {
+          size: x.size,
+          buckets: copyBuckets(x.buckets),
+          hash: x.hash,
+          eq: x.eq
+        };
+}
+
+function bucketLength(_accu, _buckets) {
+  while(true) {
+    var buckets = _buckets;
+    var accu = _accu;
+    if (buckets === undefined) {
+      return accu;
+    }
+    _buckets = buckets.next;
+    _accu = accu + 1 | 0;
+    continue ;
+  };
+}
+
+function doBucketIter(f, _buckets) {
+  while(true) {
+    var buckets = _buckets;
+    if (buckets === undefined) {
+      return ;
+    }
+    f(buckets.key);
+    _buckets = buckets.next;
+    continue ;
+  };
+}
+
+function forEachU(h, f) {
+  var d = h.buckets;
+  for(var i = 0 ,i_finish = d.length; i < i_finish; ++i){
+    doBucketIter(f, d[i]);
+  }
+}
+
+function forEach(h, f) {
+  forEachU(h, Curry.__1(f));
+}
+
+function fillArray(_i, arr, _cell) {
+  while(true) {
+    var cell = _cell;
+    var i = _i;
+    arr[i] = cell.key;
+    var v = cell.next;
+    if (v === undefined) {
+      return i + 1 | 0;
+    }
+    _cell = v;
+    _i = i + 1 | 0;
+    continue ;
+  };
+}
+
+function toArray(h) {
+  var d = h.buckets;
+  var current = 0;
+  var arr = new Array(h.size);
+  for(var i = 0 ,i_finish = d.length; i < i_finish; ++i){
+    var cell = d[i];
+    if (cell !== undefined) {
+      current = fillArray(current, arr, cell);
+    }
+    
+  }
+  return arr;
+}
+
+function doBucketFold(f, _b, _accu) {
+  while(true) {
+    var accu = _accu;
+    var b = _b;
+    if (b === undefined) {
+      return accu;
+    }
+    _accu = f(accu, b.key);
+    _b = b.next;
+    continue ;
+  };
+}
+
+function reduceU(h, init, f) {
+  var d = h.buckets;
+  var accu = init;
+  for(var i = 0 ,i_finish = d.length; i < i_finish; ++i){
+    accu = doBucketFold(f, d[i], accu);
+  }
+  return accu;
+}
+
+function reduce(h, init, f) {
+  return reduceU(h, init, Curry.__2(f));
+}
+
+function getMaxBucketLength(h) {
+  return Belt_Array.reduceU(h.buckets, 0, (function (m, b) {
+                var len = bucketLength(0, b);
+                if (m > len) {
+                  return m;
+                } else {
+                  return len;
+                }
+              }));
+}
+
+function getBucketHistogram(h) {
+  var mbl = getMaxBucketLength(h);
+  var histo = Belt_Array.makeByU(mbl + 1 | 0, (function (param) {
+          return 0;
+        }));
+  Belt_Array.forEachU(h.buckets, (function (b) {
+          var l = bucketLength(0, b);
+          histo[l] = histo[l] + 1 | 0;
+        }));
+  return histo;
+}
+
+function logStats(h) {
+  var histogram = getBucketHistogram(h);
+  console.log({
+        bindings: h.size,
+        buckets: h.buckets.length,
+        histogram: histogram
+      });
+}
+
+var C;
+
+exports.C = C;
+exports.copy = copy;
+exports.forEachU = forEachU;
+exports.forEach = forEach;
+exports.fillArray = fillArray;
+exports.toArray = toArray;
+exports.reduceU = reduceU;
+exports.reduce = reduce;
+exports.logStats = logStats;
+exports.getBucketHistogram = getBucketHistogram;
+/* No side effect */