@calcit/procs 0.7.12 → 0.7.14

package/lib/calcit.procs.mjs

@@ -1,6 +1,6 @@
 var _a;
 // CALCIT VERSION
-export const calcit_version = "0.7.12";
+export const calcit_version = "0.7.14";
 import { parse } from "@cirru/parser.ts";
 import { writeCirruCode } from "@cirru/writer.ts";
 import { CalcitSymbol, CalcitTag, CalcitRef, CalcitRecur, newTag, refsRegistry, toString, getStringName, _$n__$e_, hashFunction, } from "./calcit-data.mjs";
@@ -316,6 +316,20 @@ export let _$n_record_$o_assoc = function (xs, k, v) {
         return xs.assoc(k, v);
     throw new Error("record `assoc` expected a record");
 };
+export let _$n_record_$o_class = function (xs) {
+    if (arguments.length !== 1)
+        throw new Error("&record:class takes 1 argument");
+    if (xs instanceof CalcitRecord)
+        return xs.klass;
+    throw new Error("&record:class expected a record");
+};
+export let _$n_record_$o_with_class = function (xs, k) {
+    if (arguments.length !== 2)
+        throw new Error("&record:with-class takes 2 arguments");
+    if (xs instanceof CalcitRecord)
+        return xs.withClass(k);
+    throw new Error("&record:with-class expected a record");
+};
 export let _$n_list_$o_assoc_before = function (xs, k, v) {
     if (arguments.length !== 3) {
         throw new Error("assoc takes 3 arguments");
@@ -1082,8 +1096,8 @@ export let parse_cirru = (code) => {
 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]);
+export let parse_cirru_edn = (code, options) => {
+    return extract_cirru_edn(parse(code)[0], options);
 };
 export let format_to_lisp = (x) => {
     if (x == null) {
@@ -1175,7 +1189,6 @@ let calcit_builtin_classes = {
     set: null,
     list: null,
     map: null,
-    record: null,
     nil: null,
     fn: null,
 };
@@ -1206,6 +1219,15 @@ export function invoke_method(p, obj, ...args) {
             throw new Error("Method invoking expected a record as class");
         }
     }
+    else if (obj instanceof CalcitRecord) {
+        if (obj.klass instanceof CalcitRecord) {
+            tag = obj.name.toString();
+            klass = obj.klass;
+        }
+        else {
+            throw new Error("Method invoking expected a record as class");
+        }
+    }
     else if (typeof obj === "number") {
         tag = "&core-number-class";
         klass = calcit_builtin_classes.number;
@@ -1226,10 +1248,6 @@ export function invoke_method(p, obj, ...args) {
         tag = "&core-list-class";
         klass = calcit_builtin_classes.list;
     }
-    else if (obj instanceof CalcitRecord) {
-        tag = "&core-record-class";
-        klass = calcit_builtin_classes.record;
-    }
     else if (obj instanceof CalcitMap || obj instanceof CalcitSliceMap) {
         tag = "&core-map-class";
         klass = calcit_builtin_classes.map;

package/lib/js-cirru.mjs

@@ -6,6 +6,7 @@ import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitSet } from "./js-set.mjs";
 import { CalcitTag, CalcitSymbol, CalcitRecur, CalcitRef, newTag } from "./calcit-data.mjs";
 import { CalcitTuple } from "./js-tuple.mjs";
+import { deepEqual } from "@calcit/ternary-tree/lib/utils.mjs";
 export class CalcitCirruQuote {
     constructor(value) {
         this.value = value;
@@ -149,7 +150,7 @@ let extractFieldTag = (x) => {
         return newTag(x);
     }
 };
-export let extract_cirru_edn = (x) => {
+export let extract_cirru_edn = (x, options) => {
     if (typeof x === "string") {
         if (x === "nil") {
             return null;
@@ -190,7 +191,7 @@ export let extract_cirru_edn = (x) => {
                     return; // skip first `{}` symbol
                 }
                 if (pair instanceof Array && pair.length === 2) {
-                    result.push(extract_cirru_edn(pair[0]), extract_cirru_edn(pair[1]));
+                    result.push(extract_cirru_edn(pair[0], options), extract_cirru_edn(pair[1], options));
                 }
                 else {
                     throw new Error("Expected pairs for map");
@@ -211,7 +212,7 @@ export let extract_cirru_edn = (x) => {
                 }
                 if (pair instanceof Array && pair.length === 2) {
                     if (typeof pair[0] === "string") {
-                        entries.push([extractFieldTag(pair[0]), extract_cirru_edn(pair[1])]);
+                        entries.push([extractFieldTag(pair[0]), extract_cirru_edn(pair[1], options)]);
                     }
                     else {
                         throw new Error("Expected string as field");
@@ -230,16 +231,25 @@ export let extract_cirru_edn = (x) => {
                 fields.push(entries[idx][0]);
                 values.push(entries[idx][1]);
             }
+            if (options instanceof CalcitMap || options instanceof CalcitSliceMap) {
+                let v = options.get(extractFieldTag(name));
+                if (v != null && v instanceof CalcitRecord) {
+                    if (!deepEqual(v.fields, fields)) {
+                        throw new Error(`Fields mismatch for ${name}, expected ${fields}, got ${v.fields}`);
+                    }
+                    return new CalcitRecord(extractFieldTag(name), fields, values, v.klass);
+                }
+            }
             return new CalcitRecord(extractFieldTag(name), fields, values);
         }
         if (x[0] === "[]") {
-            return new CalcitSliceList(x.slice(1).map(extract_cirru_edn));
+            return new CalcitSliceList(x.slice(1).map((x) => extract_cirru_edn(x, options)));
         }
         if (x[0] === "#{}") {
-            return new CalcitSet(x.slice(1).map(extract_cirru_edn));
+            return new CalcitSet(x.slice(1).map((x) => extract_cirru_edn(x, options)));
         }
         if (x[0] === "do" && x.length === 2) {
-            return extract_cirru_edn(x[1]);
+            return extract_cirru_edn(x[1], options);
         }
         if (x[0] === "quote") {
             if (x.length !== 2) {
@@ -252,7 +262,7 @@ export let extract_cirru_edn = (x) => {
                 throw new Error("tuple expects at least 1 value1");
             }
             let baseClass = new CalcitRecord(newTag("base-class"), [], []);
-            return new CalcitTuple(extract_cirru_edn(x[1]), x.slice(2).map(extract_cirru_edn), baseClass);
+            return new CalcitTuple(extract_cirru_edn(x[1], options), x.slice(2).map((x) => extract_cirru_edn(x, options)), baseClass);
         }
     }
     console.error(x);

package/lib/js-record.mjs

@@ -1,7 +1,7 @@
 import { castTag, toString, findInFields } from "./calcit-data.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 export class CalcitRecord {
-    constructor(name, fields, values) {
+    constructor(name, fields, values, klass) {
         this.name = name;
         let fieldNames = fields.map(castTag);
         this.fields = fields;
@@ -15,6 +15,7 @@ export class CalcitRecord {
             this.values = new Array(fieldNames.length);
         }
         this.cachedHash = null;
+        this.klass = klass;
     }
     get(k) {
         let field = castTag(k);
@@ -37,7 +38,7 @@ export class CalcitRecord {
                 values[idx] = this.values[idx];
             }
         }
-        return new CalcitRecord(this.name, this.fields, values);
+        return new CalcitRecord(this.name, this.fields, values, this.klass);
     }
     /** return -1 for missing */
     findIndex(k) {
@@ -56,6 +57,14 @@ export class CalcitRecord {
         }
         return ret + ")";
     }
+    withClass(klass) {
+        if (klass instanceof CalcitRecord) {
+            return new CalcitRecord(this.name, this.fields, this.values, klass);
+        }
+        else {
+            throw new Error("Expected a record");
+        }
+    }
 }
 export let new_record = (name, ...fields) => {
     let fieldNames = fields.map(castTag).sort((x, y) => {
@@ -71,6 +80,20 @@ export let new_record = (name, ...fields) => {
     });
     return new CalcitRecord(castTag(name), fieldNames);
 };
+export let new_class_record = (klass, name, ...fields) => {
+    let fieldNames = fields.map(castTag).sort((x, y) => {
+        if (x.idx < y.idx) {
+            return -1;
+        }
+        else if (x.idx > y.idx) {
+            return 1;
+        }
+        else {
+            throw new Error(`Unexpected duplication in record fields: ${x.toString()}`);
+        }
+    });
+    return new CalcitRecord(castTag(name), fieldNames, undefined, klass);
+};
 export let fieldsEqual = (xs, ys) => {
     if (xs === ys) {
         return true; // special case, referential equal
@@ -111,7 +134,7 @@ export let _$n__PCT__$M_ = (proto, ...xs) => {
             }
             values[i] = xs[idx * 2 + 1];
         }
-        return new CalcitRecord(proto.name, proto.fields, values);
+        return new CalcitRecord(proto.name, proto.fields, values, proto.klass);
     }
     else {
         throw new Error("Expected prototype to be a record");

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@calcit/procs",
-  "version": "0.7.12",
+  "version": "0.7.14",
   "main": "./lib/calcit.procs.mjs",
   "devDependencies": {
-    "@types/node": "^20.4.6",
+    "@types/node": "^20.4.8",
     "typescript": "^5.1.6"
   },
   "scripts": {
@@ -11,6 +11,7 @@
     "procs-link": "ln -s ../../ node_modules/@calcit/procs",
     "cp-mac": "cargo build --release && rm -rfv builds/* && node scripts/cp-version.js && scp builds/* rsync-user@calcit-lang.org:/web-assets/repo/calcit-lang/binaries/macos/",
     "try-rs": "cargo run --bin cr -- calcit/test.cirru -1",
+    "try-js-brk": "cargo run --bin cr -- calcit/test.cirru --emit-js -1 && node js-out/main.mjs",
     "try-js": "cargo run --bin cr -- calcit/test.cirru --emit-js -1 && node js-out/main.mjs"
   },
   "repository": {
@@ -18,7 +19,7 @@
     "url": "https://github.com/calcit-lang/calcit"
   },
   "dependencies": {
-    "@calcit/ternary-tree": "0.0.22",
+    "@calcit/ternary-tree": "0.0.23",
     "@cirru/parser.ts": "^0.0.6",
     "@cirru/writer.ts": "^0.1.4"
   }

package/ts-src/calcit.procs.mts

@@ -1,5 +1,5 @@
 // CALCIT VERSION
-export const calcit_version = "0.7.12";
+export const calcit_version = "0.7.14";
 
 import { parse, ICirruNode } from "@cirru/parser.ts";
 import { writeCirruCode } from "@cirru/writer.ts";
@@ -364,6 +364,18 @@ export let _$n_record_$o_assoc = function (xs: CalcitValue, k: CalcitValue, v: C
   throw new Error("record `assoc` expected a record");
 };
 
+export let _$n_record_$o_class = function (xs: CalcitValue) {
+  if (arguments.length !== 1) throw new Error("&record:class takes 1 argument");
+  if (xs instanceof CalcitRecord) return xs.klass;
+  throw new Error("&record:class expected a record");
+};
+
+export let _$n_record_$o_with_class = function (xs: CalcitValue, k: CalcitValue) {
+  if (arguments.length !== 2) throw new Error("&record:with-class takes 2 arguments");
+  if (xs instanceof CalcitRecord) return xs.withClass(k);
+  throw new Error("&record:with-class expected a record");
+};
+
 export let _$n_list_$o_assoc_before = function (xs: CalcitList | CalcitSliceList, k: number, v: CalcitValue): CalcitList {
   if (arguments.length !== 3) {
     throw new Error("assoc takes 3 arguments");
@@ -1185,8 +1197,8 @@ 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]);
+export let parse_cirru_edn = (code: string, options: CalcitValue) => {
+  return extract_cirru_edn(parse(code)[0], options);
 };
 
 export let format_to_lisp = (x: CalcitValue): string => {
@@ -1276,7 +1288,6 @@ let calcit_builtin_classes = {
   set: null as CalcitRecord,
   list: null as CalcitRecord,
   map: null as CalcitRecord,
-  record: null as CalcitRecord,
   nil: null as CalcitRecord,
   fn: null as CalcitRecord,
 };
@@ -1307,6 +1318,13 @@ export function invoke_method(p: string, obj: CalcitValue, ...args: CalcitValue[
     } else {
       throw new Error("Method invoking expected a record as class");
     }
+  } else if (obj instanceof CalcitRecord) {
+    if (obj.klass instanceof CalcitRecord) {
+      tag = obj.name.toString();
+      klass = obj.klass;
+    } else {
+      throw new Error("Method invoking expected a record as class");
+    }
   } else if (typeof obj === "number") {
     tag = "&core-number-class";
     klass = calcit_builtin_classes.number;
@@ -1322,9 +1340,6 @@ export function invoke_method(p: string, obj: CalcitValue, ...args: CalcitValue[
   } else if (obj instanceof CalcitList || obj instanceof CalcitSliceList) {
     tag = "&core-list-class";
     klass = calcit_builtin_classes.list;
-  } else if (obj instanceof CalcitRecord) {
-    tag = "&core-record-class";
-    klass = calcit_builtin_classes.record;
   } else if (obj instanceof CalcitMap || obj instanceof CalcitSliceMap) {
     tag = "&core-map-class";
     klass = calcit_builtin_classes.map;

package/ts-src/js-cirru.mts

@@ -8,6 +8,7 @@ import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitSet } from "./js-set.mjs";
 import { CalcitTag, CalcitSymbol, CalcitRecur, CalcitRef, newTag } from "./calcit-data.mjs";
 import { CalcitTuple } from "./js-tuple.mjs";
+import { deepEqual } from "@calcit/ternary-tree/lib/utils.mjs";
 
 type CirruEdnFormat = string | CirruEdnFormat[];
 
@@ -150,7 +151,7 @@ let extractFieldTag = (x: string) => {
   }
 };
 
-export let extract_cirru_edn = (x: CirruEdnFormat): CalcitValue => {
+export let extract_cirru_edn = (x: CirruEdnFormat, options: CalcitValue): CalcitValue => {
   if (typeof x === "string") {
     if (x === "nil") {
       return null;
@@ -191,7 +192,7 @@ export let extract_cirru_edn = (x: CirruEdnFormat): CalcitValue => {
           return; // skip first `{}` symbol
         }
         if (pair instanceof Array && pair.length === 2) {
-          result.push(extract_cirru_edn(pair[0]), extract_cirru_edn(pair[1]));
+          result.push(extract_cirru_edn(pair[0], options), extract_cirru_edn(pair[1], options));
         } else {
           throw new Error("Expected pairs for map");
         }
@@ -212,7 +213,7 @@ export let extract_cirru_edn = (x: CirruEdnFormat): CalcitValue => {
 
         if (pair instanceof Array && pair.length === 2) {
           if (typeof pair[0] === "string") {
-            entries.push([extractFieldTag(pair[0]), extract_cirru_edn(pair[1])]);
+            entries.push([extractFieldTag(pair[0]), extract_cirru_edn(pair[1], options)]);
           } else {
             throw new Error("Expected string as field");
           }
@@ -230,16 +231,27 @@ export let extract_cirru_edn = (x: CirruEdnFormat): CalcitValue => {
         fields.push(entries[idx][0]);
         values.push(entries[idx][1]);
       }
+
+      if (options instanceof CalcitMap || options instanceof CalcitSliceMap) {
+        let v = options.get(extractFieldTag(name));
+        if (v != null && v instanceof CalcitRecord) {
+          if (!deepEqual(v.fields, fields)) {
+            throw new Error(`Fields mismatch for ${name}, expected ${fields}, got ${v.fields}`);
+          }
+          return new CalcitRecord(extractFieldTag(name), fields, values, v.klass);
+        }
+      }
+
       return new CalcitRecord(extractFieldTag(name), fields, values);
     }
     if (x[0] === "[]") {
-      return new CalcitSliceList(x.slice(1).map(extract_cirru_edn));
+      return new CalcitSliceList(x.slice(1).map((x) => extract_cirru_edn(x, options)));
     }
     if (x[0] === "#{}") {
-      return new CalcitSet(x.slice(1).map(extract_cirru_edn));
+      return new CalcitSet(x.slice(1).map((x) => extract_cirru_edn(x, options)));
     }
     if (x[0] === "do" && x.length === 2) {
-      return extract_cirru_edn(x[1]);
+      return extract_cirru_edn(x[1], options);
     }
     if (x[0] === "quote") {
       if (x.length !== 2) {
@@ -252,7 +264,11 @@ export let extract_cirru_edn = (x: CirruEdnFormat): CalcitValue => {
         throw new Error("tuple expects at least 1 value1");
       }
       let baseClass = new CalcitRecord(newTag("base-class"), [], []);
-      return new CalcitTuple(extract_cirru_edn(x[1]), x.slice(2).map(extract_cirru_edn), baseClass);
+      return new CalcitTuple(
+        extract_cirru_edn(x[1], options),
+        x.slice(2).map((x) => extract_cirru_edn(x, options)),
+        baseClass
+      );
     }
   }
   console.error(x);

package/ts-src/js-record.mts

@@ -8,8 +8,9 @@ export class CalcitRecord {
   name: CalcitTag;
   fields: Array<CalcitTag>;
   values: Array<CalcitValue>;
+  klass: CalcitValue;
   cachedHash: Hash;
-  constructor(name: CalcitTag, fields: Array<CalcitTag>, values?: Array<CalcitValue>) {
+  constructor(name: CalcitTag, fields: Array<CalcitTag>, values?: Array<CalcitValue>, klass?: CalcitValue) {
     this.name = name;
     let fieldNames = fields.map(castTag);
     this.fields = fields;
@@ -22,6 +23,7 @@ export class CalcitRecord {
       this.values = new Array(fieldNames.length);
     }
     this.cachedHash = null;
+    this.klass = klass;
   }
   get(k: CalcitValue) {
     let field = castTag(k);
@@ -42,7 +44,7 @@ export class CalcitRecord {
         values[idx] = this.values[idx];
       }
     }
-    return new CalcitRecord(this.name, this.fields, values);
+    return new CalcitRecord(this.name, this.fields, values, this.klass);
   }
   /** return -1 for missing */
   findIndex(k: CalcitValue) {
@@ -61,6 +63,13 @@ export class CalcitRecord {
     }
     return ret + ")";
   }
+  withClass(klass: CalcitValue): CalcitRecord {
+    if (klass instanceof CalcitRecord) {
+      return new CalcitRecord(this.name, this.fields, this.values, klass);
+    } else {
+      throw new Error("Expected a record");
+    }
+  }
 }
 
 export let new_record = (name: CalcitValue, ...fields: Array<CalcitValue>): CalcitValue => {
@@ -76,6 +85,19 @@ export let new_record = (name: CalcitValue, ...fields: Array<CalcitValue>): Calc
   return new CalcitRecord(castTag(name), fieldNames);
 };
 
+export let new_class_record = (klass: CalcitRecord, name: CalcitValue, ...fields: Array<CalcitValue>): CalcitValue => {
+  let fieldNames = fields.map(castTag).sort((x, y) => {
+    if (x.idx < y.idx) {
+      return -1;
+    } else if (x.idx > y.idx) {
+      return 1;
+    } else {
+      throw new Error(`Unexpected duplication in record fields: ${x.toString()}`);
+    }
+  });
+  return new CalcitRecord(castTag(name), fieldNames, undefined, klass);
+};
+
 export let fieldsEqual = (xs: Array<CalcitTag>, ys: Array<CalcitTag>): boolean => {
   if (xs === ys) {
     return true; // special case, referential equal
@@ -121,7 +143,7 @@ export let _$n__PCT__$M_ = (proto: CalcitValue, ...xs: Array<CalcitValue>): Calc
       values[i] = xs[idx * 2 + 1];
     }
 
-    return new CalcitRecord(proto.name, proto.fields, values);
+    return new CalcitRecord(proto.name, proto.fields, values, proto.klass);
   } else {
     throw new Error("Expected prototype to be a record");
   }