@elaraai/east 0.0.1-beta.0

package/dist/src/expr/block.js

@@ -0,0 +1,1505 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { getPlatforms } from "../ast.js";
+import { get_location, printLocation } from "../location.js";
+import { FunctionType, isSubtype, NullType, printType, isTypeEqual, StringType, NeverType, VariantType, BooleanType, TypeUnion, IntegerType, StructType, ArrayType } from "../types.js";
+import { AstSymbol, Expr } from "./expr.js";
+import { NeverExpr } from "./never.js";
+import { NullExpr } from "./null.js";
+import { BooleanExpr } from "./boolean.js";
+import { IntegerExpr } from "./integer.js";
+import { FloatExpr } from "./float.js";
+import { StringExpr } from "./string.js";
+import { DateTimeExpr } from "./datetime.js";
+import { BlobExpr } from "./blob.js";
+import { ArrayExpr } from "./array.js";
+import { SetExpr } from "./set.js";
+import { DictExpr } from "./dict.js";
+import { StructExpr } from "./struct.js";
+import { VariantExpr } from "./variant.js";
+import { createFunctionExpr } from "./function.js";
+import { valueOrExprToAst, valueOrExprToAstTyped } from "./ast.js";
+import { toEastTypeValue } from "../type_of_type.js";
+import { RefExpr } from "./ref.js";
+/** A factory function to help build `Expr` from AST.
+ * We inject this into each concrete `Expr` type so they can create new expressions recursively, without having circular dependencies between JavaScript modules.
+ */
+export function fromAst(ast) {
+    const type = ast.type.type;
+    if (type === "Never") {
+        return new NeverExpr(ast, fromAst);
+    }
+    else if (type === "Null") {
+        return new NullExpr(ast, fromAst);
+    }
+    else if (type === "Boolean") {
+        return new BooleanExpr(ast, fromAst);
+    }
+    else if (type === "Integer") {
+        return new IntegerExpr(ast, fromAst);
+    }
+    else if (type === "Float") {
+        return new FloatExpr(ast, fromAst);
+    }
+    else if (type === "String") {
+        return new StringExpr(ast, fromAst);
+    }
+    else if (type === "DateTime") {
+        return new DateTimeExpr(ast, fromAst);
+    }
+    else if (type === "Blob") {
+        return new BlobExpr(ast, fromAst);
+    }
+    else if (type === "Ref") {
+        return new RefExpr(ast.type.value, ast, fromAst);
+    }
+    else if (type === "Array") {
+        return new ArrayExpr(ast.type.value, ast, fromAst);
+    }
+    else if (type === "Set") {
+        return new SetExpr(ast.type.key, ast, fromAst);
+    }
+    else if (type === "Dict") {
+        return new DictExpr(ast.type.key, ast.type.value, ast, fromAst);
+    }
+    else if (type === "Struct") {
+        return new StructExpr(ast.type.fields, ast, fromAst);
+    }
+    else if (type === "Variant") {
+        return new VariantExpr(ast.type.cases, ast, fromAst);
+    }
+    else if (type === "Recursive") {
+        // Automatically unwrap a recursive type to give access to the node data
+        const as_ast = {
+            ast_type: "UnwrapRecursive",
+            type: ast.type.node,
+            location: ast.location,
+            value: ast,
+        };
+        return fromAst(as_ast);
+    }
+    else if (type === "Function") {
+        return createFunctionExpr(ast.type.inputs, ast.type.output, ast, fromAst);
+    }
+    else {
+        throw new Error(`fromAst not implemented for type ${printType(ast.type)} at ${printLocation(ast.location)}`);
+    }
+}
+export function from(value, type) {
+    if (value instanceof Expr) {
+        if (type) {
+            const t = Expr.type(value);
+            if (!isSubtype(t, type)) {
+                throw new Error(`Expression expected to have type ${printType(type)} but got type ${printType(t)}`);
+            }
+        }
+        return value;
+    }
+    // Handle function case specially since it requires BlockBuilder
+    if (type && type.type === "Function") {
+        if (typeof value !== "function") {
+            throw new Error(`Expected function but got ${typeof value}`);
+        }
+        const { inputs, output } = type;
+        const input_variables = inputs.map(i => ({
+            ast_type: "Variable",
+            type: i,
+            location: get_location(3),
+            mutable: false,
+        }));
+        const $ = BlockBuilder(output);
+        const input_exprs = input_variables.map(fromAst);
+        const ret = value($, ...input_exprs);
+        const statements = $.statements;
+        if (ret !== undefined) {
+            if (ret instanceof Expr) {
+                // It is possible this expression is already the last statement.
+                // Input of the form `$ => $.xxx()` or `$ => { ...; return $.xxx(); }` will cause this
+                // So we filter out this case to avoid unintended repeated statements (and if users write an identical expression twice, they won't be `===`)
+                if (statements.length === 0 || statements[statements.length - 1] !== ret[AstSymbol]) {
+                    statements.push(Expr.ast(ret));
+                }
+            }
+            else {
+                const retAst = valueOrExprToAstTyped(ret, output);
+                statements.push(retAst);
+            }
+        }
+        let body_ast;
+        if (isTypeEqual(output, NullType)) {
+            if (statements.length === 0) {
+                body_ast = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+            }
+            else if (statements.length === 1 && isSubtype(statements[0].type, NullType)) {
+                body_ast = statements[0];
+            }
+            else {
+                if (!isSubtype(statements[statements.length - 1].type, NullType)) {
+                    statements.push({ ast_type: "Value", type: NullType, location: get_location(3), value: null });
+                }
+                body_ast = {
+                    ast_type: "Block",
+                    type: statements[statements.length - 1].type,
+                    location: get_location(3),
+                    statements: statements,
+                };
+            }
+        }
+        else {
+            if (statements.length === 0) {
+                throw new Error(`Function expected output of type ${printType(output)}, but no function body or statements were provided`);
+            }
+            else if (statements.length === 1) {
+                if (!isSubtype(statements[0].type, output)) {
+                    throw new Error(`Function expected output of type ${printType(output)}, but function body has type ${printType(statements[0].type)}`);
+                }
+                body_ast = statements[0];
+            }
+            else {
+                if (!isSubtype(statements[statements.length - 1].type, output)) {
+                    throw new Error(`Function expected output of type ${printType(output)}, but function body has type ${printType(statements[statements.length - 1].type)}`);
+                }
+                body_ast = {
+                    ast_type: "Block",
+                    type: statements[statements.length - 1].type,
+                    location: get_location(3),
+                    statements: statements,
+                };
+            }
+        }
+        if (!isSubtype(body_ast.type, output)) {
+            throw new Error(`Expected function definition to return type ${printType(output)}, got ${printType(body_ast.type)}`);
+        }
+        const platforms = getPlatforms(body_ast);
+        if (type.platforms !== null) {
+            if (!platforms.every(p => type.platforms.includes(p))) {
+                throw new Error(`Function is not allowed to call platform functions: ${platforms.filter(p => !type.platforms.includes(p)).join(", ")}`);
+            }
+        }
+        const ast = {
+            ast_type: "Function",
+            type: FunctionType(inputs, output, platforms),
+            location: get_location(3),
+            parameters: input_variables,
+            body: body_ast,
+        };
+        return fromAst(ast);
+    }
+    const ast = type ? valueOrExprToAstTyped(value, type) : valueOrExprToAst(value);
+    return fromAst(ast);
+}
+export function func(input_types, output_type, body) {
+    const parameters = input_types.map(i => ({
+        ast_type: "Variable",
+        type: i,
+        location: get_location(2),
+        mutable: false,
+    }));
+    const $ = BlockBuilder(output_type ?? NeverType);
+    let ret = body($, ...parameters.map(fromAst));
+    const statements = $.statements;
+    if (output_type === undefined) {
+        if (ret === undefined) {
+            throw new Error(`When output_type is not specified, function body must return a value`);
+        }
+        const ret_ast = ret instanceof Expr ? Expr.ast(ret) : valueOrExprToAst(ret);
+        if (statements.length === 0 || statements[statements.length - 1] !== ret_ast) { // avoid duplicate statements
+            statements.push(ret_ast);
+        }
+        const ret_type = ret_ast.type;
+        let body_ast;
+        if (statements.length === 0) {
+            body_ast = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+        }
+        else if (statements.length === 1) {
+            body_ast = statements[0];
+        }
+        else {
+            body_ast = {
+                ast_type: "Block",
+                type: statements[statements.length - 1].type,
+                location: get_location(2),
+                statements: statements,
+            };
+        }
+        if (!isSubtype(body_ast.type, ret_type)) {
+            throw new Error(`function expected to return a value of type ${printType(ret_type)}, got ${printType(body_ast.type)}`);
+        }
+        const ast = {
+            ast_type: "Function",
+            type: FunctionType(input_types, ret_type, getPlatforms(body_ast)),
+            location: get_location(2),
+            parameters: parameters,
+            body: body_ast,
+        };
+        return fromAst(ast);
+    }
+    else {
+        if (ret !== undefined) {
+            const ret_ast = valueOrExprToAstTyped(ret, output_type);
+            if (statements.length === 0 || statements[statements.length - 1] !== ret_ast) { // avoid duplicate statements
+                statements.push(ret_ast);
+            }
+        }
+        let body_ast;
+        if (statements.length === 0) {
+            body_ast = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+        }
+        else if (statements.length === 1) {
+            body_ast = statements[0];
+        }
+        else {
+            body_ast = {
+                ast_type: "Block",
+                type: statements[statements.length - 1].type,
+                location: get_location(2),
+                statements: statements,
+            };
+        }
+        // This is an interesting one - do we have implicit returns? Do we need to track the absence of control flow?
+        // if (!isSubtype(expr.type, output_type)) {
+        //   throw new Error(`func expected to return a value of type ${printType(output_type)}, got ${printType(expr.type)}`);
+        // }
+        const ast = {
+            ast_type: "Function",
+            type: FunctionType(input_types, output_type, getPlatforms(body_ast)),
+            location: get_location(2),
+            parameters: parameters,
+            body: body_ast,
+        };
+        return fromAst(ast);
+    }
+}
+/** Template string literal to create an East string dynamically from components
+ *
+ * @example
+ * ```ts
+ * str`My name is ${name}`
+ * ```
+*/
+export function str(strings, ...expressions) {
+    const location = get_location(2);
+    // For simple strings, e.g: str`abc`
+    if (strings.length === 1) {
+        return fromAst({
+            ast_type: "Value",
+            type: StringType,
+            location,
+            value: strings[0],
+        });
+    }
+    // In the below we optimize away components of `strings` that is empty, removing run-time overhead.
+    // To do so correctly we need to handle when the first component is empty
+    if (strings[0] === "") {
+        let ret;
+        if (typeof expressions[0] === "string") {
+            ret = {
+                ast_type: "Value",
+                type: StringType,
+                location,
+                value: expressions[0],
+            };
+        }
+        else if (isTypeEqual(Expr.type(expressions[0]), StringType)) {
+            ret = Expr.ast(expressions[0]);
+        }
+        else {
+            ret = {
+                ast_type: "Builtin",
+                type: StringType,
+                location,
+                builtin: "Print",
+                type_parameters: [Expr.type(expressions[0])],
+                arguments: [Expr.ast(expressions[0])],
+            };
+        }
+        if (strings[1].length > 0) {
+            ret = {
+                ast_type: "Builtin",
+                type: StringType,
+                location: ret.location,
+                builtin: "StringConcat",
+                type_parameters: [],
+                arguments: [ret, {
+                        ast_type: "Value",
+                        location: ret.location,
+                        type: StringType,
+                        value: strings[1],
+                    }]
+            };
+        }
+        for (let i = 2; i < strings.length; i++) {
+            const expr = expressions[i - 1];
+            if (typeof expr === "string") {
+                ret = {
+                    ast_type: "Builtin",
+                    type: StringType,
+                    location: ret.location,
+                    builtin: "StringConcat",
+                    type_parameters: [],
+                    arguments: [ret, {
+                            ast_type: "Value",
+                            type: StringType,
+                            location,
+                            value: expr,
+                        }]
+                };
+            }
+            else if (isTypeEqual(Expr.type(expr), StringType)) {
+                ret = {
+                    ast_type: "Builtin",
+                    type: StringType,
+                    location: ret.location,
+                    builtin: "StringConcat",
+                    type_parameters: [],
+                    arguments: [ret, Expr.ast(expr)]
+                };
+            }
+            else {
+                ret = {
+                    ast_type: "Builtin",
+                    type: StringType,
+                    location: ret.location,
+                    builtin: "StringConcat",
+                    type_parameters: [],
+                    arguments: [ret, {
+                            ast_type: "Builtin",
+                            type: StringType,
+                            location: ret.location,
+                            builtin: "Print",
+                            type_parameters: [Expr.type(expr)],
+                            arguments: [Expr.ast(expr)],
+                        }]
+                };
+            }
+            if (strings[i].length > 0) {
+                ret = {
+                    ast_type: "Builtin",
+                    type: StringType,
+                    location: ret.location,
+                    builtin: "StringConcat",
+                    type_parameters: [],
+                    arguments: [ret, {
+                            ast_type: "Value",
+                            location: ret.location,
+                            type: StringType,
+                            value: strings[i],
+                        }]
+                };
+            }
+        }
+        return fromAst(ret);
+    }
+    else {
+        let ret = {
+            ast_type: "Value",
+            type: StringType,
+            location: get_location(2),
+            value: strings[0],
+        };
+        for (let i = 1; i < strings.length; i++) {
+            const expr = expressions[i - 1];
+            if (typeof expr === "string") {
+                ret = {
+                    ast_type: "Builtin",
+                    type: StringType,
+                    location: ret.location,
+                    builtin: "StringConcat",
+                    type_parameters: [],
+                    arguments: [ret, {
+                            ast_type: "Value",
+                            type: StringType,
+                            location,
+                            value: expr,
+                        }]
+                };
+            }
+            else if (isTypeEqual(Expr.type(expr), StringType)) {
+                ret = {
+                    ast_type: "Builtin",
+                    type: StringType,
+                    location: ret.location,
+                    builtin: "StringConcat",
+                    type_parameters: [],
+                    arguments: [ret, Expr.ast(expr)]
+                };
+            }
+            else {
+                ret = {
+                    ast_type: "Builtin",
+                    type: StringType,
+                    location: ret.location,
+                    builtin: "StringConcat",
+                    type_parameters: [],
+                    arguments: [ret, {
+                            ast_type: "Builtin",
+                            type: StringType,
+                            location: ret.location,
+                            builtin: "Print",
+                            type_parameters: [Expr.type(expr)],
+                            arguments: [Expr.ast(expr)],
+                        }]
+                };
+            }
+            if (strings[i].length > 0) {
+                ret = {
+                    ast_type: "Builtin",
+                    type: StringType,
+                    location: ret.location,
+                    builtin: "StringConcat",
+                    type_parameters: [],
+                    arguments: [ret, {
+                            ast_type: "Value",
+                            location: ret.location,
+                            type: StringType,
+                            value: strings[i],
+                        }]
+                };
+            }
+        }
+        return fromAst(ret);
+    }
+}
+/**
+ * Create an East block expression.
+ * The block may produce a value by returning an expressions.
+ */
+export function block(body) {
+    // Technically, a block not included in a statement will increment the var count and loop count
+    const $ = BlockBuilder(NeverType);
+    const ret = body($);
+    const statements = $.statements;
+    let ret_type = NullType;
+    for (const stmt of statements) {
+        ret_type = stmt.type;
+    }
+    if (ret === undefined) {
+        // This ensures our TypeScript type inference and actual type inference concur
+        if (!isTypeEqual(ret_type, NeverType)) {
+            throw new Error(`block without return must have type ${printType(NeverType)}, got ${printType(ret_type)} - try returning the final expression or adding \`return null\``);
+        }
+    }
+    else {
+        const ret_ast = valueOrExprToAst(ret);
+        if (statements.length === 0 || statements[statements.length - 1] !== ret_ast) { // avoid duplicate statements
+            statements.push(ret_ast);
+            ret_type = ret_ast.type;
+        }
+    }
+    if (statements.length === 0) {
+        return fromAst({
+            ast_type: "Value",
+            location: get_location(2),
+            type: ret_type,
+            value: null,
+        });
+    }
+    else if (statements.length === 1) {
+        return fromAst(statements[0]);
+    }
+    else {
+        return fromAst({
+            ast_type: "Block",
+            location: get_location(2),
+            type: ret_type,
+            statements: statements,
+        });
+    }
+}
+/**
+ * Create an East error expression
+ */
+export function error(message, location = get_location(2)) {
+    const messageAst = message instanceof Expr ? Expr.ast(message) : valueOrExprToAstTyped(message, StringType);
+    return fromAst({
+        ast_type: "Error",
+        type: NeverType,
+        message: messageAst,
+        location,
+    });
+}
+/** Create a match expression */
+export function matchExpr(variant, handlers) {
+    if (Expr.type(variant).type !== "Variant") {
+        throw new Error(`match not defined over ${printType(Expr.type(variant))}`);
+    }
+    const cases_out = {};
+    let out_type = NeverType;
+    for (const [k, t] of Object.entries(Expr.type(variant).cases)) {
+        const handler = handlers[k];
+        const data_variable = {
+            ast_type: "Variable",
+            type: t,
+            location: get_location(2),
+            mutable: false,
+        };
+        const ast = handler === undefined ? valueOrExprToAstTyped(null, NullType) : block($ => handler($, fromAst(data_variable)))[AstSymbol];
+        out_type = TypeUnion(out_type, ast.type);
+        cases_out[k] = { variable: data_variable, body: ast };
+    }
+    // TODO do we care if extra case branches exist? (we don't even call the function passed in!)
+    return fromAst({
+        ast_type: "Match",
+        type: out_type,
+        location: get_location(2),
+        variant: Expr.ast(variant),
+        cases: cases_out,
+    });
+}
+/**
+ * Create an East try-catch expression
+ */
+export function tryCatch(try_body, catch_body) {
+    const try_type = Expr.type(try_body);
+    // Create variables for the catch body
+    const message_variable = {
+        ast_type: "Variable",
+        type: StringType,
+        location: get_location(2),
+        mutable: false,
+    };
+    const stack_variable = {
+        ast_type: "Variable",
+        type: ArrayType(StructType({ filename: StringType, line: IntegerType, column: IntegerType })),
+        location: get_location(2),
+        mutable: false,
+    };
+    if (typeof catch_body !== "function") {
+        throw new Error(`tryCatch expected catch_body to be a function, got ${typeof catch_body}`);
+    }
+    const catch_body_expr = block($ => catch_body($, fromAst(message_variable), fromAst(stack_variable)));
+    const catch_body_ast = catch_body_expr[AstSymbol];
+    const catch_type = catch_body_ast.type;
+    const ret_type = TypeUnion(try_type, catch_type);
+    return fromAst({
+        ast_type: "TryCatch",
+        type: ret_type,
+        location: get_location(2),
+        try_body: Expr.ast(try_body),
+        catch_body: catch_body_ast,
+        message: message_variable,
+        stack: stack_variable,
+    });
+}
+/** Test if the first value is equal to the second. */
+export function equal(left, right) {
+    const rightAst = valueOrExprToAstTyped(right, Expr.type(left));
+    return fromAst({
+        ast_type: "Builtin",
+        type: BooleanType,
+        location: get_location(2),
+        builtin: "Equal",
+        type_parameters: [Expr.type(left)],
+        arguments: [Expr.ast(left), rightAst],
+    });
+}
+/** Test if the first value is not equal to the second. */
+export function notEqual(left, right) {
+    const rightAst = valueOrExprToAstTyped(right, Expr.type(left));
+    return fromAst({
+        ast_type: "Builtin",
+        type: BooleanType,
+        location: get_location(2),
+        builtin: "NotEqual",
+        type_parameters: [Expr.type(left)],
+        arguments: [Expr.ast(left), rightAst],
+    });
+}
+/** Test if the first value is less than the second. */
+export function less(left, right) {
+    const rightAst = valueOrExprToAstTyped(right, Expr.type(left));
+    return fromAst({
+        ast_type: "Builtin",
+        type: BooleanType,
+        location: get_location(2),
+        builtin: "Less",
+        type_parameters: [Expr.type(left)],
+        arguments: [Expr.ast(left), rightAst],
+    });
+}
+/** Test if the first value is less than or equal to the second. */
+export function lessEqual(left, right) {
+    const rightAst = valueOrExprToAstTyped(right, Expr.type(left));
+    return fromAst({
+        ast_type: "Builtin",
+        type: BooleanType,
+        location: get_location(2),
+        builtin: "LessEqual",
+        type_parameters: [Expr.type(left)],
+        arguments: [Expr.ast(left), rightAst],
+    });
+}
+/** Test if the first value is greater than the second. */
+export function greater(left, right) {
+    const rightAst = valueOrExprToAstTyped(right, Expr.type(left));
+    return fromAst({
+        ast_type: "Builtin",
+        type: BooleanType,
+        location: get_location(2),
+        builtin: "Greater",
+        type_parameters: [Expr.type(left)],
+        arguments: [Expr.ast(left), rightAst],
+    });
+}
+/** Test if the first value is greater than or equal to the second. */
+export function greaterEqual(left, right) {
+    const rightAst = valueOrExprToAstTyped(right, Expr.type(left));
+    return fromAst({
+        ast_type: "Builtin",
+        type: BooleanType,
+        location: get_location(2),
+        builtin: "GreaterEqual",
+        type_parameters: [Expr.type(left)],
+        arguments: [Expr.ast(left), rightAst],
+    });
+}
+/** Test if the first value is the same object the second.
+ * For mutable collections, such as arrays, this means that they are the same object in memory.
+ * For immutable data types, such as integers and strings, this is equivalent to equality.
+ */
+export function is(left, right) {
+    const rightAst = valueOrExprToAstTyped(right, Expr.type(left));
+    return fromAst({
+        ast_type: "Builtin",
+        type: BooleanType,
+        location: get_location(2),
+        builtin: "Is",
+        type_parameters: [Expr.type(left)],
+        arguments: [Expr.ast(left), rightAst],
+    });
+}
+/** Print a value as a string. */
+export function print(value) {
+    const valueAst = Expr.ast(value);
+    return fromAst({
+        ast_type: "Builtin",
+        type: StringType,
+        location: get_location(2),
+        builtin: "Print",
+        type_parameters: [valueAst.type],
+        arguments: [valueAst],
+    });
+}
+/** Create a callable helper to invoke a platform function.
+ *
+ * Platform functions provide access to external capabilities (logging, I/O, database access, etc.)
+ * that East code can call. They are defined by the platform when compiling and executing East IR.
+ *
+ * @param name - The name of the platform function (must match a function provided in the platform object)
+ * @param input_types - Array of input parameter types for the platform function
+ * @param output_type - The return type of the platform function
+ * @returns A callable function that creates Platform AST nodes when invoked
+ *
+ * @example
+ * ```ts
+// Define a platform function helper for logging
+const log = East.platform("log", [StringType], NullType);
+
+// Use it in East code
+const myFunction = East.function([], NullType, ($) => {
+  $(log("Hello, world!"));
+  $.return(null);
+});
+
+// Provide the implementation when compiling
+const platform = [
+  log.implement(false, (message: string) => console.log(message)),
+];
+const compiled = myFunction.toIR().compile(platform);
+compiled(); // Logs "Hello, world!" to the console
+ * ```
+ */
+export function platform(name, input_types, output_type) {
+    const fn = (...args) => {
+        if (args.length !== input_types.length) {
+            throw new Error(`Platform function ${name} expected ${input_types.length} arguments, got ${args.length}`);
+        }
+        const argAsts = args.map((arg, index) => {
+            const expectedType = input_types[index];
+            let ast = valueOrExprToAstTyped(arg, expectedType);
+            if (ast.type.type === "Never") {
+                throw new Error(`Platform function ${name} argument ${index} expected type ${printType(expectedType)}, got Never type`);
+            }
+            if (!isTypeEqual(ast.type, expectedType)) {
+                if (!isSubtype(ast.type, expectedType)) {
+                    throw new Error(`Platform function ${name} argument ${index} expected type ${printType(expectedType)}, got ${printType(ast.type)}`);
+                }
+                // Insert implicit cast
+                ast = {
+                    ast_type: "As",
+                    type: expectedType,
+                    location: get_location(2),
+                    value: ast,
+                };
+            }
+            return ast;
+        });
+        return fromAst({
+            ast_type: "Platform",
+            type: output_type,
+            location: get_location(2),
+            name: name,
+            arguments: argAsts,
+        });
+    };
+    fn.implement = (fnImpl) => {
+        // Convert types from EastType to EastTypeValue once at implementation time
+        const inputsAsValues = input_types.map(t => toEastTypeValue(t));
+        const outputAsValue = toEastTypeValue(output_type);
+        if (output_type.type === "Null") {
+            return {
+                name,
+                inputs: inputsAsValues,
+                output: outputAsValue,
+                type: 'sync',
+                fn: (...args) => { fnImpl(...args); return null; },
+            };
+        }
+        else {
+            return {
+                name,
+                inputs: inputsAsValues,
+                output: outputAsValue,
+                type: 'sync',
+                fn: fnImpl,
+            };
+        }
+    };
+    fn.implementAsync = (fnImpl) => {
+        // Convert types from EastType to EastTypeValue once at implementation time
+        const inputsAsValues = input_types.map(t => toEastTypeValue(t));
+        const outputAsValue = toEastTypeValue(output_type);
+        if (output_type.type === "Null") {
+            return {
+                name,
+                inputs: inputsAsValues,
+                output: outputAsValue,
+                type: 'async',
+                fn: async (...args) => { await fnImpl(...args); return null; },
+            };
+        }
+        else {
+            return {
+                name,
+                inputs: inputsAsValues,
+                output: outputAsValue,
+                type: 'async',
+                fn: fnImpl,
+            };
+        }
+    };
+    return fn;
+}
+export const BlockBuilder = (return_type) => {
+    const statements = [];
+    const $ = ((expr) => {
+        const ast = Expr.ast(expr);
+        statements.push(ast);
+        return expr;
+    });
+    $.statements = statements;
+    $.type = () => {
+        if (statements.length === 0) {
+            return NullType;
+        }
+        else {
+            return statements[statements.length - 1].type;
+        }
+    };
+    $.const = ((value, type) => {
+        if (isTypeEqual($.type(), NeverType)) {
+            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+        }
+        let ast;
+        if (value instanceof Expr) {
+            if (type && !isSubtype(Expr.type(value), type)) {
+                throw new Error(`Expression expected to have type ${printType(type)} but got type ${printType(Expr.type(value))}`);
+            }
+            ast = Expr.ast(value);
+        }
+        else {
+            ast = type ? valueOrExprToAstTyped(value, type) : valueOrExprToAst(value);
+        }
+        const variable = {
+            ast_type: "Variable",
+            type: type ?? ast.type,
+            location: get_location(2),
+            mutable: false,
+        };
+        statements.push({
+            ast_type: "Let",
+            type: NullType,
+            location: get_location(2),
+            variable,
+            value: ast,
+        });
+        return fromAst(variable);
+    });
+    $.let = ((value, type) => {
+        if (isTypeEqual($.type(), NeverType)) {
+            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+        }
+        let ast;
+        if (value instanceof Expr) {
+            if (type && !isSubtype(Expr.type(value), type)) {
+                throw new Error(`Expression expected to have type ${printType(type)} but got type ${printType(Expr.type(value))}`);
+            }
+            ast = Expr.ast(value);
+        }
+        else {
+            ast = type ? valueOrExprToAstTyped(value, type) : valueOrExprToAst(value);
+        }
+        const variable = {
+            ast_type: "Variable",
+            type: type ?? ast.type,
+            location: get_location(2),
+            mutable: true,
+        };
+        statements.push({
+            ast_type: "Let",
+            type: NullType,
+            location: get_location(2),
+            variable,
+            value: ast,
+        });
+        return fromAst(variable);
+    });
+    $.assign = ((variable, value) => {
+        if (isTypeEqual($.type(), NeverType)) {
+            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+        }
+        const v = Expr.ast(variable);
+        if (v.ast_type !== "Variable") {
+            throw new Error("Can only assign to a variable");
+        }
+        if (!v.mutable) {
+            throw new Error(`Cannot assign to variable defined at ${printLocation(v.location)} defined as const`);
+        }
+        const ast_value = value instanceof Expr ? Expr.ast(value) : valueOrExprToAstTyped(value, v.type);
+        const ast = {
+            ast_type: "Assign",
+            type: NullType,
+            location: get_location(2),
+            variable: v,
+            value: ast_value,
+        };
+        statements.push(ast);
+        return fromAst(ast);
+    });
+    // TODO if/when we introduce recursion, can we somehow get benefit from the typing?
+    $.return = (expr) => {
+        if (isTypeEqual($.type(), NeverType)) {
+            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+        }
+        const expAst = expr instanceof Expr ? Expr.ast(expr) : valueOrExprToAst(expr);
+        if (!isSubtype(expAst.type, return_type)) {
+            throw new Error(`Return expected to have type ${printType(return_type)}, got ${printType(expAst.type)}`);
+        }
+        const ast = {
+            ast_type: "Return",
+            type: NeverType,
+            location: get_location(2),
+            value: expAst
+        };
+        statements.push(ast);
+        return fromAst(ast);
+    };
+    $.break = (label) => {
+        if (isTypeEqual($.type(), NeverType)) {
+            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+        }
+        const ast = {
+            ast_type: "Break",
+            type: NeverType,
+            location: get_location(2),
+            label,
+        };
+        statements.push(ast);
+        return fromAst(ast);
+    };
+    $.continue = (label) => {
+        if (isTypeEqual($.type(), NeverType)) {
+            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+        }
+        const ast = {
+            ast_type: "Continue",
+            type: NeverType,
+            location: get_location(2),
+            label,
+        };
+        statements.push(ast);
+        return fromAst(ast);
+    };
+    $.if = (predicate, true_branch) => {
+        if (isTypeEqual($.type(), NeverType)) {
+            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+        }
+        const predicateAst = predicate instanceof Expr ? Expr.ast(predicate) : valueOrExprToAstTyped(predicate, BooleanType);
+        if (predicateAst.type.type !== "Boolean") {
+            throw new Error(`if predicate expected to have type Boolean, got ${printType(predicateAst.type)}`);
+        }
+        predicate = fromAst(predicateAst);
+        const $_true = BlockBuilder(return_type);
+        const ret_true = true_branch($_true);
+        const true_stmts = $_true.statements;
+        if (ret_true !== undefined) {
+            const ret_ast = valueOrExprToAst(ret_true);
+            if (true_stmts.length === 0 || true_stmts[true_stmts.length - 1] !== ret_ast) { // avoid duplicate statements
+                true_stmts.push(ret_ast);
+            }
+        }
+        let true_ast;
+        if (true_stmts.length === 0) {
+            true_ast = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+        }
+        else if (true_stmts.length === 1 && isSubtype(true_stmts[0].type, NullType)) {
+            true_ast = true_stmts[0];
+        }
+        else {
+            if (!isSubtype(true_stmts[true_stmts.length - 1].type, NullType)) {
+                true_stmts.push({ ast_type: "Value", type: NullType, location: get_location(2), value: null });
+            }
+            true_ast = {
+                ast_type: "Block",
+                type: true_stmts[true_stmts.length - 1].type,
+                location: get_location(2),
+                statements: true_stmts,
+            };
+        }
+        const if_else_ast = {
+            ast_type: "IfElse",
+            type: NullType,
+            location: get_location(2),
+            ifs: [{
+                    predicate: Expr.ast(predicate),
+                    body: true_ast,
+                }],
+            else_body: { ast_type: "Value", type: NullType, location: get_location(2), value: null },
+        };
+        statements.push(if_else_ast);
+        return new IfElseExpr(if_else_ast, return_type);
+    };
+    $.match = (variant, cases) => {
+        if (isTypeEqual($.type(), NeverType)) {
+            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+        }
+        if (Expr.type(variant).type !== "Variant") {
+            throw new Error(`match not defined over ${printType(Expr.type(variant))}`);
+        }
+        const cases_out = {};
+        let out_type = NullType;
+        for (const [k, t] of Object.entries(Expr.type(variant).cases)) {
+            const f = cases[k];
+            const data_variable = {
+                ast_type: "Variable",
+                type: t,
+                location: get_location(2),
+                mutable: false,
+            };
+            if (f === undefined) {
+                cases_out[k] = { variable: data_variable, body: { ast_type: "Value", type: NullType, location: get_location(2), value: null } };
+            }
+            else {
+                const data = fromAst(data_variable);
+                const $ = BlockBuilder(return_type);
+                const ret = f($, data);
+                const stmts = $.statements;
+                if (ret !== undefined) {
+                    const ret_ast = valueOrExprToAst(ret);
+                    if (stmts.length === 0 || stmts[stmts.length - 1] !== ret_ast) { // avoid duplicate statements
+                        stmts.push(ret_ast);
+                    }
+                }
+                let expr;
+                if (stmts.length === 0) {
+                    expr = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+                }
+                else if (stmts.length === 1 && isSubtype(stmts[0].type, NullType)) {
+                    expr = stmts[0];
+                }
+                else {
+                    if (!isSubtype(stmts[stmts.length - 1].type, NullType)) {
+                        stmts.push({ ast_type: "Value", type: NullType, location: get_location(2), value: null });
+                    }
+                    expr = {
+                        ast_type: "Block",
+                        type: stmts[stmts.length - 1].type,
+                        location: get_location(2),
+                        statements: stmts,
+                    };
+                }
+                cases_out[k] = { variable: data_variable, body: expr };
+            }
+        }
+        // TODO do we care if extra case branches exist? (we don't even call the function passed in!)
+        const ast = {
+            ast_type: "Match",
+            type: out_type,
+            location: get_location(2),
+            variant: Expr.ast(variant),
+            cases: cases_out,
+        };
+        statements.push(ast);
+        return fromAst(ast);
+    };
+    $.while = (predicate, body) => {
+        if (isTypeEqual($.type(), NeverType)) {
+            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+        }
+        const predicateAst = predicate instanceof Expr ? Expr.ast(predicate) : valueOrExprToAstTyped(predicate, BooleanType);
+        if (predicateAst.type.type !== "Boolean") {
+            throw new Error(`while predicate expected to have type Boolean, got ${printType(predicateAst.type)}`);
+        }
+        const label = { location: get_location(2) };
+        const $_body = BlockBuilder(return_type);
+        const ret = body($_body, label);
+        const stmts = $_body.statements;
+        if (ret !== undefined) {
+            const ret_ast = valueOrExprToAst(ret);
+            if (stmts.length === 0 || stmts[stmts.length - 1] !== ret_ast) { // avoid duplicate statements
+                stmts.push(ret_ast);
+            }
+        }
+        let expr;
+        if (stmts.length === 0) {
+            expr = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+        }
+        else if (stmts.length === 1 && isSubtype(stmts[0].type, NullType)) {
+            expr = stmts[0];
+        }
+        else {
+            if (!isSubtype(stmts[stmts.length - 1].type, NullType)) {
+                stmts.push({ ast_type: "Value", type: NullType, location: get_location(2), value: null });
+            }
+            expr = {
+                ast_type: "Block",
+                type: stmts[stmts.length - 1].type,
+                location: get_location(2),
+                statements: stmts,
+            };
+        }
+        // Note: we could try to look for unconditional loops with NeverType bodies and make the whole statement NeverType
+        // However, this would have a false positive on a loop which breaks itself out of the loop, which would continue execution!
+        // That is, `while (true) { break }` is valid and continues execution after the loop.
+        const ast = {
+            ast_type: "While",
+            type: NullType,
+            location: get_location(2),
+            predicate: predicateAst,
+            label,
+            body: expr,
+        };
+        statements.push(ast);
+        return fromAst(ast);
+    };
+    $.for = ((collection, body) => {
+        if (isTypeEqual($.type(), NeverType)) {
+            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+        }
+        if (collection instanceof ArrayExpr) {
+            const value_variable = {
+                ast_type: "Variable",
+                type: Expr.type(collection).value,
+                location: get_location(2),
+                mutable: false,
+            };
+            const value = fromAst(value_variable);
+            const key_variable = {
+                ast_type: "Variable",
+                type: IntegerType,
+                location: get_location(2),
+                mutable: false,
+            };
+            const key = fromAst(key_variable);
+            const label = { location: get_location(2) };
+            const $ = BlockBuilder(return_type);
+            const ret = body($, value, key, label);
+            const stmts = $.statements;
+            if (ret !== undefined) {
+                const ret_ast = valueOrExprToAst(ret);
+                if (stmts.length === 0 || stmts[stmts.length - 1] !== ret_ast) { // avoid duplicate statements
+                    stmts.push(ret_ast);
+                }
+            }
+            let expr;
+            if (stmts.length === 0) {
+                expr = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+            }
+            else if (stmts.length === 1 && isSubtype(stmts[0].type, NullType)) {
+                expr = stmts[0];
+            }
+            else {
+                if (!isSubtype(stmts[stmts.length - 1].type, NullType)) {
+                    stmts.push({ ast_type: "Value", type: NullType, location: get_location(2), value: null });
+                }
+                expr = {
+                    ast_type: "Block",
+                    type: stmts[stmts.length - 1].type,
+                    location: get_location(2),
+                    statements: stmts,
+                };
+            }
+            const ast = {
+                ast_type: "ForArray",
+                type: NullType,
+                location: get_location(2),
+                label,
+                array: Expr.ast(collection),
+                key: key_variable,
+                value: value_variable,
+                body: expr,
+            };
+            statements.push(ast);
+            return fromAst(ast);
+        }
+        else if (collection instanceof SetExpr) {
+            const key_variable = {
+                ast_type: "Variable",
+                type: Expr.type(collection).key,
+                location: get_location(2),
+                mutable: false,
+            };
+            const key = fromAst(key_variable);
+            const label = { location: get_location(2) };
+            const $ = BlockBuilder(return_type);
+            const ret = body($, key, label);
+            const stmts = $.statements;
+            if (ret !== undefined) {
+                const ret_ast = valueOrExprToAst(ret);
+                if (stmts.length === 0 || stmts[stmts.length - 1] !== ret_ast) { // avoid duplicate statements
+                    stmts.push(ret_ast);
+                }
+            }
+            let expr;
+            if (stmts.length === 0) {
+                expr = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+            }
+            else if (stmts.length === 1 && isSubtype(stmts[0].type, NullType)) {
+                expr = stmts[0];
+            }
+            else {
+                if (!isSubtype(stmts[stmts.length - 1].type, NullType)) {
+                    stmts.push({ ast_type: "Value", type: NullType, location: get_location(2), value: null });
+                }
+                expr = {
+                    ast_type: "Block",
+                    type: stmts[stmts.length - 1].type,
+                    location: get_location(2),
+                    statements: stmts,
+                };
+            }
+            const ast = {
+                ast_type: "ForSet",
+                type: NullType,
+                location: get_location(2),
+                label,
+                set: Expr.ast(collection),
+                key: key_variable,
+                body: expr,
+            };
+            statements.push(ast);
+            return fromAst(ast);
+        }
+        else if (collection instanceof DictExpr) {
+            const value_variable = {
+                ast_type: "Variable",
+                type: Expr.type(collection).value,
+                location: get_location(2),
+                mutable: false,
+            };
+            const value = fromAst(value_variable);
+            const key_variable = {
+                ast_type: "Variable",
+                type: Expr.type(collection).key,
+                location: get_location(2),
+                mutable: false,
+            };
+            const key = fromAst(key_variable);
+            const label = { location: get_location(2) };
+            const $ = BlockBuilder(return_type);
+            const ret = body($, value, key, label);
+            const stmts = $.statements;
+            if (ret !== undefined) {
+                const ret_ast = valueOrExprToAst(ret);
+                if (stmts.length === 0 || stmts[stmts.length - 1] !== ret_ast) { // avoid duplicate statements
+                    stmts.push(ret_ast);
+                }
+            }
+            let expr;
+            if (stmts.length === 0) {
+                expr = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+            }
+            else if (stmts.length === 1 && isSubtype(stmts[0].type, NullType)) {
+                expr = stmts[0];
+            }
+            else {
+                if (!isSubtype(stmts[stmts.length - 1].type, NullType)) {
+                    stmts.push({ ast_type: "Value", type: NullType, location: get_location(2), value: null });
+                }
+                expr = {
+                    ast_type: "Block",
+                    type: stmts[stmts.length - 1].type,
+                    location: get_location(2),
+                    statements: stmts,
+                };
+            }
+            const ast = {
+                ast_type: "ForDict",
+                type: NullType,
+                location: get_location(2),
+                label,
+                dict: Expr.ast(collection),
+                key: key_variable,
+                value: value_variable,
+                body: expr,
+            };
+            statements.push(ast);
+            return fromAst(ast);
+        }
+        else {
+            throw new Error(`for not defined over ${printType(Expr.type(collection))} - you can only loop over arrays, sets and dictionaries`);
+        }
+    });
+    $.error = (message, location) => {
+        if (isTypeEqual($.type(), NeverType)) {
+            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+        }
+        if (location === undefined) {
+            location = get_location(2);
+        }
+        const ast = {
+            ast_type: "Error",
+            type: NeverType,
+            message: message instanceof Expr ? Expr.ast(message) : valueOrExprToAstTyped(message, StringType),
+            location,
+        };
+        statements.push(ast);
+        return fromAst(ast);
+    };
+    $.try = (body) => {
+        if (isTypeEqual($.type(), NeverType)) {
+            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+        }
+        const $try = BlockBuilder(return_type);
+        const ret = body($try);
+        const try_stmts = $try.statements;
+        if (ret !== undefined) {
+            const ret_ast = valueOrExprToAst(ret);
+            if (try_stmts.length === 0 || try_stmts[try_stmts.length - 1] !== ret_ast) { // avoid duplicate statements
+                try_stmts.push(ret_ast);
+            }
+        }
+        if (try_stmts.length === 0 || !isSubtype(try_stmts[try_stmts.length - 1].type, NullType)) {
+            try_stmts.push({ ast_type: "Value", type: NullType, location: get_location(2), value: null });
+        }
+        let try_expr;
+        if (try_stmts.length === 1) {
+            try_expr = try_stmts[0];
+        }
+        else {
+            try_expr = {
+                ast_type: "Block",
+                type: try_stmts[try_stmts.length - 1].type,
+                location: get_location(2),
+                statements: try_stmts,
+            };
+        }
+        // Now define the variables available in the catch block
+        const message_variable = {
+            ast_type: "Variable",
+            type: StringType,
+            location: get_location(2),
+            mutable: false,
+        };
+        const stack_variable = {
+            ast_type: "Variable",
+            type: ArrayType(StructType({ filename: StringType, line: IntegerType, column: IntegerType })),
+            location: get_location(2),
+            mutable: false,
+        };
+        const try_catch_ast = {
+            ast_type: "TryCatch",
+            type: NullType,
+            location: get_location(2),
+            try_body: try_expr,
+            catch_body: { ast_type: "Value", type: NullType, location: get_location(2), value: null }, // will be updated later
+            message: message_variable,
+            stack: stack_variable,
+        };
+        statements.push(try_catch_ast);
+        return new TryCatchExpr(try_catch_ast, message_variable, stack_variable, return_type);
+    };
+    return $;
+};
+/** A helper class to perform if-elseif-else control flow. */
+class IfElseExpr extends NullExpr {
+    return_type;
+    /** @internal */
+    constructor(ast, return_type) {
+        super(ast, fromAst);
+        this.return_type = return_type;
+        // Note: the AST has been initialized to `value(null)` for the else body
+        // The idea is that the if method bellow will fill them after the fact via mutation
+    }
+    /** Define the logic to follow when the condition is false. */
+    else(body) {
+        const $ = BlockBuilder(this.return_type);
+        const ret = body($);
+        const stmts = $.statements;
+        if (ret !== undefined) {
+            const ret_ast = valueOrExprToAst(ret);
+            if (stmts.length === 0 || stmts[stmts.length - 1] !== ret_ast) { // avoid duplicate statements
+                stmts.push(ret_ast);
+            }
+        }
+        if (stmts.length === 0 || !isSubtype(stmts[stmts.length - 1].type, NullType)) {
+            stmts.push({ ast_type: "Value", type: NullType, location: get_location(2), value: null });
+        }
+        this[AstSymbol].else_body = stmts.length === 1 ? stmts[0] : {
+            ast_type: "Block",
+            type: stmts[stmts.length - 1].type,
+            location: get_location(2),
+            statements: stmts,
+        };
+        // propagate unreachable information
+        let can_terminate = true;
+        check: {
+            for (const ifStmt of this[AstSymbol].ifs) {
+                if (isTypeEqual(ifStmt.predicate.type, NeverType)) {
+                    can_terminate = false;
+                    break check;
+                }
+                else if (!isTypeEqual(ifStmt.body.type, NeverType)) {
+                    break check;
+                }
+            }
+            if (isTypeEqual(this[AstSymbol].else_body.type, NeverType)) {
+                can_terminate = false;
+            }
+        }
+        if (!can_terminate) {
+            this[AstSymbol].type = NeverType;
+        }
+        return fromAst(this[AstSymbol]);
+    }
+    /** Check for another predicate, and execute logic if it is true */
+    elseIf(predicate, body) {
+        const predicateAst = predicate instanceof Expr ? Expr.ast(predicate) : valueOrExprToAstTyped(predicate, BooleanType);
+        if (predicateAst.type.type !== "Boolean") {
+            throw new Error(`elseIf predicate expected to have type Boolean, got ${printType(predicateAst.type)}`);
+        }
+        predicate = fromAst(predicateAst);
+        const $ = BlockBuilder(this.return_type);
+        const ret = body($);
+        const stmts = $.statements;
+        if (ret !== undefined) {
+            const ret_ast = valueOrExprToAst(ret);
+            if (stmts.length === 0 || stmts[stmts.length - 1] !== ret_ast) { // avoid duplicate statements
+                stmts.push(ret_ast);
+            }
+        }
+        if (stmts.length === 0 || !isSubtype(stmts[stmts.length - 1].type, NullType)) {
+            stmts.push({ ast_type: "Value", type: NullType, location: get_location(2), value: null });
+        }
+        this[AstSymbol].ifs.push({
+            predicate: Expr.ast(predicate),
+            body: stmts.length === 1 ? stmts[0] : {
+                ast_type: "Block",
+                type: stmts[stmts.length - 1].type,
+                location: get_location(2),
+                statements: stmts,
+            },
+        });
+        return this;
+    }
+}
+/** A helper class to perform try-catch control flow. */
+class TryCatchExpr extends NullExpr {
+    message_variable;
+    stack_variable;
+    return_type;
+    catchCalled = false;
+    /** @internal */
+    constructor(ast, message_variable, stack_variable, return_type) {
+        super(ast, fromAst);
+        this.message_variable = message_variable;
+        this.stack_variable = stack_variable;
+        this.return_type = return_type;
+        // Note: the AST has been initialized to `value(null)` for the catch body
+        // The idea is that the catch method bellow will fill it after the fact via mutation
+    }
+    /** Define the logic to follow when an error is caught. The error message and stack trace is provided. */
+    catch(body) {
+        if (this.catchCalled) {
+            throw new Error(`Cannot call .catch() more than once on the same try block at ${printLocation(get_location(2))}`);
+        }
+        this.catchCalled = true;
+        const $ = BlockBuilder(this.return_type);
+        const ret = body($, fromAst(this.message_variable), fromAst(this.stack_variable));
+        const stmts = $.statements;
+        if (ret !== undefined) {
+            const ret_ast = valueOrExprToAst(ret);
+            if (stmts.length === 0 || stmts[stmts.length - 1] !== ret_ast) { // avoid duplicate statements
+                stmts.push(ret_ast);
+            }
+        }
+        if (stmts.length === 0 || !isSubtype(stmts[stmts.length - 1].type, NullType)) {
+            stmts.push({ ast_type: "Value", type: NullType, location: get_location(2), value: null });
+        }
+        this[AstSymbol].catch_body = stmts.length === 1 ? stmts[0] : {
+            ast_type: "Block",
+            type: stmts[stmts.length - 1].type,
+            location: get_location(2),
+            statements: stmts,
+        };
+        // Propagate unreachable information
+        if (isTypeEqual(this[AstSymbol].try_body.type, NeverType) && isTypeEqual(this[AstSymbol].catch_body.type, NeverType)) {
+            this[AstSymbol].type = NeverType;
+        }
+        return this;
+    }
+    /** Define cleanup logic that always executes, regardless of whether an error occurred. The finally block is for side effects only and does not affect the return type. */
+    finally(body) {
+        const $ = BlockBuilder(this.return_type);
+        const ret = body($);
+        const stmts = $.statements;
+        if (ret !== undefined) {
+            const ret_ast = valueOrExprToAst(ret);
+            if (stmts.length === 0 || stmts[stmts.length - 1] !== ret_ast) { // avoid duplicate statements
+                stmts.push(ret_ast);
+            }
+        }
+        if (stmts.length === 0 || !isSubtype(stmts[stmts.length - 1].type, NullType)) {
+            stmts.push({ ast_type: "Value", type: NullType, location: get_location(2), value: null });
+        }
+        this[AstSymbol].finally_body = stmts.length === 1 ? stmts[0] : {
+            ast_type: "Block",
+            type: stmts[stmts.length - 1].type,
+            location: get_location(2),
+            statements: stmts,
+        };
+    }
+}
+// Bind the static factory methods to the Expr class which were left undefined in expr.ts
+Object.assign(Expr, {
+    // Static factory methods - now simple functions
+    fromAst,
+    from,
+    block,
+    error,
+    tryCatch,
+    function: func,
+    print,
+    str,
+    equal,
+    notEqual,
+    less,
+    lessEqual,
+    greater,
+    greaterEqual,
+    is,
+    match: matchExpr
+});
+//# sourceMappingURL=block.js.map