@calcit/procs 0.11.0-a8 → 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

@@ -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,19 @@ export let hashFunction = (x) => {
         x.cachedHash = base;
         return base;
     }
+    if (x instanceof CalcitImpl) {
+        let base = defaultHash_impl;
+        base = mergeValueHash(base, hashFunction(x.name));
+        if (x.origin != null) {
+            base = mergeValueHash(base, hashFunction(x.origin));
+        }
+        for (let idx = 0; idx < x.fields.length; idx++) {
+            base = mergeValueHash(base, hashFunction(x.fields[idx]));
+            base = mergeValueHash(base, hashFunction(x.values[idx]));
+        }
+        x.cachedHash = base;
+        return base;
+    }
     if (x instanceof CalcitStruct) {
         let base = defaultHash_struct;
         base = mergeValueHash(base, hashFunction(x.name));
@@ -376,6 +397,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 +668,32 @@ export let _$n__$e_ = (x, y) => {
         }
         return false;
     }
+    if (x instanceof CalcitImpl) {
+        if (y instanceof CalcitImpl) {
+            if (x.name !== y.name) {
+                return false;
+            }
+            if ((x.origin == null) !== (y.origin == null)) {
+                return false;
+            }
+            if (x.origin != null && y.origin != null && x.origin.name.value !== y.origin.name.value) {
+                return false;
+            }
+            if (!fieldsEqual(x.fields, y.fields)) {
+                return false;
+            }
+            if (x.values.length !== y.values.length) {
+                return false;
+            }
+            for (let idx = 0; idx < x.fields.length; idx++) {
+                if (!_$n__$e_(x.values[idx], y.values[idx])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
     if (x instanceof CalcitStruct) {
         if (y instanceof CalcitStruct) {
             return x.name === y.name && fieldsEqual(x.fields, y.fields);

package/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");
     }
@@ -193,7 +198,47 @@ 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 origin = name instanceof CalcitTrait ? name : null;
+    const implName = origin ? origin.name : castTag(name);
+    if (pairs.length === 0) {
+        return new CalcitImpl(implName, [], [], origin);
+    }
+    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, origin);
 };
 export let _$n_struct_$o__$o_new = (name, ...entries) => {
     return defstruct(name, ...entries);
@@ -385,6 +430,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 +451,26 @@ 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");
+    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)
         throw new Error("&tuple:impl-traits takes 2+ arguments");
     if (!(x instanceof CalcitTuple))
         throw new Error("&tuple:impl-traits expects a tuple");
-    for (let idx = 0; idx < traits.length; idx++) {
-        if (!(traits[idx] instanceof CalcitRecord)) {
-            throw new Error("&tuple:impl-traits expects trait impls as records");
-        }
+    const impls = traits.map((trait) => coerce_impl(trait, "&tuple:impl-traits"));
+    let proto = x.enumPrototype;
+    if (proto == null) {
+        const tagName = x.tag instanceof CalcitTag ? x.tag : newTag("tag");
+        const anyTypes = new CalcitSliceList(new Array(x.extra.length).fill(newTag("any")));
+        proto = new CalcitEnum(new CalcitRecord(newTag("anonymous-tuple"), [tagName], [anyTypes], new CalcitStruct(newTag("anonymous-tuple"), [tagName], [anyTypes])));
     }
-    return new CalcitTuple(x.tag, x.extra, x.impls.concat(traits), x.enumPrototype);
+    return new CalcitTuple(x.tag, x.extra, proto.withImpls(impls));
 };
 export let _$n_tuple_$o_enum = function (x) {
     if (arguments.length !== 1)
@@ -427,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) {
@@ -539,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) {
@@ -547,43 +603,40 @@ 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"));
+    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)
         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));
+        return xs.withImpls(addedImpls);
     }
     if (xs instanceof CalcitRecord) {
-        return new CalcitRecord(xs.name, xs.fields, xs.values, xs.impls.concat(traits));
+        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");
@@ -1452,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);
@@ -1472,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
@@ -1493,7 +1546,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, tupleEnumPrototype.withImpls(implValue));
 };
 let calcit_builtin_impls = {
     number: null,
@@ -1516,10 +1570,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;
 }
@@ -1536,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();
@@ -1641,14 +1699,15 @@ 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 = [];
         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()}`);
@@ -1678,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") {
@@ -1689,7 +1748,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/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

@@ -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}`);
         }
@@ -353,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);
@@ -392,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) {
@@ -409,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 { CalcitRecord } from "./js-record.mjs";
+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) {
-        if (impls instanceof CalcitRecord) {
-            return new CalcitEnum(this.prototype, [impls]);
+        let nextImpls;
+        if (impls instanceof CalcitImpl) {
+            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 a record as implementation");
+        return new CalcitEnum(this.prototype.withImpls(nextImpls));
     }
     toString() {
         return `(%enum :${this.prototype.name.value})`;

package/lib/js-impl.mjs

@@ -0,0 +1,34 @@
+import { castTag, findInFields, toString } from "./calcit-data.mjs";
+export class CalcitImpl {
+    constructor(name, fields, values, origin = null) {
+        this.name = name;
+        this.origin = origin;
+        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)