@calcit/procs 0.11.0-a9 → 0.11.1

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-arity-helpers.mjs

@@ -0,0 +1,9 @@
+export let _args_throw = (name, expected, got) => {
+    return new Error(`\`${name}\` expected ${expected} params, got ${got}`);
+};
+export let _args_fewer_throw = (name, min, got) => {
+    return new Error(`\`${name}\` expected at least ${min} params, got ${got}`);
+};
+export let _args_between_throw = (name, min, max, got) => {
+    return new Error(`\`${name}\` expected ${min}-${max} params, got ${got}`);
+};

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) {
@@ -122,18 +131,28 @@ export let fieldsEqual = (xs, ys) => {
     return true;
 };
 export let _$n__PCT__$M_ = (proto, ...xs) => {
+    let recordProto;
     if (proto instanceof CalcitRecord) {
+        recordProto = proto;
+    }
+    else if (proto instanceof CalcitStruct) {
+        recordProto = new CalcitRecord(proto.name, proto.fields, new Array(proto.fields.length).fill(null), proto);
+    }
+    else {
+        throw new Error("Expected prototype to be a record");
+    }
+    {
         if (xs.length % 2 !== 0) {
             throw new Error("Expected even number of key/value");
         }
-        if (xs.length !== proto.fields.length * 2) {
+        if (xs.length !== recordProto.fields.length * 2) {
             throw new Error("fields size does not match");
         }
-        let values = new Array(proto.fields.length);
-        for (let i = 0; i < proto.fields.length; i++) {
+        let values = new Array(recordProto.fields.length);
+        for (let i = 0; i < recordProto.fields.length; i++) {
             let idx = -1;
-            let k = proto.fields[i];
-            for (let j = 0; j < proto.fields.length; j++) {
+            let k = recordProto.fields[i];
+            for (let j = 0; j < recordProto.fields.length; j++) {
                 if (k === castTag(xs[j * 2])) {
                     idx = j;
                     break;
@@ -147,10 +166,7 @@ export let _$n__PCT__$M_ = (proto, ...xs) => {
             }
             values[i] = xs[idx * 2 + 1];
         }
-        return new CalcitRecord(proto.name, proto.fields, values, proto.impls);
-    }
-    else {
-        throw new Error("Expected prototype to be a record");
+        return new CalcitRecord(recordProto.name, recordProto.fields, values, recordProto.structRef);
     }
 };
 /// update record with new values
@@ -169,7 +185,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-tag-helpers.mjs

@@ -0,0 +1,15 @@
+import { newTag } from "./calcit-data.mjs";
+let _tag_cache = {};
+export let init_tags = (arr) => {
+    let tags = {};
+    for (let idx = 0; idx < arr.length; idx++) {
+        let name = arr[idx];
+        let item = _tag_cache[name];
+        if (item === undefined) {
+            item = newTag(name);
+            _tag_cache[name] = item;
+        }
+        tags[name] = item;
+    }
+    return tags;
+};

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.1",
     "main": "./lib/calcit.procs.mjs",
     "devDependencies": {
         "@types/node": "^25.0.9",
@@ -8,11 +8,18 @@
     },
     "scripts": {
         "compile": "rm -rfv lib/* && tsc",
-        "procs-link": "ln -s ../../ node_modules/@calcit/procs",
+        "procs-link": "ln -sfn ../../ node_modules/@calcit/procs",
         "cp-mac": "cargo build --release && rm -rfv builds/* && node scripts/cp-version.js && scp builds/* rsync-user@calcit-lang.org:/web-assets/repo/calcit-lang/binaries/macos/",
         "eval": "cargo run --bin cr -- eval",
+        "fmt-rs": "cargo fmt --all",
+        "lint-rs": "cargo clippy --all-targets -- -D warnings",
+        "test-rs": "cargo test -q",
+        "test-snippets": "cargo test -q snippets::tests",
+        "bench-recur-smoke": "cargo run --bin cr -- calcit/test.cirru -1 js && node --input-type=module -e \"import { test_loop } from './js-out/test-recursion.main.mjs'; const n=3000; const t0=process.hrtime.bigint(); for(let i=0;i<n;i++) test_loop(); const dt=Number(process.hrtime.bigint()-t0)/1e6; console.log('test_loop_ms='+dt.toFixed(3));\"",
+        "check-smooth": "yarn fmt-rs && yarn lint-rs && yarn test-rs && yarn check-all",
         "check-all": "yarn compile && yarn try-rs && yarn try-js && yarn try-ir",
         "try-rs": "cargo run --bin cr -- calcit/test.cirru -1",
+        "warn-dyn-method": "cargo run --bin cr -- calcit/test.cirru -1 --warn-dyn-method",
         "try-js-brk": "cargo run --bin cr -- calcit/test.cirru -1 js && node --inspect-brk js-out/main.mjs",
         "try-js": "cargo run --bin cr -- calcit/test.cirru -1 js && node js-out/main.mjs",
         "try-ir": "cargo run --bin cr -- calcit/test.cirru -1 js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.11.0-a9",
+  "version": "0.11.1",
   "main": "./lib/calcit.procs.mjs",
   "devDependencies": {
     "@types/node": "^25.0.9",
@@ -8,11 +8,18 @@
   },
   "scripts": {
     "compile": "rm -rfv lib/* && tsc",
-    "procs-link": "ln -s ../../ node_modules/@calcit/procs",
+    "procs-link": "ln -sfn ../../ node_modules/@calcit/procs",
     "cp-mac": "cargo build --release && rm -rfv builds/* && node scripts/cp-version.js && scp builds/* rsync-user@calcit-lang.org:/web-assets/repo/calcit-lang/binaries/macos/",
     "eval": "cargo run --bin cr -- eval",
+    "fmt-rs": "cargo fmt --all",
+    "lint-rs": "cargo clippy --all-targets -- -D warnings",
+    "test-rs": "cargo test -q",
+    "test-snippets": "cargo test -q snippets::tests",
+    "bench-recur-smoke": "cargo run --bin cr -- calcit/test.cirru -1 js && node --input-type=module -e \"import { test_loop } from './js-out/test-recursion.main.mjs'; const n=3000; const t0=process.hrtime.bigint(); for(let i=0;i<n;i++) test_loop(); const dt=Number(process.hrtime.bigint()-t0)/1e6; console.log('test_loop_ms='+dt.toFixed(3));\"",
+    "check-smooth": "yarn fmt-rs && yarn lint-rs && yarn test-rs && yarn check-all",
     "check-all": "yarn compile && yarn try-rs && yarn try-js && yarn try-ir",
     "try-rs": "cargo run --bin cr -- calcit/test.cirru -1",
+    "warn-dyn-method": "cargo run --bin cr -- calcit/test.cirru -1 --warn-dyn-method",
     "try-js-brk": "cargo run --bin cr -- calcit/test.cirru -1 js && node --inspect-brk js-out/main.mjs",
     "try-js": "cargo run --bin cr -- calcit/test.cirru -1 js && node js-out/main.mjs",
     "try-ir": "cargo run --bin cr -- calcit/test.cirru -1 js"

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

@@ -41,6 +41,8 @@ export * from "./js-tuple.mjs";
 export * from "./js-trait.mjs";
 export * from "./custom-formatter.mjs";
 export * from "./js-cirru.mjs";
+export * from "./js-arity-helpers.mjs";
+export * from "./js-tag-helpers.mjs";
 export { _$n_compare } from "./js-primes.mjs";
 
 import { CalcitList, CalcitSliceList, foldl } from "./js-list.mjs";
@@ -230,14 +232,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 +271,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 +511,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 +542,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 +664,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 +672,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 +688,42 @@ 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_impl_$o_get = function (impl: CalcitValue, name: CalcitValue): CalcitValue {
+  if (arguments.length !== 2) throw new Error("&impl:get expected 2 arguments");
+  if (!(impl instanceof CalcitImpl)) {
+    throw new Error(`&impl:get expected an impl as first argument, but received: ${toString(impl, true)}`);
+  }
+  return impl.get(name);
+};
+
+export let _$n_impl_$o_nth = function (impl: CalcitValue, index: CalcitValue): CalcitValue {
+  if (arguments.length !== 2) throw new Error("&impl:nth expected 2 arguments");
+  if (!(impl instanceof CalcitImpl)) {
+    throw new Error(`&impl:nth expected an impl as first argument, but received: ${toString(impl, true)}`);
+  }
+  if (typeof index !== "number" || !Number.isInteger(index) || index < 0) {
+    throw new Error(`&impl:nth expected a non-negative integer index, but received: ${toString(index, true)}`);
+  }
+  return impl.values[index];
+};
+
 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 +1644,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 +1667,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 +1690,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 +1742,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 +1851,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 +1885,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") {
@@ -2004,9 +2048,5 @@ export let macroexpand = unavailableProc;
 export let macroexpand_all = unavailableProc;
 export let _$n_get_calcit_running_mode = unavailableProc;
 
-export let _args_throw = (name: string, expected: number, got: number) => {
-  return new Error(`\`${name}\` expected ${expected} params, got ${got}`);
-};
-
 // already handled in code emitter
 export let raise = unavailableProc;

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-arity-helpers.mts

@@ -0,0 +1,11 @@
+export let _args_throw = (name: string, expected: number, got: number) => {
+  return new Error(`\`${name}\` expected ${expected} params, got ${got}`);
+};
+
+export let _args_fewer_throw = (name: string, min: number, got: number) => {
+  return new Error(`\`${name}\` expected at least ${min} params, got ${got}`);
+};
+
+export let _args_between_throw = (name: string, min: number, max: number, got: number) => {
+  return new Error(`\`${name}\` expected ${min}-${max} params, got ${got}`);
+};

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 {