@calcit/procs 0.13.0 → 0.13.2

package/ts-src/custom-formatter.mts

@@ -2,11 +2,13 @@ import { CalcitValue, 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 { 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";
 
 declare global {
@@ -179,44 +181,38 @@ export let load_console_formatter_$x_ = () => {
               preview
             );
           }
-          if (obj instanceof CalcitRecord) {
-            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.structRef.impls[0])),
-                span({ marginLeft: "6px" }, embedObject(obj.name)),
-                span({ marginLeft: "6px" }, `...`)
-              );
-              return ret;
-            } else {
-              let ret: any[] = div({ color: hsl(280, 80, 60, 0.4), maxWidth: "100%" }, `%{} ${obj.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 CalcitTuple) {
-            if (obj.impls.length > 0) {
-              let ret: any[] = 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: any[] = 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 CalcitStructDef) {
+            return div(
+              { color: hsl(280, 80, 60, 0.4), maxWidth: "100%" },
+              "%struct-def ",
+              embedObject(new CalcitSymbol(obj.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 CalcitEnumValue) {
+            const enumName = obj.enumPrototype == null ? "_" : obj.enumPrototype.name();
+            let ret: any[] = 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(
@@ -252,9 +248,12 @@ 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 CalcitStructDef || obj instanceof CalcitEnumDef) {
+            return obj instanceof CalcitStructDef ? obj.fields.length > 0 : obj.prototype.fields.length > 0;
+          }
           return false;
         },
         body: (obj, config) => {
@@ -317,7 +316,7 @@ export let load_console_formatter_$x_ = () => {
             }
             return ret;
           }
-          if (obj instanceof CalcitRecord) {
+          if (obj instanceof CalcitStructValue) {
             let ret: any[] = table({ color: hsl(280, 80, 60), borderLeft: "1px solid #eee" });
             for (let idx = 0; idx < obj.fields.length; idx++) {
               ret.push(
@@ -330,6 +329,32 @@ export let load_console_formatter_$x_ = () => {
             }
             return ret;
           }
+          if (obj instanceof CalcitStructDef) {
+            let ret: any[] = 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 CalcitEnumDef) {
+            let ret: any[] = 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]))
+                )
+              );
+            }
+            return ret;
+          }
 
           return null;
         },

package/ts-src/js-cirru.mts

@@ -3,12 +3,12 @@ import { CirruWriterNode, writeCirruCode, writeCirruOneLiner } from "@cirru/writ
 
 import { CalcitValue, 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";
@@ -151,7 +151,7 @@ export let to_cirru_edn = (x: CalcitValue): CirruEdnFormat => {
     }
     return buffer;
   }
-  if (x instanceof CalcitRecord) {
+  if (x instanceof CalcitStructValue) {
     let buffer: [string, CirruEdnFormat][] = [];
     for (let idx = 0; idx < x.fields.length; idx++) {
       buffer.push([x.fields[idx].toString(), to_cirru_edn(x.values[idx])]);
@@ -174,7 +174,7 @@ export let to_cirru_edn = (x: CalcitValue): CirruEdnFormat => {
     }
     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) as any)] as CirruEdnFormat;
@@ -182,7 +182,7 @@ export let to_cirru_edn = (x: CalcitValue): CirruEdnFormat => {
       let enumTag = unwrap_enum_prototype_local(x.enumPrototype).name.toString();
       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) {
         return ["%::", enumTag, x.tag.name.toString(), ...x.extra.map(to_cirru_edn)];
@@ -191,7 +191,7 @@ export let to_cirru_edn = (x: CalcitValue): CirruEdnFormat => {
       }
     } 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) {
       return ["::", x.tag.name.toString(), ...x.extra.map(to_cirru_edn)];
@@ -230,9 +230,12 @@ let extractFieldTag = (x: string) => {
 let resolveEnumPrototype = (enumName: string, options: CalcitValue) => {
   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}`);
     }
@@ -240,20 +243,17 @@ let resolveEnumPrototype = (enumName: string, options: CalcitValue) => {
   return null;
 };
 
-// local helper to unwrap an enum prototype value to a CalcitRecord prototype
-const unwrap_enum_prototype_local = (enumPrototype: CalcitValue): CalcitRecord => {
-  if (enumPrototype instanceof CalcitEnum) {
+// local helper to inspect an EnumDef's variant prototype
+const unwrap_enum_prototype_local = (enumPrototype: CalcitValue): CalcitStructValue => {
+  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: CalcitValue): string => {
   if (tag instanceof CalcitTag) return tag.toString();
-  if (tag instanceof CalcitRecord) return tag.name.toString();
+  if (tag instanceof CalcitStructValue) return tag.name.toString();
   throw new Error(`Unsupported tag for EDN: ${tag}`);
 };
 
@@ -321,7 +321,7 @@ const extract_cirru_edn_inner = (x: CirruEdnFormat, options: CalcitValue, preser
     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: Array<[CalcitTag, CalcitValue]> = [];
@@ -344,7 +344,7 @@ const extract_cirru_edn_inner = (x: CirruEdnFormat, options: CalcitValue, preser
             throw new Error(`Expected pair of size 2, got: ${pair}`);
           }
         } else {
-          throw new Error(`Expected pairs for record, got: ${pair}`);
+          throw new Error(`Expected field pairs for struct, got: ${pair}`);
         }
       });
       entries.sort((a, b) => {
@@ -360,14 +360,14 @@ const extract_cirru_edn_inner = (x: CirruEdnFormat, options: CalcitValue, preser
 
       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: any) => {
       if (x instanceof Array && x[0] === ";") {
@@ -402,9 +402,9 @@ const extract_cirru_edn_inner = (x: CirruEdnFormat, options: CalcitValue, preser
     }
     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(
+      return new CalcitEnumValue(
         extract_cirru_edn_inner(x[1], options, preserveSourceEntries),
         x
           .slice(2)
@@ -424,7 +424,7 @@ const extract_cirru_edn_inner = (x: CirruEdnFormat, options: CalcitValue, preser
       // 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(
+      return new CalcitEnumValue(
         extract_cirru_edn_inner(x[2], options, preserveSourceEntries),
         x
           .slice(3)
@@ -505,12 +505,12 @@ export let to_calcit_data = (x: any, noKeyword: boolean = false): CalcitValue =>
   if (x instanceof CalcitList || x instanceof CalcitSliceList) return x;
   if (x instanceof CalcitMap || x instanceof CalcitSliceMap) return x;
   if (x instanceof CalcitSet) return x;
-  if (x instanceof CalcitRecord) return x;
+  if (x instanceof CalcitStructValue) return x;
   if (x instanceof CalcitRecur) return x;
   if (x instanceof CalcitRef) return x;
   if (x instanceof CalcitTag) return x;
   if (x instanceof CalcitSymbol) return x;
-  if (x instanceof CalcitTuple) return x;
+  if (x instanceof CalcitEnumValue) return x;
 
   // detects object
   if (x === Object(x)) {

package/ts-src/{js-enum.mts → js-enum-def.mts}

@@ -1,11 +1,11 @@
-import { CalcitRecord } from "./js-record.mjs";
+import { CalcitStructValue } from "./js-struct-value.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
 
-export class CalcitEnum {
-  prototype: CalcitRecord;
+export class CalcitEnumDef {
+  prototype: CalcitStructValue;
   cachedHash: number;
 
-  constructor(prototype: CalcitRecord) {
+  constructor(prototype: CalcitStructValue) {
     this.prototype = prototype;
     this.cachedHash = null;
   }
@@ -18,7 +18,7 @@ export class CalcitEnum {
     return this.prototype.structRef.impls;
   }
 
-  withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitEnum {
+  withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitEnumDef {
     let nextImpls: CalcitImpl[];
     if (impls instanceof CalcitImpl) {
       nextImpls = [impls];
@@ -27,10 +27,10 @@ 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(): string {
-    return `(%enum :${this.prototype.name.value})`;
+    return `(%enum-def '${this.prototype.name.value})`;
   }
 }

package/ts-src/{js-tuple.mts → js-enum-value.mts}

@@ -3,15 +3,14 @@ import { Hash } from "@calcit/ternary-tree";
 import { CalcitValue } from "./js-primes.mjs";
 import { _$n__$e_, newTag, toString } from "./calcit-data.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
-import { CalcitRecord } from "./js-record.mjs";
-import { CalcitEnum } from "./js-enum.mjs";
+import { CalcitEnumDef } from "./js-enum-def.mjs";
 
-export class CalcitTuple {
+export class CalcitEnumValue {
   tag: CalcitValue;
   extra: CalcitValue[];
-  enumPrototype: CalcitRecord | CalcitEnum;
+  enumPrototype: CalcitEnumDef;
   cachedHash: Hash;
-  constructor(tagName: CalcitValue, extra: CalcitValue[], enumPrototype: CalcitRecord | CalcitEnum = null) {
+  constructor(tagName: CalcitValue, extra: CalcitValue[], enumPrototype: CalcitEnumDef = null) {
     this.tag = tagName;
     this.extra = extra;
     this.enumPrototype = enumPrototype;
@@ -22,10 +21,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: number) {
@@ -34,24 +30,24 @@ export class CalcitTuple {
     } else if (n - 1 < this.extra.length) {
       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: number, v: CalcitValue) {
     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() {
     return 1 + this.extra.length;
   }
-  eq(y: CalcitTuple): boolean {
+  eq(y: CalcitEnumValue): boolean {
     if (!_$n__$e_(this.tag, y.tag)) {
       return false;
     }
@@ -75,11 +71,8 @@ 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;
+    const enumName = hasEnum ? this.enumPrototype.name() : null;
 
-    if (hasEnum) {
-      return `(%:: ${content} (:enum ${enumName}))`;
-    }
-    return `(:: ${content})`;
+    return `(%:: ${hasEnum ? `'${enumName}` : "_"} ${content})`;
   }
 }

package/ts-src/js-list.mts

@@ -18,7 +18,7 @@ import {
 
 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, CalcitFn } from "./calcit-data.mjs";
 
@@ -349,7 +349,7 @@ export let foldl_shortcut = function (xs: CalcitValue, acc: CalcitValue, v0: Cal
     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);
@@ -369,7 +369,7 @@ export let foldl_shortcut = function (xs: CalcitValue, acc: CalcitValue, v0: Cal
     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);
@@ -390,7 +390,7 @@ export let foldl_shortcut = function (xs: CalcitValue, acc: CalcitValue, v0: Cal
     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);
@@ -410,7 +410,7 @@ export let foldl_shortcut = function (xs: CalcitValue, acc: CalcitValue, v0: Cal
     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);
@@ -440,7 +440,7 @@ export let foldr_shortcut = function (xs: CalcitValue, acc: CalcitValue, v0: Cal
     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/ts-src/js-primes.mts

@@ -1,13 +1,13 @@
 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, cirru_deep_equal } from "./js-cirru.mjs";
 import { CalcitTrait } from "./js-trait.mjs";
 
@@ -23,14 +23,14 @@ export type CalcitValue =
   | CalcitTag
   | CalcitSymbol
   | CalcitRef
-  | CalcitTuple
+  | CalcitEnumValue
   | CalcitFn
   | CalcitRecur // should not be exposed to function
-  | CalcitRecord
+  | CalcitStructValue
   | CalcitImpl
   | CalcitTrait
-  | CalcitStruct
-  | CalcitEnum
+  | CalcitStructDef
+  | CalcitEnumDef
   | CalcitCirruQuote
   | null;
 
@@ -52,15 +52,15 @@ enum PseudoTypeIndex {
   tag,
   string,
   ref,
-  tuple,
+  enum_value,
   recur,
   list,
   set,
   map,
-  record,
+  struct_value,
   impl,
-  struct,
-  enum_type,
+  struct_def,
+  enum_def,
   fn,
   cirru_quote,
 }
@@ -75,15 +75,15 @@ let typeAsInt = (x: CalcitValue): number => {
   if (x instanceof CalcitTag) return PseudoTypeIndex.tag;
   if (t === "string") 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) return PseudoTypeIndex.list;
   if (x instanceof CalcitSet) return PseudoTypeIndex.set;
   if (x instanceof CalcitMap || x instanceof CalcitSliceMap) return PseudoTypeIndex.map;
-  if (x instanceof CalcitRecord) return PseudoTypeIndex.record;
+  if (x instanceof 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
   if (t === "function") return PseudoTypeIndex.fn;

package/ts-src/{js-struct.mts → js-struct-def.mts}

@@ -2,7 +2,7 @@ import { CalcitTag, toString } from "./calcit-data.mjs";
 import { CalcitValue } from "./js-primes.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
 
-export class CalcitStruct {
+export class CalcitStructDef {
   name: CalcitTag;
   fields: CalcitTag[];
   fieldTypes: CalcitValue[];
@@ -11,7 +11,7 @@ export class CalcitStruct {
 
   constructor(name: CalcitTag, fields: CalcitTag[], fieldTypes: CalcitValue[], impls: CalcitImpl[] = []) {
     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;
@@ -20,20 +20,20 @@ export class CalcitStruct {
     this.cachedHash = null;
   }
 
-  withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitStruct {
+  withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitStructDef {
     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: boolean = false): string {
     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: string[] = ["(%struct :", this.name.value];
+    const parts: string[] = ["(%struct-def '", this.name.value];
     for (let idx = 0; idx < this.fields.length; idx++) {
       const field = this.fields[idx];
       const fieldType = this.fieldTypes[idx];