@calcit/procs 0.5.47 → 0.6.0-a2

package/lib/calcit-data.mjs

@@ -7,6 +7,8 @@ import { _$n_compare } from "./js-primes.mjs";
 import { CalcitList, CalcitSliceList } from "./js-list.mjs";
 import { CalcitSet, overwriteSetComparator } from "./js-set.mjs";
 import { CalcitTuple } from "./js-tuple.mjs";
+import { CalcitCirruQuote, cirru_deep_equal } from "./js-cirru.mjs";
+import "@cirru/writer.ts";
 // we have to inject cache in a dirty way in some cases
 const calcit_dirty_hash_key = "_calcit_cached_hash";
 let keywordIdx = 0;
@@ -165,6 +167,7 @@ let defaultHash_set = valueHash("set:");
 let defaultHash_list = valueHash("list:");
 let defaultHash_map = valueHash("map:");
 let defaultHash_record = valueHash("record:");
+let defaultHash_cirru_quote = valueHash("cirru-quote:");
 let defaultHash_unknown = valueHash("unknown:");
 let fnHashCounter = 0;
 let jsObjectHashCounter = 0;
@@ -279,6 +282,11 @@ export let hashFunction = (x) => {
         x.cachedHash = base;
         return base;
     }
+    if (x instanceof CalcitCirruQuote) {
+        let base = defaultHash_cirru_quote;
+        base = hashCirru(base, x.value);
+        return base;
+    }
     console.warn(`[warn] calcit-js has no method for hashing this: ${x}`);
     // currently we use dirty solution here to generate a custom hash
     // probably happening in .to-pairs of maps, putting a js object into a set
@@ -289,6 +297,18 @@ export let hashFunction = (x) => {
     x[calcit_dirty_hash_key] = hashJsObject;
     return hashJsObject;
 };
+/// traverse Cirru tree to make unique hash
+let hashCirru = (base, x) => {
+    if (typeof x === "string") {
+        return mergeValueHash(base, hashFunction(x));
+    }
+    else {
+        for (let idx = 0; idx <= x.length; idx++) {
+            base = mergeValueHash(base, hashCirru(base, x[idx]));
+        }
+        return base;
+    }
+};
 // Dirty code to change ternary-tree behavior
 overwriteHashGenerator(hashFunction);
 export let toString = (x, escaped, disableJsDataWarning = false) => {
@@ -342,6 +362,9 @@ export let toString = (x, escaped, disableJsDataWarning = false) => {
     if (x instanceof CalcitTuple) {
         return x.toString(disableJsDataWarning);
     }
+    if (x instanceof CalcitCirruQuote) {
+        return x.toString();
+    }
     if (!disableJsDataWarning) {
         console.warn("Unknown structure to string, better use `console.log`", x);
     }
@@ -460,6 +483,12 @@ export let _$n__$e_ = (x, y) => {
         }
         return false;
     }
+    if (x instanceof CalcitCirruQuote) {
+        if (y instanceof CalcitCirruQuote) {
+            return cirru_deep_equal(x.value, y.value);
+        }
+        return false;
+    }
     if (x instanceof CalcitList || x instanceof CalcitSliceList) {
         if (y instanceof CalcitList || y instanceof CalcitSliceList) {
             if (x.len() !== y.len()) {

package/lib/calcit.procs.mjs

@@ -1,6 +1,6 @@
 var _a;
 // CALCIT VERSION
-export const calcit_version = "0.5.47";
+export const calcit_version = "0.6.0-a2";
 import { parse } from "@cirru/parser.ts";
 import { writeCirruCode } from "@cirru/writer.ts";
 import "./js-primes.mjs";
@@ -1063,6 +1063,10 @@ export let write_file = (path, content) => {
 export let parse_cirru = (code) => {
     return to_calcit_data(parse(code), true);
 };
+// for JavaScript, it's same as parse_cirru
+export let parse_cirru_list = (code) => {
+    return to_calcit_data(parse(code), true);
+};
 export let parse_cirru_edn = (code) => {
     return extract_cirru_edn(parse(code)[0]);
 };
@@ -1318,6 +1322,9 @@ export let _$n_buffer = (...xs) => {
 export let _$n_hash = (x) => {
     return hashFunction(x);
 };
+export let _$n_cirru_quote_$o_to_list = (x) => {
+    return x.toList();
+};
 // special procs have to be defined manually
 export let reduce = foldl;
 let unavailableProc = (...xs) => {

package/lib/js-cirru.mjs

@@ -7,7 +7,21 @@ import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitSet } from "./js-set.mjs";
 import { CalcitKeyword, CalcitSymbol, CalcitRecur, CalcitRef, kwd } from "./calcit-data.mjs";
 import { CalcitTuple } from "./js-tuple.mjs";
+export class CalcitCirruQuote {
+    constructor(value) {
+        this.value = value;
+    }
+    toString() {
+        return `(cirru-quote ${JSON.stringify(this.value)})`;
+    }
+    toList() {
+        return to_calcit_data(this.value, true);
+    }
+}
 export let format_cirru = (data, useInline) => {
+    if (data instanceof CalcitCirruQuote) {
+        return writeCirruCode(data.value, { useInline });
+    }
     let chunk = toWriterNode(data);
     if (!Array.isArray(chunk)) {
         throw new Error("Expected data of list");
@@ -43,6 +57,9 @@ export let to_cirru_edn = (x) => {
         // TODO can be faster
         return ["[]"].concat(x.toArray().map(to_cirru_edn));
     }
+    if (x instanceof CalcitCirruQuote) {
+        return ["quote", x.value];
+    }
     if (x instanceof CalcitMap || x instanceof CalcitSliceMap) {
         let buffer = ["{}"];
         let pairs = [];
@@ -219,7 +236,7 @@ export let extract_cirru_edn = (x) => {
             if (x.length !== 2) {
                 throw new Error("quote expects 1 argument");
             }
-            return new CalcitTuple(new CalcitSymbol("quote"), to_calcit_data(x[1], true));
+            return new CalcitCirruQuote(x[1]);
         }
         if (x[0] === "::") {
             if (x.length !== 3) {
@@ -314,6 +331,9 @@ let toWriterNode = (xs) => {
     if (typeof xs === "string") {
         return xs;
     }
+    else if (Array.isArray(xs)) {
+        return xs.map(toWriterNode);
+    }
     if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
         return xs.toArray().map(toWriterNode);
     }
@@ -321,3 +341,23 @@ let toWriterNode = (xs) => {
         throw new Error("Unexpected type for CirruWriteNode");
     }
 };
+/** deep compare cirru array */
+export let cirru_deep_equal = (x, y) => {
+    if (x === y) {
+        return true;
+    }
+    else if (Array.isArray(x) && Array.isArray(y)) {
+        if (x.length !== y.length) {
+            return false;
+        }
+        for (let idx = 0; idx < x.length; idx++) {
+            if (!cirru_deep_equal(x[idx], y[idx])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else {
+        return false;
+    }
+};

package/lib/js-primes.mjs

@@ -4,6 +4,7 @@ import { CalcitRecord } from "./js-record.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitSet as CalcitSet } from "./js-set.mjs";
 import { CalcitTuple } from "./js-tuple.mjs";
+import { CalcitCirruQuote } from "./js-cirru.mjs";
 export let is_literal = (x) => {
     if (x == null)
         return true;
@@ -35,6 +36,7 @@ var PseudoTypeIndex;
     PseudoTypeIndex[PseudoTypeIndex["map"] = 11] = "map";
     PseudoTypeIndex[PseudoTypeIndex["record"] = 12] = "record";
     PseudoTypeIndex[PseudoTypeIndex["fn"] = 13] = "fn";
+    PseudoTypeIndex[PseudoTypeIndex["cirru_quote"] = 14] = "cirru_quote";
 })(PseudoTypeIndex || (PseudoTypeIndex = {}));
 let typeAsInt = (x) => {
     // based on order used in Ord traint
@@ -65,6 +67,8 @@ let typeAsInt = (x) => {
         return PseudoTypeIndex.map;
     if (x instanceof CalcitRecord)
         return PseudoTypeIndex.record;
+    if (x instanceof CalcitCirruQuote)
+        return PseudoTypeIndex.cirru_quote;
     // proc, fn, macro, syntax, not distinguished
     if (t === "function")
         return PseudoTypeIndex.fn;
@@ -102,6 +106,8 @@ export let _$n_compare = (a, b) => {
                 return rawCompare(a, b);
             case PseudoTypeIndex.ref:
                 return rawCompare(a.path, b.path);
+            case PseudoTypeIndex.cirru_quote:
+                return rawCompare(a, b); // TODO not stable
             default:
                 // TODO, need more accurate solution
                 if (a < b) {

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@calcit/procs",
-  "version": "0.5.47",
+  "version": "0.6.0-a2",
   "main": "./lib/calcit.procs.mjs",
   "devDependencies": {
-    "@types/node": "^18.0.0",
+    "@types/node": "^18.0.6",
     "typescript": "^4.7.4"
   },
   "scripts": {

package/ts-src/calcit-data.mts

@@ -9,6 +9,8 @@ import { CalcitValue, _$n_compare } from "./js-primes.mjs";
 import { CalcitList, CalcitSliceList } from "./js-list.mjs";
 import { CalcitSet, overwriteSetComparator } from "./js-set.mjs";
 import { CalcitTuple } from "./js-tuple.mjs";
+import { CalcitCirruQuote, cirru_deep_equal } from "./js-cirru.mjs";
+import { CirruWriterNode } from "@cirru/writer.ts";
 
 // we have to inject cache in a dirty way in some cases
 const calcit_dirty_hash_key = "_calcit_cached_hash";
@@ -192,6 +194,7 @@ let defaultHash_set = valueHash("set:");
 let defaultHash_list = valueHash("list:");
 let defaultHash_map = valueHash("map:");
 let defaultHash_record = valueHash("record:");
+let defaultHash_cirru_quote = valueHash("cirru-quote:");
 
 let defaultHash_unknown = valueHash("unknown:");
 
@@ -311,6 +314,11 @@ export let hashFunction = (x: CalcitValue): Hash => {
     x.cachedHash = base;
     return base;
   }
+  if (x instanceof CalcitCirruQuote) {
+    let base = defaultHash_cirru_quote;
+    base = hashCirru(base, x.value);
+    return base;
+  }
   console.warn(`[warn] calcit-js has no method for hashing this: ${x}`);
   // currently we use dirty solution here to generate a custom hash
   // probably happening in .to-pairs of maps, putting a js object into a set
@@ -322,6 +330,18 @@ export let hashFunction = (x: CalcitValue): Hash => {
   return hashJsObject;
 };
 
+/// traverse Cirru tree to make unique hash
+let hashCirru = (base: number, x: CirruWriterNode) => {
+  if (typeof x === "string") {
+    return mergeValueHash(base, hashFunction(x));
+  } else {
+    for (let idx = 0; idx <= x.length; idx++) {
+      base = mergeValueHash(base, hashCirru(base, x[idx]));
+    }
+    return base;
+  }
+};
+
 // Dirty code to change ternary-tree behavior
 overwriteHashGenerator(hashFunction);
 
@@ -374,6 +394,9 @@ export let toString = (x: CalcitValue, escaped: boolean, disableJsDataWarning: b
   if (x instanceof CalcitTuple) {
     return x.toString(disableJsDataWarning);
   }
+  if (x instanceof CalcitCirruQuote) {
+    return x.toString();
+  }
 
   if (!disableJsDataWarning) {
     console.warn("Unknown structure to string, better use `console.log`", x);
@@ -501,6 +524,12 @@ export let _$n__$e_ = (x: CalcitValue, y: CalcitValue): boolean => {
     }
     return false;
   }
+  if (x instanceof CalcitCirruQuote) {
+    if (y instanceof CalcitCirruQuote) {
+      return cirru_deep_equal(x.value, y.value);
+    }
+    return false;
+  }
   if (x instanceof CalcitList || x instanceof CalcitSliceList) {
     if (y instanceof CalcitList || y instanceof CalcitSliceList) {
       if (x.len() !== y.len()) {

package/ts-src/calcit.procs.mts

@@ -1,5 +1,5 @@
 // CALCIT VERSION
-export const calcit_version = "0.5.47";
+export const calcit_version = "0.6.0-a2";
 
 import { parse, ICirruNode } from "@cirru/parser.ts";
 import { writeCirruCode } from "@cirru/writer.ts";
@@ -37,7 +37,7 @@ import { CalcitList, CalcitSliceList, foldl } from "./js-list.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitSet } from "./js-set.mjs";
 import { CalcitTuple } from "./js-tuple.mjs";
-import { to_calcit_data, extract_cirru_edn } from "./js-cirru.mjs";
+import { to_calcit_data, extract_cirru_edn, CalcitCirruQuote } from "./js-cirru.mjs";
 
 let inNodeJs = typeof process !== "undefined" && process?.release?.name === "node";
 
@@ -1162,6 +1162,11 @@ export let parse_cirru = (code: string): CalcitList => {
   return to_calcit_data(parse(code), true) as CalcitList;
 };
 
+// for JavaScript, it's same as parse_cirru
+export let parse_cirru_list = (code: string): CalcitList => {
+  return to_calcit_data(parse(code), true) as CalcitList;
+};
+
 export let parse_cirru_edn = (code: string) => {
   return extract_cirru_edn(parse(code)[0]);
 };
@@ -1414,6 +1419,10 @@ export let _$n_hash = (x: CalcitValue): number => {
   return hashFunction(x);
 };
 
+export let _$n_cirru_quote_$o_to_list = (x: CalcitCirruQuote): CalcitValue => {
+  return x.toList();
+};
+
 // special procs have to be defined manually
 export let reduce = foldl;
 

package/ts-src/js-cirru.mts

@@ -11,7 +11,23 @@ import { CalcitTuple } from "./js-tuple.mjs";
 
 type CirruEdnFormat = string | CirruEdnFormat[];
 
-export let format_cirru = (data: CalcitList, useInline: boolean): string => {
+export class CalcitCirruQuote {
+  value: CirruWriterNode;
+  constructor(value: CirruWriterNode) {
+    this.value = value;
+  }
+  toString(): string {
+    return `(cirru-quote ${JSON.stringify(this.value)})`;
+  }
+  toList(): CalcitValue {
+    return to_calcit_data(this.value, true);
+  }
+}
+
+export let format_cirru = (data: CalcitCirruQuote | CalcitList, useInline: boolean): string => {
+  if (data instanceof CalcitCirruQuote) {
+    return writeCirruCode(data.value, { useInline });
+  }
   let chunk = toWriterNode(data);
   if (!Array.isArray(chunk)) {
     throw new Error("Expected data of list");
@@ -48,6 +64,9 @@ export let to_cirru_edn = (x: CalcitValue): CirruEdnFormat => {
     // TODO can be faster
     return (["[]"] as CirruEdnFormat[]).concat(x.toArray().map(to_cirru_edn));
   }
+  if (x instanceof CalcitCirruQuote) {
+    return ["quote", x.value];
+  }
   if (x instanceof CalcitMap || x instanceof CalcitSliceMap) {
     let buffer: CirruEdnFormat = ["{}"];
     let pairs: [CalcitValue, CalcitValue][] = [];
@@ -217,7 +236,7 @@ export let extract_cirru_edn = (x: CirruEdnFormat): CalcitValue => {
       if (x.length !== 2) {
         throw new Error("quote expects 1 argument");
       }
-      return new CalcitTuple(new CalcitSymbol("quote"), to_calcit_data(x[1], true));
+      return new CalcitCirruQuote(x[1]);
     }
     if (x[0] === "::") {
       if (x.length !== 3) {
@@ -305,13 +324,34 @@ export let to_calcit_data = (x: any, noKeyword: boolean = false): CalcitValue =>
   throw new Error("Unexpected data for converting");
 };
 
-let toWriterNode = (xs: CalcitList | CalcitSliceList): CirruWriterNode => {
+let toWriterNode = (xs: CalcitList | CalcitSliceList | Array<any> | String): CirruWriterNode => {
   if (typeof xs === "string") {
     return xs;
+  } else if (Array.isArray(xs)) {
+    return xs.map(toWriterNode);
   }
   if (xs instanceof CalcitList || xs instanceof CalcitSliceList) {
-    return xs.toArray().map(toWriterNode);
+    return (xs.toArray() as Array<any>).map(toWriterNode);
   } else {
     throw new Error("Unexpected type for CirruWriteNode");
   }
 };
+
+/** deep compare cirru array */
+export let cirru_deep_equal = (x: CirruWriterNode, y: CirruWriterNode): boolean => {
+  if (x === y) {
+    return true;
+  } else if (Array.isArray(x) && Array.isArray(y)) {
+    if (x.length !== y.length) {
+      return false;
+    }
+    for (let idx = 0; idx < x.length; idx++) {
+      if (!cirru_deep_equal(x[idx], y[idx])) {
+        return false;
+      }
+    }
+    return true;
+  } else {
+    return false;
+  }
+};

package/ts-src/js-primes.mts

@@ -4,6 +4,7 @@ import { CalcitRecord } from "./js-record.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitSet as CalcitSet } from "./js-set.mjs";
 import { CalcitTuple } from "./js-tuple.mjs";
+import { CalcitCirruQuote, cirru_deep_equal } from "./js-cirru.mjs";
 
 export type CalcitValue =
   | string
@@ -21,6 +22,7 @@ export type CalcitValue =
   | CalcitFn
   | CalcitRecur // should not be exposed to function
   | CalcitRecord
+  | CalcitCirruQuote
   | null;
 
 export let is_literal = (x: CalcitValue): boolean => {
@@ -48,6 +50,7 @@ enum PseudoTypeIndex {
   map,
   record,
   fn,
+  cirru_quote,
 }
 
 let typeAsInt = (x: CalcitValue): number => {
@@ -66,6 +69,7 @@ let typeAsInt = (x: CalcitValue): number => {
   if (x instanceof CalcitSet) return PseudoTypeIndex.set;
   if (x instanceof CalcitMap || x instanceof CalcitSliceMap) return PseudoTypeIndex.map;
   if (x instanceof CalcitRecord) return PseudoTypeIndex.record;
+  if (x instanceof CalcitCirruQuote) return PseudoTypeIndex.cirru_quote;
   // proc, fn, macro, syntax, not distinguished
   if (t === "function") return PseudoTypeIndex.fn;
   throw new Error("unknown type to compare");
@@ -101,6 +105,8 @@ export let _$n_compare = (a: CalcitValue, b: CalcitValue): number => {
         return rawCompare(a, b);
       case PseudoTypeIndex.ref:
         return rawCompare((a as CalcitRef).path, (b as CalcitRef).path);
+      case PseudoTypeIndex.cirru_quote:
+        return rawCompare(a, b); // TODO not stable
       default:
         // TODO, need more accurate solution
         if (a < b) {