@calcit/procs 0.13.43 → 0.13.44

package/lib/js-primes.mjs

@@ -27,28 +27,31 @@ export let isLiteral = (x) => {
 var PseudoTypeIndex;
 (function (PseudoTypeIndex) {
     PseudoTypeIndex[PseudoTypeIndex["nil"] = 0] = "nil";
-    PseudoTypeIndex[PseudoTypeIndex["bool"] = 1] = "bool";
-    PseudoTypeIndex[PseudoTypeIndex["number"] = 2] = "number";
-    PseudoTypeIndex[PseudoTypeIndex["symbol"] = 3] = "symbol";
-    PseudoTypeIndex[PseudoTypeIndex["tag"] = 4] = "tag";
-    PseudoTypeIndex[PseudoTypeIndex["string"] = 5] = "string";
-    PseudoTypeIndex[PseudoTypeIndex["ref"] = 6] = "ref";
-    PseudoTypeIndex[PseudoTypeIndex["enum_value"] = 7] = "enum_value";
-    PseudoTypeIndex[PseudoTypeIndex["recur"] = 8] = "recur";
-    PseudoTypeIndex[PseudoTypeIndex["list"] = 9] = "list";
-    PseudoTypeIndex[PseudoTypeIndex["set"] = 10] = "set";
-    PseudoTypeIndex[PseudoTypeIndex["map"] = 11] = "map";
-    PseudoTypeIndex[PseudoTypeIndex["struct_value"] = 12] = "struct_value";
-    PseudoTypeIndex[PseudoTypeIndex["impl"] = 13] = "impl";
-    PseudoTypeIndex[PseudoTypeIndex["struct_def"] = 14] = "struct_def";
-    PseudoTypeIndex[PseudoTypeIndex["enum_def"] = 15] = "enum_def";
-    PseudoTypeIndex[PseudoTypeIndex["fn"] = 16] = "fn";
-    PseudoTypeIndex[PseudoTypeIndex["cirru_quote"] = 17] = "cirru_quote";
+    PseudoTypeIndex[PseudoTypeIndex["unit"] = 1] = "unit";
+    PseudoTypeIndex[PseudoTypeIndex["bool"] = 2] = "bool";
+    PseudoTypeIndex[PseudoTypeIndex["number"] = 3] = "number";
+    PseudoTypeIndex[PseudoTypeIndex["symbol"] = 4] = "symbol";
+    PseudoTypeIndex[PseudoTypeIndex["tag"] = 5] = "tag";
+    PseudoTypeIndex[PseudoTypeIndex["string"] = 6] = "string";
+    PseudoTypeIndex[PseudoTypeIndex["ref"] = 7] = "ref";
+    PseudoTypeIndex[PseudoTypeIndex["enum_value"] = 8] = "enum_value";
+    PseudoTypeIndex[PseudoTypeIndex["recur"] = 9] = "recur";
+    PseudoTypeIndex[PseudoTypeIndex["list"] = 10] = "list";
+    PseudoTypeIndex[PseudoTypeIndex["set"] = 11] = "set";
+    PseudoTypeIndex[PseudoTypeIndex["map"] = 12] = "map";
+    PseudoTypeIndex[PseudoTypeIndex["struct_value"] = 13] = "struct_value";
+    PseudoTypeIndex[PseudoTypeIndex["impl"] = 14] = "impl";
+    PseudoTypeIndex[PseudoTypeIndex["struct_def"] = 15] = "struct_def";
+    PseudoTypeIndex[PseudoTypeIndex["enum_def"] = 16] = "enum_def";
+    PseudoTypeIndex[PseudoTypeIndex["fn"] = 17] = "fn";
+    PseudoTypeIndex[PseudoTypeIndex["cirru_quote"] = 18] = "cirru_quote";
 })(PseudoTypeIndex || (PseudoTypeIndex = {}));
 let typeAsInt = (x) => {
     // based on order used in Ord trait
-    if (x == null)
+    if (x === null)
         return PseudoTypeIndex.nil;
+    if (x === undefined)
+        return PseudoTypeIndex.unit;
     let t = typeof x;
     if (t === "boolean")
         return PseudoTypeIndex.bool;
@@ -106,6 +109,7 @@ export let _$n_compare = (a, b) => {
     if (ta === tb) {
         switch (ta) {
             case PseudoTypeIndex.nil:
+            case PseudoTypeIndex.unit:
                 return 0;
             case PseudoTypeIndex.bool:
                 return rawCompare(a, b);

package/lib/js-struct-def.mjs

@@ -1,13 +1,11 @@
-import { toString } from "./calcit-data.mjs";
+import { canonicalizeTagPairs, toString } from "./calcit-data.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
 export class CalcitStructDef {
     constructor(name, fields, fieldTypes, impls = []) {
-        if (fields.length !== fieldTypes.length) {
-            throw new Error("CalcitStructDef: fields and fieldTypes length mismatch");
-        }
+        const [canonicalFields, canonicalTypes] = canonicalizeTagPairs(fields, fieldTypes, "CalcitStructDef");
         this.name = name;
-        this.fields = fields;
-        this.fieldTypes = fieldTypes;
+        this.fields = canonicalFields;
+        this.fieldTypes = canonicalTypes;
         this.impls = impls;
         this.cachedHash = null;
     }

package/lib/js-struct-value.d.mts

@@ -14,6 +14,10 @@ export declare class CalcitStructValue {
     getRequired(k: CalcitValue): CalcitValue;
     getOrNil(k: CalcitValue): CalcitValue;
     assoc(k: CalcitValue, v: CalcitValue): CalcitStructValue;
+    nthAt(index: CalcitValue, field: CalcitValue): CalcitValue;
+    assocAt(index: CalcitValue, field: CalcitValue, value: CalcitValue): CalcitStructValue;
+    withAt(...triples: CalcitValue[]): CalcitStructValue;
+    private assertFieldAt;
     /** return -1 for missing */
     findIndex(k: CalcitValue): number;
     contains(k: CalcitValue): boolean;
@@ -23,7 +27,7 @@ export declare class CalcitStructValue {
 export declare let new_struct_value: (name: CalcitValue, ...fields: Array<CalcitValue>) => CalcitValue;
 export declare let new_impl_struct_value: (impl: CalcitImpl, name: CalcitValue, ...fields: Array<CalcitValue>) => CalcitValue;
 /** Loose record: `?{} :field1 val1 :field2 val2` – record without a declared struct.
- *  Fields are sorted by tag index. The record name is "?" (sentinel). */
+ *  Fields use the same lexical layout as named structs. The record name is "_". */
 export declare let _$q__$M_: (...xs: Array<CalcitValue>) => CalcitValue;
 export declare let fieldsEqual: (xs: Array<CalcitTag>, ys: Array<CalcitTag>) => boolean;
 export declare let _$n__PCT__$M_: (proto: CalcitValue, ...xs: Array<CalcitValue>) => CalcitValue;

package/lib/js-struct-value.mjs

@@ -1,23 +1,22 @@
 import { CalcitImpl } from "./js-impl.mjs";
-import { newTag, castTag, toString, getStringName, findInFields } from "./calcit-data.mjs";
+import { newTag, castTag, toString, getStringName, findInFields, compareTagNames, canonicalizeTagPairs, tagNamesAreCanonical, } from "./calcit-data.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitStructDef } from "./js-struct-def.mjs";
 export class CalcitStructValue {
     constructor(name, fields, values, structRef) {
         this.name = name;
-        let fieldNames = fields.map(castTag);
-        this.fields = fields;
-        if (values != null) {
-            if (values.length !== fields.length) {
-                throw new Error("fields/values length not match");
-            }
-            this.values = values;
-        }
-        else {
-            this.values = new Array(fieldNames.length);
-        }
+        const fieldNames = fields.map(castTag);
+        const sourceValues = values ?? new Array(fieldNames.length);
+        const [canonicalFields, canonicalValues] = canonicalizeTagPairs(fieldNames, sourceValues, "CalcitStructValue");
+        this.fields = canonicalFields;
+        this.values = canonicalValues;
         this.cachedHash = null;
-        this.structRef = structRef || new CalcitStructDef(name, fields, new Array(fields.length).fill(null));
+        this.structRef =
+            structRef == null
+                ? new CalcitStructDef(name, canonicalFields, new Array(canonicalFields.length).fill(null))
+                : tagNamesAreCanonical(structRef.fields)
+                    ? structRef
+                    : new CalcitStructDef(structRef.name, structRef.fields, structRef.fieldTypes, structRef.impls);
     }
     get(k) {
         let field = castTag(k);
@@ -58,6 +57,40 @@ export class CalcitStructValue {
         }
         return new CalcitStructValue(this.name, this.fields, values, this.structRef);
     }
+    nthAt(index, field) {
+        const idx = checkedStructIndex(index, "&struct:nth");
+        this.assertFieldAt(idx, field, "&struct:nth");
+        return this.values[idx];
+    }
+    assocAt(index, field, value) {
+        const idx = checkedStructIndex(index, "&struct:assoc-at");
+        this.assertFieldAt(idx, field, "&struct:assoc-at");
+        const values = this.values.slice();
+        values[idx] = value;
+        return new CalcitStructValue(this.name, this.fields, values, this.structRef);
+    }
+    withAt(...triples) {
+        if (triples.length === 0 || triples.length % 3 !== 0) {
+            throw new Error("&struct:with-at expected index/tag/value triples");
+        }
+        const values = this.values.slice();
+        for (let base = 0; base < triples.length; base += 3) {
+            const idx = checkedStructIndex(triples[base], "&struct:with-at");
+            this.assertFieldAt(idx, triples[base + 1], "&struct:with-at");
+            values[idx] = triples[base + 2];
+        }
+        return new CalcitStructValue(this.name, this.fields, values, this.structRef);
+    }
+    assertFieldAt(idx, field, operation) {
+        if (idx >= this.fields.length) {
+            throw new Error(`${operation} index ${idx} out of range for struct '${this.name.value}' with ${this.fields.length} fields`);
+        }
+        const fieldTag = castTag(field);
+        const expectedTag = this.fields[idx];
+        if (expectedTag.value !== fieldTag.value) {
+            throw new Error(`${operation} index ${idx} expects field :${expectedTag.value}, but received :${fieldTag.value}`);
+        }
+    }
     /** return -1 for missing */
     findIndex(k) {
         let field = castTag(k);
@@ -93,37 +126,19 @@ export class CalcitStructValue {
     }
 }
 export let new_struct_value = (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 struct fields: ${x.toString()}`);
-        }
-    });
+    let fieldNames = fields.map(castTag).sort(compareTagNames);
+    assertUniqueFields(fieldNames, "Unexpected duplication in struct fields");
     return new CalcitStructValue(castTag(name), fieldNames);
 };
 export let new_impl_struct_value = (impl, 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 struct fields: ${x.toString()}`);
-        }
-    });
+    let fieldNames = fields.map(castTag).sort(compareTagNames);
+    assertUniqueFields(fieldNames, "Unexpected duplication in struct fields");
     let nameTag = castTag(name);
     let structRef = new CalcitStructDef(nameTag, fieldNames, new Array(fieldNames.length).fill(null), [impl]);
     return new CalcitStructValue(nameTag, fieldNames, undefined, structRef);
 };
 /** Loose record: `?{} :field1 val1 :field2 val2` – record without a declared struct.
- *  Fields are sorted by tag index. The record name is "?" (sentinel). */
+ *  Fields use the same lexical layout as named structs. The record name is "_". */
 export let _$q__$M_ = (...xs) => {
     if (xs.length % 2 !== 0) {
         throw new Error("?{} expected pairs of :field value");
@@ -132,10 +147,10 @@ export let _$q__$M_ = (...xs) => {
     for (let i = 0; i < xs.length; i += 2) {
         pairs.push([castTag(xs[i]), xs[i + 1]]);
     }
-    pairs.sort((a, b) => a[0].idx - b[0].idx);
+    pairs.sort((a, b) => compareTagNames(a[0], b[0]));
     // Check for duplicate fields after sorting
     for (let i = 1; i < pairs.length; i++) {
-        if (pairs[i][0].idx === pairs[i - 1][0].idx) {
+        if (pairs[i][0].value === pairs[i - 1][0].value) {
             throw new Error(`?{} received duplicate field: :${getStringName(pairs[i][0])}`);
         }
     }
@@ -144,6 +159,19 @@ export let _$q__$M_ = (...xs) => {
     let looseTag = newTag("_");
     return new CalcitStructValue(looseTag, fieldNames, values);
 };
+function checkedStructIndex(value, operation) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`${operation} expected a non-negative integer index, but received: ${value}`);
+    }
+    return value;
+}
+function assertUniqueFields(fields, message) {
+    for (let idx = 1; idx < fields.length; idx++) {
+        if (fields[idx - 1].value === fields[idx].value) {
+            throw new Error(`${message}: ${fields[idx].toString()}`);
+        }
+    }
+}
 export let fieldsEqual = (xs, ys) => {
     if (xs === ys) {
         return true; // special case, referential equal

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.13.43",
+    "version": "0.13.44",
     "main": "./lib/calcit.procs.mjs",
     "devDependencies": {
         "@types/node": "^25.7.0",
@@ -17,9 +17,15 @@
         "test-fail": "cargo test -q --bin calcit type_fail_",
         "test-snippets": "cargo test -q snippets::tests",
         "check-js-runtime": "node scripts/check-js-runtime-identity.mjs",
+        "check-literal-paths": "cargo run --bin calcit -- calcit/bench-literal-paths.cirru && cargo run --bin calcit -- --emit-path target/literal-path-js calcit/bench-literal-paths.cirru js && node scripts/bench-literal-paths.mjs",
+        "check-typed-method-rem": "cargo run --bin calcit -- calcit/fibo.cirru && cargo run --bin calcit -- --emit-path target/typed-method-rem-js calcit/fibo.cirru js && node scripts/bench-typed-method-rem.mjs",
         "bench-recur-smoke": "cargo run --bin calcit -- calcit/test.cirru js && node --input-type=module -e \"import { test_loop } from './js-out/test-recursion.main.mjs'; const n=3000; const t0=process.hrtime.bigint(); for(let i=0;i<n;i++) test_loop(); const dt=Number(process.hrtime.bigint()-t0)/1e6; console.log('test_loop_ms='+dt.toFixed(3));\"",
+        "bench-enum-match": "cargo run --release --example bench_enum_match && yarn compile && node scripts/bench-enum-match.mjs",
+        "bench-literal-paths": "cargo build --release --bin calcit && yarn compile && target/release/calcit calcit/bench-literal-paths.cirru && node scripts/bench-literal-paths-native.mjs && target/release/calcit --emit-path target/literal-path-js calcit/bench-literal-paths.cirru js && node scripts/bench-literal-paths.mjs",
+        "bench-typed-method-rem": "cargo build --release --bin calcit && yarn compile && target/release/calcit calcit/fibo.cirru && node scripts/bench-typed-method-rem-native.mjs && target/release/calcit --emit-path target/typed-method-rem-js calcit/fibo.cirru js && node scripts/bench-typed-method-rem.mjs",
+        "bench-struct-index": "yarn compile && node scripts/bench-struct-index.mjs",
         "check-smooth": "yarn fmt-rs && yarn lint-rs && yarn test-rs && yarn check-all",
-        "check-all": "yarn compile && yarn check-js-runtime && yarn check-agent-interface && yarn try-core-tests && yarn try-rs && yarn try-js && yarn try-ir && yarn try-wasm",
+        "check-all": "yarn compile && yarn check-js-runtime && yarn check-agent-interface && yarn try-core-tests && yarn try-rs && yarn try-js && yarn try-ir && yarn try-wasm && yarn check-literal-paths && yarn check-typed-method-rem",
         "check-agent-interface": "cargo build --bin calcit && node scripts/check-agent-interface.mjs",
         "try-all": "yarn check-all",
         "try-core-tests": "cargo run --bin calcit -- src/cirru/calcit-core.cirru test --tag unit --summary-only",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.13.43",
+  "version": "0.13.44",
   "main": "./lib/calcit.procs.mjs",
   "devDependencies": {
     "@types/node": "^25.7.0",
@@ -17,9 +17,15 @@
     "test-fail": "cargo test -q --bin calcit type_fail_",
     "test-snippets": "cargo test -q snippets::tests",
     "check-js-runtime": "node scripts/check-js-runtime-identity.mjs",
+    "check-literal-paths": "cargo run --bin calcit -- calcit/bench-literal-paths.cirru && cargo run --bin calcit -- --emit-path target/literal-path-js calcit/bench-literal-paths.cirru js && node scripts/bench-literal-paths.mjs",
+    "check-typed-method-rem": "cargo run --bin calcit -- calcit/fibo.cirru && cargo run --bin calcit -- --emit-path target/typed-method-rem-js calcit/fibo.cirru js && node scripts/bench-typed-method-rem.mjs",
     "bench-recur-smoke": "cargo run --bin calcit -- calcit/test.cirru js && node --input-type=module -e \"import { test_loop } from './js-out/test-recursion.main.mjs'; const n=3000; const t0=process.hrtime.bigint(); for(let i=0;i<n;i++) test_loop(); const dt=Number(process.hrtime.bigint()-t0)/1e6; console.log('test_loop_ms='+dt.toFixed(3));\"",
+    "bench-enum-match": "cargo run --release --example bench_enum_match && yarn compile && node scripts/bench-enum-match.mjs",
+    "bench-literal-paths": "cargo build --release --bin calcit && yarn compile && target/release/calcit calcit/bench-literal-paths.cirru && node scripts/bench-literal-paths-native.mjs && target/release/calcit --emit-path target/literal-path-js calcit/bench-literal-paths.cirru js && node scripts/bench-literal-paths.mjs",
+    "bench-typed-method-rem": "cargo build --release --bin calcit && yarn compile && target/release/calcit calcit/fibo.cirru && node scripts/bench-typed-method-rem-native.mjs && target/release/calcit --emit-path target/typed-method-rem-js calcit/fibo.cirru js && node scripts/bench-typed-method-rem.mjs",
+    "bench-struct-index": "yarn compile && node scripts/bench-struct-index.mjs",
     "check-smooth": "yarn fmt-rs && yarn lint-rs && yarn test-rs && yarn check-all",
-    "check-all": "yarn compile && yarn check-js-runtime && yarn check-agent-interface && yarn try-core-tests && yarn try-rs && yarn try-js && yarn try-ir && yarn try-wasm",
+    "check-all": "yarn compile && yarn check-js-runtime && yarn check-agent-interface && yarn try-core-tests && yarn try-rs && yarn try-js && yarn try-ir && yarn try-wasm && yarn check-literal-paths && yarn check-typed-method-rem",
     "check-agent-interface": "cargo build --bin calcit && node scripts/check-agent-interface.mjs",
     "try-all": "yarn check-all",
     "try-core-tests": "cargo run --bin calcit -- src/cirru/calcit-core.cirru test --tag unit --summary-only",

package/ts-src/calcit-data.mts

@@ -126,6 +126,49 @@ export let getStringName = (x: CalcitValue): string => {
   throw new Error("Cannot get string as name");
 };
 
+/** Compare tag names by Unicode scalar value, matching Rust `str` ordering. */
+export function compareTagNames(x: CalcitTag, y: CalcitTag): number {
+  let xIdx = 0;
+  let yIdx = 0;
+  while (xIdx < x.value.length && yIdx < y.value.length) {
+    const xCode = x.value.codePointAt(xIdx)!;
+    const yCode = y.value.codePointAt(yIdx)!;
+    if (xCode < yCode) return -1;
+    if (xCode > yCode) return 1;
+    xIdx += xCode > 0xffff ? 2 : 1;
+    yIdx += yCode > 0xffff ? 2 : 1;
+  }
+  if (xIdx < x.value.length) return 1;
+  if (yIdx < y.value.length) return -1;
+  return 0;
+}
+
+export function tagNamesAreCanonical(fields: CalcitTag[]): boolean {
+  for (let idx = 1; idx < fields.length; idx++) {
+    if (compareTagNames(fields[idx - 1], fields[idx]) >= 0) return false;
+  }
+  return true;
+}
+
+export function canonicalizeTagPairs<T>(fields: CalcitTag[], values: T[], context: string): [CalcitTag[], T[]] {
+  if (fields.length !== values.length) {
+    throw new Error(`${context}: fields and values length mismatch`);
+  }
+  if (tagNamesAreCanonical(fields)) return [fields, values];
+
+  const pairs = fields.map((field, idx) => [field, values[idx]] as [CalcitTag, T]);
+  pairs.sort((a, b) => compareTagNames(a[0], b[0]));
+  for (let idx = 1; idx < pairs.length; idx++) {
+    if (pairs[idx - 1][0].value === pairs[idx][0].value) {
+      throw new Error(`${context}: duplicated field :${pairs[idx][0].value}`);
+    }
+  }
+  return [
+    pairs.map(([field]) => field),
+    pairs.map(([, value]) => value),
+  ];
+}
+
 /** returns -1 when not found */
 export function findInFields(xs: Array<CalcitTag>, y: CalcitTag): number {
   let low = 0;
@@ -134,9 +177,10 @@ export function findInFields(xs: Array<CalcitTag>, y: CalcitTag): number {
   while (low <= high) {
     const mid = Math.floor((low + high) / 2);
     const midVal = xs[mid];
-    if (midVal.idx < y.idx) {
+    const ordering = compareTagNames(midVal, y);
+    if (ordering < 0) {
       low = mid + 1;
-    } else if (midVal.idx > y.idx) {
+    } else if (ordering > 0) {
       high = mid - 1;
     } else {
       return mid;
@@ -180,6 +224,7 @@ export let castTag = (x: CalcitValue): CalcitTag => {
 export var refsRegistry = new Map<string, CalcitRef>();
 
 let defaultHash_nil = valueHash("nil:");
+let defaultHash_unit = valueHash("unit:");
 let defaultHash_number = valueHash("number:");
 let defaultHash_string = valueHash("string:");
 let defaultHash_tag = valueHash("tag:");
@@ -204,9 +249,10 @@ let fnHashCounter = 0;
 let jsObjectHashCounter = 0;
 
 export let hashFunction = (x: CalcitValue): Hash => {
-  if (x == null) {
+  if (x === null) {
     return defaultHash_nil;
   }
+  if (x === undefined) return defaultHash_unit;
   if (typeof x === "number") {
     return mergeValueHash(defaultHash_number, x);
   }
@@ -398,9 +444,10 @@ let hashCirru = (base: number, x: CirruWriterNode) => {
 overwriteHashGenerator(hashFunction);
 
 export let toString = (x: CalcitValue, escaped: boolean, disableJsDataWarning: boolean = false): string => {
-  if (x == null) {
+  if (x === null) {
     return "nil";
   }
+  if (x === undefined) return "&unit";
   if (typeof x === "string") {
     if (escaped) {
       // turn to visual string representation
@@ -505,9 +552,10 @@ export let to_js_data = (x: CalcitValue, options?: CalcitValue | boolean): any =
 };
 
 let to_js_data_inner = (x: CalcitValue, addColon: boolean): any => {
-  if (x == null) {
+  if (x === null) {
     return null;
   }
+  if (x === undefined) return undefined;
   if (x === true || x === false) {
     return x;
   }
@@ -596,10 +644,7 @@ export let _$n__$e_ = (x: CalcitValue, y: CalcitValue): boolean => {
   if (x === y) {
     return true;
   }
-  if (x == null) {
-    if (y == null) {
-      return true;
-    }
+  if (x === null) {
     return false;
   }