@calcit/ternary-tree 0.0.18 → 0.0.19-a1

package/src/shape.nim

@@ -1,62 +0,0 @@
-# TODO get a ts version
-
-import random
-import tables
-import strformat
-
-import ternary_tree
-
-randomize()
-
-proc tryListShape(): void =
-  var source: seq[int] = @[]
-  var data = initTernaryTreeList[int](@[0])
-
-  for i in 0..<18:
-    source.add i
-
-  data = initTernaryTreeList(source)
-
-  for i in 0..<18:
-    # echo data.formatInline
-    let newData = data.assocAfter(i, 888)
-    echo newData.getDepth, " : ", newData.formatInline
-
-  # data.forceInplaceBalancing
-  # echo data.getDepth, " : ", data.formatInline
-
-
-proc tryMapShape(): void =
-  var dict: Table[string, int]
-  var data = initTernaryTreeMap(dict)
-
-  for idx in 0..<20:
-    data = data.assoc(fmt"x{idx}", idx + 10)
-    echo data.formatInline()
-    # echo "checked: ", data.checkStructure()
-
-proc tryConcatList(): void =
-  let a = initTernaryTreeList(@[1,2,3,4])
-  let b = initTernaryTreeList(@[5,6,7,8])
-  let c = initTernaryTreeList(@[9,10,11,12])
-
-  echo a.formatInline
-  echo b.formatInline
-  echo c.formatInline
-  echo a.concat(b).formatInline
-  echo a.concat(b).concat(c).formatInline
-
-  let d = a.concat(b)
-  d.forceInplaceBalancing
-
-  echo d.formatInline
-
-  for i in 0..<8:
-    for j in i..<9:
-      echo fmt"{i}-{j} ", d.slice(i, j).formatInline
-
-# tryListShape()
-
-# tryMapShape()
-
-tryConcatList()

package/src/test-list.ts

@@ -1,271 +0,0 @@
-import {
-  listToString,
-  initTernaryTreeList,
-  initTernaryTreeListFromRange,
-  indexOf,
-  findIndex,
-  reverse,
-  checkListStructure,
-  slice,
-  listToPairs,
-  listToItems,
-  formatListInline,
-  sameListShape,
-  assocBefore,
-  concat,
-  assocAfter,
-  prepend,
-  append,
-  rest,
-  butlast,
-  first,
-  assocList,
-  dissocList,
-  listGet,
-  insert,
-  initEmptyTernaryTreeList,
-  last,
-  listLen,
-  forceListInplaceBalancing,
-  listEqual,
-  indexToItems,
-  listMapValues,
-} from "./list";
-
-import { test, check, arrayEqual, checkEqual } from "./utils";
-
-export let runListTests = () => {
-  test("init list", () => {
-    check(
-      listToString(
-        initTernaryTreeList<number>([1, 2, 3, 4])
-      ) === "TernaryTreeList[4, ...]"
-    );
-
-    let origin11 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
-    let data11 = initTernaryTreeList<number>(origin11);
-
-    check(checkListStructure(data11));
-
-    checkEqual(formatListInline(data11), "((1 (2 3 _) 4) (5 6 7) (8 (9 10 _) 11))");
-    check(
-      arrayEqual<number>(origin11, [...listToItems(data11)])
-    );
-
-    check(arrayEqual<number>([...listToItems(data11)], [...indexToItems(data11)]));
-
-    let emptyXs = new Array<number>(0);
-    check(listEqual(initEmptyTernaryTreeList<number>(), initTernaryTreeList(emptyXs)));
-  });
-
-  test("list operations", () => {
-    let origin11 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
-    let data11 = initTernaryTreeList<number>(origin11);
-
-    // get
-    for (let idx = 0; idx < origin11.length; idx++) {
-      check(origin11[idx] === listGet(data11, idx));
-    }
-
-    check(first(data11) === 1);
-    check(last(data11) === 11);
-
-    // assoc
-    let origin5 = [1, 2, 3, 4, 5];
-    let data5 = initTernaryTreeList(origin5);
-    let updated = assocList(data5, 3, 10);
-    check(listGet(updated, 3) === 10);
-    check(listGet(data5, 3) === 4);
-    check(listLen(updated) === listLen(data5));
-
-    for (let idx = 0; idx < listLen(data5); idx++) {
-      // echo data5.dissoc(idx).formatInline
-      check(listLen(dissocList(data5, idx)) === listLen(data5) - 1);
-    }
-
-    checkEqual(formatListInline(data5), "((1 2 _) 3 (4 5 _))");
-    checkEqual(formatListInline(dissocList(data5, 0)), "(2 3 (4 5 _))");
-    checkEqual(formatListInline(dissocList(data5, 1)), "(1 3 (4 5 _))");
-    checkEqual(formatListInline(dissocList(data5, 2)), "((1 2 _) (4 5 _) _)");
-    checkEqual(formatListInline(dissocList(data5, 3)), "((1 2 _) 3 5)");
-    checkEqual(formatListInline(dissocList(data5, 4)), "((1 2 _) 3 4)");
-
-    checkEqual(formatListInline(rest(initTernaryTreeList([1]))), "_");
-    checkEqual(formatListInline(rest(initTernaryTreeList([1, 2]))), "2");
-    checkEqual(formatListInline(rest(initTernaryTreeList([1, 2, 3]))), "(2 3 _)");
-    checkEqual(formatListInline(rest(initTernaryTreeList([1, 2, 3, 4]))), "((2 3 _) 4 _)");
-    checkEqual(formatListInline(rest(initTernaryTreeList([1, 2, 3, 4, 5]))), "(2 3 (4 5 _))");
-
-    checkEqual(formatListInline(butlast(initTernaryTreeList([1]))), "_");
-    checkEqual(formatListInline(butlast(initTernaryTreeList([1, 2]))), "1");
-    checkEqual(formatListInline(butlast(initTernaryTreeList([1, 2, 3]))), "(1 2 _)");
-    checkEqual(formatListInline(butlast(initTernaryTreeList([1, 2, 3, 4]))), "(1 (2 3 _) _)");
-    checkEqual(formatListInline(butlast(initTernaryTreeList([1, 2, 3, 4, 5]))), "((1 2 _) 3 4)");
-  });
-
-  test("list insertions", () => {
-    let origin5 = [1, 2, 3, 4, 5];
-    let data5 = initTernaryTreeList(origin5);
-
-    checkEqual(formatListInline(data5), "((1 2 _) 3 (4 5 _))");
-
-    checkEqual(formatListInline(insert(data5, 0, 10, false)), "(10 ((1 2 _) 3 (4 5 _)) _)");
-    checkEqual(formatListInline(insert(data5, 0, 10, true)), "((1 10 2) 3 (4 5 _))");
-    checkEqual(formatListInline(insert(data5, 1, 10, false)), "((1 10 2) 3 (4 5 _))");
-    checkEqual(formatListInline(insert(data5, 1, 10, true)), "((1 2 10) 3 (4 5 _))");
-    checkEqual(formatListInline(insert(data5, 2, 10, false)), "((1 2 _) (10 3 _) (4 5 _))");
-    checkEqual(formatListInline(insert(data5, 2, 10, true)), "((1 2 _) (3 10 _) (4 5 _))");
-    checkEqual(formatListInline(insert(data5, 3, 10, false)), "((1 2 _) 3 (10 4 5))");
-    checkEqual(formatListInline(insert(data5, 3, 10, true)), "((1 2 _) 3 (4 10 5))");
-    checkEqual(formatListInline(insert(data5, 4, 10, false)), "((1 2 _) 3 (4 10 5))");
-    checkEqual(formatListInline(insert(data5, 4, 10, true)), "(((1 2 _) 3 (4 5 _)) 10 _)");
-
-    let origin4 = [1, 2, 3, 4];
-    let data4 = initTernaryTreeList(origin4);
-
-    checkEqual(formatListInline(assocBefore(data4, 3, 10)), "(1 (2 3 _) (10 4 _))");
-    checkEqual(formatListInline(assocAfter(data4, 3, 10)), "(1 (2 3 _) (4 10 _))");
-
-    checkEqual(formatListInline(prepend(data4, 10)), "((10 1 _) (2 3 _) 4)");
-    checkEqual(formatListInline(append(data4, 10)), "(1 (2 3 _) (4 10 _))");
-  });
-
-  test("concat", () => {
-    let data1 = initTernaryTreeList([1, 2]);
-    let data2 = initTernaryTreeList([3, 4]);
-
-    let data3 = initTernaryTreeList([5, 6]);
-    let data4 = initTernaryTreeList([7, 8]);
-
-    check(formatListInline(concat(data1, data2)) === "((1 2 _) (3 4 _) _)");
-    check(formatListInline(concat(initTernaryTreeList<number>([]), data1)) === "(1 2 _)");
-    check(formatListInline(concat(data1, data2, data3)) === "((1 2 _) (3 4 _) (5 6 _))");
-    check(formatListInline(concat(data1, data2, data3, data4)) === "((1 2 _) ((3 4 _) (5 6 _) _) (7 8 _))");
-
-    checkListStructure(concat(data1, data2));
-    checkListStructure(concat(data1, data2, data3));
-    checkListStructure(concat(data1, data2, data3, data4));
-
-    check(listLen(concat(data1, data2, data3, data4)) === 8);
-  });
-
-  test("check(equality", () => {
-    let origin4 = [1, 2, 3, 4];
-    let data4 = initTernaryTreeList(origin4);
-    let data4n = initTernaryTreeList(origin4);
-    let data4Made = prepend(initTernaryTreeList([2, 3, 4]), 1);
-
-    check(sameListShape(data4, data4) === true);
-    check(sameListShape(data4, data4n) === true);
-    check(sameListShape(data4, data4Made) === false);
-
-    check(listEqual(data4, data4n));
-    check(listEqual(data4, data4Made));
-    check(listEqual(data4n, data4Made));
-    check(data4 !== data4Made); // identical false
-  });
-
-  test("force balancing", () => {
-    var data = initTernaryTreeList<number>([]);
-    for (let idx = 0; idx < 20; idx++) {
-      data = append(data, idx, true);
-    }
-    // echo data.formatInline
-    check(formatListInline(data) === "(((0 1 2) (3 4 5) (6 7 8)) ((9 10 11) (12 13 14) (15 16 17)) (18 19 _))");
-    forceListInplaceBalancing(data);
-    check(formatListInline(data) === "(((0 1 _) (2 3 4) (5 6 _)) ((7 8 _) (9 10 _) (11 12 _)) ((13 14 _) (15 16 17) (18 19 _)))");
-    // echo data.formatInline
-  });
-
-  test("iterator", () => {
-    let origin4 = [1, 2, 3, 4];
-    let data4 = initTernaryTreeList(origin4);
-
-    var i = 0;
-    for (let item of listToItems(data4)) {
-      i = i + 1;
-    }
-
-    check(i === 4);
-
-    i = 0;
-    for (let [idx, item] of listToPairs(data4)) {
-      i = i + idx;
-    }
-
-    check(i === 6);
-  });
-
-  test("check structure", () => {
-    var data = initTernaryTreeList<number>([]);
-    for (let idx = 0; idx < 20; idx++) {
-      data = append(data, idx, true);
-    }
-
-    check(checkListStructure(data));
-
-    let origin11 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
-    let data11 = initTernaryTreeList<number>(origin11);
-
-    check(checkListStructure(data11));
-  });
-
-  test("slices", () => {
-    var data = initTernaryTreeList<number>([]);
-    for (let idx = 0; idx < 40; idx++) {
-      data = append(data, idx, true);
-    }
-
-    var list40: Array<number> = [];
-    for (let idx = 0; idx < 40; idx++) {
-      list40.push(idx);
-    }
-
-    for (let i = 0; i < 40; i++) {
-      for (let j = i; j < 40; j++) {
-        check(arrayEqual<number>([...listToItems(slice(data, i, j))], list40.slice(i, j)));
-      }
-    }
-  });
-
-  test("reverse", () => {
-    let data = initTernaryTreeList([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-    let reversedData = reverse(data);
-    check(arrayEqual([...listToItems(data)].reverse(), [...listToItems(reversedData)]));
-    check(checkListStructure(reversedData));
-  });
-
-  test("list traverse", () => {
-    var i = 0;
-    let data = initTernaryTreeList<number>([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-    for (let x of listToItems(data)) {
-      i = i + 1;
-    }
-
-    check(i === 10);
-  });
-
-  test("index of", () => {
-    let data = initTernaryTreeList<number>([1, 2, 3, 4, 5, 6, 7, 8]);
-    check(indexOf(data, 2) === 1);
-    check(findIndex(data, (x: number): boolean => x === 2) === 1);
-    check(indexOf(data, 9) === -1);
-    check(findIndex(data, (x: number): boolean => x === 9) === -1);
-  });
-
-  test("map values", () => {
-    let data = initTernaryTreeList<number>([1, 2, 3, 4]);
-    let data2 = initTernaryTreeList<number>([1, 4, 9, 16]);
-    let data3 = listMapValues(data, (x) => x * x);
-
-    checkListStructure(data3);
-    check(listEqual(data2, data3));
-    check(formatListInline(data2) === formatListInline(data3));
-  });
-
-  test("concat", () => {
-    let data1 = initTernaryTreeList([3, 4]);
-    let data2 = initTernaryTreeListFromRange([1, 2, 3, 4, 5, 6], 2, 4);
-    check(listEqual(data1, data2));
-  });
-};

package/src/test-map.ts

@@ -1,288 +0,0 @@
-import { hashGenerator } from "./types";
-import { test, check, cmp, deepEqual, justDisplay } from "./utils";
-import {
-  initTernaryTreeMap,
-  initTernaryTreeMapFromArray,
-  toHashSortedPairs,
-  merge,
-  mergeSkip,
-  forceMapInplaceBalancing,
-  formatMapInline,
-  assocMap,
-  dissocMap,
-  contains,
-  toPairs,
-  initEmptyTernaryTreeMap,
-  sameMapShape,
-  checkMapStructure,
-  mapLen,
-  mapToString,
-  mapEqual,
-  toKeys,
-  toPairsArray,
-  mapMapValues,
-  mapGetDefault,
-} from "./map";
-
-export let runMapTests = () => {
-  test("init map", () => {
-    var dict: Map<string, number> = new Map();
-    var inList: Array<[string, number]> = [];
-    for (let idx = 0; idx < 10; idx++) {
-      dict.set(`${idx}`, idx + 10);
-      inList.push([`${idx}`, idx + 10]);
-    }
-
-    // TODO
-    inList.sort((x, y: [string, number]): number => {
-      let hx = hashGenerator(x[0]);
-      let hy = hashGenerator(y[0]);
-      return cmp(hx, hy);
-    });
-
-    let data10 = initTernaryTreeMap<string, number>(dict);
-    let data11 = initTernaryTreeMapFromArray<string, number>(inList);
-    checkMapStructure(data10);
-    checkMapStructure(data11);
-
-    // echo data10
-    justDisplay(formatMapInline(data10, true), " ((0:10 1:11 2:12) (3:13 (4:14 5:15 _) 6:16) (7:17 8:18 9:19))");
-
-    check(deepEqual(toHashSortedPairs(data10), inList));
-    check(deepEqual(toHashSortedPairs(data11), inList));
-
-    check(contains(data10, "1") === true);
-    check(contains(data10, "11") === false);
-
-    check(deepEqual(mapGetDefault(data10, "1", null), 11));
-    check(deepEqual(mapGetDefault(data10, "111", 0), 0));
-    // check(deepEqual(mapGetDefault(data10, "11", {} as any), null)); // should throws error
-
-    let emptyData: Map<string, number> = new Map();
-    check(mapEqual(initEmptyTernaryTreeMap<string, number>(), initTernaryTreeMap(emptyData)));
-  });
-
-  test("assoc and contains", () => {
-    var dict: Map<string, number> = new Map();
-    for (let idx = 0; idx < 100; idx++) {
-      dict.set(`${idx * 2}`, idx);
-    }
-    let data = initTernaryTreeMap(dict);
-    for (let idx = 0; idx < 100; idx++) {
-      dict.set(`${idx * 2 + 1}`, idx);
-      let data2 = assocMap(data, `${idx * 2 + 1}`, idx);
-      check(contains(data2, `${idx * 2 + 1}`));
-    }
-
-    var dict: Map<string, number> = new Map();
-    data = initTernaryTreeMap(dict);
-    for (let idx = 0; idx < 1000; idx++) {
-      let p = 100 - idx / 10;
-      data = assocMap(data, `${p}`, idx);
-      check(contains(data, `${p}`));
-    }
-  });
-
-  test("check structure", () => {
-    var dict: Map<string, number> = new Map();
-    for (let idx = 0; idx < 100; idx++) {
-      dict.set(`${idx}`, idx + 10);
-    }
-
-    let data = initTernaryTreeMap(dict);
-
-    check(checkMapStructure(data));
-  });
-
-  test("assoc map", () => {
-    var dict: Map<string, number> = new Map();
-    for (let idx = 0; idx < 10; idx++) {
-      dict.set(`${idx}`, idx + 10);
-    }
-
-    let data = initTernaryTreeMap(dict);
-
-    // echo data.formatInline
-
-    check(contains(data, "1") === true);
-    check(contains(data, "12") === false);
-    checkMapStructure(data);
-
-    justDisplay(formatMapInline(assocMap(data, "1", 2222), true), "((0:10 1:2222 2:12) (3:13 (4:14 5:15 _) 6:16) (7:17 8:18 9:19))");
-    justDisplay(formatMapInline(assocMap(data, "23", 2222), true), "(((0:10 1:11 2:12) (3:13 (4:14 5:15 _) 6:16) (7:17 8:18 9:19)) 23:2222 _)");
-  });
-
-  test("dissoc", () => {
-    var dict: Map<string, number> = new Map();
-    for (let idx = 0; idx < 10; idx++) {
-      dict.set(`${idx}`, idx + 10);
-    }
-
-    let data = initTernaryTreeMap(dict);
-    checkMapStructure(data);
-
-    // echo data.formatInline
-
-    for (let idx = 0; idx < 10; idx++) {
-      let v = dissocMap(data, `${idx}`);
-      check(contains(v, `${idx}`) === false);
-      check(contains(data, `${idx}`) === true);
-      check(mapLen(v) === mapLen(data) - 1);
-    }
-
-    for (let idx = 10; idx < 12; idx++) {
-      let v = dissocMap(data, `${idx}`);
-      check(contains(v, `${idx}`) === false);
-      check(mapLen(v) === mapLen(data));
-    }
-  });
-
-  test("to array", () => {
-    var dict: Map<string, number> = new Map();
-    for (let idx = 0; idx < 10; idx++) {
-      dict.set(`${idx}`, idx + 10);
-    }
-
-    let data = initTernaryTreeMap(dict);
-    checkMapStructure(data);
-
-    // TODO
-    // justDisplay((mapToString(toPairs(data))) , "@[2:12, 3:13, 7:17, 9:19, 6:16, 5:15, 1:11, 8:18, 0:10, 4:14]")
-    justDisplay([...toKeys(data)], ["2", "3", "7", "9", "6", "5", "1", "8", "0", "4"]);
-
-    check(deepEqual(toPairsArray(data), [...toPairs(data)]));
-  });
-
-  test("Equality", () => {
-    var dict: Map<string, number> = new Map();
-    for (let idx = 0; idx < 10; idx++) {
-      dict.set(`${idx}`, idx + 10);
-    }
-
-    let data = initTernaryTreeMap(dict);
-    let b = dissocMap(data, "3");
-    checkMapStructure(data);
-    checkMapStructure(b);
-
-    check(mapEqual(data, data));
-    check(!mapEqual(data, b));
-
-    let c = assocMap(data, "3", 15);
-    check(sameMapShape(data, data));
-    check(sameMapShape(data, b) === false);
-    check(sameMapShape(data, c) === false);
-
-    let d = assocMap(c, "3", 13);
-    check(mapEqual(data, d));
-    check(data !== d); // not identical
-  });
-
-  test("Merge", () => {
-    var dict: Map<string, number> = new Map();
-    var dictBoth: Map<string, number> = new Map();
-    for (let idx = 0; idx < 4; idx++) {
-      dict.set(`${idx}`, idx + 10);
-      dictBoth.set(`${idx}`, idx + 10);
-    }
-
-    let data = initTernaryTreeMap(dict);
-    checkMapStructure(data);
-
-    var dictB: Map<string, number> = new Map();
-    for (let idx = 10; idx < 14; idx++) {
-      dictB.set(`${idx}`, idx + 23);
-      dictBoth.set(`${idx}`, idx + 23);
-    }
-    let b = initTernaryTreeMap(dictB);
-
-    let merged = merge(data, b);
-    let both = initTernaryTreeMap(dictBoth);
-
-    check(mapEqual(merged, both));
-  });
-
-  test("Merge skip", () => {
-    var dict: Map<string, number> = new Map();
-    for (let idx = 0; idx < 4; idx++) {
-      dict.set(`${idx}`, idx + 10);
-    }
-    let a = initTernaryTreeMap(dict);
-    checkMapStructure(a);
-
-    var dict2: Map<string, number> = new Map();
-    for (let idx = 0; idx < 4; idx++) {
-      dict2.set(`${idx}`, idx + 11);
-    }
-    let b = initTernaryTreeMap(dict2);
-    checkMapStructure(b);
-
-    let c = mergeSkip(a, b, 11);
-    check(deepEqual(mapGetDefault(c, "0", null), 10));
-    check(deepEqual(mapGetDefault(c, "1", null), 12));
-    check(deepEqual(mapGetDefault(c, "2", null), 13));
-    check(deepEqual(mapGetDefault(c, "3", null), 14));
-  });
-
-  test("iterator", () => {
-    var dict: Map<string, number> = new Map();
-    var dictBoth: Map<string, number> = new Map();
-    for (let idx = 0; idx < 4; idx++) {
-      dict.set(`${idx}`, idx + 10);
-      dictBoth.set(`${idx}`, idx + 10);
-    }
-
-    let data = initTernaryTreeMap(dict);
-    checkMapStructure(data);
-
-    var i = 0;
-    for (let [k, v] of toPairs(data)) {
-      i = i + 1;
-    }
-
-    check(i === 4);
-
-    i = 0;
-    for (let key of toPairs(data)) {
-      i = i + 1;
-    }
-    check(i === 4);
-  });
-
-  test("each map", () => {
-    var dict: Map<string, number> = new Map();
-    for (let idx = 0; idx < 100; idx++) {
-      dict.set(`${idx}`, idx + 10);
-    }
-
-    let data = initTernaryTreeMap(dict);
-    checkMapStructure(data);
-
-    var i = 0;
-    for (let [k, v] of toPairs(data)) {
-      // echo "..{k}-{v}.."
-      i = i + 1;
-    }
-    check(i === 100);
-  });
-
-  test("map values", () => {
-    var dict: Map<string, number> = new Map();
-    for (let idx = 0; idx < 4; idx++) {
-      dict.set(`${idx}`, idx + 10);
-    }
-    let data = initTernaryTreeMap(dict);
-
-    var dict2: Map<string, number> = new Map();
-    for (let idx = 0; idx < 4; idx++) {
-      dict2.set(`${idx}`, idx + 20);
-    }
-    let data2 = initTernaryTreeMap(dict2);
-
-    let data3 = mapMapValues(data, (x) => x + 10);
-    checkMapStructure(data3);
-
-    checkMapStructure(data3);
-    check(mapEqual(data2, data3));
-    check(formatMapInline(data2) === formatMapInline(data3));
-  });
-};

package/src/types.ts

@@ -1,87 +0,0 @@
-export enum TernaryTreeKind {
-  ternaryTreeBranch,
-  ternaryTreeLeaf,
-}
-
-export type TernaryTreeListTheBranch<T> = {
-  size: number;
-  kind: TernaryTreeKind.ternaryTreeBranch;
-  depth: number;
-  left: TernaryTreeList<T>;
-  middle: TernaryTreeList<T>;
-  right: TernaryTreeList<T>;
-};
-
-export type TernaryTreeListTheLeaf<T> = {
-  size: number;
-  kind: TernaryTreeKind.ternaryTreeLeaf;
-  value: T;
-};
-
-export type TernaryTreeList<T> = TernaryTreeListTheBranch<T> | TernaryTreeListTheLeaf<T>;
-
-export type TernaryTreeMapHashEntry<K, V> = {
-  hash: Hash;
-  pairs: Array<[K, V]>;
-};
-
-export type TernaryTreeMapTheBranch<K, T> = {
-  kind: TernaryTreeKind.ternaryTreeBranch;
-  depth: number;
-  maxHash: number;
-  minHash: number;
-  left: TernaryTreeMap<K, T>;
-  middle: TernaryTreeMap<K, T>;
-  right: TernaryTreeMap<K, T>;
-};
-export type TernaryTreeMapTheLeaf<K, T> = {
-  kind: TernaryTreeKind.ternaryTreeLeaf;
-  hash: number;
-  elements: Array<[K, T]>; // handle hash collapsing
-};
-
-export type TernaryTreeMap<K, T> = TernaryTreeMapTheBranch<K, T> | TernaryTreeMapTheLeaf<K, T>;
-
-export type RefInt = {
-  value: number;
-};
-
-export type Hash = number; // TODO
-
-export let valueHash = (x: any): Hash => {
-  if (typeof x === "number") {
-    // console.log("hash for x:", x, "\t", result);
-    return x;
-  } else if (typeof x === "string") {
-    let h = 0;
-    // https://gist.github.com/hyamamoto/fd435505d29ebfa3d9716fd2be8d42f0#gistcomment-2775538
-    for (var i = 0; i < x.length; i++) {
-      h = Math.imul(31, h) + (x[i].charCodeAt(0) | 0);
-    }
-    // console.log("hash for x:", x, "\t", result);
-    return h;
-  }
-  throw new Error("Hash solution not provided for this type(other than number and string)");
-};
-
-/** default hash function only handles number and string, need customization */
-export let hashGenerator: typeof valueHash = valueHash;
-
-/** allow customizing hash function from outside */
-export let overwriteHashGenerator = (f: typeof hashGenerator) => {
-  hashGenerator = f;
-};
-
-export let mergeValueHash = (base: Hash, x: number | string): Hash => {
-  if (typeof x === "number") {
-    return Math.imul(31, base) + x;
-  } else if (typeof x === "string") {
-    let h = base;
-    // https://gist.github.com/hyamamoto/fd435505d29ebfa3d9716fd2be8d42f0#gistcomment-2775538
-    for (var i = 0; i < x.length; i++) {
-      h = Math.imul(31, h) + (x[i].charCodeAt(0) | 0);
-    }
-    return h;
-  }
-  throw new Error("Hash solution not provided for this type(other than number and string)");
-};