@calcit/procs 0.5.0-a9 → 0.5.0

package/lib/js-map.js

@@ -1,7 +1,7 @@
 import * as ternaryTree from "@calcit/ternary-tree";
 import "./js-primes";
 import { CalcitSet } from "./js-set";
-import { initTernaryTreeMap, mapLen, assocMap, dissocMap, isMapEmpty, toPairsArray, mapGetDefault } from "@calcit/ternary-tree";
+import { mapLen, assocMap, dissocMap, isMapEmpty, toPairsArray, mapGetDefault, initEmptyTernaryTreeMap, initTernaryTreeMapFromArray, } from "@calcit/ternary-tree";
 import { isNestedCalcitData, tipNestedCalcitData, toString } from "./calcit-data";
 /** need to compare by Calcit */
 let DATA_EQUAL = (x, y) => {
@@ -15,60 +15,189 @@ let fakeUniqueSymbol = [];
 export class CalcitMap {
     constructor(value) {
         if (value == null) {
-            this.arrayMode = true;
-            this.arrayValue = [];
-        }
-        else if (Array.isArray(value)) {
-            this.arrayMode = true;
-            this.arrayValue = value;
+            this.value = initEmptyTernaryTreeMap();
         }
         else {
-            this.arrayMode = false;
             this.value = value;
         }
     }
-    turnMap() {
-        if (this.arrayMode) {
-            var dict = [];
-            let halfLength = this.arrayValue.length >> 1;
-            for (let idx = 0; idx < halfLength; idx++) {
-                dict.push([this.arrayValue[idx << 1], this.arrayValue[(idx << 1) + 1]]);
+    len() {
+        return mapLen(this.value);
+    }
+    get(k) {
+        return mapGetDefault(this.value, k, null);
+    }
+    assoc(...args) {
+        if (args.length % 2 !== 0)
+            throw new Error("expected even arguments");
+        let size = Math.floor(args.length / 2);
+        let result = this.value;
+        for (let idx = 0; idx < size; idx++) {
+            let k = args[idx << 1];
+            let v = args[(idx << 1) + 1];
+            result = assocMap(result, k, v);
+        }
+        return new CalcitMap(result);
+    }
+    dissoc(...args) {
+        let ret = this.value;
+        for (let idx = 0; idx < args.length; idx++) {
+            ret = dissocMap(ret, args[idx]);
+        }
+        return new CalcitMap(ret);
+    }
+    toString(shorter = false) {
+        let itemsCode = "";
+        for (let [k, v] of this.pairs()) {
+            if (shorter) {
+                let keyPart = isNestedCalcitData(k) ? tipNestedCalcitData(k) : toString(k, true);
+                let valuePart = isNestedCalcitData(v) ? tipNestedCalcitData(v) : toString(v, true);
+                itemsCode = `${itemsCode} (${keyPart} ${valuePart})`;
+            }
+            else {
+                itemsCode = `${itemsCode} (${toString(k, true)} ${toString(v, true)})`;
             }
-            this.value = initTernaryTreeMap(dict);
-            this.arrayMode = false;
-            this.arrayValue = null;
         }
+        return `({}${itemsCode})`;
     }
-    len() {
-        if (this.arrayMode) {
-            return this.arrayValue.length >> 1;
+    isEmpty() {
+        return isMapEmpty(this.value);
+    }
+    pairs() {
+        return toPairsArray(this.value);
+    }
+    keysArray() {
+        return [...ternaryTree.toKeys(this.value)];
+    }
+    contains(k) {
+        return ternaryTree.contains(this.value, k);
+    }
+    merge(ys) {
+        return this.mergeSkip(ys, fakeUniqueSymbol);
+    }
+    mergeSkip(ys, v) {
+        if (ys == null) {
+            return this;
+        }
+        if (!(ys instanceof CalcitMap || ys instanceof CalcitSliceMap)) {
+            console.error("value:", v);
+            throw new Error("Expected map to merge");
+        }
+        if (ys instanceof CalcitSliceMap) {
+            let ret = this.value;
+            let size = ys.chunk.length >> 1;
+            for (let i = 0; i < size; i++) {
+                let pos = i << 1;
+                if (ys.chunk[pos + 1] === v) {
+                    continue;
+                }
+                ret = assocMap(ret, ys.chunk[pos], ys.chunk[pos + 1]);
+            }
+            return new CalcitMap(ret);
+        }
+        else {
+            return new CalcitMap(ternaryTree.mergeSkip(this.value, ys.value, v));
+        }
+    }
+    /** TODO implement diff with low level code, opens opportunity for future optimizations */
+    diffNew(ys) {
+        let zs = this.value;
+        if (ys instanceof CalcitSliceMap) {
+            let size = ys.chunk.length >> 1;
+            for (let i = 0; i < size; i++) {
+                let pos = i << 1;
+                let k = ys.chunk[pos];
+                if (ternaryTree.contains(zs, k)) {
+                    zs = ternaryTree.dissocMap(zs, k);
+                }
+            }
+            return new CalcitMap(zs);
+        }
+        else if (ys instanceof CalcitMap) {
+            let ysKeys = ys.keysArray();
+            for (let i = 0; i < ysKeys.length; i++) {
+                let k = ysKeys[i];
+                if (ternaryTree.contains(zs, k)) {
+                    zs = ternaryTree.dissocMap(zs, k);
+                }
+            }
+            return new CalcitMap(zs);
         }
         else {
-            return mapLen(this.value);
+            throw new Error("unknown data to diff");
         }
     }
+    /** TODO implement diff with low level code, opens opportunity for future optimizations */
+    diffKeys(ys) {
+        let ret = [];
+        let ks = this.keysArray();
+        for (let i = 0; i < ks.length; i++) {
+            let k = ks[i];
+            if (!ys.contains(k)) {
+                ret.push(k);
+            }
+        }
+        return new CalcitSet(ret);
+    }
+    /** TODO implement diff with low level code, opens opportunity for future optimizations */
+    commonKeys(ys) {
+        let ret = [];
+        let ks = this.keysArray();
+        for (let i = 0; i < ks.length; i++) {
+            let k = ks[i];
+            if (ys.contains(k)) {
+                ret.push(k);
+            }
+        }
+        return new CalcitSet(ret);
+    }
+}
+// store small map in linear array to reduce cost of building tree
+export class CalcitSliceMap {
+    constructor(value) {
+        if (value == null) {
+            this.chunk = [];
+        }
+        else if (Array.isArray(value)) {
+            this.chunk = value;
+        }
+        else {
+            throw new Error("unknown data for map");
+        }
+    }
+    turnMap() {
+        var dict = [];
+        let halfLength = this.chunk.length >> 1;
+        for (let idx = 0; idx < halfLength; idx++) {
+            dict.push([this.chunk[idx << 1], this.chunk[(idx << 1) + 1]]);
+        }
+        let value = initTernaryTreeMapFromArray(dict);
+        return new CalcitMap(value);
+    }
+    len() {
+        return this.chunk.length >> 1;
+    }
     get(k) {
-        if (this.arrayMode && this.arrayValue.length <= 16) {
-            let size = this.arrayValue.length >> 1;
+        if (this.chunk.length <= 16) {
+            let size = this.chunk.length >> 1;
             for (let i = 0; i < size; i++) {
                 let pos = i << 1;
-                if (DATA_EQUAL(this.arrayValue[pos], k)) {
-                    return this.arrayValue[pos + 1];
+                if (DATA_EQUAL(this.chunk[pos], k)) {
+                    return this.chunk[pos + 1];
                 }
             }
             return null;
         }
         else {
-            this.turnMap();
-            return mapGetDefault(this.value, k, null);
+            return this.turnMap().get(k);
         }
     }
     assoc(...args) {
         if (args.length % 2 !== 0)
             throw new Error("expected even arguments");
         let size = Math.floor(args.length / 2);
-        if (this.arrayMode && this.arrayValue.length <= 16) {
-            let ret = this.arrayValue.slice(0);
+        if (this.chunk.length <= 16) {
+            let ret = this.chunk.slice(0);
             outer: for (let j = 0; j < size; j++) {
                 let k = args[j << 1];
                 let v = args[(j << 1) + 1];
@@ -80,40 +209,28 @@ export class CalcitMap {
                 }
                 ret.push(k, v);
             }
-            return new CalcitMap(ret);
+            return new CalcitSliceMap(ret);
         }
         else {
-            this.turnMap();
-            let result = this.value;
-            for (let idx = 0; idx < size; idx++) {
-                let k = args[idx << 1];
-                let v = args[(idx << 1) + 1];
-                result = assocMap(result, k, v);
-            }
-            return new CalcitMap(result);
+            return this.turnMap().assoc(...args);
         }
     }
     dissoc(...args) {
-        if (this.arrayMode && this.arrayValue.length <= 16) {
+        if (this.chunk.length <= 16) {
             let ret = [];
-            outer: for (let i = 0; i < this.arrayValue.length; i += 2) {
+            outer: for (let i = 0; i < this.chunk.length; i += 2) {
                 for (let j = 0; j < args.length; j++) {
                     let k = args[j];
-                    if (DATA_EQUAL(k, this.arrayValue[i])) {
+                    if (DATA_EQUAL(k, this.chunk[i])) {
                         continue outer;
                     }
                 }
-                ret.push(this.arrayValue[i], this.arrayValue[i + 1]);
+                ret.push(this.chunk[i], this.chunk[i + 1]);
             }
-            return new CalcitMap(ret);
+            return new CalcitSliceMap(ret);
         }
         else {
-            this.turnMap();
-            let ret = this.value;
-            for (let idx = 0; idx < args.length; idx++) {
-                ret = dissocMap(ret, args[idx]);
-            }
-            return new CalcitMap(ret);
+            return this.turnMap().dissoc(...args);
         }
     }
     toString(shorter = false) {
@@ -131,56 +248,40 @@ export class CalcitMap {
         return `({}${itemsCode})`;
     }
     isEmpty() {
-        if (this.arrayMode) {
-            return this.arrayValue.length === 0;
-        }
-        else {
-            return isMapEmpty(this.value);
-        }
+        return this.chunk.length === 0;
     }
     pairs() {
-        if (this.arrayMode) {
-            let ret = [];
-            let size = this.arrayValue.length >> 1;
-            for (let i = 0; i < size; i++) {
-                let pos = i << 1;
-                ret.push([this.arrayValue[pos], this.arrayValue[pos + 1]]);
-            }
-            return ret;
-        }
-        else {
-            return toPairsArray(this.value);
+        let ret = [];
+        let size = this.chunk.length >> 1;
+        for (let i = 0; i < size; i++) {
+            let pos = i << 1;
+            ret.push([this.chunk[pos], this.chunk[pos + 1]]);
         }
+        return ret;
     }
     keysArray() {
-        if (this.arrayMode) {
-            let ret = [];
-            let size = this.arrayValue.length >> 1;
-            for (let i = 0; i < size; i++) {
-                let pos = i << 1;
-                ret.push(this.arrayValue[pos]);
-            }
-            return ret;
-        }
-        else {
-            return [...ternaryTree.toKeys(this.value)];
+        let ret = [];
+        let size = this.chunk.length >> 1;
+        for (let i = 0; i < size; i++) {
+            let pos = i << 1;
+            ret.push(this.chunk[pos]);
         }
+        return ret;
     }
     contains(k) {
-        if (this.arrayMode && this.arrayValue.length <= 16) {
+        if (this.chunk.length <= 16) {
             // guessed number
-            let size = this.arrayValue.length >> 1;
+            let size = this.chunk.length >> 1;
             for (let i = 0; i < size; i++) {
                 let pos = i << 1;
-                if (DATA_EQUAL(this.arrayValue[pos], k)) {
+                if (DATA_EQUAL(this.chunk[pos], k)) {
                     return true;
                 }
             }
             return false;
         }
         else {
-            this.turnMap();
-            return ternaryTree.contains(this.value, k);
+            return this.turnMap().contains(k);
         }
     }
     merge(ys) {
@@ -190,69 +291,32 @@ export class CalcitMap {
         if (ys == null) {
             return this;
         }
-        if (!(ys instanceof CalcitMap)) {
+        if (!(ys instanceof CalcitMap || ys instanceof CalcitSliceMap)) {
             console.error("value:", v);
             throw new Error("Expected map to merge");
         }
-        if (this.arrayMode && ys.arrayMode && this.arrayValue.length + ys.arrayValue.length <= 24) {
+        if (ys instanceof CalcitSliceMap && this.chunk.length + ys.len() <= 24) {
             // probably this length < 16, ys length < 8
-            let ret = this.arrayValue.slice(0);
-            outer: for (let i = 0; i < ys.arrayValue.length; i = i + 2) {
-                if (ys.arrayValue[i + 1] === v) {
+            let ret = this.chunk.slice(0);
+            outer: for (let i = 0; i < ys.chunk.length; i = i + 2) {
+                if (ys.chunk[i + 1] === v) {
                     continue;
                 }
                 for (let k = 0; k < ret.length; k = k + 2) {
-                    if (DATA_EQUAL(ys.arrayValue[i], ret[k])) {
-                        ret[k + 1] = ys.arrayValue[i + 1];
+                    if (DATA_EQUAL(ys.chunk[i], ret[k])) {
+                        ret[k + 1] = ys.chunk[i + 1];
                         continue outer;
                     }
                 }
-                ret.push(ys.arrayValue[i], ys.arrayValue[i + 1]);
+                ret.push(ys.chunk[i], ys.chunk[i + 1]);
             }
-            return new CalcitMap(ret);
-        }
-        this.turnMap();
-        if (ys.arrayMode) {
-            let ret = this.value;
-            let size = ys.arrayValue.length >> 1;
-            for (let i = 0; i < size; i++) {
-                let pos = i << 1;
-                if (ys.arrayValue[pos + 1] === v) {
-                    continue;
-                }
-                ret = assocMap(ret, ys.arrayValue[pos], ys.arrayValue[pos + 1]);
-            }
-            return new CalcitMap(ret);
-        }
-        else {
-            return new CalcitMap(ternaryTree.mergeSkip(this.value, ys.value, v));
+            return new CalcitSliceMap(ret);
         }
+        return this.turnMap().mergeSkip(ys, v);
     }
     /** TODO implement diff with low level code, opens opportunity for future optimizations */
     diffNew(ys) {
-        this.turnMap();
-        let zs = this.value;
-        if (ys.arrayMode) {
-            let size = ys.arrayValue.length >> 1;
-            for (let i = 0; i < size; i++) {
-                let pos = i << 1;
-                let k = ys.arrayValue[pos];
-                if (ternaryTree.contains(zs, k)) {
-                    zs = ternaryTree.dissocMap(zs, k);
-                }
-            }
-            return new CalcitMap(zs);
-        }
-        else {
-            let ysKeys = ys.keysArray();
-            for (let i = 0; i < ysKeys.length; i++) {
-                let k = ysKeys[i];
-                if (ternaryTree.contains(zs, k)) {
-                    zs = ternaryTree.dissocMap(zs, k);
-                }
-            }
-            return new CalcitMap(zs);
-        }
+        return this.turnMap().diffNew(ys);
     }
     /** TODO implement diff with low level code, opens opportunity for future optimizations */
     diffKeys(ys) {

package/lib/js-record.js

@@ -1,11 +1,11 @@
-import { initTernaryTreeMap } from "@calcit/ternary-tree";
+import "@calcit/ternary-tree";
 import "./js-primes";
-import { kwd, castKwd, toString, getStringName, findInFields } from "./calcit-data";
-import { CalcitMap } from "./js-map";
+import { castKwd, toString, findInFields } from "./calcit-data";
+import { CalcitMap, CalcitSliceMap } from "./js-map";
 export class CalcitRecord {
     constructor(name, fields, values) {
         this.name = name;
-        let fieldNames = fields.map(getStringName).map(kwd);
+        let fieldNames = fields.map(castKwd);
         this.fields = fields;
         if (values != null) {
             if (values.length !== fields.length) {
@@ -146,7 +146,7 @@ export let _$n_record_$o_from_map = (proto, data) => {
             return new CalcitRecord(proto.name, proto.fields, values);
         }
     }
-    else if (data instanceof CalcitMap) {
+    else if (data instanceof CalcitMap || data instanceof CalcitSliceMap) {
         let pairs = [];
         for (let [k, v] of data.pairs()) {
             pairs.push([castKwd(k), v]);
@@ -174,9 +174,9 @@ export let _$n_record_$o_to_map = (x) => {
     if (x instanceof CalcitRecord) {
         var dict = [];
         for (let idx = 0; idx < x.fields.length; idx++) {
-            dict.push([x.fields[idx], x.values[idx]]);
+            dict.push(x.fields[idx], x.values[idx]);
         }
-        return new CalcitMap(initTernaryTreeMap(dict));
+        return new CalcitSliceMap(dict);
     }
     else {
         throw new Error("Expected record");

package/lib/js-set.js

@@ -1,6 +1,6 @@
 import "./js-primes";
 import { toString } from "./calcit-data";
-import { initTernaryTreeMap, mapLen, assocMap, dissocMap, toPairsArray, contains } from "@calcit/ternary-tree";
+import { mapLen, assocMap, dissocMap, toPairsArray, contains, initTernaryTreeMapFromArray, initEmptyTernaryTreeMap, } from "@calcit/ternary-tree";
 import * as ternaryTree from "@calcit/ternary-tree";
 /** need to compare by Calcit */
 let DATA_EQUAL = (x, y) => {
@@ -23,7 +23,7 @@ export class CalcitSet {
                 }
                 pairs.push([value[idx], true]);
             }
-            this.value = initTernaryTreeMap(pairs);
+            this.value = initTernaryTreeMapFromArray(pairs);
         }
         else {
             this.value = value;
@@ -60,7 +60,7 @@ export class CalcitSet {
         return new CalcitSet(result);
     }
     intersection(ys) {
-        let result = initTernaryTreeMap([]);
+        let result = initEmptyTernaryTreeMap();
         for (let k of ternaryTree.toKeys(this.value)) {
             if (ys.contains(k)) {
                 result = assocMap(result, k, true);
@@ -70,13 +70,13 @@ export class CalcitSet {
     }
     first() {
         // rather suspicious solution since set has no logical order
-        if (mapLen(this.value) == 0) {
+        if (mapLen(this.value) === 0) {
             return null;
         }
         return toPairsArray(this.value)[0][0];
     }
     rest() {
-        if (mapLen(this.value) == 0) {
+        if (mapLen(this.value) === 0) {
             return null;
         }
         let x0 = this.first();

package/lib/js-tuple.js

@@ -7,10 +7,10 @@ export class CalcitTuple {
         this.cachedHash = null;
     }
     get(n) {
-        if (n == 0) {
+        if (n === 0) {
             return this.fst;
         }
-        else if (n == 1) {
+        else if (n === 1) {
             return this.snd;
         }
         else {
@@ -18,10 +18,10 @@ export class CalcitTuple {
         }
     }
     assoc(n, v) {
-        if (n == 0) {
+        if (n === 0) {
             return new CalcitTuple(v, this.snd);
         }
-        else if (n == 1) {
+        else if (n === 1) {
             return new CalcitTuple(this.fst, v);
         }
         else {

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@calcit/procs",
-  "version": "0.5.0-a9",
+  "version": "0.5.0",
   "main": "./lib/calcit.procs.js",
   "devDependencies": {
-    "@types/node": "^16.10.5",
-    "esbuild": "^0.13.5",
+    "@types/node": "^16.11.6",
+    "esbuild": "^0.13.12",
     "typescript": "^4.4.4"
   },
   "scripts": {
@@ -20,8 +20,8 @@
     "url": "https://github.com/calcit-lang/calcit_runner.rs"
   },
   "dependencies": {
-    "@calcit/ternary-tree": "0.0.16",
-    "@cirru/parser.ts": "^0.0.4",
+    "@calcit/ternary-tree": "0.0.18",
+    "@cirru/parser.ts": "^0.0.5",
     "@cirru/writer.ts": "^0.1.3"
   }
 }