@calcit/procs 0.13.1 → 0.13.2

package/lib/custom-formatter.mjs

@@ -1,13 +1,13 @@
 import { isLiteral } from "./js-primes.mjs";
 import { CalcitSymbol, CalcitTag } from "./calcit-data.mjs";
 import { CalcitRef } from "./js-ref.mjs";
-import { CalcitRecord } from "./js-record.mjs";
-import { CalcitStruct } from "./js-struct.mjs";
-import { CalcitEnum } from "./js-enum.mjs";
+import { CalcitStructValue } from "./js-struct-value.mjs";
+import { CalcitStructDef } from "./js-struct-def.mjs";
+import { CalcitEnumDef } from "./js-enum-def.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitList, CalcitSliceList } from "./js-list.mjs";
 import { CalcitSet } from "./js-set.mjs";
-import { CalcitTuple } from "./js-tuple.mjs";
+import { CalcitEnumValue } from "./js-enum-value.mjs";
 import { CalcitCirruQuote } from "./js-cirru.mjs";
 let embedObject = (x) => {
     if (x == null) {
@@ -150,38 +150,23 @@ export let load_console_formatter_$x_ = () => {
                             color: hsl(280, 80, 80, 0.8),
                         }, `${obj.len()}`), preview);
                     }
-                    if (obj instanceof CalcitRecord) {
-                        let name = new CalcitSymbol(obj.name.value);
-                        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(name)), span({ marginLeft: "6px" }, `...`));
-                            return ret;
-                        }
-                        else {
-                            let ret = div({ color: hsl(280, 80, 60, 0.4), maxWidth: "100%" }, "%{} ", embedObject(name), " ...");
-                            return ret;
-                        }
+                    if (obj instanceof CalcitStructValue) {
+                        const name = new CalcitSymbol(obj.name.value);
+                        return div({ color: hsl(280, 80, 60, 0.4), maxWidth: "100%" }, "%{} ", embedObject(name), " ...");
                     }
-                    if (obj instanceof CalcitStruct) {
-                        return div({ color: hsl(280, 80, 60, 0.4), maxWidth: "100%" }, "%struct ", embedObject(new CalcitSymbol(obj.name.value)), " ...");
+                    if (obj instanceof CalcitStructDef) {
+                        return div({ color: hsl(280, 80, 60, 0.4), maxWidth: "100%" }, "%struct-def ", embedObject(new CalcitSymbol(obj.name.value)), " ...");
                     }
-                    if (obj instanceof CalcitEnum) {
-                        return div({ color: hsl(280, 80, 60, 0.4), maxWidth: "100%" }, "%enum ", embedObject(new CalcitSymbol(obj.prototype.name.value)), " ...");
+                    if (obj instanceof CalcitEnumDef) {
+                        return div({ color: hsl(280, 80, 60, 0.4), maxWidth: "100%" }, "%enum-def ", embedObject(new CalcitSymbol(obj.prototype.name.value)), " ...");
                     }
-                    if (obj instanceof CalcitTuple) {
-                        if (obj.impls.length > 0) {
-                            let ret = div({ marginRight: "16px" }, div({ display: "inline-block", color: hsl(300, 100, 40) }, "%::"), div({ marginLeft: "6px", display: "inline-block" }, embedObject(obj.impls[0])), div({ marginLeft: "6px", display: "inline-block" }, embedObject(obj.tag)));
-                            for (let idx = 0; idx < obj.extra.length; idx++) {
-                                ret.push(div({ marginLeft: "6px", display: "inline-block" }, embedObject(obj.extra[idx])));
-                            }
-                            return ret;
-                        }
-                        else {
-                            let ret = div({ marginRight: "16px" }, div({ display: "inline-block", color: hsl(300, 100, 40) }, "::"), div({ marginLeft: "6px", display: "inline-block" }, embedObject(obj.tag)));
-                            for (let idx = 0; idx < obj.extra.length; idx++) {
-                                ret.push(div({ marginLeft: "6px", display: "inline-block" }, embedObject(obj.extra[idx])));
-                            }
-                            return ret;
+                    if (obj instanceof CalcitEnumValue) {
+                        const enumName = obj.enumPrototype == null ? "_" : obj.enumPrototype.name();
+                        let ret = div({ marginRight: "16px" }, div({ display: "inline-block", color: hsl(300, 100, 40) }, "%::"), div({ marginLeft: "6px", display: "inline-block" }, embedObject(new CalcitSymbol(enumName))), div({ marginLeft: "6px", display: "inline-block" }, embedObject(obj.tag)));
+                        for (let idx = 0; idx < obj.extra.length; idx++) {
+                            ret.push(div({ marginLeft: "6px", display: "inline-block" }, embedObject(obj.extra[idx])));
                         }
+                        return ret;
                     }
                     if (obj instanceof CalcitRef) {
                         return div({
@@ -206,11 +191,11 @@ export let load_console_formatter_$x_ = () => {
                         let hasCollection = obj.nestedDataInChildren();
                         return obj.len() > 0 && hasCollection;
                     }
-                    if (obj instanceof CalcitRecord) {
+                    if (obj instanceof CalcitStructValue) {
                         return obj.fields.length > 0;
                     }
-                    if (obj instanceof CalcitStruct || obj instanceof CalcitEnum) {
-                        return obj instanceof CalcitStruct ? obj.fields.length > 0 : obj.prototype.fields.length > 0;
+                    if (obj instanceof CalcitStructDef || obj instanceof CalcitEnumDef) {
+                        return obj instanceof CalcitStructDef ? obj.fields.length > 0 : obj.prototype.fields.length > 0;
                     }
                     return false;
                 },
@@ -260,21 +245,21 @@ export let load_console_formatter_$x_ = () => {
                         }
                         return ret;
                     }
-                    if (obj instanceof CalcitRecord) {
+                    if (obj instanceof CalcitStructValue) {
                         let ret = table({ color: hsl(280, 80, 60), borderLeft: "1px solid #eee" });
                         for (let idx = 0; idx < obj.fields.length; idx++) {
                             ret.push(tr({}, td({ paddingLeft: "8px", verticalAlign: "top", whiteSpace: "pre", minWidth: "40px" }, embedObject(obj.fields[idx])), td({ paddingLeft: "8px" }, embedObject(obj.values[idx]))));
                         }
                         return ret;
                     }
-                    if (obj instanceof CalcitStruct) {
+                    if (obj instanceof CalcitStructDef) {
                         let ret = table({ color: hsl(280, 80, 60), borderLeft: "1px solid #eee" });
                         for (let idx = 0; idx < obj.fields.length; idx++) {
                             ret.push(tr({}, td({ paddingLeft: "8px", verticalAlign: "top", whiteSpace: "pre", minWidth: "40px" }, embedObject(obj.fields[idx])), td({ paddingLeft: "8px" }, embedObject(obj.fieldTypes[idx]))));
                         }
                         return ret;
                     }
-                    if (obj instanceof CalcitEnum) {
+                    if (obj instanceof CalcitEnumDef) {
                         let ret = table({ color: hsl(280, 80, 60), borderLeft: "1px solid #eee" });
                         for (let idx = 0; idx < obj.prototype.fields.length; idx++) {
                             ret.push(tr({}, td({ paddingLeft: "8px", verticalAlign: "top", whiteSpace: "pre", minWidth: "40px" }, embedObject(obj.prototype.fields[idx])), td({ paddingLeft: "8px" }, embedObject(obj.prototype.values[idx]))));

package/lib/js-cirru.mjs

@@ -1,12 +1,12 @@
 import { writeCirruCode, writeCirruOneLiner } from "@cirru/writer.ts";
 import { isLiteral, _$n_compare } from "./js-primes.mjs";
 import { CalcitList, CalcitSliceList } from "./js-list.mjs";
-import { CalcitRecord } from "./js-record.mjs";
+import { CalcitStructValue } from "./js-struct-value.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 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 { CalcitEnumValue } from "./js-enum-value.mjs";
+import { CalcitEnumDef } from "./js-enum-def.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
 import { CalcitRef } from "./js-ref.mjs";
 import { deepEqual } from "@calcit/ternary-tree/lib/utils.mjs";
@@ -148,7 +148,7 @@ export let to_cirru_edn = (x) => {
         }
         return buffer;
     }
-    if (x instanceof CalcitRecord) {
+    if (x instanceof CalcitStructValue) {
         let buffer = [];
         for (let idx = 0; idx < x.fields.length; idx++) {
             buffer.push([x.fields[idx].toString(), to_cirru_edn(x.values[idx])]);
@@ -171,7 +171,7 @@ export let to_cirru_edn = (x) => {
         }
         return buffer;
     }
-    if (x instanceof CalcitTuple) {
+    if (x instanceof CalcitEnumValue) {
         if (x.tag instanceof CalcitSymbol && x.tag.value === "quote") {
             // turn `x.snd` with CalcitList into raw Cirru nodes, which is in plain Array
             return ["quote", toWriterNode(x.get(1))];
@@ -181,7 +181,7 @@ export let to_cirru_edn = (x) => {
             if (x.tag instanceof CalcitTag) {
                 return ["%::", enumTag, x.tag.toString(), ...x.extra.map(to_cirru_edn)];
             }
-            else if (x.tag instanceof CalcitRecord) {
+            else if (x.tag instanceof CalcitStructValue) {
                 return ["%::", enumTag, x.tag.name.toString(), ...x.extra.map(to_cirru_edn)];
             }
             else if (x.tag instanceof CalcitImpl) {
@@ -194,7 +194,7 @@ export let to_cirru_edn = (x) => {
         else if (x.tag instanceof CalcitTag) {
             return ["::", x.tag.toString(), ...x.extra.map(to_cirru_edn)];
         }
-        else if (x.tag instanceof CalcitRecord) {
+        else if (x.tag instanceof CalcitStructValue) {
             return ["::", x.tag.name.toString(), ...x.extra.map(to_cirru_edn)];
         }
         else if (x.tag instanceof CalcitImpl) {
@@ -235,29 +235,29 @@ let extractFieldTag = (x) => {
 let resolveEnumPrototype = (enumName, options) => {
     if (options instanceof CalcitMap || options instanceof CalcitSliceMap) {
         let value = options.get(extractFieldTag(enumName));
-        if (value instanceof CalcitEnum || value instanceof CalcitRecord) {
+        if (value instanceof CalcitEnumDef) {
             return value;
         }
+        if (value instanceof CalcitStructValue) {
+            throw new Error(`Enum ${enumName} uses a legacy struct prototype; provide an EnumDef produced by defenum`);
+        }
         if (value != null) {
             throw new Error(`Expected enum prototype for ${enumName}, got: ${value}`);
         }
     }
     return null;
 };
-// local helper to unwrap an enum prototype value to a CalcitRecord prototype
+// local helper to inspect an EnumDef's variant prototype
 const unwrap_enum_prototype_local = (enumPrototype) => {
-    if (enumPrototype instanceof CalcitEnum) {
+    if (enumPrototype instanceof CalcitEnumDef) {
         return enumPrototype.prototype;
     }
-    if (enumPrototype instanceof CalcitRecord) {
-        return enumPrototype;
-    }
-    throw new Error(`expected enum prototype`);
+    throw new Error(`expected an EnumDef produced by defenum`);
 };
 const tag_to_string = (tag) => {
     if (tag instanceof CalcitTag)
         return tag.toString();
-    if (tag instanceof CalcitRecord)
+    if (tag instanceof CalcitStructValue)
         return tag.name.toString();
     throw new Error(`Unsupported tag for EDN: ${tag}`);
 };
@@ -330,7 +330,7 @@ const extract_cirru_edn_inner = (x, options, preserveSourceEntries) => {
         if (x[0] === "%{}") {
             let name = x[1];
             if (typeof name != "string") {
-                throw new Error(`Expected string for record name, got: ${name}`);
+                throw new Error(`Expected string for struct name, got: ${name}`);
             }
             // put to entries first, sort and then...
             let entries = [];
@@ -357,7 +357,7 @@ const extract_cirru_edn_inner = (x, options, preserveSourceEntries) => {
                     }
                 }
                 else {
-                    throw new Error(`Expected pairs for record, got: ${pair}`);
+                    throw new Error(`Expected field pairs for struct, got: ${pair}`);
                 }
             });
             entries.sort((a, b) => {
@@ -371,13 +371,13 @@ const extract_cirru_edn_inner = (x, options, preserveSourceEntries) => {
             }
             if (options instanceof CalcitMap || options instanceof CalcitSliceMap) {
                 let v = options.get(extractFieldTag(name));
-                if (v != null && v instanceof CalcitRecord) {
+                if (v != null && v instanceof CalcitStructValue) {
                     if (deepEqual(v.fields, fields)) {
-                        return new CalcitRecord(extractFieldTag(name), fields, values, v.structRef);
+                        return new CalcitStructValue(extractFieldTag(name), fields, values, v.structRef);
                     }
                 }
             }
-            return new CalcitRecord(extractFieldTag(name), fields, values);
+            return new CalcitStructValue(extractFieldTag(name), fields, values);
         }
         let notComment = (x) => {
             if (x instanceof Array && x[0] === ";") {
@@ -410,9 +410,9 @@ const extract_cirru_edn_inner = (x, options, preserveSourceEntries) => {
         }
         if (x[0] === "::") {
             if (x.length < 2) {
-                throw new Error(`tuple expects at least 1 value, got: ${x}`);
+                throw new Error(`anonymous enum expects at least 1 value, got: ${x}`);
             }
-            return new CalcitTuple(extract_cirru_edn_inner(x[1], options, preserveSourceEntries), x
+            return new CalcitEnumValue(extract_cirru_edn_inner(x[1], options, preserveSourceEntries), x
                 .slice(2)
                 .filter(notComment)
                 .map((x) => extract_cirru_edn_inner(x, options, preserveSourceEntries)));
@@ -429,7 +429,7 @@ const extract_cirru_edn_inner = (x, options, preserveSourceEntries) => {
             // unwrap prototype to record then extract name
             const proto = enumPrototype != null ? unwrap_enum_prototype_local(enumPrototype) : null;
             const enumTag = proto != null ? proto.name.toString() : enumName;
-            return new CalcitTuple(extract_cirru_edn_inner(x[2], options, preserveSourceEntries), x
+            return new CalcitEnumValue(extract_cirru_edn_inner(x[2], options, preserveSourceEntries), x
                 .slice(3)
                 .filter(notComment)
                 .map((x) => extract_cirru_edn_inner(x, options, preserveSourceEntries)), enumPrototype);
@@ -504,7 +504,7 @@ export let to_calcit_data = (x, noKeyword = false) => {
         return x;
     if (x instanceof CalcitSet)
         return x;
-    if (x instanceof CalcitRecord)
+    if (x instanceof CalcitStructValue)
         return x;
     if (x instanceof CalcitRecur)
         return x;
@@ -514,7 +514,7 @@ export let to_calcit_data = (x, noKeyword = false) => {
         return x;
     if (x instanceof CalcitSymbol)
         return x;
-    if (x instanceof CalcitTuple)
+    if (x instanceof CalcitEnumValue)
         return x;
     // detects object
     if (x === Object(x)) {

package/lib/js-enum-def.d.mts

@@ -0,0 +1,11 @@
+import { CalcitStructValue } from "./js-struct-value.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
+export declare class CalcitEnumDef {
+    prototype: CalcitStructValue;
+    cachedHash: number;
+    constructor(prototype: CalcitStructValue);
+    name(): string;
+    get impls(): CalcitImpl[];
+    withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitEnumDef;
+    toString(): string;
+}

package/lib/{js-enum.mjs → js-enum-def.mjs}

@@ -1,5 +1,5 @@
 import { CalcitImpl } from "./js-impl.mjs";
-export class CalcitEnum {
+export class CalcitEnumDef {
     constructor(prototype) {
         this.prototype = prototype;
         this.cachedHash = null;
@@ -21,9 +21,9 @@ export class CalcitEnum {
         else {
             throw new Error("Expected an impl as implementation");
         }
-        return new CalcitEnum(this.prototype.withImpls(nextImpls));
+        return new CalcitEnumDef(this.prototype.withImpls(nextImpls));
     }
     toString() {
-        return `(%enum '${this.prototype.name.value})`;
+        return `(%enum-def '${this.prototype.name.value})`;
     }
 }

package/lib/{js-tuple.d.mts → js-enum-value.d.mts}

@@ -1,18 +1,17 @@
 import { Hash } from "@calcit/ternary-tree";
 import { CalcitValue } from "./js-primes.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
-import { CalcitRecord } from "./js-record.mjs";
-import { CalcitEnum } from "./js-enum.mjs";
-export declare class CalcitTuple {
+import { CalcitEnumDef } from "./js-enum-def.mjs";
+export declare class CalcitEnumValue {
     tag: CalcitValue;
     extra: CalcitValue[];
-    enumPrototype: CalcitRecord | CalcitEnum;
+    enumPrototype: CalcitEnumDef;
     cachedHash: Hash;
-    constructor(tagName: CalcitValue, extra: CalcitValue[], enumPrototype?: CalcitRecord | CalcitEnum);
+    constructor(tagName: CalcitValue, extra: CalcitValue[], enumPrototype?: CalcitEnumDef);
     get impls(): CalcitImpl[];
     get(n: number): CalcitValue;
-    assoc(n: number, v: CalcitValue): CalcitTuple;
+    assoc(n: number, v: CalcitValue): CalcitEnumValue;
     count(): number;
-    eq(y: CalcitTuple): boolean;
+    eq(y: CalcitEnumValue): boolean;
     toString(disableJsDataWarning?: boolean): string;
 }

package/lib/{js-tuple.mjs → js-enum-value.mjs}

@@ -1,6 +1,5 @@
 import { _$n__$e_, toString } from "./calcit-data.mjs";
-import { CalcitEnum } from "./js-enum.mjs";
-export class CalcitTuple {
+export class CalcitEnumValue {
     constructor(tagName, extra, enumPrototype = null) {
         this.tag = tagName;
         this.extra = extra;
@@ -11,10 +10,7 @@ export class CalcitTuple {
         if (this.enumPrototype == null) {
             return [];
         }
-        if (this.enumPrototype instanceof CalcitEnum) {
-            return this.enumPrototype.impls;
-        }
-        return this.enumPrototype.structRef.impls;
+        return this.enumPrototype.impls;
     }
     get(n) {
         if (n === 0) {
@@ -24,20 +20,20 @@ export class CalcitTuple {
             return this.extra[n - 1];
         }
         else {
-            throw new Error(`Tuple only have ${this.extra.length + 1} elements`);
+            throw new Error(`Enum value only has ${this.extra.length + 1} elements`);
         }
     }
     assoc(n, v) {
         if (n === 0) {
-            return new CalcitTuple(v, this.extra, this.enumPrototype);
+            return new CalcitEnumValue(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.enumPrototype);
+            return new CalcitEnumValue(this.tag, next_extra, this.enumPrototype);
         }
         else {
-            throw new Error(`Tuple only have ${this.extra.length} elements`);
+            throw new Error(`Enum value only has ${this.extra.length} elements`);
         }
     }
     count() {
@@ -67,10 +63,7 @@ export class CalcitTuple {
             content += toString(args[i], true, disableJsDataWarning);
         }
         const hasEnum = this.enumPrototype != null;
-        const enumName = hasEnum ? (this.enumPrototype instanceof CalcitEnum ? this.enumPrototype.prototype.name.value : this.enumPrototype.name.value) : null;
-        if (hasEnum) {
-            return `(%:: ${content} (:enum ${enumName}))`;
-        }
-        return `(:: ${content})`;
+        const enumName = hasEnum ? this.enumPrototype.name() : null;
+        return `(%:: ${hasEnum ? `'${enumName}` : "_"} ${content})`;
     }
 }

package/lib/js-list.mjs

@@ -3,7 +3,7 @@ import { isLiteral } from "./js-primes.mjs";
 import { initTernaryTreeList, initTernaryTreeListFromRange, listLen, listGet, assocList, listToItems, dissocList, assocBefore, assocAfter, } from "@calcit/ternary-tree";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitSet } from "./js-set.mjs";
-import { CalcitTuple } from "./js-tuple.mjs";
+import { CalcitEnumValue } from "./js-enum-value.mjs";
 import { isNestedCalcitData, tipNestedCalcitData, toString } from "./calcit-data.mjs";
 // two list implementations, should offer same interface
 export class CalcitList {
@@ -328,7 +328,7 @@ export let foldl_shortcut = function (xs, acc, v0, f) {
         for (let idx = 0; idx < size; idx++) {
             let item = xs.get(idx);
             let pair = f(state, item);
-            if (pair instanceof CalcitTuple) {
+            if (pair instanceof CalcitEnumValue) {
                 if (typeof pair.tag === "boolean") {
                     if (pair.tag) {
                         return pair.get(1);
@@ -350,7 +350,7 @@ export let foldl_shortcut = function (xs, acc, v0, f) {
         for (let idx = 0; idx < values.length; idx++) {
             let item = values[idx];
             let pair = f(state, item);
-            if (pair instanceof CalcitTuple) {
+            if (pair instanceof CalcitEnumValue) {
                 if (typeof pair.tag === "boolean") {
                     if (pair.tag) {
                         return pair.get(1);
@@ -373,7 +373,7 @@ export let foldl_shortcut = function (xs, acc, v0, f) {
         for (let i = 0; i < size; i++) {
             let pos = i << 1;
             let pair = f(state, new CalcitSliceList([xs.chunk[pos], xs.chunk[pos + 1]]));
-            if (pair instanceof CalcitTuple) {
+            if (pair instanceof CalcitEnumValue) {
                 if (typeof pair.tag === "boolean") {
                     if (pair.tag) {
                         return pair.get(1);
@@ -395,7 +395,7 @@ export let foldl_shortcut = function (xs, acc, v0, f) {
         for (let idx = 0; idx < pairs.length; idx++) {
             let item = pairs[idx];
             let pair = f(state, new CalcitSliceList(item));
-            if (pair instanceof CalcitTuple) {
+            if (pair instanceof CalcitEnumValue) {
                 if (typeof pair.tag === "boolean") {
                     if (pair.tag) {
                         return pair.get(1);
@@ -426,7 +426,7 @@ export let foldr_shortcut = function (xs, acc, v0, f) {
         for (let idx = xs.len() - 1; idx >= 0; idx--) {
             let item = xs.get(idx);
             let pair = f(state, item);
-            if (pair instanceof CalcitTuple) {
+            if (pair instanceof CalcitEnumValue) {
                 if (typeof pair.tag === "boolean") {
                     if (pair.tag) {
                         return pair.get(1);

package/lib/js-primes.d.mts

@@ -1,15 +1,15 @@
 import { CalcitTag, CalcitSymbol, CalcitFn, 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 { CalcitStructValue } from "./js-struct-value.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
-import { CalcitStruct } from "./js-struct.mjs";
-import { CalcitEnum } from "./js-enum.mjs";
+import { CalcitStructDef } from "./js-struct-def.mjs";
+import { CalcitEnumDef } from "./js-enum-def.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitSet as CalcitSet } from "./js-set.mjs";
-import { CalcitTuple } from "./js-tuple.mjs";
+import { CalcitEnumValue } from "./js-enum-value.mjs";
 import { CalcitCirruQuote } from "./js-cirru.mjs";
 import { CalcitTrait } from "./js-trait.mjs";
-export type CalcitValue = string | number | boolean | CalcitMap | CalcitSliceMap | CalcitList | CalcitSliceList | CalcitSet | CalcitTag | CalcitSymbol | CalcitRef | CalcitTuple | CalcitFn | CalcitRecur | CalcitRecord | CalcitImpl | CalcitTrait | CalcitStruct | CalcitEnum | CalcitCirruQuote | null;
+export type CalcitValue = string | number | boolean | CalcitMap | CalcitSliceMap | CalcitList | CalcitSliceList | CalcitSet | CalcitTag | CalcitSymbol | CalcitRef | CalcitEnumValue | CalcitFn | CalcitRecur | CalcitStructValue | CalcitImpl | CalcitTrait | CalcitStructDef | CalcitEnumDef | CalcitCirruQuote | null;
 export declare let isLiteral: (x: CalcitValue) => boolean;
 export declare let _$n_compare: (a: CalcitValue, b: CalcitValue) => number;

package/lib/js-primes.mjs

@@ -1,13 +1,13 @@
 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 { CalcitStructValue } from "./js-struct-value.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
-import { CalcitStruct } from "./js-struct.mjs";
-import { CalcitEnum } from "./js-enum.mjs";
+import { CalcitStructDef } from "./js-struct-def.mjs";
+import { CalcitEnumDef } from "./js-enum-def.mjs";
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 import { CalcitSet as CalcitSet } from "./js-set.mjs";
-import { CalcitTuple } from "./js-tuple.mjs";
+import { CalcitEnumValue } from "./js-enum-value.mjs";
 import { CalcitCirruQuote } from "./js-cirru.mjs";
 export let isLiteral = (x) => {
     if (x == null)
@@ -33,15 +33,15 @@ var PseudoTypeIndex;
     PseudoTypeIndex[PseudoTypeIndex["tag"] = 4] = "tag";
     PseudoTypeIndex[PseudoTypeIndex["string"] = 5] = "string";
     PseudoTypeIndex[PseudoTypeIndex["ref"] = 6] = "ref";
-    PseudoTypeIndex[PseudoTypeIndex["tuple"] = 7] = "tuple";
+    PseudoTypeIndex[PseudoTypeIndex["enum_value"] = 7] = "enum_value";
     PseudoTypeIndex[PseudoTypeIndex["recur"] = 8] = "recur";
     PseudoTypeIndex[PseudoTypeIndex["list"] = 9] = "list";
     PseudoTypeIndex[PseudoTypeIndex["set"] = 10] = "set";
     PseudoTypeIndex[PseudoTypeIndex["map"] = 11] = "map";
-    PseudoTypeIndex[PseudoTypeIndex["record"] = 12] = "record";
+    PseudoTypeIndex[PseudoTypeIndex["struct_value"] = 12] = "struct_value";
     PseudoTypeIndex[PseudoTypeIndex["impl"] = 13] = "impl";
-    PseudoTypeIndex[PseudoTypeIndex["struct"] = 14] = "struct";
-    PseudoTypeIndex[PseudoTypeIndex["enum_type"] = 15] = "enum_type";
+    PseudoTypeIndex[PseudoTypeIndex["struct_def"] = 14] = "struct_def";
+    PseudoTypeIndex[PseudoTypeIndex["enum_def"] = 15] = "enum_def";
     PseudoTypeIndex[PseudoTypeIndex["fn"] = 16] = "fn";
     PseudoTypeIndex[PseudoTypeIndex["cirru_quote"] = 17] = "cirru_quote";
 })(PseudoTypeIndex || (PseudoTypeIndex = {}));
@@ -62,8 +62,8 @@ let typeAsInt = (x) => {
         return PseudoTypeIndex.string;
     if (x instanceof CalcitRef)
         return PseudoTypeIndex.ref;
-    if (x instanceof CalcitTuple)
-        return PseudoTypeIndex.tuple;
+    if (x instanceof CalcitEnumValue)
+        return PseudoTypeIndex.enum_value;
     if (x instanceof CalcitRecur)
         return PseudoTypeIndex.recur;
     if (x instanceof CalcitList || x instanceof CalcitSliceList)
@@ -72,14 +72,14 @@ let typeAsInt = (x) => {
         return PseudoTypeIndex.set;
     if (x instanceof CalcitMap || x instanceof CalcitSliceMap)
         return PseudoTypeIndex.map;
-    if (x instanceof CalcitRecord)
-        return PseudoTypeIndex.record;
+    if (x instanceof CalcitStructValue)
+        return PseudoTypeIndex.struct_value;
     if (x instanceof CalcitImpl)
         return PseudoTypeIndex.impl;
-    if (x instanceof CalcitStruct)
-        return PseudoTypeIndex.struct;
-    if (x instanceof CalcitEnum)
-        return PseudoTypeIndex.enum_type;
+    if (x instanceof CalcitStructDef)
+        return PseudoTypeIndex.struct_def;
+    if (x instanceof CalcitEnumDef)
+        return PseudoTypeIndex.enum_def;
     if (x instanceof CalcitCirruQuote)
         return PseudoTypeIndex.cirru_quote;
     // proc, fn, macro, syntax, not distinguished

package/lib/{js-struct.d.mts → js-struct-def.d.mts}

@@ -1,13 +1,13 @@
 import { CalcitTag } from "./calcit-data.mjs";
 import { CalcitValue } from "./js-primes.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
-export declare class CalcitStruct {
+export declare class CalcitStructDef {
     name: CalcitTag;
     fields: CalcitTag[];
     fieldTypes: CalcitValue[];
     impls: CalcitImpl[];
     cachedHash: number;
     constructor(name: CalcitTag, fields: CalcitTag[], fieldTypes: CalcitValue[], impls?: CalcitImpl[]);
-    withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitStruct;
+    withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitStructDef;
     toString(disableJsDataWarning?: boolean): string;
 }

package/lib/{js-struct.mjs → js-struct-def.mjs}

@@ -1,9 +1,9 @@
 import { toString } from "./calcit-data.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
-export class CalcitStruct {
+export class CalcitStructDef {
     constructor(name, fields, fieldTypes, impls = []) {
         if (fields.length !== fieldTypes.length) {
-            throw new Error("CalcitStruct: fields and fieldTypes length mismatch");
+            throw new Error("CalcitStructDef: fields and fieldTypes length mismatch");
         }
         this.name = name;
         this.fields = fields;
@@ -13,18 +13,18 @@ export class CalcitStruct {
     }
     withImpls(impls) {
         if (impls instanceof CalcitImpl) {
-            return new CalcitStruct(this.name, this.fields, this.fieldTypes, [impls]);
+            return new CalcitStructDef(this.name, this.fields, this.fieldTypes, [impls]);
         }
         else if (Array.isArray(impls)) {
-            return new CalcitStruct(this.name, this.fields, this.fieldTypes, impls);
+            return new CalcitStructDef(this.name, this.fields, this.fieldTypes, impls);
         }
         throw new Error("Expected an impl as implementation");
     }
     toString(disableJsDataWarning = false) {
         if (this.fields.length !== this.fieldTypes.length) {
-            throw new Error("CalcitStruct: fields and fieldTypes length mismatch");
+            throw new Error("CalcitStructDef: fields and fieldTypes length mismatch");
         }
-        const parts = ["(%struct '", this.name.value];
+        const parts = ["(%struct-def '", this.name.value];
         for (let idx = 0; idx < this.fields.length; idx++) {
             const field = this.fields[idx];
             const fieldType = this.fieldTypes[idx];

package/lib/{js-record.d.mts → js-struct-value.d.mts}

@@ -2,35 +2,36 @@ import { Hash } from "@calcit/ternary-tree";
 import { CalcitValue } from "./js-primes.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
 import { CalcitTag } from "./calcit-data.mjs";
-import { CalcitStruct } from "./js-struct.mjs";
-export declare class CalcitRecord {
+import { CalcitStructDef } from "./js-struct-def.mjs";
+export declare class CalcitStructValue {
     name: CalcitTag;
     fields: Array<CalcitTag>;
     values: Array<CalcitValue>;
-    structRef: CalcitStruct;
+    structRef: CalcitStructDef;
     cachedHash: Hash;
-    constructor(name: CalcitTag, fields: Array<CalcitTag>, values?: Array<CalcitValue>, structRef?: CalcitStruct);
+    constructor(name: CalcitTag, fields: Array<CalcitTag>, values?: Array<CalcitValue>, structRef?: CalcitStructDef);
     get(k: CalcitValue): CalcitValue;
+    getRequired(k: CalcitValue): CalcitValue;
     getOrNil(k: CalcitValue): CalcitValue;
-    assoc(k: CalcitValue, v: CalcitValue): CalcitRecord;
+    assoc(k: CalcitValue, v: CalcitValue): CalcitStructValue;
     /** return -1 for missing */
     findIndex(k: CalcitValue): number;
     contains(k: CalcitValue): boolean;
     toString(disableJsDataWarning?: boolean): string;
-    withImpls(impl: CalcitValue | CalcitImpl[]): CalcitRecord;
+    withImpls(impl: CalcitValue | CalcitImpl[]): CalcitStructValue;
 }
-export declare let new_record: (name: CalcitValue, ...fields: Array<CalcitValue>) => CalcitValue;
-export declare let new_impl_record: (impl: CalcitImpl, name: CalcitValue, ...fields: Array<CalcitValue>) => CalcitValue;
+export declare let new_struct_value: (name: CalcitValue, ...fields: Array<CalcitValue>) => CalcitValue;
+export declare let new_impl_struct_value: (impl: CalcitImpl, name: CalcitValue, ...fields: Array<CalcitValue>) => CalcitValue;
 /** Loose record: `?{} :field1 val1 :field2 val2` – record without a declared struct.
  *  Fields are sorted by tag index. The record name is "?" (sentinel). */
 export declare let _$q__$M_: (...xs: Array<CalcitValue>) => CalcitValue;
 export declare let fieldsEqual: (xs: Array<CalcitTag>, ys: Array<CalcitTag>) => boolean;
 export declare let _$n__PCT__$M_: (proto: CalcitValue, ...xs: Array<CalcitValue>) => CalcitValue;
 export declare let _$n__PCT__$M__$q_: (proto: CalcitValue, ...xs: Array<CalcitValue>) => CalcitValue;
-export declare let _$n_record_$o_with: (proto: CalcitValue, ...xs: Array<CalcitValue>) => CalcitValue;
-export declare let _$n_record_$o_get_name: (x: CalcitValue) => CalcitTag;
-export declare let _$n_record_$o_struct: (x: CalcitValue) => CalcitValue;
-export declare let _$n_record_$o_from_map: (proto: CalcitValue, data: CalcitValue) => CalcitValue;
-export declare let _$n_record_$o_to_map: (x: CalcitValue) => CalcitValue;
-export declare let _$n_record_$o_matches_$q_: (x: CalcitValue, y: CalcitValue) => boolean;
-export declare function _$n_record_$o_extend_as(obj: CalcitValue, new_name: CalcitValue, new_key: CalcitValue, new_value: CalcitValue): CalcitRecord;
+export declare let _$n_struct_$o_with: (proto: CalcitValue, ...xs: Array<CalcitValue>) => CalcitValue;
+export declare let _$n_struct_$o_get_name: (x: CalcitValue) => CalcitTag;
+export declare let _$n_struct_$o_definition: (x: CalcitValue) => CalcitValue;
+export declare let _$n_struct_$o_from_map: (proto: CalcitValue, data: CalcitValue) => CalcitValue;
+export declare let _$n_struct_$o_to_map: (x: CalcitValue) => CalcitValue;
+export declare let _$n_struct_$o_matches_$q_: (x: CalcitValue, y: CalcitValue) => boolean;
+export declare function _$n_struct_$o_extend_as(obj: CalcitValue, new_name: CalcitValue, new_key: CalcitValue, new_value: CalcitValue): CalcitStructValue;