@tellahq/rescript 10.1.0-alpha.1

package/lib/es6/belt_MapString.js

@@ -0,0 +1,307 @@
+
+
+import * as Curry from "./curry.js";
+import * as Caml_option from "./caml_option.js";
+import * as Belt_internalAVLtree from "./belt_internalAVLtree.js";
+import * as Belt_internalMapString from "./belt_internalMapString.js";
+
+function set(t, newK, newD) {
+  if (t === undefined) {
+    return Belt_internalAVLtree.singleton(newK, newD);
+  }
+  var k = t.k;
+  if (newK === k) {
+    return Belt_internalAVLtree.updateValue(t, newD);
+  }
+  var v = t.v;
+  if (newK < k) {
+    return Belt_internalAVLtree.bal(set(t.l, newK, newD), k, v, t.r);
+  } else {
+    return Belt_internalAVLtree.bal(t.l, k, v, set(t.r, newK, newD));
+  }
+}
+
+function updateU(t, x, f) {
+  if (t !== undefined) {
+    var k = t.k;
+    if (x === k) {
+      var data = f(Caml_option.some(t.v));
+      if (data !== undefined) {
+        return Belt_internalAVLtree.updateValue(t, Caml_option.valFromOption(data));
+      }
+      var l = t.l;
+      var r = t.r;
+      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);
+    }
+    var v = t.v;
+    var l$1 = t.l;
+    var r$2 = t.r;
+    if (x < k) {
+      var ll = updateU(l$1, x, f);
+      if (l$1 === ll) {
+        return t;
+      } else {
+        return Belt_internalAVLtree.bal(ll, k, v, r$2);
+      }
+    }
+    var rr = updateU(r$2, x, f);
+    if (r$2 === rr) {
+      return t;
+    } else {
+      return Belt_internalAVLtree.bal(l$1, k, v, rr);
+    }
+  }
+  var data$1 = f(undefined);
+  if (data$1 !== undefined) {
+    return Belt_internalAVLtree.singleton(x, Caml_option.valFromOption(data$1));
+  } else {
+    return t;
+  }
+}
+
+function update(t, x, f) {
+  return updateU(t, x, Curry.__1(f));
+}
+
+function removeAux(n, x) {
+  var v = n.k;
+  var l = n.l;
+  var r = n.r;
+  if (x === v) {
+    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);
+  }
+  if (x < v) {
+    if (l === undefined) {
+      return n;
+    }
+    var ll = removeAux(l, x);
+    if (ll === l) {
+      return n;
+    } else {
+      return Belt_internalAVLtree.bal(ll, v, n.v, r);
+    }
+  }
+  if (r === undefined) {
+    return n;
+  }
+  var rr = removeAux(r, x);
+  return Belt_internalAVLtree.bal(l, v, n.v, rr);
+}
+
+function remove(n, x) {
+  if (n !== undefined) {
+    return removeAux(n, x);
+  }
+  
+}
+
+function removeMany(t, keys) {
+  var len = keys.length;
+  if (t !== undefined) {
+    var _t = t;
+    var _i = 0;
+    while(true) {
+      var i = _i;
+      var t$1 = _t;
+      if (i >= len) {
+        return t$1;
+      }
+      var ele = keys[i];
+      var u = removeAux(t$1, ele);
+      if (u === undefined) {
+        return u;
+      }
+      _i = i + 1 | 0;
+      _t = u;
+      continue ;
+    };
+  }
+  
+}
+
+function mergeMany(h, arr) {
+  var len = arr.length;
+  var v = h;
+  for(var i = 0; i < len; ++i){
+    var match = arr[i];
+    v = set(v, match[0], match[1]);
+  }
+  return v;
+}
+
+var empty;
+
+var isEmpty = Belt_internalAVLtree.isEmpty;
+
+var has = Belt_internalMapString.has;
+
+var cmpU = Belt_internalMapString.cmpU;
+
+var cmp = Belt_internalMapString.cmp;
+
+var eqU = Belt_internalMapString.eqU;
+
+var eq = Belt_internalMapString.eq;
+
+var findFirstByU = Belt_internalAVLtree.findFirstByU;
+
+var findFirstBy = Belt_internalAVLtree.findFirstBy;
+
+var forEachU = Belt_internalAVLtree.forEachU;
+
+var forEach = Belt_internalAVLtree.forEach;
+
+var reduceU = Belt_internalAVLtree.reduceU;
+
+var reduce = Belt_internalAVLtree.reduce;
+
+var everyU = Belt_internalAVLtree.everyU;
+
+var every = Belt_internalAVLtree.every;
+
+var someU = Belt_internalAVLtree.someU;
+
+var some = Belt_internalAVLtree.some;
+
+var size = Belt_internalAVLtree.size;
+
+var toList = Belt_internalAVLtree.toList;
+
+var toArray = Belt_internalAVLtree.toArray;
+
+var fromArray = Belt_internalMapString.fromArray;
+
+var keysToArray = Belt_internalAVLtree.keysToArray;
+
+var valuesToArray = Belt_internalAVLtree.valuesToArray;
+
+var minKey = Belt_internalAVLtree.minKey;
+
+var minKeyUndefined = Belt_internalAVLtree.minKeyUndefined;
+
+var maxKey = Belt_internalAVLtree.maxKey;
+
+var maxKeyUndefined = Belt_internalAVLtree.maxKeyUndefined;
+
+var minimum = Belt_internalAVLtree.minimum;
+
+var minUndefined = Belt_internalAVLtree.minUndefined;
+
+var maximum = Belt_internalAVLtree.maximum;
+
+var maxUndefined = Belt_internalAVLtree.maxUndefined;
+
+var get = Belt_internalMapString.get;
+
+var getUndefined = Belt_internalMapString.getUndefined;
+
+var getWithDefault = Belt_internalMapString.getWithDefault;
+
+var getExn = Belt_internalMapString.getExn;
+
+var checkInvariantInternal = Belt_internalAVLtree.checkInvariantInternal;
+
+var mergeU = Belt_internalMapString.mergeU;
+
+var merge = Belt_internalMapString.merge;
+
+var keepU = Belt_internalAVLtree.keepSharedU;
+
+var keep = Belt_internalAVLtree.keepShared;
+
+var partitionU = Belt_internalAVLtree.partitionSharedU;
+
+var partition = Belt_internalAVLtree.partitionShared;
+
+var split = Belt_internalMapString.split;
+
+var mapU = Belt_internalAVLtree.mapU;
+
+var map = Belt_internalAVLtree.map;
+
+var mapWithKeyU = Belt_internalAVLtree.mapWithKeyU;
+
+var mapWithKey = Belt_internalAVLtree.mapWithKey;
+
+export {
+  empty ,
+  isEmpty ,
+  has ,
+  cmpU ,
+  cmp ,
+  eqU ,
+  eq ,
+  findFirstByU ,
+  findFirstBy ,
+  forEachU ,
+  forEach ,
+  reduceU ,
+  reduce ,
+  everyU ,
+  every ,
+  someU ,
+  some ,
+  size ,
+  toList ,
+  toArray ,
+  fromArray ,
+  keysToArray ,
+  valuesToArray ,
+  minKey ,
+  minKeyUndefined ,
+  maxKey ,
+  maxKeyUndefined ,
+  minimum ,
+  minUndefined ,
+  maximum ,
+  maxUndefined ,
+  get ,
+  getUndefined ,
+  getWithDefault ,
+  getExn ,
+  checkInvariantInternal ,
+  remove ,
+  removeMany ,
+  set ,
+  updateU ,
+  update ,
+  mergeU ,
+  merge ,
+  mergeMany ,
+  keepU ,
+  keep ,
+  partitionU ,
+  partition ,
+  split ,
+  mapU ,
+  map ,
+  mapWithKeyU ,
+  mapWithKey ,
+}
+/* No side effect */

package/lib/es6/belt_MutableMap.js

@@ -0,0 +1,395 @@
+
+
+import * as Curry from "./curry.js";
+import * as Caml_option from "./caml_option.js";
+import * as Belt_internalAVLtree from "./belt_internalAVLtree.js";
+
+function removeMutateAux(nt, x, cmp) {
+  var k = nt.k;
+  var c = cmp(x, k);
+  if (c === 0) {
+    var l = nt.l;
+    var r = nt.r;
+    if (l !== undefined) {
+      if (r !== undefined) {
+        nt.r = Belt_internalAVLtree.removeMinAuxWithRootMutate(nt, r);
+        return Belt_internalAVLtree.balMutate(nt);
+      } else {
+        return l;
+      }
+    } else if (r !== undefined) {
+      return r;
+    } else {
+      return l;
+    }
+  }
+  if (c < 0) {
+    var l$1 = nt.l;
+    if (l$1 !== undefined) {
+      nt.l = removeMutateAux(l$1, x, cmp);
+      return Belt_internalAVLtree.balMutate(nt);
+    } else {
+      return nt;
+    }
+  }
+  var r$1 = nt.r;
+  if (r$1 !== undefined) {
+    nt.r = removeMutateAux(r$1, x, cmp);
+    return Belt_internalAVLtree.balMutate(nt);
+  } else {
+    return nt;
+  }
+}
+
+function remove(d, k) {
+  var oldRoot = d.data;
+  if (oldRoot === undefined) {
+    return ;
+  }
+  var newRoot = removeMutateAux(oldRoot, k, d.cmp);
+  if (newRoot !== oldRoot) {
+    d.data = newRoot;
+    return ;
+  }
+  
+}
+
+function removeArrayMutateAux(_t, xs, _i, len, cmp) {
+  while(true) {
+    var i = _i;
+    var t = _t;
+    if (i >= len) {
+      return t;
+    }
+    var ele = xs[i];
+    var u = removeMutateAux(t, ele, cmp);
+    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;
+  var newRoot = removeArrayMutateAux(oldRoot, xs, 0, len, d.cmp);
+  if (newRoot !== oldRoot) {
+    d.data = newRoot;
+    return ;
+  }
+  
+}
+
+function updateDone(t, x, f, cmp) {
+  if (t !== undefined) {
+    var k = t.k;
+    var c = cmp(x, k);
+    if (c === 0) {
+      var data = f(Caml_option.some(t.v));
+      if (data !== undefined) {
+        t.v = Caml_option.valFromOption(data);
+        return t;
+      }
+      var l = t.l;
+      var r = t.r;
+      if (l !== undefined) {
+        if (r !== undefined) {
+          t.r = Belt_internalAVLtree.removeMinAuxWithRootMutate(t, r);
+          return Belt_internalAVLtree.balMutate(t);
+        } else {
+          return l;
+        }
+      } else if (r !== undefined) {
+        return r;
+      } else {
+        return l;
+      }
+    }
+    if (c < 0) {
+      t.l = updateDone(t.l, x, f, cmp);
+    } else {
+      t.r = updateDone(t.r, x, f, cmp);
+    }
+    return Belt_internalAVLtree.balMutate(t);
+  }
+  var data$1 = f(undefined);
+  if (data$1 !== undefined) {
+    return Belt_internalAVLtree.singleton(x, Caml_option.valFromOption(data$1));
+  } else {
+    return t;
+  }
+}
+
+function updateU(t, x, f) {
+  var oldRoot = t.data;
+  var newRoot = updateDone(oldRoot, x, f, t.cmp);
+  if (newRoot !== oldRoot) {
+    t.data = newRoot;
+    return ;
+  }
+  
+}
+
+function update(t, x, f) {
+  updateU(t, x, Curry.__1(f));
+}
+
+function make(id) {
+  return {
+          cmp: id.cmp,
+          data: undefined
+        };
+}
+
+function clear(m) {
+  m.data = undefined;
+}
+
+function isEmpty(d) {
+  var x = d.data;
+  return x === undefined;
+}
+
+function minKey(m) {
+  return Belt_internalAVLtree.minKey(m.data);
+}
+
+function minKeyUndefined(m) {
+  return Belt_internalAVLtree.minKeyUndefined(m.data);
+}
+
+function maxKey(m) {
+  return Belt_internalAVLtree.maxKey(m.data);
+}
+
+function maxKeyUndefined(m) {
+  return Belt_internalAVLtree.maxKeyUndefined(m.data);
+}
+
+function minimum(m) {
+  return Belt_internalAVLtree.minimum(m.data);
+}
+
+function minUndefined(m) {
+  return Belt_internalAVLtree.minUndefined(m.data);
+}
+
+function maximum(m) {
+  return Belt_internalAVLtree.maximum(m.data);
+}
+
+function maxUndefined(m) {
+  return Belt_internalAVLtree.maxUndefined(m.data);
+}
+
+function forEachU(d, f) {
+  Belt_internalAVLtree.forEachU(d.data, f);
+}
+
+function forEach(d, f) {
+  Belt_internalAVLtree.forEachU(d.data, Curry.__2(f));
+}
+
+function reduceU(d, acc, cb) {
+  return Belt_internalAVLtree.reduceU(d.data, acc, cb);
+}
+
+function reduce(d, acc, cb) {
+  return reduceU(d, acc, Curry.__3(cb));
+}
+
+function everyU(d, p) {
+  return Belt_internalAVLtree.everyU(d.data, p);
+}
+
+function every(d, p) {
+  return Belt_internalAVLtree.everyU(d.data, Curry.__2(p));
+}
+
+function someU(d, p) {
+  return Belt_internalAVLtree.someU(d.data, p);
+}
+
+function some(d, p) {
+  return Belt_internalAVLtree.someU(d.data, Curry.__2(p));
+}
+
+function size(d) {
+  return Belt_internalAVLtree.size(d.data);
+}
+
+function toList(d) {
+  return Belt_internalAVLtree.toList(d.data);
+}
+
+function toArray(d) {
+  return Belt_internalAVLtree.toArray(d.data);
+}
+
+function keysToArray(d) {
+  return Belt_internalAVLtree.keysToArray(d.data);
+}
+
+function valuesToArray(d) {
+  return Belt_internalAVLtree.valuesToArray(d.data);
+}
+
+function checkInvariantInternal(d) {
+  Belt_internalAVLtree.checkInvariantInternal(d.data);
+}
+
+function cmpU(m1, m2, cmp) {
+  return Belt_internalAVLtree.cmpU(m1.data, m2.data, m1.cmp, cmp);
+}
+
+function cmp(m1, m2, cmp$1) {
+  return cmpU(m1, m2, Curry.__2(cmp$1));
+}
+
+function eqU(m1, m2, cmp) {
+  return Belt_internalAVLtree.eqU(m1.data, m2.data, m1.cmp, cmp);
+}
+
+function eq(m1, m2, cmp) {
+  return eqU(m1, m2, Curry.__2(cmp));
+}
+
+function mapU(m, f) {
+  return {
+          cmp: m.cmp,
+          data: Belt_internalAVLtree.mapU(m.data, f)
+        };
+}
+
+function map(m, f) {
+  return mapU(m, Curry.__1(f));
+}
+
+function mapWithKeyU(m, f) {
+  return {
+          cmp: m.cmp,
+          data: Belt_internalAVLtree.mapWithKeyU(m.data, f)
+        };
+}
+
+function mapWithKey(m, f) {
+  return mapWithKeyU(m, Curry.__2(f));
+}
+
+function get(m, x) {
+  return Belt_internalAVLtree.get(m.data, x, m.cmp);
+}
+
+function getUndefined(m, x) {
+  return Belt_internalAVLtree.getUndefined(m.data, x, m.cmp);
+}
+
+function getWithDefault(m, x, def) {
+  return Belt_internalAVLtree.getWithDefault(m.data, x, def, m.cmp);
+}
+
+function getExn(m, x) {
+  return Belt_internalAVLtree.getExn(m.data, x, m.cmp);
+}
+
+function has(m, x) {
+  return Belt_internalAVLtree.has(m.data, x, m.cmp);
+}
+
+function fromArray(data, id) {
+  var cmp = id.cmp;
+  return {
+          cmp: cmp,
+          data: Belt_internalAVLtree.fromArray(data, cmp)
+        };
+}
+
+function set(m, e, v) {
+  var oldRoot = m.data;
+  var newRoot = Belt_internalAVLtree.updateMutate(oldRoot, e, v, m.cmp);
+  if (newRoot !== oldRoot) {
+    m.data = newRoot;
+    return ;
+  }
+  
+}
+
+function mergeManyAux(t, xs, cmp) {
+  var v = t;
+  for(var i = 0 ,i_finish = xs.length; i < i_finish; ++i){
+    var match = xs[i];
+    v = Belt_internalAVLtree.updateMutate(v, match[0], match[1], cmp);
+  }
+  return v;
+}
+
+function mergeMany(d, xs) {
+  var oldRoot = d.data;
+  var newRoot = mergeManyAux(oldRoot, xs, d.cmp);
+  if (newRoot !== oldRoot) {
+    d.data = newRoot;
+    return ;
+  }
+  
+}
+
+var Int;
+
+var $$String;
+
+export {
+  Int ,
+  $$String ,
+  make ,
+  clear ,
+  isEmpty ,
+  has ,
+  cmpU ,
+  cmp ,
+  eqU ,
+  eq ,
+  forEachU ,
+  forEach ,
+  reduceU ,
+  reduce ,
+  everyU ,
+  every ,
+  someU ,
+  some ,
+  size ,
+  toList ,
+  toArray ,
+  fromArray ,
+  keysToArray ,
+  valuesToArray ,
+  minKey ,
+  minKeyUndefined ,
+  maxKey ,
+  maxKeyUndefined ,
+  minimum ,
+  minUndefined ,
+  maximum ,
+  maxUndefined ,
+  get ,
+  getUndefined ,
+  getWithDefault ,
+  getExn ,
+  checkInvariantInternal ,
+  remove ,
+  removeMany ,
+  set ,
+  updateU ,
+  update ,
+  mergeMany ,
+  mapU ,
+  map ,
+  mapWithKeyU ,
+  mapWithKey ,
+}
+/* No side effect */