@calcit/procs 0.5.0-a9 → 0.5.0

package/lib/custom-formatter.js

@@ -1,9 +1,9 @@
 import "./js-primes";
 import { CalcitRef, CalcitSymbol, CalcitKeyword } from "./calcit-data";
-import { toPairs } from "@calcit/ternary-tree";
+import "@calcit/ternary-tree";
 import { CalcitRecord } from "./js-record";
-import { CalcitMap } from "./js-map";
-import { CalcitList } from "./js-list";
+import { CalcitMap, CalcitSliceMap } from "./js-map";
+import { CalcitList, CalcitSliceList } from "./js-list";
 import { CalcitSet } from "./js-set";
 import { CalcitTuple } from "./js-tuple";
 let embedObject = (x) => {
@@ -28,7 +28,7 @@ export let load_console_formatter_$x_ = () => {
                     if (obj instanceof CalcitSymbol) {
                         return ["div", { style: "color: hsl(340, 80%, 60%)" }, obj.toString()];
                     }
-                    if (obj instanceof CalcitList) {
+                    if (obj instanceof CalcitList || obj instanceof CalcitSliceList) {
                         return [
                             "div",
                             { style: "color: hsl(280, 80%, 60%, 0.4)" },
@@ -36,7 +36,7 @@ export let load_console_formatter_$x_ = () => {
                             ["span", { style: "font-size: 80%; vertical-align: 0.7em; color: hsl(280, 80%, 60%, 0.8)" }, `${obj.len()}`],
                         ];
                     }
-                    if (obj instanceof CalcitMap) {
+                    if (obj instanceof CalcitMap || obj instanceof CalcitSliceMap) {
                         return ["div", { style: "color: hsl(280, 80%, 60%, 0.4)" }, obj.toString(true)];
                     }
                     if (obj instanceof CalcitSet) {
@@ -65,10 +65,10 @@ export let load_console_formatter_$x_ = () => {
                     return null;
                 },
                 hasBody: (obj) => {
-                    if (obj instanceof CalcitList) {
+                    if (obj instanceof CalcitList || obj instanceof CalcitSliceList) {
                         return obj.len() > 0;
                     }
-                    if (obj instanceof CalcitMap) {
+                    if (obj instanceof CalcitMap || obj instanceof CalcitSliceMap) {
                         return obj.len() > 0;
                     }
                     if (obj instanceof CalcitSet) {
@@ -77,7 +77,7 @@ export let load_console_formatter_$x_ = () => {
                     return false;
                 },
                 body: (obj, config) => {
-                    if (obj instanceof CalcitList) {
+                    if (obj instanceof CalcitList || obj instanceof CalcitSliceList) {
                         return ["div", { style: "color: hsl(280, 80%, 60%)" }].concat(obj.toArray().map((x, idx) => {
                             return [
                                 "div",
@@ -102,10 +102,10 @@ export let load_console_formatter_$x_ = () => {
                         ret.push(["div", { style: "margin-left: 8px; display: inline-block;" }, embedObject(obj.snd)]);
                         return ret;
                     }
-                    if (obj instanceof CalcitMap) {
+                    if (obj instanceof CalcitMap || obj instanceof CalcitSliceMap) {
                         let ret = ["div", { style: "color: hsl(280, 80%, 60%)" }];
-                        obj.turnMap();
-                        for (let [k, v] of toPairs(obj.value)) {
+                        let pairs = obj.pairs();
+                        for (let [k, v] of pairs) {
                             ret.push([
                                 "div",
                                 { style: "margin-left: 8px; display: flex;" },

package/lib/js-cirru.js

@@ -1,9 +1,9 @@
-import { initTernaryTreeMap } from "@calcit/ternary-tree";
+import "@calcit/ternary-tree";
 import { writeCirruCode } from "@cirru/writer.ts";
 import "./js-primes";
-import { CalcitList } from "./js-list";
+import { CalcitList, CalcitSliceList } from "./js-list";
 import { CalcitRecord } from "./js-record";
-import { CalcitMap } from "./js-map";
+import { CalcitMap, CalcitSliceMap } from "./js-map";
 import { CalcitSet } from "./js-set";
 import { CalcitKeyword, CalcitSymbol, CalcitRecur, CalcitRef, kwd } from "./calcit-data";
 import { CalcitTuple } from "./js-tuple";
@@ -39,11 +39,11 @@ export let to_cirru_edn = (x) => {
     if (x instanceof CalcitSymbol) {
         return x.toString();
     }
-    if (x instanceof CalcitList) {
+    if (x instanceof CalcitList || x instanceof CalcitSliceList) {
         // TODO can be faster
         return ["[]"].concat(x.toArray().map(to_cirru_edn));
     }
-    if (x instanceof CalcitMap) {
+    if (x instanceof CalcitMap || x instanceof CalcitSliceMap) {
         let buffer = ["{}"];
         for (let [k, v] of x.pairs()) {
             buffer.push([to_cirru_edn(k), to_cirru_edn(v)]);
@@ -101,7 +101,7 @@ export let extract_cirru_edn = (x) => {
         if (x === "false") {
             return false;
         }
-        if (x == "") {
+        if (x === "") {
             throw new Error("cannot be empty");
         }
         if (x[0] === "|" || x[0] === '"') {
@@ -127,17 +127,17 @@ export let extract_cirru_edn = (x) => {
         if (x[0] === "{}") {
             let result = [];
             x.forEach((pair, idx) => {
-                if (idx == 0) {
+                if (idx === 0) {
                     return; // skip first `{}` symbol
                 }
-                if (pair instanceof Array && pair.length == 2) {
-                    result.push([extract_cirru_edn(pair[0]), extract_cirru_edn(pair[1])]);
+                if (pair instanceof Array && pair.length === 2) {
+                    result.push(extract_cirru_edn(pair[0]), extract_cirru_edn(pair[1]));
                 }
                 else {
                     throw new Error("Expected pairs for map");
                 }
             });
-            return new CalcitMap(initTernaryTreeMap(result));
+            return new CalcitSliceMap(result);
         }
         if (x[0] === "%{}") {
             let name = x[1];
@@ -150,7 +150,7 @@ export let extract_cirru_edn = (x) => {
                 if (idx <= 1) {
                     return; // skip %{} name
                 }
-                if (pair instanceof Array && pair.length == 2) {
+                if (pair instanceof Array && pair.length === 2) {
                     if (typeof pair[0] === "string") {
                         entries.push([extractFieldKwd(pair[0]), extract_cirru_edn(pair[1])]);
                     }
@@ -174,7 +174,7 @@ export let extract_cirru_edn = (x) => {
             return new CalcitRecord(extractFieldKwd(name), fields, values);
         }
         if (x[0] === "[]") {
-            return new CalcitList(x.slice(1).map(extract_cirru_edn));
+            return new CalcitSliceList(x.slice(1).map(extract_cirru_edn));
         }
         if (x[0] === "#{}") {
             return new CalcitSet(x.slice(1).map(extract_cirru_edn));
@@ -205,10 +205,10 @@ export let format_cirru_edn = (data, useInline = true) => {
     if (typeof data === "string") {
         return "\ndo " + to_cirru_edn(data) + "\n";
     }
-    if (typeof data == "boolean") {
+    if (typeof data === "boolean") {
         return "\ndo " + to_cirru_edn(data) + "\n";
     }
-    if (typeof data == "string") {
+    if (typeof data === "string") {
         return "\ndo " + to_cirru_edn(data) + "\n";
     }
     if (data instanceof CalcitSymbol) {
@@ -239,7 +239,7 @@ export let to_calcit_data = (x, noKeyword = false) => {
         x.forEach((v) => {
             result.push(to_calcit_data(v, noKeyword));
         });
-        return new CalcitList(result);
+        return new CalcitSliceList(result);
     }
     if (x instanceof Set) {
         let result = [];
@@ -248,9 +248,9 @@ export let to_calcit_data = (x, noKeyword = false) => {
         });
         return new CalcitSet(result);
     }
-    if (x instanceof CalcitList)
+    if (x instanceof CalcitList || x instanceof CalcitSliceList)
         return x;
-    if (x instanceof CalcitMap)
+    if (x instanceof CalcitMap || x instanceof CalcitSliceMap)
         return x;
     if (x instanceof CalcitSet)
         return x;
@@ -270,9 +270,9 @@ export let to_calcit_data = (x, noKeyword = false) => {
     if (x === Object(x)) {
         let result = [];
         Object.keys(x).forEach((k) => {
-            result.push([to_calcit_data(k, noKeyword), to_calcit_data(x[k], noKeyword)]);
+            result.push(to_calcit_data(k, noKeyword), to_calcit_data(x[k], noKeyword));
         });
-        return new CalcitMap(initTernaryTreeMap(result));
+        return new CalcitSliceMap(result);
     }
     console.error(x);
     throw new Error("Unexpected data for converting");
@@ -281,7 +281,7 @@ let toWriterNode = (xs) => {
     if (typeof xs === "string") {
         return xs;
     }
-    if (xs instanceof CalcitList) {
+    if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
         return xs.toArray().map(toWriterNode);
     }
     else {

package/lib/js-list.js

@@ -1,92 +1,153 @@
 import * as ternaryTree from "@calcit/ternary-tree";
 import "./js-primes";
-import { initTernaryTreeList, listLen, listGet, assocList, listToItems, dissocList, assocBefore, assocAfter, } from "@calcit/ternary-tree";
-import { CalcitMap } from "./js-map";
+import { initTernaryTreeList, initTernaryTreeListFromRange, listLen, listGet, assocList, listToItems, dissocList, assocBefore, assocAfter, } from "@calcit/ternary-tree";
+import { CalcitMap, CalcitSliceMap } from "./js-map";
 import { CalcitSet } from "./js-set";
 import { CalcitTuple } from "./js-tuple";
-import "./calcit.procs";
 import { isNestedCalcitData, tipNestedCalcitData, toString } from "./calcit-data";
+// two list implementations, should offer same interface
 export class CalcitList {
     constructor(value) {
-        if (value == null) {
-            value = []; // dirty, better handled from outside
-        }
         this.cachedHash = null;
-        if (Array.isArray(value)) {
-            this.arrayMode = true;
-            this.arrayValue = value;
-            this.arrayStart = 0;
-            this.arrayEnd = value.length;
-            this.value = null;
+        if (value == null) {
+            this.value = initTernaryTreeList([]);
         }
         else {
-            this.arrayMode = false;
             this.value = value;
-            this.arrayValue = [];
-            this.arrayStart = null;
-            this.arrayEnd = null;
-        }
-    }
-    turnListMode() {
-        if (this.arrayMode) {
-            this.value = initTernaryTreeList(this.arrayValue.slice(this.arrayStart, this.arrayEnd));
-            this.arrayValue = null;
-            this.arrayStart = null;
-            this.arrayEnd = null;
-            this.arrayMode = false;
         }
     }
     len() {
-        if (this.arrayMode) {
-            return this.arrayEnd - this.arrayStart;
-        }
-        else {
-            return listLen(this.value);
-        }
+        return listLen(this.value);
     }
     get(idx) {
-        if (this.arrayMode) {
-            return this.arrayValue[this.arrayStart + idx];
-        }
-        else {
-            return listGet(this.value, idx);
-        }
+        return listGet(this.value, idx);
     }
     assoc(idx, v) {
-        this.turnListMode();
         return new CalcitList(assocList(this.value, idx, v));
     }
     assocBefore(idx, v) {
-        this.turnListMode();
         return new CalcitList(assocBefore(this.value, idx, v));
     }
     assocAfter(idx, v) {
-        this.turnListMode();
         return new CalcitList(assocAfter(this.value, idx, v));
     }
     dissoc(idx) {
-        this.turnListMode();
         return new CalcitList(dissocList(this.value, idx));
     }
     slice(from, to) {
-        if (this.arrayMode) {
-            if (from < 0) {
-                throw new Error(`from index too small: ${from}`);
-            }
-            if (to > this.len()) {
-                throw new Error(`end index too large: ${to}`);
+        return new CalcitList(ternaryTree.slice(this.value, from, to));
+    }
+    toString(shorter = false) {
+        let result = "";
+        for (let item of this.items()) {
+            if (shorter && isNestedCalcitData(item)) {
+                result = `${result} ${tipNestedCalcitData(item)}`;
             }
-            if (to < from) {
-                throw new Error("end index too small");
+            else {
+                result = `${result} ${toString(item, true)}`;
             }
-            let result = new CalcitList(this.arrayValue);
-            result.arrayStart = this.arrayStart + from;
-            result.arrayEnd = this.arrayStart + to;
-            return result;
+        }
+        return `([]${result})`;
+    }
+    isEmpty() {
+        return this.len() === 0;
+    }
+    /** usage: `for of` */
+    items() {
+        return listToItems(this.value);
+    }
+    append(v) {
+        return new CalcitList(ternaryTree.append(this.value, v));
+    }
+    prepend(v) {
+        return new CalcitList(ternaryTree.prepend(this.value, v));
+    }
+    first() {
+        return ternaryTree.first(this.value);
+    }
+    rest() {
+        return new CalcitList(ternaryTree.rest(this.value));
+    }
+    concat(ys) {
+        if (ys instanceof CalcitSliceList) {
+            return new CalcitList(ternaryTree.concat(this.value, ys.turnListMode().value));
+        }
+        else if (ys instanceof CalcitList) {
+            return new CalcitList(ternaryTree.concat(this.value, ys.value));
         }
         else {
-            return new CalcitList(ternaryTree.slice(this.value, from, to));
+            throw new Error(`Unknown data to concat: ${ys}`);
+        }
+    }
+    map(f) {
+        return new CalcitList(ternaryTree.listMapValues(this.value, f));
+    }
+    toArray() {
+        return [...ternaryTree.listToItems(this.value)];
+    }
+    reverse() {
+        return new CalcitList(ternaryTree.reverse(this.value));
+    }
+}
+// represent append-only immutable list in Array slices
+export class CalcitSliceList {
+    constructor(value) {
+        if (value == null) {
+            value = []; // dirty, better handled from outside
         }
+        this.cachedHash = null;
+        this.value = value;
+        this.start = 0;
+        this.end = value.length;
+    }
+    turnListMode() {
+        return new CalcitList(initTernaryTreeListFromRange(this.value, this.start, this.end));
+    }
+    len() {
+        return this.end - this.start;
+    }
+    get(idx) {
+        return this.value[this.start + idx];
+    }
+    assoc(idx, v) {
+        return this.turnListMode().assoc(idx, v);
+    }
+    assocBefore(idx, v) {
+        return this.turnListMode().assocBefore(idx, v);
+    }
+    assocAfter(idx, v) {
+        if (idx === this.len() - 1) {
+            return this.append(v);
+        }
+        else {
+            return this.turnListMode().assocAfter(idx, v);
+        }
+    }
+    dissoc(idx) {
+        if (idx === 0) {
+            return this.rest();
+        }
+        else if (idx === this.len() - 1) {
+            return this.slice(0, idx);
+        }
+        else {
+            return this.turnListMode().dissoc(idx);
+        }
+    }
+    slice(from, to) {
+        if (from < 0) {
+            throw new Error(`from index too small: ${from}`);
+        }
+        if (to > this.len()) {
+            throw new Error(`end index too large: ${to}`);
+        }
+        if (to < from) {
+            throw new Error("end index too small");
+        }
+        let result = new CalcitSliceList(this.value);
+        result.start = this.start + from;
+        result.end = this.start + to;
+        return result;
     }
     toString(shorter = false) {
         let result = "";
@@ -105,59 +166,40 @@ export class CalcitList {
     }
     /** usage: `for of` */
     items() {
-        if (this.arrayMode) {
-            return sliceGenerator(this.arrayValue, this.arrayStart, this.arrayEnd);
-        }
-        else {
-            return listToItems(this.value);
-        }
+        return sliceGenerator(this.value, this.start, this.end);
     }
     append(v) {
-        if (this.arrayMode && this.arrayEnd === this.arrayValue.length && this.arrayStart < 32) {
+        if (this.end === this.value.length && this.start < 32) {
             // dirty trick to reuse list memory, data storage actually appended at existing array
-            this.arrayValue.push(v);
-            let newList = new CalcitList(this.arrayValue);
-            newList.arrayStart = this.arrayStart;
-            newList.arrayEnd = this.arrayEnd + 1;
+            this.value.push(v);
+            let newList = new CalcitSliceList(this.value);
+            newList.start = this.start;
+            newList.end = this.end + 1;
             return newList;
         }
         else {
-            this.turnListMode();
-            return new CalcitList(ternaryTree.append(this.value, v));
+            return this.turnListMode().append(v);
         }
     }
     prepend(v) {
-        this.turnListMode();
-        return new CalcitList(ternaryTree.prepend(this.value, v));
+        return this.turnListMode().prepend(v);
     }
     first() {
-        if (this.arrayMode) {
-            if (this.arrayValue.length > this.arrayStart) {
-                return this.arrayValue[this.arrayStart];
-            }
-            else {
-                return null;
-            }
+        if (this.value.length > this.start) {
+            return this.value[this.start];
         }
         else {
-            return ternaryTree.first(this.value);
+            return null;
         }
     }
     rest() {
-        if (this.arrayMode) {
-            return this.slice(1, this.arrayEnd - this.arrayStart);
-        }
-        else {
-            return new CalcitList(ternaryTree.rest(this.value));
-        }
+        return this.slice(1, this.end - this.start);
     }
+    // TODO
     concat(ys) {
-        if (!(ys instanceof CalcitList)) {
-            throw new Error("Expected list");
-        }
-        if (this.arrayMode && ys.arrayMode) {
-            let size = this.arrayEnd - this.arrayStart;
-            let otherSize = ys.arrayEnd - ys.arrayStart;
+        if (ys instanceof CalcitSliceList) {
+            let size = this.end - this.start;
+            let otherSize = ys.end - ys.start;
             let combined = new Array(size + otherSize);
             for (let i = 0; i < size; i++) {
                 combined[i] = this.get(i);
@@ -165,38 +207,39 @@ export class CalcitList {
             for (let i = 0; i < otherSize; i++) {
                 combined[i + size] = ys.get(i);
             }
-            return new CalcitList(combined);
+            return new CalcitSliceList(combined);
+        }
+        else if (ys instanceof CalcitList) {
+            return this.turnListMode().concat(ys);
         }
         else {
-            this.turnListMode();
-            ys.turnListMode();
-            return new CalcitList(ternaryTree.concat(this.value, ys.value));
+            throw new Error("Expected list");
         }
     }
     map(f) {
-        if (this.arrayMode) {
-            return new CalcitList(this.arrayValue.slice(this.arrayStart, this.arrayEnd).map(f));
-        }
-        else {
-            return new CalcitList(ternaryTree.listMapValues(this.value, f));
+        let ys = [];
+        for (let x in sliceGenerator(this.value, this.start, this.end)) {
+            ys.push(f(x));
         }
+        return new CalcitSliceList(ys);
     }
     toArray() {
-        if (this.arrayMode) {
-            return this.arrayValue.slice(this.arrayStart, this.arrayEnd);
-        }
-        else {
-            return [...ternaryTree.listToItems(this.value)];
-        }
+        return this.value.slice(this.start, this.end);
     }
     reverse() {
-        this.turnListMode();
-        return new CalcitList(ternaryTree.reverse(this.value));
+        return this.turnListMode().reverse();
     }
 }
 function* sliceGenerator(xs, start, end) {
-    for (let idx = start; idx < end; idx++) {
-        yield xs[idx];
+    if (xs == null) {
+        if (end <= start) {
+            throw new Error("invalid list to slice");
+        }
+    }
+    else {
+        for (let idx = start; idx < end; idx++) {
+            yield xs[idx];
+        }
     }
 }
 export let foldl = function (xs, acc, f) {
@@ -204,10 +247,9 @@ export let foldl = function (xs, acc, f) {
         throw new Error("foldl takes 3 arguments");
     }
     if (f == null) {
-        debugger;
         throw new Error("Expected function for folding");
     }
-    if (xs instanceof CalcitList) {
+    if (xs instanceof CalcitSliceList || xs instanceof CalcitList) {
         var result = acc;
         for (let idx = 0; idx < xs.len(); idx++) {
             let item = xs.get(idx);
@@ -222,10 +264,20 @@ export let foldl = function (xs, acc, f) {
         });
         return result;
     }
+    if (xs instanceof CalcitSliceMap) {
+        let result = acc;
+        // low-level code for performance
+        let size = xs.chunk.length >> 1;
+        for (let i = 0; i < size; i++) {
+            let pos = i << 1;
+            result = f(result, new CalcitSliceList([xs.chunk[pos], xs.chunk[pos + 1]]));
+        }
+        return result;
+    }
     if (xs instanceof CalcitMap) {
         let result = acc;
-        xs.pairs().forEach(([k, item]) => {
-            result = f(result, new CalcitList([k, item]));
+        xs.pairs().forEach((pair) => {
+            result = f(result, new CalcitSliceList(pair));
         });
         return result;
     }
@@ -236,10 +288,9 @@ export let foldl_shortcut = function (xs, acc, v0, f) {
         throw new Error("foldl-shortcut takes 4 arguments");
     }
     if (f == null) {
-        debugger;
         throw new Error("Expected function for folding");
     }
-    if (xs instanceof CalcitList) {
+    if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
         var state = acc;
         for (let idx = 0; idx < xs.len(); idx++) {
             let item = xs.get(idx);
@@ -280,10 +331,33 @@ export let foldl_shortcut = function (xs, acc, v0, f) {
         }
         return v0;
     }
+    if (xs instanceof CalcitSliceMap) {
+        let state = acc;
+        // low-level code for performance
+        let size = xs.chunk.length >> 1;
+        for (let i = 0; i < size; i++) {
+            let pos = i << 1;
+            let pair = f(state, new CalcitSliceList([xs.chunk[pos], xs.chunk[pos + 1]]));
+            if (pair instanceof CalcitTuple) {
+                if (typeof pair.fst === "boolean") {
+                    if (pair.fst) {
+                        return pair.snd;
+                    }
+                    else {
+                        state = pair.snd;
+                    }
+                }
+            }
+            else {
+                throw new Error("Expected return value in `:: bool acc` structure");
+            }
+        }
+        return v0;
+    }
     if (xs instanceof CalcitMap) {
         let state = acc;
         for (let item of xs.pairs()) {
-            let pair = f(state, new CalcitList(item));
+            let pair = f(state, new CalcitSliceList(item));
             if (pair instanceof CalcitTuple) {
                 if (typeof pair.fst === "boolean") {
                     if (pair.fst) {
@@ -307,10 +381,9 @@ export let foldr_shortcut = function (xs, acc, v0, f) {
         throw new Error("foldr-shortcut takes 4 arguments");
     }
     if (f == null) {
-        debugger;
         throw new Error("Expected function for folding");
     }
-    if (xs instanceof CalcitList) {
+    if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
         var state = acc;
         // iterate from right
         for (let idx = xs.len() - 1; idx >= 0; idx--) {