@calcit/procs 0.13.42 → 0.13.44

package/examples/bench_enum_match.rs

@@ -0,0 +1,41 @@
+use std::hint::black_box;
+use std::sync::Arc;
+use std::time::Instant;
+
+use calcit::calcit::{Calcit, CalcitEnumDef, CalcitList, CalcitStructDef, CalcitStructValue};
+use cirru_edn::EdnTag;
+
+const ITERATIONS: usize = 5_000_000;
+const VARIANT_COUNT: usize = 16;
+
+fn main() {
+  let fields: Vec<EdnTag> = (0..VARIANT_COUNT).map(|idx| EdnTag::new(format!("variant-{idx:02}"))).collect();
+  let values = vec![Calcit::from(CalcitList::Vector(vec![])); fields.len()];
+  let enum_def = CalcitEnumDef::from_struct(CalcitStructValue {
+    struct_ref: Arc::new(CalcitStructDef::from_fields(EdnTag::new("DispatchState"), fields)),
+    values: Arc::new(values),
+  })
+  .expect("valid benchmark enum");
+  let target = enum_def.variants().last().expect("last variant").tag.clone();
+
+  run("linear-tag-scan", || {
+    enum_def
+      .variants()
+      .iter()
+      .position(|variant| variant.tag == target)
+      .expect("target variant")
+  });
+  run("indexed-branch-slot", || enum_def.variant_index(&target).expect("target variant"));
+}
+
+fn run(label: &str, mut dispatch: impl FnMut() -> usize) {
+  let mut checksum = 0usize;
+  for _ in 0..100_000 {
+    checksum = checksum.wrapping_add(black_box(dispatch()));
+  }
+  let started = Instant::now();
+  for _ in 0..ITERATIONS {
+    checksum = checksum.wrapping_add(black_box(dispatch()));
+  }
+  println!("{label}: {:.2}ms checksum={checksum}", started.elapsed().as_secs_f64() * 1000.0);
+}

package/lib/calcit-data.d.mts

@@ -25,6 +25,10 @@ export declare let isNestedCalcitData: (x: CalcitValue) => boolean;
 export declare let tipNestedCalcitData: (x: CalcitValue) => string;
 export type CalcitFn = (...xs: CalcitValue[]) => CalcitValue;
 export declare let getStringName: (x: CalcitValue) => string;
+/** Compare tag names by Unicode scalar value, matching Rust `str` ordering. */
+export declare function compareTagNames(x: CalcitTag, y: CalcitTag): number;
+export declare function tagNamesAreCanonical(fields: CalcitTag[]): boolean;
+export declare function canonicalizeTagPairs<T>(fields: CalcitTag[], values: T[], context: string): [CalcitTag[], T[]];
 /** returns -1 when not found */
 export declare function findInFields(xs: Array<CalcitTag>, y: CalcitTag): number;
 export declare let newTag: (content: string) => CalcitTag;

package/lib/calcit-data.mjs

@@ -105,6 +105,51 @@ export let getStringName = (x) => {
     }
     throw new Error("Cannot get string as name");
 };
+/** Compare tag names by Unicode scalar value, matching Rust `str` ordering. */
+export function compareTagNames(x, y) {
+    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) {
+    for (let idx = 1; idx < fields.length; idx++) {
+        if (compareTagNames(fields[idx - 1], fields[idx]) >= 0)
+            return false;
+    }
+    return true;
+}
+export function canonicalizeTagPairs(fields, values, context) {
+    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]]);
+    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, y) {
     let low = 0;
@@ -112,10 +157,11 @@ export function findInFields(xs, y) {
     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 {
@@ -156,6 +202,7 @@ export let castTag = (x) => {
 };
 export var refsRegistry = new Map();
 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:");
@@ -177,9 +224,11 @@ let defaultHash_unknown = valueHash("unknown:");
 let fnHashCounter = 0;
 let jsObjectHashCounter = 0;
 export let hashFunction = (x) => {
-    if (x == null) {
+    if (x === null) {
         return defaultHash_nil;
     }
+    if (x === undefined)
+        return defaultHash_unit;
     if (typeof x === "number") {
         return mergeValueHash(defaultHash_number, x);
     }
@@ -367,9 +416,11 @@ let hashCirru = (base, x) => {
 // Dirty code to change ternary-tree behavior
 overwriteHashGenerator(hashFunction);
 export let toString = (x, escaped, disableJsDataWarning = false) => {
-    if (x == null) {
+    if (x === null) {
         return "nil";
     }
+    if (x === undefined)
+        return "&unit";
     if (typeof x === "string") {
         if (escaped) {
             // turn to visual string representation
@@ -473,9 +524,11 @@ export let to_js_data = (x, options) => {
     return to_js_data_inner(x, addColon);
 };
 let to_js_data_inner = (x, addColon) => {
-    if (x == null) {
+    if (x === null) {
         return null;
     }
+    if (x === undefined)
+        return undefined;
     if (x === true || x === false) {
         return x;
     }
@@ -560,10 +613,7 @@ export let _$n__$e_ = (x, y) => {
     if (x === y) {
         return true;
     }
-    if (x == null) {
-        if (y == null) {
-            return true;
-        }
+    if (x === null) {
         return false;
     }
     let tx = typeof x;

package/lib/calcit.procs.d.mts

@@ -18,7 +18,13 @@ export declare const calcit_package_json: {
         "test-fail": string;
         "test-snippets": string;
         "check-js-runtime": string;
+        "check-literal-paths": string;
+        "check-typed-method-rem": string;
         "bench-recur-smoke": string;
+        "bench-enum-match": string;
+        "bench-literal-paths": string;
+        "bench-typed-method-rem": string;
+        "bench-struct-index": string;
         "check-smooth": string;
         "check-all": string;
         "check-agent-interface": string;
@@ -87,7 +93,9 @@ export declare function _$n_str_$o_count(x: CalcitValue): number;
 export declare function _$n_map_$o_count(x: CalcitValue): number;
 export declare function _$n_struct_$o_count(x: CalcitValue): number;
 export declare function _$n_struct_$o_field_tag(x: CalcitValue, idx: CalcitValue): CalcitTag;
-export declare function _$n_struct_$o_nth(x: CalcitValue, idx: CalcitValue): CalcitValue;
+export declare function _$n_struct_$o_nth(x: CalcitValue, idx: CalcitValue, field?: CalcitValue): CalcitValue;
+export declare function _$n_struct_$o_assoc_at(x: CalcitValue, idx: CalcitValue, field: CalcitValue, value: CalcitValue): CalcitValue;
+export declare function _$n_struct_$o_with_at(x: CalcitValue, ...triples: CalcitValue[]): CalcitValue;
 export declare function _$n_set_$o_count(x: CalcitValue): number;
 export declare let _$L_: (...xs: CalcitValue[]) => CalcitSliceList;
 export declare let _SQUO_: (...xs: CalcitValue[]) => CalcitSliceList;
@@ -119,7 +127,7 @@ export declare let _$n_enum_$o_definition: (x: CalcitEnumValue) => CalcitEnumDef
 export declare let _$n_enum_def_$o_has_variant_$q_: (enumPrototype: CalcitValue, variantTag: CalcitTag) => boolean;
 export declare let _$n_enum_def_$o_has_variant: (enumPrototype: CalcitValue, variantTag: CalcitTag) => boolean;
 export declare let _$n_enum_def_$o_variant_arity: (enumPrototype: CalcitValue, variantTag: CalcitTag) => number;
-export declare let _$n_enum_$o_validate: (enumValue: CalcitValue, tag: CalcitValue) => CalcitValue;
+export declare let _$n_enum_$o_validate: (enumValue: CalcitValue, tag: CalcitValue) => void;
 export declare let _$n_struct_$o_get: (xs: CalcitValue, k: CalcitTag) => CalcitValue;
 export declare let _$n_list_$o_assoc: (xs: CalcitValue, k: CalcitValue, v: CalcitValue) => CalcitList;
 export declare let _$n_enum_$o_assoc: (xs: CalcitValue, k: CalcitValue, v: CalcitValue) => CalcitEnumValue;
@@ -136,10 +144,10 @@ export declare let _$n_list_$o_assoc_before: (xs: CalcitList | CalcitSliceList,
 export declare let _$n_list_$o_assoc_after: (xs: CalcitSliceList, k: number, v: CalcitValue) => CalcitList | CalcitSliceList;
 export declare let _$n_list_$o_dissoc: (xs: CalcitValue | CalcitSliceList, k: CalcitValue) => CalcitList | CalcitSliceList;
 export declare let _$n_map_$o_dissoc: (xs: CalcitValue, ...args: CalcitValue[]) => CalcitMap | CalcitSliceMap;
-export declare let reset_$x_: (a: CalcitRef, v: CalcitValue) => null;
-export declare let add_watch: (a: CalcitRef, k: CalcitTag, f: CalcitFn) => null;
-export declare let remove_watch: (a: CalcitRef, k: CalcitTag) => null;
-export declare let range: (n: number, m: number, step?: number) => CalcitSliceList | CalcitList;
+export declare let reset_$x_: (a: CalcitRef, v: CalcitValue) => CalcitValue;
+export declare let add_watch: (a: CalcitRef, k: CalcitTag, f: CalcitFn) => void;
+export declare let remove_watch: (a: CalcitRef, k: CalcitTag) => void;
+export declare let range: (n: number, m?: number, step?: number) => CalcitSliceList;
 export declare function _$n_list_$o_empty_$q_(xs: CalcitValue): boolean;
 export declare function _$n_str_$o_empty_$q_(xs: CalcitValue): boolean;
 export declare function _$n_map_$o_empty_$q_(xs: CalcitValue): boolean;
@@ -149,7 +157,7 @@ export declare let _$n_list_$o_last: (xs: CalcitValue) => CalcitValue;
 export declare let _$n_str_$o_first: (xs: CalcitValue) => CalcitValue;
 export declare let _$n_map_$o_destruct: (xs: CalcitValue) => CalcitValue;
 export declare let _$n_set_$o_destruct: (xs: CalcitValue) => CalcitValue;
-export declare let timeout_call: (duration: number, f: CalcitFn) => null;
+export declare let timeout_call: (duration: number, f: CalcitFn) => void;
 export declare let _$n_list_$o_rest: (xs: CalcitValue) => CalcitList | CalcitSliceList;
 export declare let _$n_str_$o_rest: (xs: CalcitValue) => CalcitValue;
 export declare let recur: (...xs: CalcitValue[]) => CalcitRecur;
@@ -162,7 +170,7 @@ export declare let butlast: (xs: CalcitValue) => CalcitList | CalcitSliceList |
 export declare let initCrTernary: (x: string) => CalcitValue;
 export declare let _SHA__$M_: (...xs: CalcitValue[]) => CalcitValue;
 export declare let generate_id_$x_: () => string;
-export declare let _$n_display_stack: () => null;
+export declare let _$n_display_stack: () => void;
 export declare let _$n_list_$o_slice: (xs: CalcitList, from: number, to: number) => CalcitSliceList | CalcitList;
 export declare let _$n_list_$o_concat: (...lists: (CalcitList | CalcitSliceList)[]) => CalcitList | CalcitSliceList;
 export declare let _$n_list_$o_reverse: (xs: CalcitList) => CalcitList;
@@ -247,7 +255,7 @@ export declare let parse_cirru: (code: string) => CalcitCirruQuote;
 export declare let parse_cirru_list: (code: string) => CalcitList;
 export declare let parse_cirru_edn: (code: string, options: CalcitValue) => CalcitValue;
 type DataShapeNode = {
-    kind: "unit" | "bool" | "number" | "string" | "symbol" | "tag" | "buffer" | "cirru-quote" | "dynamic";
+    kind: "nil" | "unit" | "bool" | "number" | "string" | "symbol" | "tag" | "buffer" | "cirru-quote" | "dynamic";
 } | {
     kind: "optional" | "list" | "set" | "ref";
     inner: number;