@calcit/procs 0.11.0-a8 → 0.11.0

package/lib/js-record.mjs

@@ -1,7 +1,9 @@
+import { CalcitImpl } from "./js-impl.mjs";
 import { castTag, toString, findInFields } from "./calcit-data.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
+import { CalcitStruct } from "./js-struct.mjs";
 export class CalcitRecord {
-    constructor(name, fields, values, impls) {
+    constructor(name, fields, values, structRef) {
         this.name = name;
         let fieldNames = fields.map(castTag);
         this.fields = fields;
@@ -15,7 +17,7 @@ export class CalcitRecord {
             this.values = new Array(fieldNames.length);
         }
         this.cachedHash = null;
-        this.impls = impls || [];
+        this.structRef = structRef || new CalcitStruct(name, fields, new Array(fields.length).fill(null));
     }
     get(k) {
         let field = castTag(k);
@@ -48,7 +50,7 @@ export class CalcitRecord {
                 values[idx] = this.values[idx];
             }
         }
-        return new CalcitRecord(this.name, this.fields, values, this.impls);
+        return new CalcitRecord(this.name, this.fields, values, this.structRef);
     }
     /** return -1 for missing */
     findIndex(k) {
@@ -70,12 +72,18 @@ export class CalcitRecord {
         return parts.join("");
     }
     withImpls(impl) {
-        if (impl instanceof CalcitRecord) {
-            return new CalcitRecord(this.name, this.fields, this.values, [impl]);
+        let nextImpls;
+        if (impl instanceof CalcitImpl) {
+            nextImpls = [impl];
+        }
+        else if (Array.isArray(impl)) {
+            nextImpls = impl;
         }
         else {
-            throw new Error("Expected a record");
+            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);
     }
 }
 export let new_record = (name, ...fields) => {
@@ -104,7 +112,9 @@ export let new_impl_record = (impl, name, ...fields) => {
             throw new Error(`Unexpected duplication in record fields: ${x.toString()}`);
         }
     });
-    return new CalcitRecord(castTag(name), fieldNames, undefined, [impl]);
+    let nameTag = castTag(name);
+    let structRef = new CalcitStruct(nameTag, fieldNames, new Array(fieldNames.length).fill(null), [impl]);
+    return new CalcitRecord(nameTag, fieldNames, undefined, structRef);
 };
 export let fieldsEqual = (xs, ys) => {
     if (xs === ys) {
@@ -146,7 +156,7 @@ export let _$n__PCT__$M_ = (proto, ...xs) => {
             }
             values[i] = xs[idx * 2 + 1];
         }
-        return new CalcitRecord(proto.name, proto.fields, values, proto.impls);
+        return new CalcitRecord(proto.name, proto.fields, values, proto.structRef);
     }
     else {
         throw new Error("Expected prototype to be a record");
@@ -168,7 +178,7 @@ export let _$n_record_$o_with = (proto, ...xs) => {
             }
             values[idx] = v;
         }
-        return new CalcitRecord(proto.name, proto.fields, values, proto.impls);
+        return new CalcitRecord(proto.name, proto.fields, values, proto.structRef);
     }
     else {
         throw new Error("Expected prototype to be a record");

package/lib/js-struct.mjs

@@ -1,5 +1,5 @@
 import { toString } from "./calcit-data.mjs";
-import { CalcitRecord } from "./js-record.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
 export class CalcitStruct {
     constructor(name, fields, fieldTypes, impls = []) {
         if (fields.length !== fieldTypes.length) {
@@ -12,13 +12,13 @@ export class CalcitStruct {
         this.cachedHash = null;
     }
     withImpls(impls) {
-        if (impls instanceof CalcitRecord) {
+        if (impls instanceof CalcitImpl) {
             return new CalcitStruct(this.name, this.fields, this.fieldTypes, [impls]);
         }
         else if (Array.isArray(impls)) {
             return new CalcitStruct(this.name, this.fields, this.fieldTypes, impls);
         }
-        throw new Error("Expected a record as implementation");
+        throw new Error("Expected an impl as implementation");
     }
     toString(disableJsDataWarning = false) {
         if (this.fields.length !== this.fieldTypes.length) {

package/lib/js-tuple.mjs

@@ -1,13 +1,21 @@
 import { _$n__$e_, toString } from "./calcit-data.mjs";
 import { CalcitEnum } from "./js-enum.mjs";
 export class CalcitTuple {
-    constructor(tagName, extra, impls = [], enumPrototype = null) {
+    constructor(tagName, extra, enumPrototype = null) {
         this.tag = tagName;
         this.extra = extra;
-        this.impls = impls;
         this.enumPrototype = enumPrototype;
         this.cachedHash = null;
     }
+    get impls() {
+        if (this.enumPrototype == null) {
+            return [];
+        }
+        if (this.enumPrototype instanceof CalcitEnum) {
+            return this.enumPrototype.impls;
+        }
+        return this.enumPrototype.structRef.impls;
+    }
     get(n) {
         if (n === 0) {
             return this.tag;
@@ -21,12 +29,12 @@ export class CalcitTuple {
     }
     assoc(n, v) {
         if (n === 0) {
-            return new CalcitTuple(v, this.extra, this.impls, this.enumPrototype);
+            return new CalcitTuple(v, this.extra, this.enumPrototype);
         }
         else if (n - 1 < this.extra.length) {
             let next_extra = this.extra.slice();
             next_extra[n - 1] = v;
-            return new CalcitTuple(this.tag, next_extra, this.impls, this.enumPrototype);
+            return new CalcitTuple(this.tag, next_extra, this.enumPrototype);
         }
         else {
             throw new Error(`Tuple only have ${this.extra.length} elements`);
@@ -60,15 +68,9 @@ export class CalcitTuple {
         }
         const hasEnum = this.enumPrototype != null;
         const enumName = hasEnum ? (this.enumPrototype instanceof CalcitEnum ? this.enumPrototype.prototype.name.value : this.enumPrototype.name.value) : null;
-        if (this.impls.length > 0 && hasEnum) {
-            return `(%:: ${content} (:impls ${this.impls[0].name.value}) (:enum ${enumName}))`;
-        }
         if (hasEnum) {
             return `(%:: ${content} (:enum ${enumName}))`;
         }
-        if (this.impls.length > 0) {
-            return `(:: ${content} (:impls ${this.impls[0].name.value}))`;
-        }
         return `(:: ${content})`;
     }
 }

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.11.0-a8",
+    "version": "0.11.0",
     "main": "./lib/calcit.procs.mjs",
     "devDependencies": {
         "@types/node": "^25.0.9",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.11.0-a8",
+  "version": "0.11.0",
   "main": "./lib/calcit.procs.mjs",
   "devDependencies": {
     "@types/node": "^25.0.9",

package/ts-src/calcit-data.mts

@@ -4,6 +4,7 @@ import { overwriteMapComparator } from "./js-map.mjs";
 import { disableListStructureCheck } from "@calcit/ternary-tree";
 
 import { CalcitRecord, fieldsEqual } from "./js-record.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
 import { CalcitStruct } from "./js-struct.mjs";
 import { CalcitEnum } from "./js-enum.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
@@ -82,6 +83,9 @@ export let isNestedCalcitData = (x: CalcitValue): boolean => {
   if (x instanceof CalcitRecord) {
     return x.fields.length > 0;
   }
+  if (x instanceof CalcitImpl) {
+    return x.fields.length > 0;
+  }
   if (x instanceof CalcitSet) {
     return false;
   }
@@ -98,6 +102,9 @@ export let tipNestedCalcitData = (x: CalcitValue): string => {
   if (x instanceof CalcitRecord) {
     return "'%{}...";
   }
+  if (x instanceof CalcitImpl) {
+    return "'%impl...";
+  }
   if (x instanceof CalcitSet) {
     return "'#{}...";
   }
@@ -180,6 +187,7 @@ let defaultHash_set = valueHash("set:");
 let defaultHash_list = valueHash("list:");
 let defaultHash_map = valueHash("map:");
 let defaultHash_record = valueHash("record:");
+let defaultHash_impl = valueHash("impl:");
 let defaultHash_struct = valueHash("struct:");
 let defaultHash_enum = valueHash("enum:");
 let defaultHash_cirru_quote = valueHash("cirru-quote:");
@@ -309,6 +317,19 @@ export let hashFunction = (x: CalcitValue): Hash => {
     x.cachedHash = base;
     return base;
   }
+  if (x instanceof CalcitImpl) {
+    let base = defaultHash_impl;
+    base = mergeValueHash(base, hashFunction(x.name));
+    if (x.origin != null) {
+      base = mergeValueHash(base, hashFunction(x.origin));
+    }
+    for (let idx = 0; idx < x.fields.length; idx++) {
+      base = mergeValueHash(base, hashFunction(x.fields[idx]));
+      base = mergeValueHash(base, hashFunction(x.values[idx]));
+    }
+    x.cachedHash = base;
+    return base;
+  }
   if (x instanceof CalcitStruct) {
     let base = defaultHash_struct;
     base = mergeValueHash(base, hashFunction(x.name));
@@ -405,6 +426,9 @@ export let toString = (x: CalcitValue, escaped: boolean, disableJsDataWarning: b
   if (x instanceof CalcitRecord) {
     return x.toString(disableJsDataWarning);
   }
+  if (x instanceof CalcitImpl) {
+    return x.toString(disableJsDataWarning);
+  }
   if (x instanceof CalcitStruct) {
     return x.toString(disableJsDataWarning);
   }
@@ -682,6 +706,32 @@ export let _$n__$e_ = (x: CalcitValue, y: CalcitValue): boolean => {
     }
     return false;
   }
+  if (x instanceof CalcitImpl) {
+    if (y instanceof CalcitImpl) {
+      if (x.name !== y.name) {
+        return false;
+      }
+      if ((x.origin == null) !== (y.origin == null)) {
+        return false;
+      }
+      if (x.origin != null && y.origin != null && x.origin.name.value !== y.origin.name.value) {
+        return false;
+      }
+      if (!fieldsEqual(x.fields, y.fields)) {
+        return false;
+      }
+      if (x.values.length !== y.values.length) {
+        return false;
+      }
+      for (let idx = 0; idx < x.fields.length; idx++) {
+        if (!_$n__$e_(x.values[idx], y.values[idx])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return false;
+  }
   if (x instanceof CalcitStruct) {
     if (y instanceof CalcitStruct) {
       return x.name === y.name && fieldsEqual(x.fields, y.fields);

package/ts-src/calcit.procs.mts

@@ -23,12 +23,14 @@ import {
 
 import { CalcitRef } from "./js-ref.mjs";
 import { fieldsEqual, CalcitRecord } from "./js-record.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
 import { CalcitStruct } from "./js-struct.mjs";
 import { CalcitEnum } from "./js-enum.mjs";
 import { CalcitTrait } from "./js-trait.mjs";
 
 export * from "./calcit-data.mjs";
 export * from "./js-record.mjs";
+export * from "./js-impl.mjs";
 export * from "./js-struct.mjs";
 export * from "./js-enum.mjs";
 export * from "./js-map.mjs";
@@ -83,6 +85,9 @@ export let type_of = (x: any): CalcitTag => {
   if (x instanceof CalcitRecord) {
     return newTag("record");
   }
+  if (x instanceof CalcitImpl) {
+    return newTag("impl");
+  }
   if (x instanceof CalcitStruct) {
     return newTag("struct");
   }
@@ -225,7 +230,46 @@ export let defenum = (name: CalcitValue, ...variants: CalcitValue[]): CalcitEnum
   const tags = entries.map((entry) => entry.tag);
   const values = entries.map((entry) => entry.payload);
   const prototype = new CalcitRecord(enumName, tags, values, null);
-  return new CalcitEnum(prototype, null);
+  return new CalcitEnum(prototype);
+};
+
+export let _$n_impl_$o__$o_new = (name: CalcitValue, ...pairs: CalcitValue[]): CalcitImpl => {
+  if (name === undefined) throw new Error("&impl::new expected arguments");
+  const origin = name instanceof CalcitTrait ? name : null;
+  const implName = origin ? origin.name : castTag(name);
+  if (pairs.length === 0) {
+    return new CalcitImpl(implName, [], [], origin);
+  }
+  const entries: Array<{ tag: CalcitTag; value: CalcitValue }> = [];
+  for (let idx = 0; idx < pairs.length; idx++) {
+    const pairValue = pairs[idx];
+    let fieldTag: CalcitTag;
+    let value: CalcitValue;
+    if (pairValue instanceof CalcitTuple) {
+      if (pairValue.extra.length !== 1) {
+        throw new Error(`&impl::new expects (field value) pairs, got: ${toString(pairValue, true)}`);
+      }
+      fieldTag = castTag(pairValue.tag);
+      value = pairValue.extra[0];
+    } else {
+      const pair = list_items(pairValue);
+      if (pair.length !== 2) {
+        throw new Error(`&impl::new expects (field value) pairs, got: ${toString(pairValue, true)}`);
+      }
+      fieldTag = castTag(pair[0]);
+      value = pair[1];
+    }
+    entries.push({ tag: fieldTag, value });
+  }
+  entries.sort((a, b) => a.tag.idx - b.tag.idx);
+  for (let i = 1; i < entries.length; i++) {
+    if (entries[i - 1].tag.value === entries[i].tag.value) {
+      throw new Error(`&impl::new duplicated field: ${entries[i].tag.toString()}`);
+    }
+  }
+  const fields = entries.map((entry) => entry.tag);
+  const values = entries.map((entry) => entry.value);
+  return new CalcitImpl(implName, fields, values, origin);
 };
 
 export let _$n_struct_$o__$o_new = (name: CalcitValue, ...entries: CalcitValue[]): CalcitStruct => {
@@ -444,6 +488,13 @@ export let _$n_tuple_$o_count = function (xs: CalcitValue) {
   throw new Error("Does not support `count` on this type");
 };
 
+const coerce_impl = (value: CalcitValue, procName: string): CalcitImpl => {
+  if (value instanceof CalcitImpl) {
+    return value;
+  }
+  throw new Error(`${procName} expects trait impls as impls`);
+};
+
 export let _$n_tuple_$o_impls = function (x: CalcitTuple) {
   if (arguments.length !== 1) throw new Error("&tuple:impls takes 1 argument");
   return new CalcitSliceList(x.impls);
@@ -454,22 +505,30 @@ export let _$n_tuple_$o_params = function (x: CalcitTuple) {
   return new CalcitSliceList(x.extra);
 };
 
-export let _$n_tuple_$o_with_impls = function (x: CalcitTuple, y: CalcitRecord) {
+export let _$n_tuple_$o_with_impls = function (x: CalcitTuple, y: CalcitValue) {
   if (arguments.length !== 2) throw new Error("&tuple:with-impls takes 2 arguments");
   if (!(x instanceof CalcitTuple)) throw new Error("&tuple:with-impls expects a tuple");
-  if (!(y instanceof CalcitRecord)) throw new Error("&tuple:with-impls expects second argument in record");
-  return new CalcitTuple(x.tag, x.extra, [y], x.enumPrototype);
+  const impl = coerce_impl(y, "&tuple:with-impls");
+  let proto = x.enumPrototype;
+  if (proto == null) {
+    proto = new CalcitEnum(new CalcitRecord(newTag("anonymous-tuple"), [], [], new CalcitStruct(newTag("anonymous-tuple"), [], [])));
+  }
+  return new CalcitTuple(x.tag, x.extra, proto.withImpls(impl));
 };
 
 export let _$n_tuple_$o_impl_traits = function (x: CalcitValue, ...traits: CalcitValue[]) {
   if (traits.length < 1) throw new Error("&tuple:impl-traits takes 2+ arguments");
   if (!(x instanceof CalcitTuple)) throw new Error("&tuple:impl-traits expects a tuple");
-  for (let idx = 0; idx < traits.length; idx++) {
-    if (!(traits[idx] instanceof CalcitRecord)) {
-      throw new Error("&tuple:impl-traits expects trait impls as records");
-    }
+  const impls = traits.map((trait) => coerce_impl(trait, "&tuple:impl-traits"));
+  let proto = x.enumPrototype;
+  if (proto == null) {
+    const tagName = x.tag instanceof CalcitTag ? x.tag : newTag("tag");
+    const anyTypes = new CalcitSliceList(new Array(x.extra.length).fill(newTag("any")));
+    proto = new CalcitEnum(
+      new CalcitRecord(newTag("anonymous-tuple"), [tagName], [anyTypes], new CalcitStruct(newTag("anonymous-tuple"), [tagName], [anyTypes]))
+    );
   }
-  return new CalcitTuple(x.tag, x.extra, x.impls.concat(traits as CalcitRecord[]), x.enumPrototype);
+  return new CalcitTuple(x.tag, x.extra, proto.withImpls(impls));
 };
 
 export let _$n_tuple_$o_enum = function (x: CalcitTuple) {
@@ -481,7 +540,7 @@ export let _$n_tuple_$o_enum = function (x: CalcitTuple) {
   if (x.enumPrototype instanceof CalcitEnum) {
     return x.enumPrototype;
   }
-  return new CalcitEnum(x.enumPrototype as CalcitRecord, null);
+  return new CalcitEnum(x.enumPrototype as CalcitRecord);
 };
 
 const unwrap_enum_prototype = (enumPrototype: CalcitValue, procName: string): CalcitRecord => {
@@ -603,50 +662,47 @@ export let _$n_record_$o_assoc = function (xs: CalcitValue, k: CalcitValue, v: C
 
 export let _$n_record_$o_impls = function (xs: CalcitValue) {
   if (arguments.length !== 1) throw new Error("&record:impls takes 1 argument");
-  if (xs instanceof CalcitRecord) return new CalcitSliceList(xs.impls);
+  if (xs instanceof CalcitRecord) return new CalcitSliceList(xs.structRef.impls);
   throw new Error("&record:impls expected a record");
 };
 
 export let _$n_record_$o_impl_traits = function (xs: CalcitValue, ...traits: CalcitValue[]) {
   if (traits.length < 1) throw new Error("&record:impl-traits takes 2+ arguments");
   if (!(xs instanceof CalcitRecord)) throw new Error("&record:impl-traits expected a record");
-  for (let idx = 0; idx < traits.length; idx++) {
-    if (!(traits[idx] instanceof CalcitRecord)) {
-      throw new Error("&record:impl-traits expects trait impls as records");
-    }
-  }
-  return new CalcitRecord(xs.name, xs.fields, xs.values, xs.impls.concat(traits as CalcitRecord[]));
+  const impls = traits.map((trait) => coerce_impl(trait, "&record:impl-traits"));
+  const nextStruct = new CalcitStruct(xs.name, xs.fields, xs.structRef.fieldTypes, xs.structRef.impls.concat(impls));
+  return new CalcitRecord(xs.name, xs.fields, xs.values, nextStruct);
 };
 
 export let _$n_struct_$o_impl_traits = function (xs: CalcitValue, ...traits: CalcitValue[]) {
   if (traits.length < 1) throw new Error("&struct:impl-traits takes 2+ arguments");
   if (!(xs instanceof CalcitStruct)) throw new Error("&struct:impl-traits expected a struct");
-  for (let idx = 0; idx < traits.length; idx++) {
-    if (!(traits[idx] instanceof CalcitRecord)) {
-      throw new Error("&struct:impl-traits expects trait impls as records");
-    }
-  }
-  const impls = xs.impls ?? [];
-  return new CalcitStruct(xs.name, xs.fields, xs.fieldTypes, impls.concat(traits as CalcitRecord[]));
+  const addedImpls = traits.map((trait) => coerce_impl(trait, "&struct:impl-traits"));
+  const baseImpls = xs.impls ?? [];
+  return new CalcitStruct(xs.name, xs.fields, xs.fieldTypes, baseImpls.concat(addedImpls));
 };
 
 export let _$n_enum_$o_impl_traits = function (xs: CalcitValue, ...traits: CalcitValue[]) {
   if (traits.length < 1) throw new Error("&enum:impl-traits takes 2+ arguments");
-  for (let idx = 0; idx < traits.length; idx++) {
-    if (!(traits[idx] instanceof CalcitRecord)) {
-      throw new Error("&enum:impl-traits expects trait impls as records");
-    }
-  }
+  const addedImpls = traits.map((trait) => coerce_impl(trait, "&enum:impl-traits"));
   if (xs instanceof CalcitEnum) {
-    const impls = xs.impls ?? [];
-    return new CalcitEnum(xs.prototype, impls.concat(traits as CalcitRecord[]));
+    return xs.withImpls(addedImpls);
   }
   if (xs instanceof CalcitRecord) {
-    return new CalcitRecord(xs.name, xs.fields, xs.values, xs.impls.concat(traits as CalcitRecord[]));
+    const nextStruct = new CalcitStruct(xs.name, xs.fields, xs.structRef.fieldTypes, xs.structRef.impls.concat(addedImpls));
+    return new CalcitRecord(xs.name, xs.fields, xs.values, nextStruct);
   }
   throw new Error("&enum:impl-traits expected an enum or enum record");
 };
 
+export let _$n_impl_$o_origin = function (impl: CalcitValue): CalcitValue {
+  if (arguments.length !== 1) throw new Error("&impl:origin expected 1 argument");
+  if (impl instanceof CalcitImpl) {
+    return impl.origin ?? null;
+  }
+  throw new Error(`&impl:origin expected an impl, but received: ${toString(impl, true)}`);
+};
+
 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");
@@ -1567,7 +1623,7 @@ export let _$n_js_object = (...xs: CalcitValue[]): Record<string, CalcitValue> =
 };
 
 export let _$o__$o_ = (tagName: CalcitValue, ...extra: CalcitValue[]): CalcitTuple => {
-  return new CalcitTuple(tagName, extra, [], null);
+  return new CalcitTuple(tagName, extra, null);
 };
 
 export let _PCT__$o__$o_ = (enumPrototype: CalcitValue, tag: CalcitValue, ...extra: CalcitValue[]): CalcitTuple => {
@@ -1590,10 +1646,10 @@ export let _PCT__$o__$o_ = (enumPrototype: CalcitValue, tag: CalcitValue, ...ext
   }
 
   const tupleEnumPrototype = enumPrototype instanceof CalcitEnum ? enumPrototype : proto;
-  return new CalcitTuple(tag, extra, [], tupleEnumPrototype);
+  return new CalcitTuple(tag, extra, tupleEnumPrototype);
 };
 
-export let _PCT__PCT__$o__$o_ = (impl: CalcitRecord, enumPrototype: CalcitValue, tag: CalcitValue, ...extra: CalcitValue[]): CalcitTuple => {
+export let _PCT__PCT__$o__$o_ = (impl: CalcitValue, enumPrototype: CalcitValue, tag: CalcitValue, ...extra: CalcitValue[]): CalcitTuple => {
   // Runtime validation: check if tag exists in enum and arity matches
   const proto = assert_enum_tag_args("%%::", enumPrototype, tag as CalcitTag);
   const tagValue = tag as CalcitTag;
@@ -1613,12 +1669,13 @@ export let _PCT__PCT__$o__$o_ = (impl: CalcitRecord, enumPrototype: CalcitValue,
     throw new Error(`Expected variant definition to be a list, got ${variantDefinition}`);
   }
 
-  const tupleEnumPrototype = enumPrototype instanceof CalcitEnum ? enumPrototype : proto;
-  return new CalcitTuple(tag, extra, [impl], tupleEnumPrototype);
+  const tupleEnumPrototype = enumPrototype instanceof CalcitEnum ? enumPrototype : (proto as any);
+  const implValue = coerce_impl(impl, "%:: with impl");
+  return new CalcitTuple(tag, extra, tupleEnumPrototype.withImpls(implValue));
 };
 
 // mutable place for core to register
-type CalcitImplEntry = CalcitRecord | CalcitList | CalcitSliceList | null;
+type CalcitImplEntry = CalcitImpl | CalcitList | CalcitSliceList | null;
 
 let calcit_builtin_impls = {
   number: null as CalcitImplEntry,
@@ -1641,17 +1698,20 @@ export function invoke_method_closure(p: string) {
   };
 }
 
-function normalize_builtin_impls(entry: CalcitImplEntry): CalcitRecord[] | null {
+function normalize_builtin_impls(entry: CalcitImplEntry): CalcitImpl[] | null {
   if (entry == null) return null;
-  if (entry instanceof CalcitRecord) return [entry];
+  if (entry instanceof CalcitImpl) return [entry];
   if (entry instanceof CalcitList || entry instanceof CalcitSliceList) {
-    return list_items(entry) as CalcitRecord[];
+    return list_items(entry).map((item) => {
+      if (item instanceof CalcitImpl) return item;
+      throw new Error(`invoke-method expects impls in list, but received: ${toString(item, true)}`);
+    }) as CalcitImpl[];
   }
   return null;
 }
 
-function lookup_impls(obj: CalcitValue): [CalcitRecord[], string] {
-  let impls: CalcitRecord[];
+function lookup_impls(obj: CalcitValue): [CalcitImpl[], string] {
+  let impls: CalcitImpl[];
   let tag: string;
   if (obj instanceof CalcitList || obj instanceof CalcitSliceList) {
     tag = "&core-list-methods";
@@ -1661,7 +1721,7 @@ function lookup_impls(obj: CalcitValue): [CalcitRecord[], string] {
     impls = normalize_builtin_impls(calcit_builtin_impls.map);
   } else if (obj instanceof CalcitRecord) {
     tag = obj.name.toString();
-    impls = obj.impls;
+    impls = obj.structRef.impls;
   } else if (obj instanceof CalcitTuple) {
     tag = obj.tag.toString();
     impls = obj.impls;
@@ -1755,7 +1815,7 @@ export function _$n_inspect_methods(obj: CalcitValue, note: CalcitValue): Calcit
   console.log("Method call syntax: `.method self p1 p2`");
   console.log("  - dot is part of the method name, first arg is the receiver\n");
 
-  let implsInOrder: CalcitRecord[] = [];
+  let implsInOrder: CalcitImpl[] = [];
   let idx = reverse ? impls.length - 1 : 0;
   while (reverse ? idx >= 0 : idx < impls.length) {
     let impl = impls[idx];
@@ -1763,14 +1823,15 @@ export function _$n_inspect_methods(obj: CalcitValue, note: CalcitValue): Calcit
     idx += reverse ? -1 : 1;
   }
 
-  console.log(`Impl records (high → low precedence): ${implsInOrder.length}`);
+  console.log(`Impls (high → low precedence): ${implsInOrder.length}`);
   for (let i = 0; i < implsInOrder.length; i++) {
     let impl = implsInOrder[i];
     let names: string[] = [];
     for (let k = 0; k < impl.fields.length; k++) {
       names.push("." + impl.fields[k].value);
     }
-    console.log(`  #${i}: ${impl.name.toString()}  (${names.join(" ")})`);
+    const originName = impl.origin != null ? impl.origin.name.toString() : impl.name.toString();
+    console.log(`  #${i}: ${originName}  (${names.join(" ")})`);
   }
 
   let ms = _$n_methods_of(obj);
@@ -1803,7 +1864,7 @@ export function _$n_trait_call(traitDef: CalcitValue, method: CalcitValue, obj:
   let idx = reverse ? impls.length - 1 : 0;
   while (reverse ? idx >= 0 : idx < impls.length) {
     const impl = impls[idx];
-    if (impl != null && impl.name.value === traitDef.name.value) {
+    if (impl != null && impl.origin != null && impl.origin.name.value === traitDef.name.value) {
       const fn = impl.getOrNil(methodName);
       if (fn != null) {
         if (typeof fn !== "function") {
@@ -1815,7 +1876,7 @@ export function _$n_trait_call(traitDef: CalcitValue, method: CalcitValue, obj:
     idx += reverse ? -1 : 1;
   }
   throw new Error(
-    `&trait-call: cannot find impl for trait ${traitDef.name.toString()} on ${toString(obj, true)}. Hint: use defimpl to create impl records tagged by trait.`
+    `&trait-call: cannot find impl for trait ${traitDef.name.toString()} on ${toString(obj, true)}. Hint: use defimpl to create impls tagged by trait.`
   );
 }
 

package/ts-src/custom-formatter.mts

@@ -180,11 +180,11 @@ export let load_console_formatter_$x_ = () => {
             );
           }
           if (obj instanceof CalcitRecord) {
-            if (obj.impls.length > 0) {
+            if (obj.structRef.impls.length > 0) {
               let ret: any[] = div(
                 { color: hsl(280, 80, 60, 0.4), maxWidth: "100%" },
                 span({}, "%{}"),
-                span({ marginLeft: "6px" }, embedObject(obj.impls[0])),
+                span({ marginLeft: "6px" }, embedObject(obj.structRef.impls[0])),
                 span({ marginLeft: "6px" }, embedObject(obj.name)),
                 span({ marginLeft: "6px" }, `...`)
               );

package/ts-src/js-cirru.mts

@@ -9,6 +9,7 @@ import { CalcitSet } from "./js-set.mjs";
 import { CalcitTag, CalcitSymbol, CalcitRecur, newTag } from "./calcit-data.mjs";
 import { CalcitTuple } from "./js-tuple.mjs";
 import { CalcitEnum } from "./js-enum.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
 import { CalcitRef } from "./js-ref.mjs";
 import { deepEqual } from "@calcit/ternary-tree/lib/utils.mjs";
 import { atom } from "./js-ref.mjs";
@@ -182,6 +183,8 @@ export let to_cirru_edn = (x: CalcitValue): CirruEdnFormat => {
         return ["%::", enumTag, x.tag.toString(), ...x.extra.map(to_cirru_edn)];
       } else if (x.tag instanceof CalcitRecord) {
         return ["%::", enumTag, x.tag.name.toString(), ...x.extra.map(to_cirru_edn)];
+      } else if (x.tag instanceof CalcitImpl) {
+        return ["%::", enumTag, x.tag.name.toString(), ...x.extra.map(to_cirru_edn)];
       } else {
         throw new Error(`Unsupported tag for EDN: ${x.tag}`);
       }
@@ -189,6 +192,8 @@ export let to_cirru_edn = (x: CalcitValue): CirruEdnFormat => {
       return ["::", x.tag.toString(), ...x.extra.map(to_cirru_edn)];
     } else if (x.tag instanceof CalcitRecord) {
       return ["::", x.tag.name.toString(), ...x.extra.map(to_cirru_edn)];
+    } else if (x.tag instanceof CalcitImpl) {
+      return ["::", x.tag.name.toString(), ...x.extra.map(to_cirru_edn)];
     } else {
       throw new Error(`Unsupported tag for EDN: ${x.tag}`);
     }
@@ -346,7 +351,7 @@ export let extract_cirru_edn = (x: CirruEdnFormat, options: CalcitValue): Calcit
           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.impls);
+          return new CalcitRecord(extractFieldTag(name), fields, values, v.structRef);
         }
       }
 
@@ -392,8 +397,7 @@ export let extract_cirru_edn = (x: CirruEdnFormat, options: CalcitValue): Calcit
         x
           .slice(2)
           .filter(notComment)
-          .map((x) => extract_cirru_edn(x, options)),
-        []
+          .map((x) => extract_cirru_edn(x, options))
       );
     }
     if (x[0] === "%::") {
@@ -414,7 +418,6 @@ export let extract_cirru_edn = (x: CirruEdnFormat, options: CalcitValue): Calcit
           .slice(3)
           .filter(notComment)
           .map((x) => extract_cirru_edn(x, options)),
-        [],
         enumPrototype
       );
     }