@calcit/procs 0.29.0-alpha.19 → 0.29.0-alpha.20

package/lib/calcit-data.mjs

@@ -208,6 +208,7 @@ export var refsRegistry = new Map();
 let defaultHash_nil = valueHash("nil:");
 let defaultHash_unit = valueHash("unit:");
 let defaultHash_number = valueHash("number:");
+let defaultHash_nan = valueHash("number:NaN");
 let defaultHash_string = valueHash("string:");
 let defaultHash_tag = valueHash("tag:");
 let defaultHash_true = valueHash("bool:true");
@@ -237,7 +238,10 @@ export let hashFunction = (x) => {
     if (x === undefined)
         return defaultHash_unit;
     if (typeof x === "number") {
-        return mergeValueHash(defaultHash_number, x);
+        // NaN equals NaN, so it needs a hash that equals itself; `0` and `-0` share one hash
+        if (Number.isNaN(x))
+            return defaultHash_nan;
+        return mergeValueHash(defaultHash_number, x === 0 ? 0 : x);
     }
     if (typeof x === "string") {
         return mergeValueHash(defaultHash_string, x);
@@ -369,7 +373,8 @@ export let hashFunction = (x) => {
         let base = defaultHash_impl;
         base = mergeValueHash(base, hashFunction(x.name));
         if (x.origin != null) {
-            base = mergeValueHash(base, hashFunction(x.origin));
+            // Impl equality compares origin names, not trait object identities.
+            base = mergeValueHash(base, hashFunction(x.origin.name.value));
         }
         for (let idx = 0; idx < x.fields.length; idx++) {
             base = mergeValueHash(base, hashFunction(x.fields[idx]));
@@ -656,8 +661,8 @@ export let _$n__$e_ = (x, y) => {
         return false;
     }
     if (tx === "number") {
-        // already checked above
-        return false;
+        // value equality: NaN equals NaN (`0 === -0` already held above)
+        return Number.isNaN(x) && Number.isNaN(y);
     }
     if (tx === "function") {
         // method values are closures created on the fly (see invoke_method_closure),
@@ -837,7 +842,11 @@ export let _$n__$e_ = (x, y) => {
     }
     if (x instanceof CalcitEnumDef) {
         if (y instanceof CalcitEnumDef) {
-            return x.name === y.name;
+            // The prototype carries the nominal origin, variant tags and payload
+            // schemas. Comparing name methods compares one shared function object.
+            return _$n__$e_(x.prototype, y.prototype)
+                && x.impls.length === y.impls.length
+                && x.impls.every((impl, index) => _$n__$e_(impl, y.impls[index]));
         }
         return false;
     }

package/lib/calcit.procs.mjs

@@ -1419,7 +1419,12 @@ export let _$n_str_$o_replace = (x, y, z) => {
     return x.replace(new RegExp(literalPattern, "gu"), () => z);
 };
 export let split = (xs, x) => {
-    return new CalcitSliceList(xs.split(x));
+    // An empty delimiter splits by code point, matching native for astral characters.
+    if (x === "") {
+        return new CalcitSliceList(Array.from(xs));
+    }
+    // Drop empty pieces to match native and WASM: `split | |,` is an empty list.
+    return new CalcitSliceList(xs.split(x).filter((piece) => piece !== ""));
 };
 export let split_lines = (xs) => {
     return new CalcitSliceList(xs.split("\n"));

package/lib/js-primes.d.mts

@@ -12,4 +12,6 @@ import { CalcitCirruQuote } from "./js-cirru.mjs";
 import { CalcitTrait } from "./js-trait.mjs";
 export type CalcitValue = string | number | boolean | CalcitMap | CalcitSliceMap | CalcitList | CalcitSliceList | CalcitSet | CalcitTag | CalcitSymbol | CalcitRef | CalcitEnumValue | CalcitFn | CalcitRecur | CalcitStructValue | CalcitImpl | CalcitTrait | CalcitStructDef | CalcitEnumDef | CalcitCirruQuote | Uint8Array | undefined | null;
 export declare let isLiteral: (x: CalcitValue) => boolean;
+/** total order over numbers: `-0` equals `0`, NaN equals NaN and sorts after every number */
+export declare let compareNumbers: (x: number, y: number) => number;
 export declare let _$n_compare: (a: CalcitValue, b: CalcitValue) => number;

package/lib/js-primes.mjs

@@ -101,6 +101,14 @@ let rawCompare = (x, y) => {
         return 0;
     }
 };
+/** total order over numbers: `-0` equals `0`, NaN equals NaN and sorts after every number */
+export let compareNumbers = (x, y) => {
+    if (x < y)
+        return -1;
+    if (x > y)
+        return 1;
+    return (Number.isNaN(x) ? 1 : 0) - (Number.isNaN(y) ? 1 : 0);
+};
 /** lexicographic order over two sequences of values, a shorter prefix sorts first (same as Rust `Vec::cmp`) */
 let compareSequences = (xs, ys) => {
     let n = Math.min(xs.length, ys.length);
@@ -112,6 +120,18 @@ let compareSequences = (xs, ys) => {
     return rawCompare(xs.length, ys.length);
 };
 let listToArray = (x) => Array.from(x.items());
+// Plain functions compare by identity. IDs are process-local, never serialized,
+// and kept weakly so ordering does not retain closures or mutate frozen hosts.
+const functionOrderIds = new WeakMap();
+let nextFunctionOrderId = 0;
+const functionOrderId = (fn) => {
+    let id = functionOrderIds.get(fn);
+    if (id === undefined) {
+        id = ++nextFunctionOrderId;
+        functionOrderIds.set(fn, id);
+    }
+    return id;
+};
 export let _$n_compare = (a, b) => {
     if (a === b)
         return 0;
@@ -125,7 +145,7 @@ export let _$n_compare = (a, b) => {
             case PseudoTypeIndex.bool:
                 return rawCompare(a, b);
             case PseudoTypeIndex.number:
-                return rawCompare(a, b);
+                return compareNumbers(a, b);
             case PseudoTypeIndex.tag:
                 return rawCompare(a.value, b.value);
             case PseudoTypeIndex.symbol:
@@ -134,6 +154,36 @@ export let _$n_compare = (a, b) => {
                 return rawCompare(a, b);
             case PseudoTypeIndex.ref:
                 return rawCompare(a.path, b.path);
+            case PseudoTypeIndex.fn: {
+                const left = a;
+                const right = b;
+                // Method closures use name equality, unlike ordinary function values.
+                if (left.__calcitMethodName != null || right.__calcitMethodName != null) {
+                    if (left.__calcitMethodName == null)
+                        return -1;
+                    if (right.__calcitMethodName == null)
+                        return 1;
+                    return compareUnicodeStrings(left.__calcitMethodName, right.__calcitMethodName);
+                }
+                return rawCompare(functionOrderId(left), functionOrderId(right));
+            }
+            case PseudoTypeIndex.impl: {
+                const left = a;
+                const right = b;
+                const nameOrder = compareUnicodeStrings(left.name.value, right.name.value);
+                if (nameOrder !== 0)
+                    return nameOrder;
+                if (left.origin == null && right.origin != null)
+                    return -1;
+                if (left.origin != null && right.origin == null)
+                    return 1;
+                if (left.origin != null && right.origin != null) {
+                    const originOrder = compareUnicodeStrings(left.origin.name.value, right.origin.name.value);
+                    if (originOrder !== 0)
+                        return originOrder;
+                }
+                return compareSequences(left.fields, right.fields) || compareSequences(left.values, right.values);
+            }
             case PseudoTypeIndex.struct_value: {
                 const left = a;
                 const right = b;
@@ -176,6 +226,43 @@ export let _$n_compare = (a, b) => {
                     return tagOrder;
                 return compareSequences(left.extra, right.extra);
             }
+            case PseudoTypeIndex.enum_def: {
+                const left = a;
+                const right = b;
+                const leftRef = left.prototype.structRef.definitionRef;
+                const rightRef = right.prototype.structRef.definitionRef;
+                if (leftRef !== rightRef) {
+                    if (leftRef == null)
+                        return -1;
+                    if (rightRef == null)
+                        return 1;
+                    return compareUnicodeStrings(leftRef, rightRef);
+                }
+                const nameOrder = compareUnicodeStrings(left.name(), right.name());
+                if (nameOrder !== 0)
+                    return nameOrder;
+                const variantCountOrder = rawCompare(left.prototype.fields.length, right.prototype.fields.length);
+                if (variantCountOrder !== 0)
+                    return variantCountOrder;
+                for (let index = 0; index < left.prototype.fields.length; index++) {
+                    const tagOrder = _$n_compare(left.prototype.fields[index], right.prototype.fields[index]);
+                    if (tagOrder !== 0)
+                        return tagOrder;
+                    const leftPayload = left.prototype.values[index];
+                    const rightPayload = right.prototype.values[index];
+                    // Native orders variant payloads by arity before comparing types.
+                    if ((leftPayload instanceof CalcitList || leftPayload instanceof CalcitSliceList)
+                        && (rightPayload instanceof CalcitList || rightPayload instanceof CalcitSliceList)) {
+                        const arityOrder = rawCompare(leftPayload.len(), rightPayload.len());
+                        if (arityOrder !== 0)
+                            return arityOrder;
+                    }
+                    const payloadOrder = _$n_compare(leftPayload, rightPayload);
+                    if (payloadOrder !== 0)
+                        return payloadOrder;
+                }
+                return rawCompare(left.impls.length, right.impls.length) || compareSequences(left.impls, right.impls);
+            }
             case PseudoTypeIndex.set: {
                 // like native: smaller sets first, then the sorted elements
                 const left = Array.from(a.values());

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.29.0-alpha.19",
+    "version": "0.29.0-alpha.20",
     "main": "./lib/calcit.procs.mjs",
     "files": [
         "lib/",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.29.0-alpha.19",
+  "version": "0.29.0-alpha.20",
   "main": "./lib/calcit.procs.mjs",
   "files": [
     "lib/",