@elaraai/east 0.0.1-beta.9 → 1.0.0

package/dist/src/expr/vector.js

@@ -0,0 +1,202 @@
+import { get_location_id } from "../location.js";
+import { IntegerType, VectorType, MatrixType, NullType, FunctionType, ArrayType, isSubtype, printType, isTypeEqual } from "../types.js";
+import { valueOrExprToAst, valueOrExprToAstTyped } from "./ast.js";
+import { AstSymbol, Expr, FactorySymbol, TypeSymbol } from "./expr.js";
+/**
+ * Expression representing mutable vector (1D typed array) values and operations.
+ *
+ * VectorExpr provides methods for vector manipulation including element access,
+ * mutation, slicing, concatenation, conversion, and higher-order operations.
+ * Vectors are backed by contiguous typed arrays (Float64Array, BigInt64Array,
+ * or Uint8Array) for efficient numeric computation and zero-copy interop
+ * with ML libraries.
+ */
+export class VectorExpr extends Expr {
+    element_type;
+    constructor(element_type, ast, createExpr) {
+        super(ast.type, ast, createExpr);
+        this.element_type = element_type;
+    }
+    /**
+     * Returns the number of elements in the vector.
+     *
+     * @returns An IntegerExpr representing the length
+     */
+    length() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: IntegerType,
+            loc_id: get_location_id(),
+            builtin: "VectorLength",
+            type_parameters: [this.element_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Gets the element at the specified index.
+     *
+     * @param index - The zero-based index to access
+     * @returns An expression of the element type
+     *
+     * @throws East runtime error if the index is out of bounds
+     */
+    get(index) {
+        const idx = valueOrExprToAstTyped(index, IntegerType);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: this.element_type,
+            loc_id: get_location_id(),
+            builtin: "VectorGet",
+            type_parameters: [this.element_type],
+            arguments: [this[AstSymbol], idx],
+        });
+    }
+    /**
+     * Sets the element at the specified index (mutates the vector).
+     *
+     * @param index - The zero-based index to set
+     * @param value - The new value to store at that index
+     * @returns NullExpr (operation performed for side effect)
+     *
+     * @throws East runtime error if the index is out of bounds
+     */
+    set(index, value) {
+        const idx = valueOrExprToAstTyped(index, IntegerType);
+        const val = valueOrExprToAstTyped(value, this.element_type);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            loc_id: get_location_id(),
+            builtin: "VectorSet",
+            type_parameters: [this.element_type],
+            arguments: [this[AstSymbol], idx, val],
+        });
+    }
+    /**
+     * Returns a new vector containing elements from start (inclusive) to end (exclusive).
+     *
+     * @param start - The start index (inclusive)
+     * @param end - The end index (exclusive)
+     * @returns A new VectorExpr containing the sliced elements
+     *
+     * @throws East runtime error if indices are out of bounds
+     */
+    slice(start, end) {
+        const s = valueOrExprToAstTyped(start, IntegerType);
+        const e = valueOrExprToAstTyped(end, IntegerType);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: VectorType(this.element_type),
+            loc_id: get_location_id(),
+            builtin: "VectorSlice",
+            type_parameters: [this.element_type],
+            arguments: [this[AstSymbol], s, e],
+        });
+    }
+    /**
+     * Concatenates this vector with another vector of the same element type.
+     *
+     * @param other - The other vector to concatenate
+     * @returns A new VectorExpr containing elements from both vectors
+     */
+    concat(other) {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: VectorType(this.element_type),
+            loc_id: get_location_id(),
+            builtin: "VectorConcat",
+            type_parameters: [this.element_type],
+            arguments: [this[AstSymbol], Expr.ast(other)],
+        });
+    }
+    /**
+     * Converts this vector to an Array.
+     *
+     * @returns An ArrayExpr containing the same elements
+     */
+    toArray() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: ArrayType(this.element_type),
+            loc_id: get_location_id(),
+            builtin: "VectorToArray",
+            type_parameters: [this.element_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Reshapes this vector into a matrix with the specified dimensions.
+     * Requires rows * cols == length of the vector.
+     *
+     * @param rows - The number of rows in the resulting matrix
+     * @param cols - The number of columns in the resulting matrix
+     * @returns A MatrixExpr with the specified shape
+     *
+     * @throws East runtime error if rows * cols does not equal the vector length
+     */
+    toMatrix(rows, cols) {
+        const r = valueOrExprToAstTyped(rows, IntegerType);
+        const c = valueOrExprToAstTyped(cols, IntegerType);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: MatrixType(this.element_type),
+            loc_id: get_location_id(),
+            builtin: "VectorToMatrix",
+            type_parameters: [this.element_type],
+            arguments: [this[AstSymbol], r, c],
+        });
+    }
+    map(fn) {
+        if (fn instanceof Expr) {
+            if (!(fn[TypeSymbol] && fn[TypeSymbol].type === "Function")) {
+                throw new Error("Expected a Function expression");
+            }
+            const output_type = fn[TypeSymbol].output;
+            const n_inputs = fn[TypeSymbol].inputs.length;
+            if (n_inputs === 2) {
+                if (!isSubtype(this.element_type, fn[TypeSymbol].inputs[0])) {
+                    throw new Error(`Expected Function input to be ${printType(this.element_type)}, got ${printType(fn[TypeSymbol].inputs[0])}`);
+                }
+                if (!isTypeEqual(IntegerType, fn[TypeSymbol].inputs[1])) {
+                    throw new Error(`Expected Function second input to be ${printType(IntegerType)}, got ${printType(fn[TypeSymbol].inputs[1])}`);
+                }
+                return this[FactorySymbol]({
+                    ast_type: "Builtin",
+                    type: VectorType(output_type),
+                    loc_id: get_location_id(),
+                    builtin: "VectorMap",
+                    type_parameters: [this.element_type, output_type],
+                    arguments: [this[AstSymbol], fn[AstSymbol]],
+                });
+            }
+            else {
+                throw new Error(`Expected Function to have 2 inputs, got ${n_inputs} inputs`);
+            }
+        }
+        else {
+            const functionExpr = Expr.function([this.element_type, IntegerType], undefined, fn);
+            return this.map(functionExpr);
+        }
+    }
+    /**
+     * Reduces the vector to a single value using an accumulator function and initial value.
+     *
+     * @param combineFn - Function taking (accumulator, element, index) and returning the new accumulator value
+     * @param init - Initial value for the reduction (determines output type)
+     * @returns The final accumulated value
+     */
+    reduce(combineFn, init) {
+        const initAst = valueOrExprToAst(init);
+        const returnType = initAst.type;
+        const combineAst = valueOrExprToAstTyped(combineFn, FunctionType([returnType, this.element_type, IntegerType], returnType));
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: returnType,
+            loc_id: get_location_id(),
+            builtin: "VectorFold",
+            type_parameters: [this.element_type, returnType],
+            arguments: [this[AstSymbol], initAst, combineAst],
+        });
+    }
+}
+//# sourceMappingURL=vector.js.map

package/dist/src/expr/vector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector.js","sourceRoot":"","sources":["../../../src/expr/vector.ts"],"names":[],"mappings":"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"}

package/dist/src/fuzz.d.ts

@@ -10,6 +10,7 @@ import { type EastTypeValue } from "./type_of_type.js";
  * Generates a random East type for fuzz testing.
  *
  * @param depth - Current nesting depth (used internally to limit recursion)
+ * @param options - Configuration options
  * @returns A randomly generated {@link EastType}
  *
  * @remarks
@@ -19,8 +20,37 @@ import { type EastTypeValue } from "./type_of_type.js";
  * - Sets and Dicts use {@link StringType} keys (immutability constraint)
  * - Structs have 0-4 random fields
  * - Variants have 1-3 random cases, with 30% chance of {@link OptionType}
+ * - Recursive types include linked lists, trees, and option-wrapped patterns
+ * - Function types have 0-3 arguments with random input/output types
  */
-export declare function randomType(depth?: number): EastType;
+export declare function randomType(depth?: number, options?: {
+    includeRecursive?: boolean;
+    includeFunctions?: boolean;
+}): EastType;
+/**
+ * Generates a random recursive type pattern.
+ *
+ * @returns A randomly generated {@link RecursiveType}
+ *
+ * @remarks
+ * Generates common recursive patterns:
+ * - Linked list: `rec t. <nil: Null, cons: (head: T, tail: t)>`
+ * - Tree: `rec t. (value: T, children: Array<t>)`
+ * - Option chain: `rec t. (value: T, next: Option<t>)`
+ * - Binary tree: `rec t. <leaf: T, node: (left: t, right: t)>`
+ * - Nested variant: `rec t. <a: T, b: (inner: t)>`
+ */
+export declare function randomRecursiveType(): EastType;
+/**
+ * Generates a random function type.
+ *
+ * @returns A randomly generated {@link FunctionType}
+ *
+ * @remarks
+ * Functions have 0-3 arguments with random primitive or simple types.
+ * Output types are also kept simple to avoid excessive nesting.
+ */
+export declare function randomFunctionType(): EastType;
 /**
  * Creates a function that generates random values of a given type.
  *
@@ -37,6 +67,7 @@ export declare function randomType(depth?: number): EastType;
  * - DateTimes are within one year of 2025-01-01
  * - Collections have 0-4 elements (kept small for performance)
  * - Variants randomly select one of their cases
+ * - Recursive types generate finite values with depth limiting
  */
 export declare function randomValueFor(type: EastTypeValue): () => any;
 export declare function randomValueFor<T extends EastType>(type: T): () => ValueTypeOf<T>;
@@ -76,5 +107,8 @@ export declare function randomValueFor<T extends EastType>(type: T): () => Value
  * );
  * ```
  */
-export declare function fuzzerTest(fn: (type: EastType) => (value: any) => Promise<void>, n_types?: number, n_samples?: number): Promise<boolean>;
+export declare function fuzzerTest(fn: (type: EastType) => (value: any) => Promise<void>, n_types?: number, n_samples?: number, options?: {
+    includeRecursive?: boolean;
+    includeFunctions?: boolean;
+}): Promise<boolean>;
 //# sourceMappingURL=fuzz.d.ts.map

package/dist/src/fuzz.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fuzz.d.ts","sourceRoot":"","sources":["../../src/fuzz.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,WAAW,EAcjB,MAAM,YAAY,CAAC;AAIpB,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAMxE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,KAAK,GAAE,MAAU,GAAG,QAAQ,CAqDtD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,GAAG,CAAA;AAC9D,wBAAgB,cAAc,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,MAAM,WAAW,CAAC,CAAC,CAAC,CAAA;AA2GjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,UAAU,CAC9B,EAAE,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,EACrD,OAAO,GAAE,MAAY,EACrB,SAAS,GAAE,MAAW,GACrB,OAAO,CAAC,OAAO,CAAC,CAyDlB"}
+{"version":3,"file":"fuzz.d.ts","sourceRoot":"","sources":["../../src/fuzz.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,WAAW,EAmBjB,MAAM,YAAY,CAAC;AAKpB,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAiBxE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CACxB,KAAK,GAAE,MAAU,EACjB,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAO,GACvE,QAAQ,CAkEV;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,IAAI,QAAQ,CAmD9C;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,IAAI,QAAQ,CAqB7C;AAyTD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,GAAG,CAAC;AAC/D,wBAAgB,cAAc,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,MAAM,WAAW,CAAC,CAAC,CAAC,CAAC;AAuBlF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,UAAU,CAC9B,EAAE,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,EACrD,OAAO,GAAE,MAAY,EACrB,SAAS,GAAE,MAAW,EACtB,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAO,GACvE,OAAO,CAAC,OAAO,CAAC,CA4DlB"}