@elaraai/east 0.0.1-beta.0 → 0.0.1-beta.2

package/dist/src/types.js

@@ -48,9 +48,6 @@ export const BlobType = { type: "Blob" };
  * @throws When the element type contains functions
  */
 export function RefType(type) {
-    if (typeof type !== "string" && !isDataType(type)) {
-        throw new Error(`Ref value type must be a (non-function) data type, got ${printType(type)}`);
-    }
     return { type: "Ref", value: type };
 }
 ;
@@ -63,9 +60,6 @@ export function RefType(type) {
  * @throws When the element type contains functions
  */
 export function ArrayType(type) {
-    if (typeof type !== "string" && !isDataType(type)) {
-        throw new Error(`Array value type must be a (non-function) data type, got ${printType(type)}`);
-    }
     return { type: "Array", value: type };
 }
 ;
@@ -98,9 +92,6 @@ export function DictType(key, value) {
     if (typeof key !== "string" && !isImmutableType(key)) {
         throw new Error(`Dict key type must be an immutable type, got ${printType(key)}`);
     }
-    if (typeof value !== "string" && !isDataType(value)) {
-        throw new Error(`Dict value type must be a (non-function) data type, got ${printType(value)}`);
-    }
     return { type: "Dict", key, value };
 }
 ;
@@ -112,12 +103,6 @@ export function DictType(key, value) {
  * @returns A Struct type
  */
 export function StructType(field_types) {
-    // Validate all field types are data types (no functions)
-    for (const [field_name, field_type] of Object.entries(field_types)) {
-        if (typeof field_type !== "string" && !isDataType(field_type)) {
-            throw new Error(`Struct field ${field_name} must be a (non-function) data type, got ${printType(field_type)}`);
-        }
-    }
     return { type: "Struct", fields: field_types };
 }
 ;
@@ -129,12 +114,6 @@ export function StructType(field_types) {
  * @returns A Variant type with cases sorted alphabetically
  */
 export function VariantType(case_types) {
-    // Validate all case types are data types (no functions)
-    for (const [case_name, case_type] of Object.entries(case_types)) {
-        if (typeof case_type !== "string" && !isDataType(case_type)) {
-            throw new Error(`Variant case ${case_name} must be a (non-function) data type, got ${printType(case_type)}`);
-        }
-    }
     // Cases are sorted alphabetically by their name
     const cases_sorted = Object.fromEntries(Object.entries(case_types).sort((x, y) => x[0] < y[0] ? -1 : x[0] === y[0] ? 0 : 1));
     return { type: "Variant", cases: cases_sorted };
@@ -154,7 +133,7 @@ export function VariantType(case_types) {
  */
 function validateNotMutuallyRecursive(type, allowedMarker) {
     const visited = new Set();
-    function check(t) {
+    function check(t, allowed) {
         // Skip string placeholders (used for generic builtins)
         if (typeof t === "string")
             return;
@@ -167,8 +146,12 @@ function validateNotMutuallyRecursive(type, allowedMarker) {
             throw new Error(`Invalid type encountered during recursion validation: ${t}${allowedMarkerString === null ? "" : ` (allowed marker: ${allowedMarkerString})`}`);
         }
         // Skip allowedMarker
-        if (t === allowedMarker)
+        if (t === allowedMarker) {
+            if (!allowed) {
+                throw new Error("RecursiveType cannot pass into set keys, dictionary keys, or function input/output types");
+            }
             return;
+        }
         // Avoid infinite loops
         if (visited.has(t))
             return;
@@ -185,31 +168,38 @@ function validateNotMutuallyRecursive(type, allowedMarker) {
         }
         else if (t.type === "Struct") {
             for (const [_, field_type] of Object.entries(t.fields)) {
-                check(field_type);
+                check(field_type, allowed);
             }
         }
         else if (t.type === "Variant") {
             for (const [_, case_type] of Object.entries(t.cases)) {
-                check(case_type);
+                check(case_type, allowed);
             }
         }
+        else if (t.type === "Ref") {
+            check(t.value, allowed);
+        }
         else if (t.type === "Array") {
-            check(t.value);
+            check(t.value, allowed);
         }
         else if (t.type === "Set") {
-            check(t.key);
+            check(t.key, false);
         }
         else if (t.type === "Dict") {
-            check(t.key);
-            check(t.value);
+            check(t.key, false);
+            check(t.value, allowed);
         }
         else if (t.type === "Function") {
-            t.inputs.forEach(check);
-            check(t.output);
+            t.inputs.forEach(input => check(input, false));
+            check(t.output, false);
+        }
+        else if (t.type === "AsyncFunction") {
+            t.inputs.forEach(input => check(input, false));
+            check(t.output, false);
         }
         // Primitive types don't need recursion
     }
-    check(type);
+    check(type, true);
 }
 /**
  * Constructs a recursive type with the specified node structure.
@@ -252,25 +242,33 @@ export function RecursiveType(f) {
     ret.node = type;
     // Validate SCC size 1 (no nested RecursiveTypes with cross-references)
     validateNotMutuallyRecursive(type, ret);
-    if (typeof type !== "string" && !isDataType(type)) {
-        throw new Error(`Recursive node type must be a (non-function) data type, got ${printType(type)}`);
-    }
     return ret;
 }
 ;
 /**
  * Constructs a Function type with the specified input and output types.
  *
- * @typeParam I - Tuple type of input parameter types
- * @typeParam O - The output/return type
  * @param inputs - Array of {@link EastType} instances for each parameter
  * @param output - The {@link EastType} of the return value
  * @returns A Function type
+ *
+ * @see {@link AsyncFunctionType} for asynchronous functions.
  */
-export function FunctionType(inputs, output, platforms) {
-    // TODO - for the moment we default function types to being pure, meaning users may need to annotate their higher-order functions.
-    // In future we may want to track side-effects more precisely.
-    return { type: "Function", inputs, output, platforms };
+export function FunctionType(inputs, output) {
+    return { type: "Function", inputs, output };
+}
+;
+/**
+ * Constructs an AsyncFunction type with the specified input and output types.
+ *
+ * @param inputs - Array of {@link EastType} instances for each parameter
+ * @param output - The {@link EastType} of the return value
+ * @returns An AsyncFunction type
+ *
+ * @see {@link AsyncFunctionType} for asynchronous functions.
+ */
+export function AsyncFunctionType(inputs, output) {
+    return { type: "AsyncFunction", inputs, output };
 }
 ;
 /**
@@ -281,8 +279,7 @@ export function FunctionType(inputs, output, platforms) {
  * @returns `true` if the type is a pure data type, `false` if it contains functions
  *
  * @remarks
- * Data types can be fully serialized and transmitted between runtimes.
- * This recursively checks {@link StructType}, {@link VariantType}, and {@link RecursiveType} fields.
+ * Data types have a total ordering, can be fully serialized and transmitted between runtimes.
  */
 export function isDataType(type, recursive_type) {
     // Avoid infinite loops
@@ -290,20 +287,18 @@ export function isDataType(type, recursive_type) {
         return true;
     }
     if (type.type === "Ref") {
-        // Ref constructors check their value type are data types
-        return true;
+        return isDataType(type.value, recursive_type);
     }
     else if (type.type === "Array") {
-        // Array constructors check their value type are data types
-        return true;
+        return isDataType(type.value, recursive_type);
     }
     else if (type.type === "Set") {
-        // Set constructors check their value type are (immutable) data types
+        // Set constructors check their key type is an (immutable) data type
         return true;
     }
     else if (type.type === "Dict") {
-        // Dict constructors check their key and value types are data types
-        return true;
+        // Dict constructors check their key type is an (immutable) data type
+        return isDataType(type.value, recursive_type);
     }
     else if (type.type === "Struct") {
         for (const field_type of Object.values(type.fields)) {
@@ -327,6 +322,9 @@ export function isDataType(type, recursive_type) {
     else if (type.type === "Function") {
         return false;
     }
+    else if (type.type === "AsyncFunction") {
+        return false;
+    }
     else {
         // Primitive types are data types
         return true;
@@ -340,8 +338,7 @@ export function isDataType(type, recursive_type) {
  * @returns `true` if the type is immutable, `false` if it contains mutable collections or functions
  *
  * @remarks
- * Immutable types exclude {@link ArrayType}, {@link SetType}, {@link DictType}, and {@link FunctionType}.
- * This recursively checks {@link StructType}, {@link VariantType}, and {@link RecursiveType} fields.
+ * Immutable types exclude {@link ArrayType}, {@link SetType}, {@link DictType}, {@link FunctionType} and {@link AsyncFunctionType}.
  */
 export function isImmutableType(type, recursive_type) {
     // Avoid infinite loops
@@ -387,6 +384,10 @@ export function isImmutableType(type, recursive_type) {
         // Functions are not data types, and "immutable data" is a subset of "data"
         return false;
     }
+    else if (type.type === "AsyncFunction") {
+        // Functions are not data types, and "immutable data" is a subset of "data"
+        return false;
+    }
     else {
         // Primitive types are immutable
         return true;
@@ -470,7 +471,34 @@ export function EastTypeOf(value) {
  * For {@link StructType} and {@link VariantType}, field/case order matters.
  * For {@link RecursiveType}, uses cycle tracking to handle recursive references.
  */
+// Cache for memoizing isTypeEqual results (top-level calls only)
+const typeEqualCache = new WeakMap();
 export function isTypeEqual(t1, t2, r1 = t1, r2 = t2) {
+    // Fast path: reference equality
+    if (t1 === t2)
+        return true;
+    // Memoization for top-level calls only (r1/r2 are just for internal cycle detection)
+    const isTopLevel = r1 === t1 && r2 === t2;
+    if (isTopLevel) {
+        const innerCache = typeEqualCache.get(t1);
+        if (innerCache) {
+            const cached = innerCache.get(t2);
+            if (cached !== undefined)
+                return cached;
+        }
+        const result = isTypeEqualImpl(t1, t2, r1, r2);
+        // Store result in cache
+        let cache = typeEqualCache.get(t1);
+        if (!cache) {
+            cache = new WeakMap();
+            typeEqualCache.set(t1, cache);
+        }
+        cache.set(t2, result);
+        return result;
+    }
+    return isTypeEqualImpl(t1, t2, r1, r2);
+}
+function isTypeEqualImpl(t1, t2, r1, r2) {
     if (t1.type === "Recursive") {
         if (t2.type === "Recursive") {
             if (t1.node === r1) {
@@ -607,21 +635,25 @@ export function isTypeEqual(t1, t2, r1 = t1, r2 = t2) {
         if (!isTypeEqual(t1.output, t2.output, r1, r2)) {
             return false;
         }
-        // Check platform requirements match
-        if (t1.platforms === null && t2.platforms === null) {
-            return true;
-        }
-        if (t1.platforms === null || t2.platforms === null) {
+        return true;
+    }
+    else if (t1.type === "AsyncFunction") {
+        if (t2.type !== "AsyncFunction") {
             return false;
         }
-        if (t1.platforms.length !== t2.platforms.length) {
+        // Check input types match
+        if (t1.inputs.length !== t2.inputs.length) {
             return false;
         }
-        for (let i = 0; i < t1.platforms.length; i++) {
-            if (t1.platforms[i] !== t2.platforms[i]) {
+        for (let i = 0; i < t1.inputs.length; i++) {
+            if (!isTypeEqual(t1.inputs[i], t2.inputs[i], r1, r2)) {
                 return false;
             }
         }
+        // Check output type matches
+        if (!isTypeEqual(t1.output, t2.output, r1, r2)) {
+            return false;
+        }
         return true;
     }
     else {
@@ -750,6 +782,9 @@ export function isValueOf(value, type, node_type, nodes_visited) {
     else if (type.type === "Function") {
         throw new Error('Javascript functions cannot be converted to East functions');
     }
+    else if (type.type === "AsyncFunction") {
+        throw new Error('Javascript functions cannot be converted to East async functions');
+    }
     else {
         throw new Error(`Unknown type encountered during value type check: ${type.type}`);
     }
@@ -843,7 +878,14 @@ export function printType(type, stack = []) {
     else if (type.type === "Function") {
         // Note: functions can't be inside recursive types
         stack.push(type);
-        const ret = `.Function (inputs=[${type.inputs.map(t => printType(t, stack)).join(", ")}], output=${printType(type.output, stack)}, platforms=${type.platforms === null ? "null" : `[${type.platforms.map(p => JSON.stringify(p)).join(", ")}]`})`;
+        const ret = `.Function (inputs=[${type.inputs.map(t => printType(t, stack)).join(", ")}], output=${printType(type.output, stack)})`;
+        stack.pop();
+        return ret;
+    }
+    else if (type.type === "AsyncFunction") {
+        // Note: functions can't be inside recursive types
+        stack.push(type);
+        const ret = `.AsyncFunction (inputs=[${type.inputs.map(t => printType(t, stack)).join(", ")}], output=${printType(type.output, stack)})`;
         stack.pop();
         return ret;
     }
@@ -865,7 +907,30 @@ export function printType(type, stack = []) {
  * - {@link VariantType} supports width subtyping (more cases → fewer cases)
  * - {@link FunctionType} uses contravariant inputs and covariant outputs
  */
+// Cache for memoizing isSubtype results
+const isSubtypeCache = new WeakMap();
 export function isSubtype(t1, t2) {
+    // Fast path: reference equality (reflexivity)
+    if (t1 === t2)
+        return true;
+    // Check cache
+    const innerCache = isSubtypeCache.get(t1);
+    if (innerCache) {
+        const cached = innerCache.get(t2);
+        if (cached !== undefined)
+            return cached;
+    }
+    const result = isSubtypeImpl(t1, t2);
+    // Store in cache
+    let cache = isSubtypeCache.get(t1);
+    if (!cache) {
+        cache = new WeakMap();
+        isSubtypeCache.set(t1, cache);
+    }
+    cache.set(t2, result);
+    return result;
+}
+function isSubtypeImpl(t1, t2) {
     // Equi-recursive type subtyping: unfold recursive types when only one side is recursive
     if (t1.type === "Recursive") {
         if (t2.type === "Recursive") {
@@ -975,7 +1040,15 @@ export function isSubtype(t1, t2) {
         }
     }
     else if (t1.type === "Function") {
-        if (t2.type === "Function") {
+        if (t2.type === "Function" || t2.type === "AsyncFunction") {
+            return t1.inputs.length === t2.inputs.length && t1.inputs.every((t, i) => isSubtype(t2.inputs[i], t)) && isSubtype(t1.output, t2.output); // contravariant inputs and covariant output
+        }
+        else {
+            return false;
+        }
+    }
+    else if (t1.type === "AsyncFunction") {
+        if (t2.type === "AsyncFunction") {
             return t1.inputs.length === t2.inputs.length && t1.inputs.every((t, i) => isSubtype(t2.inputs[i], t)) && isSubtype(t1.output, t2.output); // contravariant inputs and covariant output
         }
         else {
@@ -1112,17 +1185,30 @@ export function TypeUnion(t1, t2) {
                 if (t1.inputs.length !== t2.inputs.length) {
                     throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: functions take different number of arguments`);
                 }
-                let platforms;
-                if (t1.platforms === null) {
-                    platforms = null;
+                return FunctionType(t1.inputs.map((t, i) => TypeIntersect(t, t2.inputs[i])), TypeUnion(t1.output, t2.output));
+            }
+            else if (t2.type === "AsyncFunction") {
+                if (t1.inputs.length !== t2.inputs.length) {
+                    throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: functions take different number of arguments`);
                 }
-                else if (t2.platforms === null) {
-                    platforms = null;
+                return AsyncFunctionType(t1.inputs.map((t, i) => TypeIntersect(t, t2.inputs[i])), TypeUnion(t1.output, t2.output));
+            }
+            else {
+                throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "AsyncFunction") {
+            if (t2.type === "Function") {
+                if (t1.inputs.length !== t2.inputs.length) {
+                    throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: functions take different number of arguments`);
                 }
-                else {
-                    platforms = [...new Set([...t1.platforms, ...t2.platforms])].sort();
+                return AsyncFunctionType(t1.inputs.map((t, i) => TypeIntersect(t, t2.inputs[i])), TypeUnion(t1.output, t2.output));
+            }
+            else if (t2.type === "AsyncFunction") {
+                if (t1.inputs.length !== t2.inputs.length) {
+                    throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: functions take different number of arguments`);
                 }
-                return FunctionType(t1.inputs.map((t, i) => TypeIntersect(t, t2.inputs[i])), TypeUnion(t1.output, t2.output), platforms);
+                return AsyncFunctionType(t1.inputs.map((t, i) => TypeIntersect(t, t2.inputs[i])), TypeUnion(t1.output, t2.output));
             }
             else {
                 throw new TypeMismatchError(`Cannot union ${printType(t1)} with ${printType(t2)}: incompatible types`);
@@ -1265,17 +1351,30 @@ export function TypeIntersect(t1, t2) {
                 if (t1.inputs.length !== t2.inputs.length) {
                     throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: functions take different number of arguments`);
                 }
-                let platforms;
-                if (t1.platforms === null) {
-                    platforms = t2.platforms;
+                return FunctionType(t1.inputs.map((t, i) => TypeUnion(t, t2.inputs[i])), TypeIntersect(t1.output, t2.output));
+            }
+            else if (t2.type === "AsyncFunction") {
+                if (t1.inputs.length !== t2.inputs.length) {
+                    throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: functions take different number of arguments`);
                 }
-                else if (t2.platforms === null) {
-                    platforms = t1.platforms;
+                return FunctionType(t1.inputs.map((t, i) => TypeUnion(t, t2.inputs[i])), TypeIntersect(t1.output, t2.output));
+            }
+            else {
+                throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "AsyncFunction") {
+            if (t2.type === "Function") {
+                if (t1.inputs.length !== t2.inputs.length) {
+                    throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: functions take different number of arguments`);
                 }
-                else {
-                    platforms = t1.platforms.filter(p => t2.platforms.includes(p));
+                return FunctionType(t1.inputs.map((t, i) => TypeUnion(t, t2.inputs[i])), TypeIntersect(t1.output, t2.output));
+            }
+            else if (t2.type === "AsyncFunction") {
+                if (t1.inputs.length !== t2.inputs.length) {
+                    throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: functions take different number of arguments`);
                 }
-                return FunctionType(t1.inputs.map((t, i) => TypeUnion(t, t2.inputs[i])), TypeIntersect(t1.output, t2.output), platforms);
+                return AsyncFunctionType(t1.inputs.map((t, i) => TypeUnion(t, t2.inputs[i])), TypeIntersect(t1.output, t2.output));
             }
             else {
                 throw new TypeMismatchError(`Cannot intersect ${printType(t1)} with ${printType(t2)}: incompatible types`);
@@ -1423,20 +1522,18 @@ export function TypeEqual(t1, t2, r1 = t1, r2 = t2) {
                 if (t1.inputs.length !== t2.inputs.length) {
                     throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: functions take different number of arguments`);
                 }
-                if (t1.platforms === null) {
-                    if (t2.platforms !== null) {
-                        throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: functions have different platform effects`);
-                    }
-                }
-                else if (t2.platforms === null) {
-                    throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: functions have different platform effects`);
-                }
-                else {
-                    if (t1.platforms.length !== t2.platforms.length || !t1.platforms.every((p, i) => p === t2.platforms[i])) {
-                        throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: functions have different platform effects`);
-                    }
+                return FunctionType(t1.inputs.map((t, i) => TypeEqual(t, t2.inputs[i], r1, r2)), TypeEqual(t1.output, t2.output, r1, r2));
+            }
+            else {
+                throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: incompatible types`);
+            }
+        }
+        else if (t1.type === "AsyncFunction") {
+            if (t2.type === "AsyncFunction") {
+                if (t1.inputs.length !== t2.inputs.length) {
+                    throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: functions take different number of arguments`);
                 }
-                return FunctionType(t1.inputs.map((t, i) => TypeEqual(t, t2.inputs[i], r1, r2)), TypeEqual(t1.output, t2.output, r1, r2), t1.platforms);
+                return AsyncFunctionType(t1.inputs.map((t, i) => TypeEqual(t, t2.inputs[i], r1, r2)), TypeEqual(t1.output, t2.output, r1, r2));
             }
             else {
                 throw new TypeMismatchError(`${printType(t1)} is not equal to ${printType(t2)}: incompatible types`);
@@ -1565,6 +1662,9 @@ export function TypeWiden(t1, t2) {
         else if (t1.type === "Function") {
             throw new TypeMismatchError(`Cannot widen ${printType(t1)} with ${printType(t2)}: functions not supported`);
         }
+        else if (t1.type === "AsyncFunction") {
+            throw new TypeMismatchError(`Cannot widen ${printType(t1)} with ${printType(t2)}: functions not supported`);
+        }
         else {
             if (t1.type === t2.type) {
                 return t1;