@calcit/procs 0.11.0-a9 → 0.11.0

package/build.rs

@@ -0,0 +1,74 @@
+use cirru_edn::{Edn, from_edn};
+use cirru_parser::Cirru;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::env;
+use std::fs;
+use std::path::Path;
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SnapshotConfigs {
+  #[serde(rename = "init-fn")]
+  pub init_fn: String,
+  #[serde(rename = "reload-fn")]
+  pub reload_fn: String,
+  #[serde(default)]
+  pub modules: Vec<String>,
+  #[serde(default)]
+  pub version: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CodeEntry {
+  pub doc: String,
+  #[serde(default)]
+  pub examples: Vec<Cirru>,
+  pub code: Cirru,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct FileInSnapShot {
+  pub ns: CodeEntry,
+  pub defs: HashMap<String, CodeEntry>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Snapshot {
+  pub package: String,
+  pub about: Option<String>,
+  pub configs: SnapshotConfigs,
+  pub entries: HashMap<String, SnapshotConfigs>,
+  pub files: HashMap<String, FileInSnapShot>,
+}
+
+fn main() {
+  println!("cargo:rerun-if-changed=src/cirru/calcit-core.cirru");
+
+  let out_dir = env::var_os("OUT_DIR").unwrap();
+  let dest_path = Path::new(&out_dir).join("calcit-core.rmp");
+
+  let core_content = fs::read_to_string("src/cirru/calcit-core.cirru").expect("read core");
+  let core_data = cirru_edn::parse(&core_content).expect("parse core");
+
+  // Minimal logic to convert Edn to Snapshot as in src/snapshot.rs
+  let data = core_data.view_map().expect("map");
+  let pkg: String = from_edn(data.get_or_nil("package")).expect("pkg");
+  let about = match data.get_or_nil("about") {
+    Edn::Nil => None,
+    value => Some(from_edn::<String>(value).expect("about")),
+  };
+
+  let files: HashMap<String, FileInSnapShot> = from_edn(data.get_or_nil("files")).expect("files");
+
+  let snapshot = Snapshot {
+    package: pkg,
+    about,
+    configs: from_edn(data.get_or_nil("configs")).expect("configs"),
+    entries: from_edn(data.get_or_nil("entries")).expect("entries"),
+    files,
+  };
+
+  let mut buf = Vec::new();
+  snapshot.serialize(&mut rmp_serde::Serializer::new(&mut buf)).expect("serialize");
+  fs::write(dest_path, buf).expect("write");
+}

package/lib/calcit-data.mjs

@@ -291,6 +291,9 @@ export let hashFunction = (x) => {
     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]));
@@ -670,6 +673,12 @@ export let _$n__$e_ = (x, y) => {
             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;
             }

package/lib/calcit.procs.mjs

@@ -198,14 +198,15 @@ export let defenum = (name, ...variants) => {
     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, ...pairs) => {
     if (name === undefined)
         throw new Error("&impl::new expected arguments");
-    const implName = castTag(name);
+    const origin = name instanceof CalcitTrait ? name : null;
+    const implName = origin ? origin.name : castTag(name);
     if (pairs.length === 0) {
-        return new CalcitImpl(implName, [], []);
+        return new CalcitImpl(implName, [], [], origin);
     }
     const entries = [];
     for (let idx = 0; idx < pairs.length; idx++) {
@@ -237,7 +238,7 @@ export let _$n_impl_$o__$o_new = (name, ...pairs) => {
     }
     const fields = entries.map((entry) => entry.tag);
     const values = entries.map((entry) => entry.value);
-    return new CalcitImpl(implName, fields, values);
+    return new CalcitImpl(implName, fields, values, origin);
 };
 export let _$n_struct_$o__$o_new = (name, ...entries) => {
     return defstruct(name, ...entries);
@@ -451,7 +452,11 @@ export let _$n_tuple_$o_with_impls = function (x, y) {
     if (!(x instanceof CalcitTuple))
         throw new Error("&tuple:with-impls expects a tuple");
     const impl = coerce_impl(y, "&tuple:with-impls");
-    return new CalcitTuple(x.tag, x.extra, [impl], x.enumPrototype);
+    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, ...traits) {
     if (traits.length < 1)
@@ -459,7 +464,13 @@ export let _$n_tuple_$o_impl_traits = function (x, ...traits) {
     if (!(x instanceof CalcitTuple))
         throw new Error("&tuple:impl-traits expects a tuple");
     const impls = traits.map((trait) => coerce_impl(trait, "&tuple:impl-traits"));
-    return new CalcitTuple(x.tag, x.extra, x.impls.concat(impls), x.enumPrototype);
+    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, proto.withImpls(impls));
 };
 export let _$n_tuple_$o_enum = function (x) {
     if (arguments.length !== 1)
@@ -472,7 +483,7 @@ export let _$n_tuple_$o_enum = function (x) {
     if (x.enumPrototype instanceof CalcitEnum) {
         return x.enumPrototype;
     }
-    return new CalcitEnum(x.enumPrototype, null);
+    return new CalcitEnum(x.enumPrototype);
 };
 const unwrap_enum_prototype = (enumPrototype, procName) => {
     if (enumPrototype instanceof CalcitEnum) {
@@ -584,7 +595,7 @@ export let _$n_record_$o_impls = function (xs) {
     if (arguments.length !== 1)
         throw new Error("&record:impls takes 1 argument");
     if (xs instanceof CalcitRecord)
-        return new CalcitSliceList(xs.impls);
+        return new CalcitSliceList(xs.structRef.impls);
     throw new Error("&record:impls expected a record");
 };
 export let _$n_record_$o_impl_traits = function (xs, ...traits) {
@@ -593,7 +604,8 @@ export let _$n_record_$o_impl_traits = function (xs, ...traits) {
     if (!(xs instanceof CalcitRecord))
         throw new Error("&record:impl-traits expected a record");
     const impls = traits.map((trait) => coerce_impl(trait, "&record:impl-traits"));
-    return new CalcitRecord(xs.name, xs.fields, xs.values, xs.impls.concat(impls));
+    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, ...traits) {
     if (traits.length < 1)
@@ -609,14 +621,22 @@ export let _$n_enum_$o_impl_traits = function (xs, ...traits) {
         throw new Error("&enum:impl-traits takes 2+ arguments");
     const addedImpls = traits.map((trait) => coerce_impl(trait, "&enum:impl-traits"));
     if (xs instanceof CalcitEnum) {
-        const baseImpls = xs.impls ?? [];
-        return new CalcitEnum(xs.prototype, baseImpls.concat(addedImpls));
+        return xs.withImpls(addedImpls);
     }
     if (xs instanceof CalcitRecord) {
-        return new CalcitRecord(xs.name, xs.fields, xs.values, xs.impls.concat(addedImpls));
+        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) {
+    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, k, v) {
     if (arguments.length !== 3) {
         throw new Error("assoc takes 3 arguments");
@@ -1485,7 +1505,7 @@ export let _$n_js_object = (...xs) => {
     return ret;
 };
 export let _$o__$o_ = (tagName, ...extra) => {
-    return new CalcitTuple(tagName, extra, [], null);
+    return new CalcitTuple(tagName, extra, null);
 };
 export let _PCT__$o__$o_ = (enumPrototype, tag, ...extra) => {
     const proto = assert_enum_tag_args("%::", enumPrototype, tag);
@@ -1505,7 +1525,7 @@ export let _PCT__$o__$o_ = (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, [], tupleEnumPrototype);
+    return new CalcitTuple(tag, extra, tupleEnumPrototype);
 };
 export let _PCT__PCT__$o__$o_ = (impl, enumPrototype, tag, ...extra) => {
     // Runtime validation: check if tag exists in enum and arity matches
@@ -1527,7 +1547,7 @@ export let _PCT__PCT__$o__$o_ = (impl, enumPrototype, tag, ...extra) => {
     }
     const tupleEnumPrototype = enumPrototype instanceof CalcitEnum ? enumPrototype : proto;
     const implValue = coerce_impl(impl, "%:: with impl");
-    return new CalcitTuple(tag, extra, [implValue], tupleEnumPrototype);
+    return new CalcitTuple(tag, extra, tupleEnumPrototype.withImpls(implValue));
 };
 let calcit_builtin_impls = {
     number: null,
@@ -1574,7 +1594,7 @@ function lookup_impls(obj) {
     }
     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();
@@ -1686,7 +1706,8 @@ export function _$n_inspect_methods(obj, note) {
         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);
     console.log(`\nAll methods (unique, high → low): ${ms.len()}`);
@@ -1716,7 +1737,7 @@ export function _$n_trait_call(traitDef, method, obj, ...args) {
     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") {

package/lib/custom-formatter.mjs

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

package/lib/js-cirru.mjs

@@ -360,7 +360,7 @@ export let extract_cirru_edn = (x, options) => {
                     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);
                 }
             }
             return new CalcitRecord(extractFieldTag(name), fields, values);
@@ -399,7 +399,7 @@ export let extract_cirru_edn = (x, options) => {
             return new CalcitTuple(extract_cirru_edn(x[1], options), x
                 .slice(2)
                 .filter(notComment)
-                .map((x) => extract_cirru_edn(x, options)), []);
+                .map((x) => extract_cirru_edn(x, options)));
         }
         if (x[0] === "%::") {
             if (x.length < 3) {
@@ -416,7 +416,7 @@ export let extract_cirru_edn = (x, options) => {
             return new CalcitTuple(extract_cirru_edn(x[2], options), x
                 .slice(3)
                 .filter(notComment)
-                .map((x) => extract_cirru_edn(x, options)), [], enumPrototype);
+                .map((x) => extract_cirru_edn(x, options)), enumPrototype);
         }
         if (x[0] === "atom") {
             if (x.length !== 2) {

package/lib/js-enum.mjs

@@ -1,21 +1,27 @@
 import { CalcitImpl } from "./js-impl.mjs";
 export class CalcitEnum {
-    constructor(prototype, impls = []) {
+    constructor(prototype) {
         this.prototype = prototype;
-        this.impls = impls;
         this.cachedHash = null;
     }
     name() {
         return this.prototype.name.value;
     }
+    get impls() {
+        return this.prototype.structRef.impls;
+    }
     withImpls(impls) {
+        let nextImpls;
         if (impls instanceof CalcitImpl) {
-            return new CalcitEnum(this.prototype, [impls]);
+            nextImpls = [impls];
         }
         else if (Array.isArray(impls)) {
-            return new CalcitEnum(this.prototype, impls);
+            nextImpls = impls;
+        }
+        else {
+            throw new Error("Expected an impl as implementation");
         }
-        throw new Error("Expected an impl as implementation");
+        return new CalcitEnum(this.prototype.withImpls(nextImpls));
     }
     toString() {
         return `(%enum :${this.prototype.name.value})`;

package/lib/js-impl.mjs

@@ -1,7 +1,8 @@
 import { castTag, findInFields, toString } from "./calcit-data.mjs";
 export class CalcitImpl {
-    constructor(name, fields, values) {
+    constructor(name, fields, values, origin = null) {
         this.name = name;
+        this.origin = origin;
         this.fields = fields;
         this.values = values;
         this.cachedHash = null;

package/lib/js-record.mjs

@@ -1,8 +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;
@@ -16,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);
@@ -49,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) {
@@ -71,12 +72,18 @@ export class CalcitRecord {
         return parts.join("");
     }
     withImpls(impl) {
+        let nextImpls;
         if (impl instanceof CalcitImpl) {
-            return new CalcitRecord(this.name, this.fields, this.values, [impl]);
+            nextImpls = [impl];
+        }
+        else if (Array.isArray(impl)) {
+            nextImpls = impl;
         }
         else {
-            throw new Error("Expected an impl");
+            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) => {
@@ -105,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) {
@@ -147,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");
@@ -169,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-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-a9",
+    "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-a9",
+  "version": "0.11.0",
   "main": "./lib/calcit.procs.mjs",
   "devDependencies": {
     "@types/node": "^25.0.9",

package/ts-src/calcit-data.mts

@@ -320,6 +320,9 @@ export let hashFunction = (x: CalcitValue): Hash => {
   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]));
@@ -708,6 +711,12 @@ export let _$n__$e_ = (x: CalcitValue, y: CalcitValue): boolean => {
       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;
       }

package/ts-src/calcit.procs.mts

@@ -230,14 +230,15 @@ 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 implName = castTag(name);
+  const origin = name instanceof CalcitTrait ? name : null;
+  const implName = origin ? origin.name : castTag(name);
   if (pairs.length === 0) {
-    return new CalcitImpl(implName, [], []);
+    return new CalcitImpl(implName, [], [], origin);
   }
   const entries: Array<{ tag: CalcitTag; value: CalcitValue }> = [];
   for (let idx = 0; idx < pairs.length; idx++) {
@@ -268,7 +269,7 @@ export let _$n_impl_$o__$o_new = (name: CalcitValue, ...pairs: CalcitValue[]): C
   }
   const fields = entries.map((entry) => entry.tag);
   const values = entries.map((entry) => entry.value);
-  return new CalcitImpl(implName, fields, values);
+  return new CalcitImpl(implName, fields, values, origin);
 };
 
 export let _$n_struct_$o__$o_new = (name: CalcitValue, ...entries: CalcitValue[]): CalcitStruct => {
@@ -508,14 +509,26 @@ 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");
   const impl = coerce_impl(y, "&tuple:with-impls");
-  return new CalcitTuple(x.tag, x.extra, [impl], x.enumPrototype);
+  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");
   const impls = traits.map((trait) => coerce_impl(trait, "&tuple:impl-traits"));
-  return new CalcitTuple(x.tag, x.extra, x.impls.concat(impls), x.enumPrototype);
+  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, proto.withImpls(impls));
 };
 
 export let _$n_tuple_$o_enum = function (x: CalcitTuple) {
@@ -527,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 => {
@@ -649,7 +662,7 @@ 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");
 };
 
@@ -657,7 +670,8 @@ export let _$n_record_$o_impl_traits = function (xs: CalcitValue, ...traits: Cal
   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");
   const impls = traits.map((trait) => coerce_impl(trait, "&record:impl-traits"));
-  return new CalcitRecord(xs.name, xs.fields, xs.values, xs.impls.concat(impls));
+  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[]) {
@@ -672,15 +686,23 @@ export let _$n_enum_$o_impl_traits = function (xs: CalcitValue, ...traits: Calci
   if (traits.length < 1) throw new Error("&enum:impl-traits takes 2+ arguments");
   const addedImpls = traits.map((trait) => coerce_impl(trait, "&enum:impl-traits"));
   if (xs instanceof CalcitEnum) {
-    const baseImpls = xs.impls ?? [];
-    return new CalcitEnum(xs.prototype, baseImpls.concat(addedImpls));
+    return xs.withImpls(addedImpls);
   }
   if (xs instanceof CalcitRecord) {
-    return new CalcitRecord(xs.name, xs.fields, xs.values, xs.impls.concat(addedImpls));
+    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");
@@ -1601,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 => {
@@ -1624,7 +1646,7 @@ 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: CalcitValue, enumPrototype: CalcitValue, tag: CalcitValue, ...extra: CalcitValue[]): CalcitTuple => {
@@ -1647,9 +1669,9 @@ export let _PCT__PCT__$o__$o_ = (impl: CalcitValue, enumPrototype: CalcitValue,
     throw new Error(`Expected variant definition to be a list, got ${variantDefinition}`);
   }
 
-  const tupleEnumPrototype = enumPrototype instanceof CalcitEnum ? enumPrototype : proto;
+  const tupleEnumPrototype = enumPrototype instanceof CalcitEnum ? enumPrototype : (proto as any);
   const implValue = coerce_impl(impl, "%:: with impl");
-  return new CalcitTuple(tag, extra, [implValue], tupleEnumPrototype);
+  return new CalcitTuple(tag, extra, tupleEnumPrototype.withImpls(implValue));
 };
 
 // mutable place for core to register
@@ -1699,7 +1721,7 @@ function lookup_impls(obj: CalcitValue): [CalcitImpl[], 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;
@@ -1808,7 +1830,8 @@ export function _$n_inspect_methods(obj: CalcitValue, note: CalcitValue): Calcit
     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);
@@ -1841,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") {

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

@@ -351,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);
         }
       }
 
@@ -397,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] === "%::") {
@@ -419,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
       );
     }

package/ts-src/js-enum.mts

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

package/ts-src/js-impl.mts

@@ -1,15 +1,18 @@
 import { Hash } from "@calcit/ternary-tree";
 import { CalcitValue } from "./js-primes.mjs";
 import { CalcitTag, castTag, findInFields, toString } from "./calcit-data.mjs";
+import type { CalcitTrait } from "./js-trait.mjs";
 
 export class CalcitImpl {
   name: CalcitTag;
+  origin: CalcitTrait | null;
   fields: Array<CalcitTag>;
   values: Array<CalcitValue>;
   cachedHash: Hash;
 
-  constructor(name: CalcitTag, fields: Array<CalcitTag>, values: Array<CalcitValue>) {
+  constructor(name: CalcitTag, fields: Array<CalcitTag>, values: Array<CalcitValue>, origin: CalcitTrait | null = null) {
     this.name = name;
+    this.origin = origin;
     this.fields = fields;
     this.values = values;
     this.cachedHash = null;

package/ts-src/js-primes.mts

@@ -9,6 +9,7 @@ import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitSet as CalcitSet } from "./js-set.mjs";
 import { CalcitTuple } from "./js-tuple.mjs";
 import { CalcitCirruQuote, cirru_deep_equal } from "./js-cirru.mjs";
+import { CalcitTrait } from "./js-trait.mjs";
 
 export type CalcitValue =
   | string
@@ -27,6 +28,7 @@ export type CalcitValue =
   | CalcitRecur // should not be exposed to function
   | CalcitRecord
   | CalcitImpl
+  | CalcitTrait
   | CalcitStruct
   | CalcitEnum
   | CalcitCirruQuote

package/ts-src/js-record.mts

@@ -5,13 +5,15 @@ import { newTag, castTag, toString, CalcitTag, getStringName, findInFields } fro
 
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 
+import { CalcitStruct } from "./js-struct.mjs";
+
 export class CalcitRecord {
   name: CalcitTag;
   fields: Array<CalcitTag>;
   values: Array<CalcitValue>;
-  impls: Array<CalcitImpl>;
+  structRef: CalcitStruct;
   cachedHash: Hash;
-  constructor(name: CalcitTag, fields: Array<CalcitTag>, values?: Array<CalcitValue>, impls?: Array<CalcitImpl>) {
+  constructor(name: CalcitTag, fields: Array<CalcitTag>, values?: Array<CalcitValue>, structRef?: CalcitStruct) {
     this.name = name;
     let fieldNames = fields.map(castTag);
     this.fields = fields;
@@ -24,7 +26,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: CalcitValue) {
     let field = castTag(k);
@@ -54,7 +56,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: CalcitValue) {
@@ -75,12 +77,17 @@ export class CalcitRecord {
     parts.push(")");
     return parts.join("");
   }
-  withImpls(impl: CalcitValue): CalcitRecord {
+  withImpls(impl: CalcitValue | CalcitImpl[]): CalcitRecord {
+    let nextImpls: CalcitImpl[];
     if (impl instanceof CalcitImpl) {
-      return new CalcitRecord(this.name, this.fields, this.values, [impl]);
+      nextImpls = [impl];
+    } else if (Array.isArray(impl)) {
+      nextImpls = impl;
     } else {
-      throw new Error("Expected an impl");
+      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);
   }
 }
 
@@ -107,7 +114,9 @@ export let new_impl_record = (impl: CalcitImpl, name: CalcitValue, ...fields: Ar
       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: Array<CalcitTag>, ys: Array<CalcitTag>): boolean => {
@@ -155,7 +164,7 @@ export let _$n__PCT__$M_ = (proto: CalcitValue, ...xs: Array<CalcitValue>): Calc
       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");
   }
@@ -177,7 +186,7 @@ export let _$n_record_$o_with = (proto: CalcitValue, ...xs: Array<CalcitValue>):
       }
       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/ts-src/js-tuple.mts

@@ -9,16 +9,25 @@ import { CalcitEnum } from "./js-enum.mjs";
 export class CalcitTuple {
   tag: CalcitValue;
   extra: CalcitValue[];
-  impls: CalcitImpl[];
   enumPrototype: CalcitRecord | CalcitEnum;
   cachedHash: Hash;
-  constructor(tagName: CalcitValue, extra: CalcitValue[], impls: CalcitImpl[] = [], enumPrototype: CalcitRecord | CalcitEnum = null) {
+  constructor(tagName: CalcitValue, extra: CalcitValue[], enumPrototype: CalcitRecord | CalcitEnum = null) {
     this.tag = tagName;
     this.extra = extra;
-    this.impls = impls;
     this.enumPrototype = enumPrototype;
     this.cachedHash = null;
   }
+
+  get impls(): CalcitImpl[] {
+    if (this.enumPrototype == null) {
+      return [];
+    }
+    if (this.enumPrototype instanceof CalcitEnum) {
+      return this.enumPrototype.impls;
+    }
+    return this.enumPrototype.structRef.impls;
+  }
+
   get(n: number) {
     if (n === 0) {
       return this.tag;
@@ -30,11 +39,11 @@ export class CalcitTuple {
   }
   assoc(n: number, v: CalcitValue) {
     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`);
     }
@@ -68,15 +77,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})`;
   }
 }