@calcit/procs 0.13.1 → 0.13.4

package/lib/{js-record.d.mts → js-struct-value.d.mts}

@@ -2,35 +2,36 @@ import { Hash } from "@calcit/ternary-tree";
 import { CalcitValue } from "./js-primes.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
 import { CalcitTag } from "./calcit-data.mjs";
-import { CalcitStruct } from "./js-struct.mjs";
-export declare class CalcitRecord {
+import { CalcitStructDef } from "./js-struct-def.mjs";
+export declare class CalcitStructValue {
     name: CalcitTag;
     fields: Array<CalcitTag>;
     values: Array<CalcitValue>;
-    structRef: CalcitStruct;
+    structRef: CalcitStructDef;
     cachedHash: Hash;
-    constructor(name: CalcitTag, fields: Array<CalcitTag>, values?: Array<CalcitValue>, structRef?: CalcitStruct);
+    constructor(name: CalcitTag, fields: Array<CalcitTag>, values?: Array<CalcitValue>, structRef?: CalcitStructDef);
     get(k: CalcitValue): CalcitValue;
+    getRequired(k: CalcitValue): CalcitValue;
     getOrNil(k: CalcitValue): CalcitValue;
-    assoc(k: CalcitValue, v: CalcitValue): CalcitRecord;
+    assoc(k: CalcitValue, v: CalcitValue): CalcitStructValue;
     /** return -1 for missing */
     findIndex(k: CalcitValue): number;
     contains(k: CalcitValue): boolean;
     toString(disableJsDataWarning?: boolean): string;
-    withImpls(impl: CalcitValue | CalcitImpl[]): CalcitRecord;
+    withImpls(impl: CalcitValue | CalcitImpl[]): CalcitStructValue;
 }
-export declare let new_record: (name: CalcitValue, ...fields: Array<CalcitValue>) => CalcitValue;
-export declare let new_impl_record: (impl: CalcitImpl, name: CalcitValue, ...fields: Array<CalcitValue>) => CalcitValue;
+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). */
 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;
 export declare let _$n__PCT__$M__$q_: (proto: CalcitValue, ...xs: Array<CalcitValue>) => CalcitValue;
-export declare let _$n_record_$o_with: (proto: CalcitValue, ...xs: Array<CalcitValue>) => CalcitValue;
-export declare let _$n_record_$o_get_name: (x: CalcitValue) => CalcitTag;
-export declare let _$n_record_$o_struct: (x: CalcitValue) => CalcitValue;
-export declare let _$n_record_$o_from_map: (proto: CalcitValue, data: CalcitValue) => CalcitValue;
-export declare let _$n_record_$o_to_map: (x: CalcitValue) => CalcitValue;
-export declare let _$n_record_$o_matches_$q_: (x: CalcitValue, y: CalcitValue) => boolean;
-export declare function _$n_record_$o_extend_as(obj: CalcitValue, new_name: CalcitValue, new_key: CalcitValue, new_value: CalcitValue): CalcitRecord;
+export declare let _$n_struct_$o_with: (proto: CalcitValue, ...xs: Array<CalcitValue>) => CalcitValue;
+export declare let _$n_struct_$o_get_name: (x: CalcitValue) => CalcitTag;
+export declare let _$n_struct_$o_definition: (x: CalcitValue) => CalcitValue;
+export declare let _$n_struct_$o_from_map: (proto: CalcitValue, data: CalcitValue) => CalcitValue;
+export declare let _$n_struct_$o_to_map: (x: CalcitValue) => CalcitValue;
+export declare let _$n_struct_$o_matches_$q_: (x: CalcitValue, y: CalcitValue) => boolean;
+export declare function _$n_struct_$o_extend_as(obj: CalcitValue, new_name: CalcitValue, new_key: CalcitValue, new_value: CalcitValue): CalcitStructValue;

package/lib/{js-record.mjs → js-struct-value.mjs}

@@ -1,8 +1,8 @@
 import { CalcitImpl } from "./js-impl.mjs";
 import { newTag, castTag, toString, getStringName, findInFields } from "./calcit-data.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
-import { CalcitStruct } from "./js-struct.mjs";
-export class CalcitRecord {
+import { CalcitStructDef } from "./js-struct-def.mjs";
+export class CalcitStructValue {
     constructor(name, fields, values, structRef) {
         this.name = name;
         let fieldNames = fields.map(castTag);
@@ -17,7 +17,7 @@ export class CalcitRecord {
             this.values = new Array(fieldNames.length);
         }
         this.cachedHash = null;
-        this.structRef = structRef || new CalcitStruct(name, fields, new Array(fields.length).fill(null));
+        this.structRef = structRef || new CalcitStructDef(name, fields, new Array(fields.length).fill(null));
     }
     get(k) {
         let field = castTag(k);
@@ -29,6 +29,12 @@ export class CalcitRecord {
             return undefined;
         }
     }
+    getRequired(k) {
+        const value = this.get(k);
+        if (value !== undefined)
+            return value;
+        throw new Error(`struct '${this.name.value}' does not define field ${castTag(k).toString()}`);
+    }
     getOrNil(k) {
         let field = castTag(k);
         let idx = findInFields(this.fields, field);
@@ -50,7 +56,7 @@ export class CalcitRecord {
                 values[idx] = this.values[idx];
             }
         }
-        return new CalcitRecord(this.name, this.fields, values, this.structRef);
+        return new CalcitStructValue(this.name, this.fields, values, this.structRef);
     }
     /** return -1 for missing */
     findIndex(k) {
@@ -64,7 +70,7 @@ export class CalcitRecord {
     }
     toString(disableJsDataWarning = false) {
         // Optimize string building using array join instead of concatenation
-        const parts = ["(%{} '", this.name.value];
+        const parts = this.name.value === "_" ? ["(%{} _"] : ["(%{} '", this.name.value];
         for (let idx = 0; idx < this.fields.length; idx++) {
             parts.push(" (", this.fields[idx].toString(), " ", toString(this.values[idx], true, disableJsDataWarning), ")");
         }
@@ -82,11 +88,11 @@ export class CalcitRecord {
         else {
             throw new Error("Expected an impl or array of impls");
         }
-        let nextStruct = new CalcitStruct(this.name, this.fields, this.structRef.fieldTypes, this.structRef.impls.concat(nextImpls));
-        return new CalcitRecord(this.name, this.fields, this.values, nextStruct);
+        let nextStruct = new CalcitStructDef(this.name, this.fields, this.structRef.fieldTypes, this.structRef.impls.concat(nextImpls));
+        return new CalcitStructValue(this.name, this.fields, this.values, nextStruct);
     }
 }
-export let new_record = (name, ...fields) => {
+export let new_struct_value = (name, ...fields) => {
     let fieldNames = fields.map(castTag).sort((x, y) => {
         if (x.idx < y.idx) {
             return -1;
@@ -95,12 +101,12 @@ export let new_record = (name, ...fields) => {
             return 1;
         }
         else {
-            throw new Error(`Unexpected duplication in record fields: ${x.toString()}`);
+            throw new Error(`Unexpected duplication in struct fields: ${x.toString()}`);
         }
     });
-    return new CalcitRecord(castTag(name), fieldNames);
+    return new CalcitStructValue(castTag(name), fieldNames);
 };
-export let new_impl_record = (impl, name, ...fields) => {
+export let new_impl_struct_value = (impl, name, ...fields) => {
     let fieldNames = fields.map(castTag).sort((x, y) => {
         if (x.idx < y.idx) {
             return -1;
@@ -109,12 +115,12 @@ export let new_impl_record = (impl, name, ...fields) => {
             return 1;
         }
         else {
-            throw new Error(`Unexpected duplication in record fields: ${x.toString()}`);
+            throw new Error(`Unexpected duplication in struct fields: ${x.toString()}`);
         }
     });
     let nameTag = castTag(name);
-    let structRef = new CalcitStruct(nameTag, fieldNames, new Array(fieldNames.length).fill(null), [impl]);
-    return new CalcitRecord(nameTag, fieldNames, undefined, structRef);
+    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). */
@@ -135,8 +141,8 @@ export let _$q__$M_ = (...xs) => {
     }
     let fieldNames = pairs.map((p) => p[0]);
     let values = pairs.map((p) => p[1]);
-    let looseTag = newTag("?");
-    return new CalcitRecord(looseTag, fieldNames, values);
+    let looseTag = newTag("_");
+    return new CalcitStructValue(looseTag, fieldNames, values);
 };
 export let fieldsEqual = (xs, ys) => {
     if (xs === ys) {
@@ -154,14 +160,14 @@ export let fieldsEqual = (xs, ys) => {
 };
 export let _$n__PCT__$M_ = (proto, ...xs) => {
     let recordProto;
-    if (proto instanceof CalcitRecord) {
+    if (proto instanceof CalcitStructValue) {
         recordProto = proto;
     }
-    else if (proto instanceof CalcitStruct) {
-        recordProto = new CalcitRecord(proto.name, proto.fields, new Array(proto.fields.length).fill(null), proto);
+    else if (proto instanceof CalcitStructDef) {
+        recordProto = new CalcitStructValue(proto.name, proto.fields, new Array(proto.fields.length).fill(null), proto);
     }
     else {
-        throw new Error("Expected prototype to be a record");
+        throw new Error("Expected prototype to be a StructDef");
     }
     {
         if (xs.length % 2 !== 0) {
@@ -181,21 +187,21 @@ export let _$n__PCT__$M_ = (proto, ...xs) => {
                 }
             }
             if (idx < 0) {
-                throw new Error("invalid field name for this record");
+                throw new Error("invalid field name for this struct");
             }
             if (values[i] != null) {
-                throw new Error("record field already has value, probably duplicated key");
+                throw new Error("struct field already has value, probably duplicated key");
             }
             values[i] = xs[idx * 2 + 1];
         }
-        return new CalcitRecord(recordProto.name, recordProto.fields, values, recordProto.structRef);
+        return new CalcitStructValue(recordProto.name, recordProto.fields, values, recordProto.structRef);
     }
 };
 export let _$n__PCT__$M__$q_ = (proto, ...xs) => {
     let recordProto;
     let values;
-    if (proto instanceof CalcitStruct) {
-        recordProto = new CalcitRecord(proto.name, proto.fields, new Array(proto.fields.length).fill(null), proto);
+    if (proto instanceof CalcitStructDef) {
+        recordProto = new CalcitStructValue(proto.name, proto.fields, new Array(proto.fields.length).fill(null), proto);
         values = recordProto.values.slice();
     }
     else {
@@ -212,16 +218,16 @@ export let _$n__PCT__$M__$q_ = (proto, ...xs) => {
             throw new Error(`Cannot find field ${k} among ${recordProto.fields}`);
         }
         if (touched.has(idx)) {
-            throw new Error(`record field already has value, probably duplicated key: ${k}`);
+            throw new Error(`struct field already has value, probably duplicated key: ${k}`);
         }
         touched.add(idx);
         values[idx] = xs[i + 1];
     }
-    return new CalcitRecord(recordProto.name, recordProto.fields, values, recordProto.structRef);
+    return new CalcitStructValue(recordProto.name, recordProto.fields, values, recordProto.structRef);
 };
 /// update record with new values
-export let _$n_record_$o_with = (proto, ...xs) => {
-    if (proto instanceof CalcitRecord) {
+export let _$n_struct_$o_with = (proto, ...xs) => {
+    if (proto instanceof CalcitStructValue) {
         if (xs.length % 2 !== 0) {
             throw new Error("Expected even number of key/value");
         }
@@ -235,39 +241,41 @@ export let _$n_record_$o_with = (proto, ...xs) => {
             }
             values[idx] = v;
         }
-        return new CalcitRecord(proto.name, proto.fields, values, proto.structRef);
+        return new CalcitStructValue(proto.name, proto.fields, values, proto.structRef);
     }
     else {
-        throw new Error("Expected prototype to be a record");
+        throw new Error("Expected prototype to be a StructDef");
     }
 };
-export let _$n_record_$o_get_name = (x) => {
-    if (x instanceof CalcitRecord) {
+export let _$n_struct_$o_get_name = (x) => {
+    if (x instanceof CalcitStructValue) {
         return x.name;
     }
     else {
-        throw new Error("Expected a record");
+        throw new Error("Expected a struct value");
     }
 };
-export let _$n_record_$o_struct = (x) => {
-    if (x instanceof CalcitRecord) {
+export let _$n_struct_$o_definition = (x) => {
+    if (x instanceof CalcitStructValue) {
+        if (x.name.value === "_")
+            return null;
         return x.structRef ?? null;
     }
     else {
-        throw new Error("Expected a record");
+        throw new Error("Expected a struct value");
     }
 };
-export let _$n_record_$o_from_map = (proto, data) => {
+export let _$n_struct_$o_from_map = (proto, data) => {
     let recordProto;
-    if (proto instanceof CalcitStruct) {
-        recordProto = new CalcitRecord(proto.name, proto.fields, new Array(proto.fields.length).fill(null), proto);
+    if (proto instanceof CalcitStructDef) {
+        recordProto = new CalcitStructValue(proto.name, proto.fields, new Array(proto.fields.length).fill(null), proto);
     }
     else {
         throw new Error("Expected prototype to be struct");
     }
-    if (data instanceof CalcitRecord) {
+    if (data instanceof CalcitStructValue) {
         if (fieldsEqual(recordProto.fields, data.fields)) {
-            return new CalcitRecord(recordProto.name, recordProto.fields, data.values, recordProto.structRef);
+            return new CalcitStructValue(recordProto.name, recordProto.fields, data.values, recordProto.structRef);
         }
         else {
             let values = [];
@@ -279,7 +287,7 @@ export let _$n_record_$o_from_map = (proto, data) => {
                 }
                 values.push(data.values[idx]);
             }
-            return new CalcitRecord(recordProto.name, recordProto.fields, values, recordProto.structRef);
+            return new CalcitStructValue(recordProto.name, recordProto.fields, values, recordProto.structRef);
         }
     }
     else if (data instanceof CalcitMap || data instanceof CalcitSliceMap) {
@@ -304,14 +312,14 @@ export let _$n_record_$o_from_map = (proto, data) => {
             }
             throw new Error(`Cannot find field ${field} among ${pairs_buffer}`);
         }
-        return new CalcitRecord(recordProto.name, recordProto.fields, values, recordProto.structRef);
+        return new CalcitStructValue(recordProto.name, recordProto.fields, values, recordProto.structRef);
     }
     else {
-        throw new Error("Expected record or data for making a record");
+        throw new Error("Expected a struct value or data for making a struct");
     }
 };
-export let _$n_record_$o_to_map = (x) => {
-    if (x instanceof CalcitRecord) {
+export let _$n_struct_$o_to_map = (x) => {
+    if (x instanceof CalcitStructValue) {
         var dict = [];
         for (let idx = 0; idx < x.fields.length; idx++) {
             dict.push(x.fields[idx], x.values[idx]);
@@ -319,35 +327,35 @@ export let _$n_record_$o_to_map = (x) => {
         return new CalcitSliceMap(dict);
     }
     else {
-        throw new Error("Expected record");
+        throw new Error("Expected a struct value");
     }
 };
-export let _$n_record_$o_matches_$q_ = (x, y) => {
+export let _$n_struct_$o_matches_$q_ = (x, y) => {
     let targetStruct;
-    if (y instanceof CalcitRecord) {
+    if (y instanceof CalcitStructValue) {
         targetStruct = y.structRef;
     }
-    else if (y instanceof CalcitStruct) {
+    else if (y instanceof CalcitStructDef) {
         targetStruct = y;
     }
     else {
-        throw new Error("Expected second argument to be record or struct");
+        throw new Error("Expected second argument to be a struct value or StructDef");
     }
-    if (x instanceof CalcitRecord) {
+    if (x instanceof CalcitStructValue) {
         if (x.name !== targetStruct.name) {
             return false;
         }
         return fieldsEqual(x.fields, targetStruct.fields);
     }
     else {
-        throw new Error("Expected first argument to be record");
+        throw new Error("Expected first argument to be a struct value");
     }
 };
-export function _$n_record_$o_extend_as(obj, new_name, new_key, new_value) {
+export function _$n_struct_$o_extend_as(obj, new_name, new_key, new_value) {
     if (arguments.length !== 4)
         throw new Error(`Expected 4 arguments, got ${arguments.length}`);
-    if (!(obj instanceof CalcitRecord))
-        throw new Error("Expected record");
+    if (!(obj instanceof CalcitStructValue))
+        throw new Error("Expected a struct value");
     let field = castTag(new_key);
     let new_name_tag = castTag(new_name);
     let new_fields = [];
@@ -372,7 +380,7 @@ export function _$n_record_$o_extend_as(obj, new_name, new_key, new_value) {
                 new_values.push(obj.values[i]);
             }
             else {
-                throw new Error("Does not extend existed record field");
+                throw new Error("Cannot extend an existing struct field");
             }
         }
     }
@@ -380,5 +388,5 @@ export function _$n_record_$o_extend_as(obj, new_name, new_key, new_value) {
         new_fields.push(field);
         new_values.push(new_value);
     }
-    return new CalcitRecord(new_name_tag, new_fields, new_values);
+    return new CalcitStructValue(new_name_tag, new_fields, new_values);
 }

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.13.1",
+    "version": "0.13.4",
     "main": "./lib/calcit.procs.mjs",
     "devDependencies": {
         "@types/node": "^25.7.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.13.1",
+  "version": "0.13.4",
   "main": "./lib/calcit.procs.mjs",
   "devDependencies": {
     "@types/node": "^25.7.0",

package/ts-src/calcit-data.mts

@@ -3,16 +3,16 @@ import { overwriteComparator, initTernaryTreeMap } from "@calcit/ternary-tree";
 import { overwriteMapComparator } from "./js-map.mjs";
 import { disableListStructureCheck } from "@calcit/ternary-tree";
 
-import { CalcitRecord, fieldsEqual } from "./js-record.mjs";
+import { CalcitStructValue, fieldsEqual } from "./js-struct-value.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
-import { CalcitStruct } from "./js-struct.mjs";
-import { CalcitEnum } from "./js-enum.mjs";
+import { CalcitStructDef } from "./js-struct-def.mjs";
+import { CalcitEnumDef } from "./js-enum-def.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 
 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 { CalcitEnumValue } from "./js-enum-value.mjs";
 import { CalcitTrait } from "./js-trait.mjs";
 import { CalcitCirruQuote, cirru_deep_equal } from "./js-cirru.mjs";
 import { CirruWriterNode } from "@cirru/writer.ts";
@@ -80,7 +80,7 @@ export let isNestedCalcitData = (x: CalcitValue): boolean => {
   if (x instanceof CalcitMap || x instanceof CalcitSliceMap) {
     return x.len() > 0;
   }
-  if (x instanceof CalcitRecord) {
+  if (x instanceof CalcitStructValue) {
     return x.fields.length > 0;
   }
   if (x instanceof CalcitImpl) {
@@ -99,7 +99,7 @@ export let tipNestedCalcitData = (x: CalcitValue): string => {
   if (x instanceof CalcitMap || x instanceof CalcitSliceMap) {
     return "'{}...";
   }
-  if (x instanceof CalcitRecord) {
+  if (x instanceof CalcitStructValue) {
     return "'%{}...";
   }
   if (x instanceof CalcitImpl) {
@@ -256,7 +256,7 @@ export let hashFunction = (x: CalcitValue): Hash => {
     x.cachedHash = h;
     return h;
   }
-  if (x instanceof CalcitTuple) {
+  if (x instanceof CalcitEnumValue) {
     let base = defaultHash_tuple;
     base = mergeValueHash(base, hashFunction(x.tag));
     for (let idx = 0; idx < x.extra.length; idx++) {
@@ -322,7 +322,7 @@ export let hashFunction = (x: CalcitValue): Hash => {
     x.cachedHash = base;
     return base;
   }
-  if (x instanceof CalcitRecord) {
+  if (x instanceof CalcitStructValue) {
     let base = defaultHash_record;
     for (let idx = 0; idx < x.fields.length; idx++) {
       base = mergeValueHash(base, hashFunction(x.fields[idx]));
@@ -344,7 +344,7 @@ export let hashFunction = (x: CalcitValue): Hash => {
     x.cachedHash = base;
     return base;
   }
-  if (x instanceof CalcitStruct) {
+  if (x instanceof CalcitStructDef) {
     let base = defaultHash_struct;
     base = mergeValueHash(base, hashFunction(x.name));
     for (let idx = 0; idx < x.fields.length; idx++) {
@@ -357,7 +357,7 @@ export let hashFunction = (x: CalcitValue): Hash => {
     x.cachedHash = base;
     return base;
   }
-  if (x instanceof CalcitEnum) {
+  if (x instanceof CalcitEnumDef) {
     let base = defaultHash_enum;
     base = mergeValueHash(base, hashFunction(x.prototype));
     for (let impl of x.impls) {
@@ -441,16 +441,16 @@ export let toString = (x: CalcitValue, escaped: boolean, disableJsDataWarning: b
   if (x instanceof CalcitSet) {
     return x.toString(disableJsDataWarning);
   }
-  if (x instanceof CalcitRecord) {
+  if (x instanceof CalcitStructValue) {
     return x.toString(disableJsDataWarning);
   }
   if (x instanceof CalcitImpl) {
     return x.toString(disableJsDataWarning);
   }
-  if (x instanceof CalcitStruct) {
+  if (x instanceof CalcitStructDef) {
     return x.toString(disableJsDataWarning);
   }
-  if (x instanceof CalcitEnum) {
+  if (x instanceof CalcitEnumDef) {
     return x.toString();
   }
   if (x instanceof CalcitTrait) {
@@ -459,7 +459,7 @@ export let toString = (x: CalcitValue, escaped: boolean, disableJsDataWarning: b
   if (x instanceof CalcitRef) {
     return x.toString();
   }
-  if (x instanceof CalcitTuple) {
+  if (x instanceof CalcitEnumValue) {
     return x.toString(disableJsDataWarning);
   }
   if (x instanceof CalcitCirruQuote) {
@@ -532,7 +532,7 @@ let to_js_data_inner = (x: CalcitValue, addColon: boolean): any => {
     }
     return Symbol(x.value);
   }
-  if (x instanceof CalcitTuple) {
+  if (x instanceof CalcitEnumValue) {
     var result: any[] = [to_js_data_inner(x.tag, false)];
     for (let i = 0; i < x.extra.length; i++) {
       let item = x.extra[i];
@@ -565,7 +565,7 @@ let to_js_data_inner = (x: CalcitValue, addColon: boolean): any => {
     });
     return result;
   }
-  if (x instanceof CalcitRecord) {
+  if (x instanceof CalcitStructValue) {
     let result: Record<string, CalcitValue> = {};
     for (let idx = 0; idx < x.fields.length; idx++) {
       result[x.fields[idx].value] = to_js_data_inner(x.values[idx], false);
@@ -693,8 +693,8 @@ export let _$n__$e_ = (x: CalcitValue, y: CalcitValue): boolean => {
     }
     return false;
   }
-  if (x instanceof CalcitTuple) {
-    if (y instanceof CalcitTuple) {
+  if (x instanceof CalcitEnumValue) {
+    if (y instanceof CalcitEnumValue) {
       return x.eq(y);
     }
     return false;
@@ -743,8 +743,8 @@ export let _$n__$e_ = (x: CalcitValue, y: CalcitValue): boolean => {
     }
     return false;
   }
-  if (x instanceof CalcitRecord) {
-    if (y instanceof CalcitRecord) {
+  if (x instanceof CalcitStructValue) {
+    if (y instanceof CalcitStructValue) {
       if (x.name !== y.name) {
         return false;
       }
@@ -789,14 +789,14 @@ export let _$n__$e_ = (x: CalcitValue, y: CalcitValue): boolean => {
     }
     return false;
   }
-  if (x instanceof CalcitStruct) {
-    if (y instanceof CalcitStruct) {
+  if (x instanceof CalcitStructDef) {
+    if (y instanceof CalcitStructDef) {
       return x.name === y.name && fieldsEqual(x.fields, y.fields);
     }
     return false;
   }
-  if (x instanceof CalcitEnum) {
-    if (y instanceof CalcitEnum) {
+  if (x instanceof CalcitEnumDef) {
+    if (y instanceof CalcitEnumDef) {
       return x.name === y.name;
     }
     return false;