@calcit/procs 0.11.0-a9 → 0.11.1

package/ts-src/js-impl.mts

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

package/ts-src/js-primes.mts

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

package/ts-src/js-record.mts

@@ -5,13 +5,15 @@ import { newTag, castTag, toString, CalcitTag, getStringName, findInFields } fro
 
 import { CalcitMap, CalcitSliceMap } from "./js-map.mjs";
 
+import { CalcitStruct } from "./js-struct.mjs";
+
 export class CalcitRecord {
   name: CalcitTag;
   fields: Array<CalcitTag>;
   values: Array<CalcitValue>;
-  impls: Array<CalcitImpl>;
+  structRef: CalcitStruct;
   cachedHash: Hash;
-  constructor(name: CalcitTag, fields: Array<CalcitTag>, values?: Array<CalcitValue>, impls?: Array<CalcitImpl>) {
+  constructor(name: CalcitTag, fields: Array<CalcitTag>, values?: Array<CalcitValue>, structRef?: CalcitStruct) {
     this.name = name;
     let fieldNames = fields.map(castTag);
     this.fields = fields;
@@ -24,7 +26,7 @@ export class CalcitRecord {
       this.values = new Array(fieldNames.length);
     }
     this.cachedHash = null;
-    this.impls = impls || [];
+    this.structRef = structRef || new CalcitStruct(name, fields, new Array(fields.length).fill(null));
   }
   get(k: CalcitValue) {
     let field = castTag(k);
@@ -54,7 +56,7 @@ export class CalcitRecord {
         values[idx] = this.values[idx];
       }
     }
-    return new CalcitRecord(this.name, this.fields, values, this.impls);
+    return new CalcitRecord(this.name, this.fields, values, this.structRef);
   }
   /** return -1 for missing */
   findIndex(k: CalcitValue) {
@@ -75,12 +77,17 @@ export class CalcitRecord {
     parts.push(")");
     return parts.join("");
   }
-  withImpls(impl: CalcitValue): CalcitRecord {
+  withImpls(impl: CalcitValue | CalcitImpl[]): CalcitRecord {
+    let nextImpls: CalcitImpl[];
     if (impl instanceof CalcitImpl) {
-      return new CalcitRecord(this.name, this.fields, this.values, [impl]);
+      nextImpls = [impl];
+    } else if (Array.isArray(impl)) {
+      nextImpls = impl;
     } else {
-      throw new Error("Expected an impl");
+      throw new Error("Expected an impl or array of impls");
     }
+    let nextStruct = new CalcitStruct(this.name, this.fields, this.structRef.fieldTypes, this.structRef.impls.concat(nextImpls));
+    return new CalcitRecord(this.name, this.fields, this.values, nextStruct);
   }
 }
 
@@ -107,7 +114,9 @@ export let new_impl_record = (impl: CalcitImpl, name: CalcitValue, ...fields: Ar
       throw new Error(`Unexpected duplication in record fields: ${x.toString()}`);
     }
   });
-  return new CalcitRecord(castTag(name), fieldNames, undefined, [impl]);
+  let nameTag = castTag(name);
+  let structRef = new CalcitStruct(nameTag, fieldNames, new Array(fieldNames.length).fill(null), [impl]);
+  return new CalcitRecord(nameTag, fieldNames, undefined, structRef);
 };
 
 export let fieldsEqual = (xs: Array<CalcitTag>, ys: Array<CalcitTag>): boolean => {
@@ -126,20 +135,28 @@ export let fieldsEqual = (xs: Array<CalcitTag>, ys: Array<CalcitTag>): boolean =
 };
 
 export let _$n__PCT__$M_ = (proto: CalcitValue, ...xs: Array<CalcitValue>): CalcitValue => {
+  let recordProto: CalcitRecord;
   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);
+    let values = new Array(recordProto.fields.length);
 
-    for (let i = 0; i < proto.fields.length; i++) {
+    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;
@@ -155,9 +172,7 @@ export let _$n__PCT__$M_ = (proto: CalcitValue, ...xs: Array<CalcitValue>): Calc
       values[i] = xs[idx * 2 + 1];
     }
 
-    return new CalcitRecord(proto.name, proto.fields, values, proto.impls);
-  } else {
-    throw new Error("Expected prototype to be a record");
+    return new CalcitRecord(recordProto.name, recordProto.fields, values, recordProto.structRef);
   }
 };
 
@@ -177,7 +192,7 @@ export let _$n_record_$o_with = (proto: CalcitValue, ...xs: Array<CalcitValue>):
       }
       values[idx] = v;
     }
-    return new CalcitRecord(proto.name, proto.fields, values, proto.impls);
+    return new CalcitRecord(proto.name, proto.fields, values, proto.structRef);
   } else {
     throw new Error("Expected prototype to be a record");
   }

package/ts-src/js-tag-helpers.mts

@@ -0,0 +1,17 @@
+import { CalcitTag, newTag } from "./calcit-data.mjs";
+
+let _tag_cache: Record<string, CalcitTag> = {};
+
+export let init_tags = (arr: string[]) => {
+  let tags: Record<string, CalcitTag> = {};
+  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/ts-src/js-tuple.mts

@@ -9,16 +9,25 @@ import { CalcitEnum } from "./js-enum.mjs";
 export class CalcitTuple {
   tag: CalcitValue;
   extra: CalcitValue[];
-  impls: CalcitImpl[];
   enumPrototype: CalcitRecord | CalcitEnum;
   cachedHash: Hash;
-  constructor(tagName: CalcitValue, extra: CalcitValue[], impls: CalcitImpl[] = [], enumPrototype: CalcitRecord | CalcitEnum = null) {
+  constructor(tagName: CalcitValue, extra: CalcitValue[], enumPrototype: CalcitRecord | CalcitEnum = null) {
     this.tag = tagName;
     this.extra = extra;
-    this.impls = impls;
     this.enumPrototype = enumPrototype;
     this.cachedHash = null;
   }
+
+  get impls(): CalcitImpl[] {
+    if (this.enumPrototype == null) {
+      return [];
+    }
+    if (this.enumPrototype instanceof CalcitEnum) {
+      return this.enumPrototype.impls;
+    }
+    return this.enumPrototype.structRef.impls;
+  }
+
   get(n: number) {
     if (n === 0) {
       return this.tag;
@@ -30,11 +39,11 @@ export class CalcitTuple {
   }
   assoc(n: number, v: CalcitValue) {
     if (n === 0) {
-      return new CalcitTuple(v, this.extra, this.impls, this.enumPrototype);
+      return new CalcitTuple(v, this.extra, this.enumPrototype);
     } else if (n - 1 < this.extra.length) {
       let next_extra = this.extra.slice();
       next_extra[n - 1] = v;
-      return new CalcitTuple(this.tag, next_extra, this.impls, this.enumPrototype);
+      return new CalcitTuple(this.tag, next_extra, this.enumPrototype);
     } else {
       throw new Error(`Tuple only have ${this.extra.length} elements`);
     }
@@ -68,15 +77,9 @@ export class CalcitTuple {
     const hasEnum = this.enumPrototype != null;
     const enumName = hasEnum ? (this.enumPrototype instanceof CalcitEnum ? this.enumPrototype.prototype.name.value : this.enumPrototype.name.value) : null;
 
-    if (this.impls.length > 0 && hasEnum) {
-      return `(%:: ${content} (:impls ${this.impls[0].name.value}) (:enum ${enumName}))`;
-    }
     if (hasEnum) {
       return `(%:: ${content} (:enum ${enumName}))`;
     }
-    if (this.impls.length > 0) {
-      return `(:: ${content} (:impls ${this.impls[0].name.value}))`;
-    }
     return `(:: ${content})`;
   }
 }