@calcit/procs 0.11.0-a8 → 0.11.0

package/ts-src/js-enum.mts

@@ -1,13 +1,12 @@
 import { CalcitRecord } from "./js-record.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
 
 export class CalcitEnum {
   prototype: CalcitRecord;
-  impls: CalcitRecord[];
   cachedHash: number;
 
-  constructor(prototype: CalcitRecord, impls: CalcitRecord[] = []) {
+  constructor(prototype: CalcitRecord) {
     this.prototype = prototype;
-    this.impls = impls;
     this.cachedHash = null;
   }
 
@@ -15,13 +14,20 @@ export class CalcitEnum {
     return this.prototype.name.value;
   }
 
-  withImpls(impls: CalcitRecord | CalcitRecord[]): CalcitEnum {
-    if (impls instanceof CalcitRecord) {
-      return new CalcitEnum(this.prototype, [impls]);
+  get impls(): CalcitImpl[] {
+    return this.prototype.structRef.impls;
+  }
+
+  withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitEnum {
+    let nextImpls: CalcitImpl[];
+    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(): string {

package/ts-src/js-impl.mts

@@ -0,0 +1,47 @@
+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>, origin: CalcitTrait | null = null) {
+    this.name = name;
+    this.origin = origin;
+    this.fields = fields;
+    this.values = values;
+    this.cachedHash = null;
+  }
+
+  get(k: CalcitValue) {
+    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: CalcitValue) {
+    let field = castTag(k);
+    let idx = findInFields(this.fields, field);
+    if (idx >= 0) {
+      return this.values[idx];
+    }
+    return undefined;
+  }
+
+  toString(disableJsDataWarning: boolean = false): string {
+    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/ts-src/js-primes.mts

@@ -2,12 +2,14 @@ import { CalcitTag, CalcitSymbol, CalcitFn, CalcitRecur } from "./calcit-data.mj
 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";
 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
@@ -25,6 +27,8 @@ export type CalcitValue =
   | CalcitFn
   | CalcitRecur // should not be exposed to function
   | CalcitRecord
+  | CalcitImpl
+  | CalcitTrait
   | CalcitStruct
   | CalcitEnum
   | CalcitCirruQuote
@@ -54,6 +58,7 @@ enum PseudoTypeIndex {
   set,
   map,
   record,
+  impl,
   struct,
   enum_type,
   fn,
@@ -76,6 +81,7 @@ let typeAsInt = (x: CalcitValue): number => {
   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 CalcitImpl) return PseudoTypeIndex.impl;
   if (x instanceof CalcitStruct) return PseudoTypeIndex.struct;
   if (x instanceof CalcitEnum) return PseudoTypeIndex.enum_type;
   if (x instanceof CalcitCirruQuote) return PseudoTypeIndex.cirru_quote;

package/ts-src/js-record.mts

@@ -1,16 +1,19 @@
 import { initTernaryTreeMap, Hash, insert } from "@calcit/ternary-tree";
 import { CalcitValue } from "./js-primes.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
 import { newTag, castTag, toString, CalcitTag, getStringName, findInFields } from "./calcit-data.mjs";
 
 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<CalcitRecord>;
+  structRef: CalcitStruct;
   cachedHash: Hash;
-  constructor(name: CalcitTag, fields: Array<CalcitTag>, values?: Array<CalcitValue>, impls?: Array<CalcitRecord>) {
+  constructor(name: CalcitTag, fields: Array<CalcitTag>, values?: Array<CalcitValue>, structRef?: CalcitStruct) {
     this.name = name;
     let fieldNames = fields.map(castTag);
     this.fields = fields;
@@ -23,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);
@@ -53,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) {
@@ -74,12 +77,17 @@ export class CalcitRecord {
     parts.push(")");
     return parts.join("");
   }
-  withImpls(impl: CalcitValue): CalcitRecord {
-    if (impl instanceof CalcitRecord) {
-      return new CalcitRecord(this.name, this.fields, this.values, [impl]);
+  withImpls(impl: CalcitValue | CalcitImpl[]): CalcitRecord {
+    let nextImpls: CalcitImpl[];
+    if (impl instanceof CalcitImpl) {
+      nextImpls = [impl];
+    } else if (Array.isArray(impl)) {
+      nextImpls = impl;
     } else {
-      throw new Error("Expected a record");
+      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);
   }
 }
 
@@ -96,7 +104,7 @@ export let new_record = (name: CalcitValue, ...fields: Array<CalcitValue>): Calc
   return new CalcitRecord(castTag(name), fieldNames);
 };
 
-export let new_impl_record = (impl: CalcitRecord, name: CalcitValue, ...fields: Array<CalcitValue>): CalcitValue => {
+export let new_impl_record = (impl: CalcitImpl, name: CalcitValue, ...fields: Array<CalcitValue>): CalcitValue => {
   let fieldNames = fields.map(castTag).sort((x, y) => {
     if (x.idx < y.idx) {
       return -1;
@@ -106,7 +114,9 @@ export let new_impl_record = (impl: CalcitRecord, name: CalcitValue, ...fields:
       throw new Error(`Unexpected duplication in record fields: ${x.toString()}`);
     }
   });
-  return new CalcitRecord(castTag(name), fieldNames, undefined, [impl]);
+  let nameTag = castTag(name);
+  let structRef = new CalcitStruct(nameTag, fieldNames, new Array(fieldNames.length).fill(null), [impl]);
+  return new CalcitRecord(nameTag, fieldNames, undefined, structRef);
 };
 
 export let fieldsEqual = (xs: Array<CalcitTag>, ys: Array<CalcitTag>): boolean => {
@@ -154,7 +164,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);
+    return new CalcitRecord(proto.name, proto.fields, values, proto.structRef);
   } else {
     throw new Error("Expected prototype to be a record");
   }
@@ -176,7 +186,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-struct.mts

@@ -1,15 +1,15 @@
 import { CalcitTag, toString } from "./calcit-data.mjs";
 import { CalcitValue } from "./js-primes.mjs";
-import { CalcitRecord } from "./js-record.mjs";
+import { CalcitImpl } from "./js-impl.mjs";
 
 export class CalcitStruct {
   name: CalcitTag;
   fields: CalcitTag[];
   fieldTypes: CalcitValue[];
-  impls: CalcitRecord[];
+  impls: CalcitImpl[];
   cachedHash: number;
 
-  constructor(name: CalcitTag, fields: CalcitTag[], fieldTypes: CalcitValue[], impls: CalcitRecord[] = []) {
+  constructor(name: CalcitTag, fields: CalcitTag[], fieldTypes: CalcitValue[], impls: CalcitImpl[] = []) {
     if (fields.length !== fieldTypes.length) {
       throw new Error("CalcitStruct: fields and fieldTypes length mismatch");
     }
@@ -20,13 +20,13 @@ export class CalcitStruct {
     this.cachedHash = null;
   }
 
-  withImpls(impls: CalcitRecord | CalcitRecord[]): CalcitStruct {
-    if (impls instanceof CalcitRecord) {
+  withImpls(impls: CalcitImpl | CalcitImpl[]): CalcitStruct {
+    if (impls instanceof CalcitImpl) {
       return new CalcitStruct(this.name, this.fields, this.fieldTypes, [impls]);
     } else if (Array.isArray(impls)) {
       return new CalcitStruct(this.name, this.fields, this.fieldTypes, impls);
     }
-    throw new Error("Expected a record as implementation");
+    throw new Error("Expected an impl as implementation");
   }
 
   toString(disableJsDataWarning: boolean = false): string {

package/ts-src/js-tuple.mts

@@ -2,22 +2,32 @@ 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";
 
 export class CalcitTuple {
   tag: CalcitValue;
   extra: CalcitValue[];
-  impls: CalcitRecord[];
   enumPrototype: CalcitRecord | CalcitEnum;
   cachedHash: Hash;
-  constructor(tagName: CalcitValue, extra: CalcitValue[], impls: CalcitRecord[] = [], 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;
@@ -29,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`);
     }
@@ -67,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})`;
   }
 }