@calcit/procs 0.11.0-a8 → 0.11.0-a9

package/lib/calcit-data.mjs

@@ -3,6 +3,7 @@ import { overwriteComparator } from "@calcit/ternary-tree";
 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";
@@ -66,6 +67,9 @@ export let isNestedCalcitData = (x) => {
     if (x instanceof CalcitRecord) {
         return x.fields.length > 0;
     }
+    if (x instanceof CalcitImpl) {
+        return x.fields.length > 0;
+    }
     if (x instanceof CalcitSet) {
         return false;
     }
@@ -81,6 +85,9 @@ export let tipNestedCalcitData = (x) => {
     if (x instanceof CalcitRecord) {
         return "'%{}...";
     }
+    if (x instanceof CalcitImpl) {
+        return "'%impl...";
+    }
     if (x instanceof CalcitSet) {
         return "'#{}...";
     }
@@ -156,6 +163,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:");
@@ -280,6 +288,16 @@ export let hashFunction = (x) => {
         x.cachedHash = base;
         return base;
     }
+    if (x instanceof CalcitImpl) {
+        let base = defaultHash_impl;
+        base = mergeValueHash(base, hashFunction(x.name));
+        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));
@@ -376,6 +394,9 @@ export let toString = (x, escaped, disableJsDataWarning = false) => {
     if (x instanceof CalcitRecord) {
         return x.toString(disableJsDataWarning);
     }
+    if (x instanceof CalcitImpl) {
+        return x.toString(disableJsDataWarning);
+    }
     if (x instanceof CalcitStruct) {
         return x.toString(disableJsDataWarning);
     }
@@ -644,6 +665,26 @@ export let _$n__$e_ = (x, y) => {
         }
         return false;
     }
+    if (x instanceof CalcitImpl) {
+        if (y instanceof CalcitImpl) {
+            if (x.name !== y.name) {
+                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/lib/calcit.procs.mjs

@@ -6,11 +6,13 @@ import { writeCirruCode } from "@cirru/writer.ts";
 import { CalcitSymbol, CalcitTag, CalcitRecur, castTag, newTag, refsRegistry, toString, getStringName, _$n__$e_, hashFunction, } from "./calcit-data.mjs";
 import { CalcitRef } from "./js-ref.mjs";
 import { 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";
@@ -62,6 +64,9 @@ export let type_of = (x) => {
     if (x instanceof CalcitRecord) {
         return newTag("record");
     }
+    if (x instanceof CalcitImpl) {
+        return newTag("impl");
+    }
     if (x instanceof CalcitStruct) {
         return newTag("struct");
     }
@@ -195,6 +200,45 @@ export let defenum = (name, ...variants) => {
     const prototype = new CalcitRecord(enumName, tags, values, null);
     return new CalcitEnum(prototype, null);
 };
+export let _$n_impl_$o__$o_new = (name, ...pairs) => {
+    if (name === undefined)
+        throw new Error("&impl::new expected arguments");
+    const implName = castTag(name);
+    if (pairs.length === 0) {
+        return new CalcitImpl(implName, [], []);
+    }
+    const entries = [];
+    for (let idx = 0; idx < pairs.length; idx++) {
+        const pairValue = pairs[idx];
+        let fieldTag;
+        let value;
+        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);
+};
 export let _$n_struct_$o__$o_new = (name, ...entries) => {
     return defstruct(name, ...entries);
 };
@@ -385,6 +429,12 @@ export let _$n_tuple_$o_count = function (xs) {
         return xs.count();
     throw new Error("Does not support `count` on this type");
 };
+const coerce_impl = (value, procName) => {
+    if (value instanceof CalcitImpl) {
+        return value;
+    }
+    throw new Error(`${procName} expects trait impls as impls`);
+};
 export let _$n_tuple_$o_impls = function (x) {
     if (arguments.length !== 1)
         throw new Error("&tuple:impls takes 1 argument");
@@ -400,21 +450,16 @@ export let _$n_tuple_$o_with_impls = function (x, y) {
         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");
+    return new CalcitTuple(x.tag, x.extra, [impl], x.enumPrototype);
 };
 export let _$n_tuple_$o_impl_traits = function (x, ...traits) {
     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");
-        }
-    }
-    return new CalcitTuple(x.tag, x.extra, x.impls.concat(traits), x.enumPrototype);
+    const impls = traits.map((trait) => coerce_impl(trait, "&tuple:impl-traits"));
+    return new CalcitTuple(x.tag, x.extra, x.impls.concat(impls), x.enumPrototype);
 };
 export let _$n_tuple_$o_enum = function (x) {
     if (arguments.length !== 1)
@@ -547,40 +592,28 @@ export let _$n_record_$o_impl_traits = function (xs, ...traits) {
         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));
+    const impls = traits.map((trait) => coerce_impl(trait, "&record:impl-traits"));
+    return new CalcitRecord(xs.name, xs.fields, xs.values, xs.impls.concat(impls));
 };
 export let _$n_struct_$o_impl_traits = function (xs, ...traits) {
     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));
+    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, ...traits) {
     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));
+        const baseImpls = xs.impls ?? [];
+        return new CalcitEnum(xs.prototype, baseImpls.concat(addedImpls));
     }
     if (xs instanceof CalcitRecord) {
-        return new CalcitRecord(xs.name, xs.fields, xs.values, xs.impls.concat(traits));
+        return new CalcitRecord(xs.name, xs.fields, xs.values, xs.impls.concat(addedImpls));
     }
     throw new Error("&enum:impl-traits expected an enum or enum record");
 };
@@ -1493,7 +1526,8 @@ export let _PCT__PCT__$o__$o_ = (impl, enumPrototype, tag, ...extra) => {
         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 implValue = coerce_impl(impl, "%:: with impl");
+    return new CalcitTuple(tag, extra, [implValue], tupleEnumPrototype);
 };
 let calcit_builtin_impls = {
     number: null,
@@ -1516,10 +1550,14 @@ export function invoke_method_closure(p) {
 function normalize_builtin_impls(entry) {
     if (entry == null)
         return null;
-    if (entry instanceof CalcitRecord)
+    if (entry instanceof CalcitImpl)
         return [entry];
     if (entry instanceof CalcitList || entry instanceof CalcitSliceList) {
-        return list_items(entry);
+        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)}`);
+        });
     }
     return null;
 }
@@ -1641,7 +1679,7 @@ export function _$n_inspect_methods(obj, note) {
             implsInOrder.push(impl);
         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 = [];
@@ -1689,7 +1727,7 @@ export function _$n_trait_call(traitDef, method, obj, ...args) {
         }
         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.`);
+    throw new Error(`&trait-call: cannot find impl for trait ${traitDef.name.toString()} on ${toString(obj, true)}. Hint: use defimpl to create impls tagged by trait.`);
 }
 export let _$n_map_$o_to_list = (m) => {
     if (m instanceof CalcitMap || m instanceof CalcitSliceMap) {

package/lib/js-cirru.mjs

@@ -7,6 +7,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,9 @@ export let to_cirru_edn = (x) => {
             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}`);
             }
@@ -192,6 +196,9 @@ export let to_cirru_edn = (x) => {
         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}`);
         }

package/lib/js-enum.mjs

@@ -1,4 +1,4 @@
-import { CalcitRecord } from "./js-record.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
 export class CalcitEnum {
     constructor(prototype, impls = []) {
         this.prototype = prototype;
@@ -9,13 +9,13 @@ export class CalcitEnum {
         return this.prototype.name.value;
     }
     withImpls(impls) {
-        if (impls instanceof CalcitRecord) {
+        if (impls instanceof CalcitImpl) {
             return new CalcitEnum(this.prototype, [impls]);
         }
         else if (Array.isArray(impls)) {
             return new CalcitEnum(this.prototype, impls);
         }
-        throw new Error("Expected a record as implementation");
+        throw new Error("Expected an impl as implementation");
     }
     toString() {
         return `(%enum :${this.prototype.name.value})`;

package/lib/js-impl.mjs

@@ -0,0 +1,33 @@
+import { castTag, findInFields, toString } from "./calcit-data.mjs";
+export class CalcitImpl {
+    constructor(name, fields, values) {
+        this.name = name;
+        this.fields = fields;
+        this.values = values;
+        this.cachedHash = null;
+    }
+    get(k) {
+        let field = castTag(k);
+        let idx = findInFields(this.fields, field);
+        if (idx >= 0) {
+            return this.values[idx];
+        }
+        throw new Error(`Cannot find :${field} among (${this.fields.join(",")})`);
+    }
+    getOrNil(k) {
+        let field = castTag(k);
+        let idx = findInFields(this.fields, field);
+        if (idx >= 0) {
+            return this.values[idx];
+        }
+        return undefined;
+    }
+    toString(disableJsDataWarning = false) {
+        const parts = ["(%impl ", this.name.toString()];
+        for (let idx = 0; idx < this.fields.length; idx++) {
+            parts.push(" (", this.fields[idx].toString(), " ", toString(this.values[idx], true, disableJsDataWarning), ")");
+        }
+        parts.push(")");
+        return parts.join("");
+    }
+}

package/lib/js-primes.mjs

@@ -2,6 +2,7 @@ import { CalcitTag, CalcitSymbol, CalcitRecur } from "./calcit-data.mjs";
 import { CalcitRef } from "./js-ref.mjs";
 import { CalcitList, CalcitSliceList } from "./js-list.mjs";
 import { CalcitRecord } 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";
@@ -38,10 +39,11 @@ var PseudoTypeIndex;
     PseudoTypeIndex[PseudoTypeIndex["set"] = 10] = "set";
     PseudoTypeIndex[PseudoTypeIndex["map"] = 11] = "map";
     PseudoTypeIndex[PseudoTypeIndex["record"] = 12] = "record";
-    PseudoTypeIndex[PseudoTypeIndex["struct"] = 13] = "struct";
-    PseudoTypeIndex[PseudoTypeIndex["enum_type"] = 14] = "enum_type";
-    PseudoTypeIndex[PseudoTypeIndex["fn"] = 15] = "fn";
-    PseudoTypeIndex[PseudoTypeIndex["cirru_quote"] = 16] = "cirru_quote";
+    PseudoTypeIndex[PseudoTypeIndex["impl"] = 13] = "impl";
+    PseudoTypeIndex[PseudoTypeIndex["struct"] = 14] = "struct";
+    PseudoTypeIndex[PseudoTypeIndex["enum_type"] = 15] = "enum_type";
+    PseudoTypeIndex[PseudoTypeIndex["fn"] = 16] = "fn";
+    PseudoTypeIndex[PseudoTypeIndex["cirru_quote"] = 17] = "cirru_quote";
 })(PseudoTypeIndex || (PseudoTypeIndex = {}));
 let typeAsInt = (x) => {
     // based on order used in Ord trait
@@ -72,6 +74,8 @@ let typeAsInt = (x) => {
         return PseudoTypeIndex.map;
     if (x instanceof CalcitRecord)
         return PseudoTypeIndex.record;
+    if (x instanceof CalcitImpl)
+        return PseudoTypeIndex.impl;
     if (x instanceof CalcitStruct)
         return PseudoTypeIndex.struct;
     if (x instanceof CalcitEnum)

package/lib/js-record.mjs

@@ -1,3 +1,4 @@
+import { CalcitImpl } from "./js-impl.mjs";
 import { castTag, toString, findInFields } from "./calcit-data.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 export class CalcitRecord {
@@ -70,11 +71,11 @@ export class CalcitRecord {
         return parts.join("");
     }
     withImpls(impl) {
-        if (impl instanceof CalcitRecord) {
+        if (impl instanceof CalcitImpl) {
             return new CalcitRecord(this.name, this.fields, this.values, [impl]);
         }
         else {
-            throw new Error("Expected a record");
+            throw new Error("Expected an impl");
         }
     }
 }

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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.11.0-a8",
+    "version": "0.11.0-a9",
     "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-a9",
   "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,16 @@ 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));
+    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 +423,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 +703,26 @@ 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 (!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");
   }
@@ -228,6 +233,44 @@ export let defenum = (name: CalcitValue, ...variants: CalcitValue[]): CalcitEnum
   return new CalcitEnum(prototype, null);
 };
 
+export let _$n_impl_$o__$o_new = (name: CalcitValue, ...pairs: CalcitValue[]): CalcitImpl => {
+  if (name === undefined) throw new Error("&impl::new expected arguments");
+  const implName = castTag(name);
+  if (pairs.length === 0) {
+    return new CalcitImpl(implName, [], []);
+  }
+  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);
+};
+
 export let _$n_struct_$o__$o_new = (name: CalcitValue, ...entries: CalcitValue[]): CalcitStruct => {
   return defstruct(name, ...entries);
 };
@@ -444,6 +487,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 +504,18 @@ 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");
+  return new CalcitTuple(x.tag, x.extra, [impl], x.enumPrototype);
 };
 
 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");
-    }
-  }
-  return new CalcitTuple(x.tag, x.extra, x.impls.concat(traits as CalcitRecord[]), x.enumPrototype);
+  const impls = traits.map((trait) => coerce_impl(trait, "&tuple:impl-traits"));
+  return new CalcitTuple(x.tag, x.extra, x.impls.concat(impls), x.enumPrototype);
 };
 
 export let _$n_tuple_$o_enum = function (x: CalcitTuple) {
@@ -610,39 +656,27 @@ export let _$n_record_$o_impls = function (xs: CalcitValue) {
 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"));
+  return new CalcitRecord(xs.name, xs.fields, xs.values, xs.impls.concat(impls));
 };
 
 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[]));
+    const baseImpls = xs.impls ?? [];
+    return new CalcitEnum(xs.prototype, baseImpls.concat(addedImpls));
   }
   if (xs instanceof CalcitRecord) {
-    return new CalcitRecord(xs.name, xs.fields, xs.values, xs.impls.concat(traits as CalcitRecord[]));
+    return new CalcitRecord(xs.name, xs.fields, xs.values, xs.impls.concat(addedImpls));
   }
   throw new Error("&enum:impl-traits expected an enum or enum record");
 };
@@ -1593,7 +1627,7 @@ export let _PCT__$o__$o_ = (enumPrototype: CalcitValue, tag: CalcitValue, ...ext
   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;
@@ -1614,11 +1648,12 @@ export let _PCT__PCT__$o__$o_ = (impl: CalcitRecord, enumPrototype: CalcitValue,
   }
 
   const tupleEnumPrototype = enumPrototype instanceof CalcitEnum ? enumPrototype : proto;
-  return new CalcitTuple(tag, extra, [impl], tupleEnumPrototype);
+  const implValue = coerce_impl(impl, "%:: with impl");
+  return new CalcitTuple(tag, extra, [implValue], tupleEnumPrototype);
 };
 
 // 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 +1676,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";
@@ -1755,7 +1793,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,7 +1801,7 @@ 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[] = [];
@@ -1815,7 +1853,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/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}`);
     }

package/ts-src/js-enum.mts

@@ -1,11 +1,12 @@
 import { CalcitRecord } from "./js-record.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
 
 export class CalcitEnum {
   prototype: CalcitRecord;
-  impls: CalcitRecord[];
+  impls: CalcitImpl[];
   cachedHash: number;
 
-  constructor(prototype: CalcitRecord, impls: CalcitRecord[] = []) {
+  constructor(prototype: CalcitRecord, impls: CalcitImpl[] = []) {
     this.prototype = prototype;
     this.impls = impls;
     this.cachedHash = null;
@@ -15,13 +16,13 @@ export class CalcitEnum {
     return this.prototype.name.value;
   }
 
-  withImpls(impls: CalcitRecord | CalcitRecord[]): CalcitEnum {
-    if (impls instanceof CalcitRecord) {
+  withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitEnum {
+    if (impls instanceof CalcitImpl) {
       return new CalcitEnum(this.prototype, [impls]);
     } else if (Array.isArray(impls)) {
       return new CalcitEnum(this.prototype, impls);
     }
-    throw new Error("Expected a record as implementation");
+    throw new Error("Expected an impl as implementation");
   }
 
   toString(): string {

package/ts-src/js-impl.mts

@@ -0,0 +1,44 @@
+import { Hash } from "@calcit/ternary-tree";
+import { CalcitValue } from "./js-primes.mjs";
+import { CalcitTag, castTag, findInFields, toString } from "./calcit-data.mjs";
+
+export class CalcitImpl {
+  name: CalcitTag;
+  fields: Array<CalcitTag>;
+  values: Array<CalcitValue>;
+  cachedHash: Hash;
+
+  constructor(name: CalcitTag, fields: Array<CalcitTag>, values: Array<CalcitValue>) {
+    this.name = name;
+    this.fields = fields;
+    this.values = values;
+    this.cachedHash = null;
+  }
+
+  get(k: CalcitValue) {
+    let field = castTag(k);
+    let idx = findInFields(this.fields, field);
+    if (idx >= 0) {
+      return this.values[idx];
+    }
+    throw new Error(`Cannot find :${field} among (${this.fields.join(",")})`);
+  }
+
+  getOrNil(k: CalcitValue) {
+    let field = castTag(k);
+    let idx = findInFields(this.fields, field);
+    if (idx >= 0) {
+      return this.values[idx];
+    }
+    return undefined;
+  }
+
+  toString(disableJsDataWarning: boolean = false): string {
+    const parts = ["(%impl ", this.name.toString()];
+    for (let idx = 0; idx < this.fields.length; idx++) {
+      parts.push(" (", this.fields[idx].toString(), " ", toString(this.values[idx], true, disableJsDataWarning), ")");
+    }
+    parts.push(")");
+    return parts.join("");
+  }
+}

package/ts-src/js-primes.mts

@@ -2,6 +2,7 @@ import { CalcitTag, CalcitSymbol, CalcitFn, CalcitRecur } from "./calcit-data.mj
 import { CalcitRef } from "./js-ref.mjs";
 import { CalcitList, CalcitSliceList } from "./js-list.mjs";
 import { CalcitRecord } 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";
@@ -25,6 +26,7 @@ export type CalcitValue =
   | CalcitFn
   | CalcitRecur // should not be exposed to function
   | CalcitRecord
+  | CalcitImpl
   | CalcitStruct
   | CalcitEnum
   | CalcitCirruQuote
@@ -54,6 +56,7 @@ enum PseudoTypeIndex {
   set,
   map,
   record,
+  impl,
   struct,
   enum_type,
   fn,
@@ -76,6 +79,7 @@ let typeAsInt = (x: CalcitValue): number => {
   if (x instanceof CalcitSet) return PseudoTypeIndex.set;
   if (x instanceof CalcitMap || x instanceof CalcitSliceMap) return PseudoTypeIndex.map;
   if (x instanceof CalcitRecord) return PseudoTypeIndex.record;
+  if (x instanceof CalcitImpl) return PseudoTypeIndex.impl;
   if (x instanceof CalcitStruct) return PseudoTypeIndex.struct;
   if (x instanceof CalcitEnum) return PseudoTypeIndex.enum_type;
   if (x instanceof CalcitCirruQuote) return PseudoTypeIndex.cirru_quote;

package/ts-src/js-record.mts

@@ -1,5 +1,6 @@
 import { initTernaryTreeMap, Hash, insert } from "@calcit/ternary-tree";
 import { CalcitValue } from "./js-primes.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
 import { newTag, castTag, toString, CalcitTag, getStringName, findInFields } from "./calcit-data.mjs";
 
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
@@ -8,9 +9,9 @@ export class CalcitRecord {
   name: CalcitTag;
   fields: Array<CalcitTag>;
   values: Array<CalcitValue>;
-  impls: Array<CalcitRecord>;
+  impls: Array<CalcitImpl>;
   cachedHash: Hash;
-  constructor(name: CalcitTag, fields: Array<CalcitTag>, values?: Array<CalcitValue>, impls?: Array<CalcitRecord>) {
+  constructor(name: CalcitTag, fields: Array<CalcitTag>, values?: Array<CalcitValue>, impls?: Array<CalcitImpl>) {
     this.name = name;
     let fieldNames = fields.map(castTag);
     this.fields = fields;
@@ -75,10 +76,10 @@ export class CalcitRecord {
     return parts.join("");
   }
   withImpls(impl: CalcitValue): CalcitRecord {
-    if (impl instanceof CalcitRecord) {
+    if (impl instanceof CalcitImpl) {
       return new CalcitRecord(this.name, this.fields, this.values, [impl]);
     } else {
-      throw new Error("Expected a record");
+      throw new Error("Expected an impl");
     }
   }
 }
@@ -96,7 +97,7 @@ export let new_record = (name: CalcitValue, ...fields: Array<CalcitValue>): Calc
   return new CalcitRecord(castTag(name), fieldNames);
 };
 
-export let new_impl_record = (impl: CalcitRecord, name: CalcitValue, ...fields: Array<CalcitValue>): CalcitValue => {
+export let new_impl_record = (impl: CalcitImpl, name: CalcitValue, ...fields: Array<CalcitValue>): CalcitValue => {
   let fieldNames = fields.map(castTag).sort((x, y) => {
     if (x.idx < y.idx) {
       return -1;

package/ts-src/js-struct.mts

@@ -1,15 +1,15 @@
 import { CalcitTag, toString } from "./calcit-data.mjs";
 import { CalcitValue } from "./js-primes.mjs";
-import { CalcitRecord } from "./js-record.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
 
 export class CalcitStruct {
   name: CalcitTag;
   fields: CalcitTag[];
   fieldTypes: CalcitValue[];
-  impls: CalcitRecord[];
+  impls: CalcitImpl[];
   cachedHash: number;
 
-  constructor(name: CalcitTag, fields: CalcitTag[], fieldTypes: CalcitValue[], impls: CalcitRecord[] = []) {
+  constructor(name: CalcitTag, fields: CalcitTag[], fieldTypes: CalcitValue[], impls: CalcitImpl[] = []) {
     if (fields.length !== fieldTypes.length) {
       throw new Error("CalcitStruct: fields and fieldTypes length mismatch");
     }
@@ -20,13 +20,13 @@ export class CalcitStruct {
     this.cachedHash = null;
   }
 
-  withImpls(impls: CalcitRecord | CalcitRecord[]): CalcitStruct {
-    if (impls instanceof CalcitRecord) {
+  withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitStruct {
+    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: boolean = false): string {

package/ts-src/js-tuple.mts

@@ -2,16 +2,17 @@ import { Hash } from "@calcit/ternary-tree";
 
 import { CalcitValue } from "./js-primes.mjs";
 import { _$n__$e_, newTag, toString } from "./calcit-data.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
 import { CalcitRecord } from "./js-record.mjs";
 import { CalcitEnum } from "./js-enum.mjs";
 
 export class CalcitTuple {
   tag: CalcitValue;
   extra: CalcitValue[];
-  impls: CalcitRecord[];
+  impls: CalcitImpl[];
   enumPrototype: CalcitRecord | CalcitEnum;
   cachedHash: Hash;
-  constructor(tagName: CalcitValue, extra: CalcitValue[], impls: CalcitRecord[] = [], enumPrototype: CalcitRecord | CalcitEnum = null) {
+  constructor(tagName: CalcitValue, extra: CalcitValue[], impls: CalcitImpl[] = [], enumPrototype: CalcitRecord | CalcitEnum = null) {
     this.tag = tagName;
     this.extra = extra;
     this.impls = impls;