@elaraai/east 0.0.1-beta.0

package/dist/src/expr/function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../../src/expr/function.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAErC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAGtC,OAAO,EAAE,YAAY,EAAiB,MAAM,aAAa,CAAC;AAE1D,OAAO,EAAa,IAAI,EAAiB,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AACxE,OAAO,KAAK,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE/D;;;EAGE;AACF,qBAAa,YAAY,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC,SAAS,GAAG,CAAE,SAAQ,IAAI,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC5E,OAAO,CAAC,WAAW;IAAK,OAAO,CAAC,WAAW;gBAAnC,WAAW,EAAE,CAAC,EAAU,WAAW,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM;IAIxF;;mBAEe;IACf,IAAI,CAAC,GAAG,IAAI,EAAE;SAAG,CAAC,IAAI,MAAM,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KAAE,GAAG,QAAQ,CAAC,CAAC,CAAC;IAgBxE;;;MAGE;IACF,IAAI,IAAI,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;CAIrB;AAED;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC,IAAI,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AAErJ;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC,SAAS,GAAG,EAC/D,WAAW,EAAE,CAAC,EACd,WAAW,EAAE,CAAC,EACd,GAAG,EAAE,GAAG,EACR,UAAU,EAAE,MAAM,GACjB,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,CAO5B"}

package/dist/src/expr/function.js

@@ -0,0 +1,58 @@
+import { ast_to_ir } from "../ast_to_ir.js";
+import { EastIR } from "../eastir.js";
+import { get_location } from "../location.js";
+import { FunctionType } from "../types.js";
+import { valueOrExprToAstTyped } from "./ast.js";
+import { AstSymbol, Expr, FactorySymbol } from "./expr.js";
+/**
+* Expression representing the Function type.
+* Used for function calls, composition, etc.
+*/
+export class FunctionExpr extends Expr {
+    input_types;
+    output_type;
+    constructor(input_types, output_type, ast, createExpr) {
+        super(ast.type, ast, createExpr);
+        this.input_types = input_types;
+        this.output_type = output_type;
+    }
+    /** Note that {@link CallableFunctionExpr} provides a more ergonomic way to call functions.
+     *
+     * @internal */
+    call(...args) {
+        if (args.length !== this.input_types.length) {
+            throw new Error(`Expected ${this.input_types.length} arguments, got ${args.length}`);
+        }
+        const inputs = this.input_types.map((input_type, i) => valueOrExprToAstTyped(args[i], input_type));
+        return this[FactorySymbol]({
+            ast_type: "Call",
+            type: this.output_type,
+            location: get_location(2),
+            function: this[AstSymbol],
+            arguments: inputs,
+        });
+    }
+    /** Convert the function to East's "intermediate representation" (IR). This can then be serialized or compiled.
+    *
+    * Note that the function must be a "free" function, with no captures.
+    */
+    toIR() {
+        const ir = ast_to_ir(this[AstSymbol]);
+        return new EastIR(ir);
+    }
+}
+/**
+ * Factory producing a callable FunctionExpr so users can invoke it directly.
+ * Prototype chain preserved for instanceof checks.
+ *
+ * @internal
+ */
+export function createFunctionExpr(input_types, output_type, ast, createExpr) {
+    const inst = new FunctionExpr(input_types, output_type, ast, createExpr);
+    const callable = function (...args) {
+        return inst.call(...args);
+    };
+    Object.setPrototypeOf(callable, inst);
+    return callable;
+}
+//# sourceMappingURL=function.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"function.js","sourceRoot":"","sources":["../../../src/expr/function.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAiB,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,aAAa,EAAe,MAAM,WAAW,CAAC;AAGxE;;;EAGE;AACF,MAAM,OAAO,YAA6C,SAAQ,IAAwB;IACpE;IAAwB;IAA5C,YAAoB,WAAc,EAAU,WAAc,EAAE,GAAQ,EAAE,UAAkB;QACtF,KAAK,CAAC,GAAG,CAAC,IAA0B,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC;QADrC,gBAAW,GAAX,WAAW,CAAG;QAAU,gBAAW,GAAX,WAAW,CAAG;IAE1D,CAAC;IAED;;mBAEe;IACf,IAAI,CAAC,GAAG,IAAkD;QACxD,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC;YAC5C,MAAM,IAAI,KAAK,CAAC,YAAY,IAAI,CAAC,WAAW,CAAC,MAAM,mBAAmB,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;QACvF,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,UAAoB,EAAE,CAAC,EAAE,EAAE,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC;QAE7G,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC;YACzB,QAAQ,EAAE,MAAM;YAChB,IAAI,EAAE,IAAI,CAAC,WAAuB;YAClC,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC;YACzB,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC;YACzB,SAAS,EAAE,MAAM;SAClB,CAAgB,CAAC;IACpB,CAAC;IAED;;;MAGE;IACF,IAAI;QACF,MAAM,EAAE,GAAG,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAe,CAAC;QACpD,OAAO,IAAI,MAAM,CAAC,EAAE,CAAC,CAAC;IACxB,CAAC;CACF;AAUD;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAChC,WAAc,EACd,WAAc,EACd,GAAQ,EACR,UAAkB;IAElB,MAAM,IAAI,GAAG,IAAI,YAAY,CAAO,WAAW,EAAE,WAAW,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC;IAC/E,MAAM,QAAQ,GAAG,UAAU,GAAG,IAAkD;QAC9E,OAAO,IAAI,CAAC,IAAI,CAAC,GAAI,IAAY,CAAC,CAAC;IACrC,CAA0C,CAAC;IAC3C,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IACtC,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/src/expr/index.d.ts

@@ -0,0 +1,450 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+export * from './types.js';
+import { Expr } from './expr.js';
+export { Expr } from './expr.js';
+import { from, equal, notEqual, less, lessEqual, print, is, greaterEqual, greater, func, str, platform } from './block.js';
+export { BlockBuilder } from './block.js';
+export type { ToExpr as ExprFactory } from './expr.js';
+/**
+ * Standard entry point for constructing East expressions.
+ *
+ * @example
+ * ```ts
+ * // Create expressions from values
+ * East.value(3.14).add(2)
+ *
+ * // String interpolation
+ * East.str`Hello, ${name}!`
+ *
+ * // Comparisons
+ * East.equal(x, y)
+ * East.less(x, y)
+ *
+ * // Create functions
+ * East.function([IntegerType], IntegerType, ($, x) => $.return(x.add(1n)))
+ *
+ * // Standard library
+ * East.Integer.printCommaSeperated(1234567890n)
+ * East.Array.range(0n, 10n)
+ * ```
+ */
+export declare const East: {
+    /**
+     * Creates an East expression from a JavaScript value.
+     * Type is inferred from the value, or can be explicitly specified.
+     *
+     * @param value - The JavaScript value to convert to an East expression
+     * @param type - Optional explicit type specification
+     * @returns An East expression wrapping the value
+     *
+     * @example
+     * ```ts
+     * East.value(42n)                    // IntegerExpr
+     * East.value(3.14)                   // FloatExpr
+     * East.value("hello")                // StringExpr
+     * East.value([1n, 2n, 3n])           // ArrayExpr<IntegerType>
+     * East.value(new Map([[1n, "a"]]))   // DictExpr<IntegerType, StringType>
+     * ```
+     */
+    value: typeof from;
+    /**
+     * Creates a string expression with interpolation support.
+     * Allows embedding East expressions inside template literals.
+     *
+     * @returns A StringExpr with the interpolated values
+     *
+     * @example
+     * ```ts
+     * East.str`Hello, ${name}!`
+     * East.str`Total: ${count} items`
+     * East.str`Result: ${x.add(y)}`
+     * ```
+     */
+    str: typeof str;
+    /**
+     * Creates an East function with typed inputs and output.
+     * Functions can be nested, serialized to IR, and compiled to JavaScript.
+     *
+     * @param inputs - Array of East types for function parameters
+     * @param output - East type for function return value
+     * @param body - Function body using block builder and parameters
+     * @returns A FunctionExpr that can be compiled or serialized
+     *
+     * @example
+     * ```ts
+     * const add = East.function(
+     *   [IntegerType, IntegerType],
+     *   IntegerType,
+     *   ($, a, b) => $.return(a.add(b))
+     * );
+     *
+     * const fibonacci = East.function([IntegerType], IntegerType, ($, n) => {
+     *   $.if(East.lessEqual(n, 1n), $ => $.return(n));
+     *   $.return(fibonacci(n.subtract(1n)).add(fibonacci(n.subtract(2n))));
+     * });
+     * ```
+     */
+    function: typeof func;
+    /**
+     * Defines a platform function that can be called from East code.
+     * Platform functions allow East code to interact with the external environment.
+     *
+     * @param name - The name of the platform function
+     * @param inputs - Array of East types for the function parameters
+     * @param output - East type for the function return value
+     * @returns A callable platform function helper
+     *
+     * @example
+     * ```ts
+     * const log = East.platform("log", [StringType], NullType);
+     * const readFile = East.platform("readFile", [StringType], StringType);
+     *
+     * const myFunction = East.function([StringType], NullType, ($, msg) => {
+     *   $(log(East.str`Message: ${msg}`));
+     *   $.return(null);
+     * });
+     *
+     * const platform = [
+     *   log.implement(console.log),
+     *   readFile.implement(fs.readFileSync),
+     * ];
+     * ```
+     */
+    platform: typeof platform;
+    /**
+     * Converts any East expression to its string representation.
+     * Uses the East serialization format (not JSON).
+     *
+     * @param expr - The expression to convert to a string
+     * @returns A StringExpr containing the string representation
+     *
+     * @example
+     * ```ts
+     * East.print(42n)                    // "42"
+     * East.print(3.14)                   // "3.14"
+     * East.print([1n, 2n, 3n])           // "[1, 2, 3]"
+     * East.print({a: 1n, b: true})       // "(a=1, b=true)"
+     * ```
+     */
+    print: typeof print;
+    /**
+     * Deep equality comparison between two expressions.
+     * Compares values recursively, including nested structures.
+     *
+     * @param a - First expression to compare
+     * @param b - Second expression to compare
+     * @returns BooleanExpr that is true if values are deeply equal
+     *
+     * @example
+     * ```ts
+     * East.equal(42n, 42n)                     // true
+     * East.equal([1n, 2n], [1n, 2n])           // true
+     * East.equal({a: 1n}, {a: 1n})             // true
+     * East.equal(x, y)                         // compare two expressions
+     * ```
+     */
+    equal: typeof equal;
+    /**
+     * Deep inequality comparison between two expressions.
+     * Returns true if values are not deeply equal.
+     *
+     * @param a - First expression to compare
+     * @param b - Second expression to compare
+     * @returns BooleanExpr that is true if values are not equal
+     *
+     * @example
+     * ```ts
+     * East.notEqual(42n, 43n)                  // true
+     * East.notEqual([1n, 2n], [1n, 3n])        // true
+     * ```
+     */
+    notEqual: typeof notEqual;
+    /**
+     * Less-than comparison using East's total ordering.
+     * All East types have a defined total ordering, even complex structures.
+     *
+     * @param a - First expression to compare
+     * @param b - Second expression to compare
+     * @returns BooleanExpr that is true if a < b
+     *
+     * @example
+     * ```ts
+     * East.less(1n, 2n)                        // true
+     * East.less(3.14, 2.0)                     // false
+     * East.less("apple", "banana")             // true
+     * ```
+     */
+    less: typeof less;
+    /**
+     * Less-than-or-equal comparison using East's total ordering.
+     *
+     * @param a - First expression to compare
+     * @param b - Second expression to compare
+     * @returns BooleanExpr that is true if a <= b
+     *
+     * @example
+     * ```ts
+     * East.lessEqual(1n, 1n)                   // true
+     * East.lessEqual(2n, 1n)                   // false
+     * ```
+     */
+    lessEqual: typeof lessEqual;
+    /**
+     * Greater-than comparison using East's total ordering.
+     *
+     * @param a - First expression to compare
+     * @param b - Second expression to compare
+     * @returns BooleanExpr that is true if a > b
+     *
+     * @example
+     * ```ts
+     * East.greater(2n, 1n)                     // true
+     * East.greater("banana", "apple")          // true
+     * ```
+     */
+    greater: typeof greater;
+    /**
+     * Greater-than-or-equal comparison using East's total ordering.
+     *
+     * @param a - First expression to compare
+     * @param b - Second expression to compare
+     * @returns BooleanExpr that is true if a >= b
+     *
+     * @example
+     * ```ts
+     * East.greaterEqual(2n, 2n)                // true
+     * East.greaterEqual(1n, 2n)                // false
+     * ```
+     */
+    greaterEqual: typeof greaterEqual;
+    /**
+     * Reference equality comparison for mutable types (Array, Set, Dict).
+     * Checks if two expressions reference the same object in memory.
+     *
+     * @param a - First expression to compare
+     * @param b - Second expression to compare
+     * @returns BooleanExpr that is true if they reference the same object
+     *
+     * @example
+     * ```ts
+     * const arr = $.let(East.value([1n, 2n]));
+     * East.is(arr, arr)                        // true (same reference)
+     * East.is([1n, 2n], [1n, 2n])              // false (different objects)
+     * ```
+     */
+    is: typeof is;
+    /**
+     * Returns the minimum of two values using East's total ordering.
+     *
+     * @param a - First value
+     * @param b - Second value
+     * @returns The smaller of the two values
+     *
+     * @example
+     * ```ts
+     * East.min(5n, 3n)                         // 3n
+     * East.min(3.14, 2.71)                     // 2.71
+     * ```
+     */
+    min: typeof Expr.min;
+    /**
+     * Returns the maximum of two values using East's total ordering.
+     *
+     * @param a - First value
+     * @param b - Second value
+     * @returns The larger of the two values
+     *
+     * @example
+     * ```ts
+     * East.max(5n, 3n)                         // 5n
+     * East.max(3.14, 2.71)                     // 3.14
+     * ```
+     */
+    max: typeof Expr.max;
+    /**
+     * Clamps a value between minimum and maximum bounds.
+     *
+     * @param value - The value to clamp
+     * @param min - The minimum bound
+     * @param max - The maximum bound
+     * @returns The clamped value
+     *
+     * @example
+     * ```ts
+     * East.clamp(5n, 0n, 10n)                  // 5n
+     * East.clamp(-5n, 0n, 10n)                 // 0n
+     * East.clamp(15n, 0n, 10n)                 // 10n
+     * ```
+     */
+    clamp: typeof Expr.clamp;
+    /**
+     * Standard library functions for Integer operations.
+     * Provides formatting, rounding, and utility functions for integers.
+     *
+     * @example
+     * ```ts
+     * East.Integer.printCommaSeperated(1234567n)   // "1,234,567"
+     * East.Integer.printCompact(1500000n)          // "1.5M"
+     * East.Integer.printOrdinal(42n)               // "42nd"
+     * East.Integer.roundNearest(47n, 10n)          // 50n
+     * ```
+     */
+    Integer: {
+        printCommaSeperated: import("./function.js").CallableFunctionExpr<[import("../types.js").IntegerType], import("../types.js").StringType>;
+        printCompact: import("./function.js").CallableFunctionExpr<[import("../types.js").IntegerType], import("../types.js").StringType>;
+        printCompactSI: import("./function.js").CallableFunctionExpr<[import("../types.js").IntegerType], import("../types.js").StringType>;
+        printCompactComputing: import("./function.js").CallableFunctionExpr<[import("../types.js").IntegerType], import("../types.js").StringType>;
+        printOrdinal: import("./function.js").CallableFunctionExpr<[import("../types.js").IntegerType], import("../types.js").StringType>;
+        digitCount: import("./function.js").CallableFunctionExpr<[import("../types.js").IntegerType], import("../types.js").IntegerType>;
+        roundNearest: import("./function.js").CallableFunctionExpr<[import("../types.js").IntegerType, import("../types.js").IntegerType], import("../types.js").IntegerType>;
+        roundUp: import("./function.js").CallableFunctionExpr<[import("../types.js").IntegerType, import("../types.js").IntegerType], import("../types.js").IntegerType>;
+        roundDown: import("./function.js").CallableFunctionExpr<[import("../types.js").IntegerType, import("../types.js").IntegerType], import("../types.js").IntegerType>;
+        roundTruncate: import("./function.js").CallableFunctionExpr<[import("../types.js").IntegerType, import("../types.js").IntegerType], import("../types.js").IntegerType>;
+        printPercentage: import("./function.js").CallableFunctionExpr<[import("../types.js").IntegerType], import("../types.js").StringType>;
+    };
+    /**
+     * Standard library functions for Float operations.
+     * Provides rounding, formatting, and comparison functions for floating-point numbers.
+     *
+     * @example
+     * ```ts
+     * East.Float.roundToDecimals(3.14159, 2n)      // 3.14
+     * East.Float.printCurrency(1234.56)            // "$1234.56"
+     * East.Float.printPercentage(0.452, 1n)        // "45.2%"
+     * East.Float.approxEqual(0.1, 0.10001, 0.001)  // true
+     * ```
+     */
+    Float: {
+        approxEqual: import("./function.js").CallableFunctionExpr<[import("../types.js").FloatType, import("../types.js").FloatType, import("../types.js").FloatType], import("../types.js").BooleanType>;
+        roundFloor: import("./function.js").CallableFunctionExpr<[import("../types.js").FloatType], import("../types.js").IntegerType>;
+        roundCeil: import("./function.js").CallableFunctionExpr<[import("../types.js").FloatType], import("../types.js").IntegerType>;
+        roundHalf: import("./function.js").CallableFunctionExpr<[import("../types.js").FloatType], import("../types.js").IntegerType>;
+        roundTrunc: import("./function.js").CallableFunctionExpr<[import("../types.js").FloatType], import("../types.js").IntegerType>;
+        roundNearest: import("./function.js").CallableFunctionExpr<[import("../types.js").FloatType, import("../types.js").FloatType], import("../types.js").FloatType>;
+        roundUp: import("./function.js").CallableFunctionExpr<[import("../types.js").FloatType, import("../types.js").FloatType], import("../types.js").FloatType>;
+        roundDown: import("./function.js").CallableFunctionExpr<[import("../types.js").FloatType, import("../types.js").FloatType], import("../types.js").FloatType>;
+        roundTruncate: import("./function.js").CallableFunctionExpr<[import("../types.js").FloatType, import("../types.js").FloatType], import("../types.js").FloatType>;
+        roundToDecimals: import("./function.js").CallableFunctionExpr<[import("../types.js").FloatType, import("../types.js").IntegerType], import("../types.js").FloatType>;
+        printCommaSeperated: import("./function.js").CallableFunctionExpr<[import("../types.js").FloatType, import("../types.js").IntegerType], import("../types.js").StringType>;
+        printCurrency: import("./function.js").CallableFunctionExpr<[import("../types.js").FloatType], import("../types.js").StringType>;
+        printFixed: import("./function.js").CallableFunctionExpr<[import("../types.js").FloatType, import("../types.js").IntegerType], import("../types.js").StringType>;
+        printCompact: import("./function.js").CallableFunctionExpr<[import("../types.js").FloatType], import("../types.js").StringType>;
+        printPercentage: import("./function.js").CallableFunctionExpr<[import("../types.js").FloatType, import("../types.js").IntegerType], import("../types.js").StringType>;
+    };
+    /**
+     * Standard library functions for DateTime operations.
+     * Provides construction, parsing, and rounding functions for date/time values.
+     *
+     * @example
+     * ```ts
+     * East.DateTime.fromEpochMilliseconds(1640000000000n)
+     * East.DateTime.fromComponents(2025n, 1n, 15n, 10n, 30n)
+     * East.DateTime.roundDownDay(date, 1n)
+     * East.DateTime.parseFormatted("%Y-%m-%d", "2025-01-15")
+     * ```
+     */
+    DateTime: {
+        fromEpochMilliseconds: typeof import("./datetime.js").fromEpochMilliseconds;
+        fromComponents: typeof import("./datetime.js").fromComponents;
+        parseFormatted: typeof import("./datetime.js").parseFormatted;
+        roundDownMillisecond: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundDownSecond: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundDownMinute: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundDownHour: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundUpMillisecond: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundNearestMillisecond: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundUpSecond: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundNearestSecond: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundUpMinute: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundNearestMinute: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundUpHour: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundNearestHour: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundDownDay: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundUpDay: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundNearestDay: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundDownWeek: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundUpWeek: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundNearestWeek: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundDownMonth: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+        roundDownYear: import("./function.js").CallableFunctionExpr<[import("../types.js").DateTimeType, import("../types.js").IntegerType], import("../types.js").DateTimeType>;
+    };
+    /**
+     * Standard library functions for String operations.
+     * Provides error formatting utilities.
+     *
+     * @example
+     * ```ts
+     * East.String.printError(errorMsg, stackTrace)
+     * ```
+     */
+    String: {
+        printError(message: import("./string.js").StringExpr, stack: import("./array.js").ArrayExpr<import("../types.js").StructType<{
+            filename: import("../types.js").StringType;
+            line: import("../types.js").IntegerType;
+            column: import("../types.js").IntegerType;
+        }>>): import("./string.js").StringExpr;
+        printJson(value: Expr): import("./string.js").StringExpr;
+    };
+    /**
+     * Standard library functions for Blob operations.
+     * Provides binary encoding utilities.
+     *
+     * @example
+     * ```ts
+     * East.Blob.encodeBeast(myValue, 'v2')         // Encode to BEAST format
+     * ```
+     */
+    Blob: {
+        encodeBeast(value: Expr, version?: "v1" | "v2"): import("./blob.js").BlobExpr;
+    };
+    /**
+     * Standard library functions for Array operations.
+     * Provides generation utilities for creating arrays.
+     *
+     * @example
+     * ```ts
+     * East.Array.range(0n, 10n, 2n)                // [0n, 2n, 4n, 6n, 8n]
+     * East.Array.linspace(0.0, 1.0, 11n)           // [0.0, 0.1, ..., 1.0]
+     * East.Array.generate(5n, IntegerType, ($, i) => i.multiply(i))
+     * ```
+     */
+    Array: {
+        range(start: Expr<import("../types.js").IntegerType> | bigint, end: Expr<import("../types.js").IntegerType> | bigint, step?: Expr<import("../types.js").IntegerType> | bigint): import("./types.js").ExprType<import("../types.js").ArrayType<import("../types.js").IntegerType>>;
+        linspace(start: Expr<import("../types.js").FloatType> | number, stop: Expr<import("../types.js").FloatType> | number, size: Expr<import("../types.js").IntegerType> | bigint): import("./types.js").ExprType<import("../types.js").ArrayType<import("../types.js").FloatType>>;
+        generate<T>(size: Expr<import("../types.js").IntegerType> | bigint, valueType: T, valueFn: import("./types.js").SubtypeExprOrValue<import("../types.js").FunctionType<[import("../types.js").IntegerType], NoInfer<T>>>): import("./types.js").ExprType<import("../types.js").ArrayType<T>>;
+    };
+    /**
+     * Standard library functions for Set operations.
+     * Provides generation utilities for creating sets.
+     *
+     * @example
+     * ```ts
+     * East.Set.generate(5n, IntegerType, ($, i) => i.multiply(2n))
+     * ```
+     */
+    Set: {
+        generate<K extends import("../types.js").EastType>(size: Expr<import("../types.js").IntegerType> | bigint, keyType: K, keyFn: import("./types.js").SubtypeExprOrValue<import("../types.js").FunctionType<[import("../types.js").IntegerType], NoInfer<K>>>, onConflict?: import("./types.js").SubtypeExprOrValue<import("../types.js").FunctionType<[NoInfer<K>], NoInfer<K>>>): import("./types.js").ExprType<import("../types.js").SetType<K>>;
+    };
+    /**
+     * Standard library functions for Dict operations.
+     * Provides generation utilities for creating dictionaries.
+     *
+     * @example
+     * ```ts
+     * East.Dict.generate(
+     *   5n,
+     *   IntegerType,
+     *   IntegerType,
+     *   ($, i) => i,
+     *   ($, i) => i.multiply(10n)
+     * )
+     * ```
+     */
+    Dict: {
+        generate<K extends import("../types.js").EastType, V extends import("../types.js").EastType>(size: Expr<import("../types.js").IntegerType> | bigint, keyType: K, valueType: V, keyFn: import("./types.js").SubtypeExprOrValue<import("../types.js").FunctionType<[import("../types.js").IntegerType], NoInfer<K>>>, valueFn: import("./types.js").SubtypeExprOrValue<import("../types.js").FunctionType<[import("../types.js").IntegerType], NoInfer<V>>>, onConflict?: import("./types.js").SubtypeExprOrValue<import("../types.js").FunctionType<[NoInfer<V>, NoInfer<V>, NoInfer<K>], NoInfer<V>>>): import("./types.js").ExprType<import("../types.js").DictType<K, V>>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/expr/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/expr/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,cAAc,YAAY,CAAC;AAG3B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,EAAE,YAAY,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3H,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAgB1C,YAAY,EAAE,MAAM,IAAI,WAAW,EAAE,MAAM,WAAW,CAAC;AAwBvD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,IAAI;IAGf;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;OAYG;;IAGH;;;;;;;;;;;;;;;;;;;;;;OAsBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;IAUH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;OAYG;;IAGH;;;;;;;;;;;;OAYG;;IAGH;;;;;;;;;;;;OAYG;;IAGH;;;;;;;;;;;;;;OAcG;;IAKH;;;;;;;;;;;;OAYG;;IAGH;;;;;;;;;;;;OAYG;;IAGH;;;;;;;;;;;;;;OAcG;;IAKH;;;;;;;;;;;OAWG;;;;;;;;;;;;;;IAGH;;;;;;;;;;;OAWG;;;;;;;;;;;;;;;;;;IAGH;;;;;;;;;;;OAWG;;;;;;;;;;;;;;;;;;;;;;;;;;IAGH;;;;;;;;OAQG;;;;;;;;;IAGH;;;;;;;;OAQG;;;;IAGH;;;;;;;;;;OAUG;;;;;;IAGH;;;;;;;;OAQG;;;;IAGH;;;;;;;;;;;;;;OAcG;;;;CAEJ,CAAC"}