@elaraai/east 0.0.1-beta.3 → 0.0.1-beta.31

package/dist/src/expr/block.js

@@ -3,9 +3,9 @@
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
 import {} from "../ast.js";
-import { get_location, printLocation } from "../location.js";
+import { get_location, printLocations } from "../location.js";
 import { FunctionType, isSubtype, NullType, printType, isTypeEqual, StringType, NeverType, VariantType, BooleanType, TypeUnion, IntegerType, StructType, ArrayType, AsyncFunctionType } from "../types.js";
-import { AstSymbol, Expr } from "./expr.js";
+import { AstSymbol, Expr, TypeSymbol } from "./expr.js";
 import { NeverExpr } from "./never.js";
 import { NullExpr } from "./null.js";
 import { BooleanExpr } from "./boolean.js";
@@ -19,11 +19,14 @@ 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 { RecursiveExpr } from "./recursive.js";
+import { createFunctionExpr, FunctionExpr } from "./function.js";
 import { valueOrExprToAst, valueOrExprToAstTyped } from "./ast.js";
 import { toEastTypeValue } from "../type_of_type.js";
+import { isVariant } from "../containers/variant.js";
 import { RefExpr } from "./ref.js";
-import { createAsyncFunctionExpr } from "./asyncfunction.js";
+import { AsyncFunctionExpr, createAsyncFunctionExpr } from "./asyncfunction.js";
+import { PatchType } from "../patch/index.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.
  */
@@ -72,14 +75,8 @@ export function fromAst(ast) {
         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);
+        // Return RecursiveExpr to preserve the RecursiveType wrapper for TypeOf
+        return new RecursiveExpr(ast.type.node, ast, fromAst);
     }
     else if (type === "Function") {
         return createFunctionExpr(ast.type.inputs, ast.type.output, ast, fromAst);
@@ -88,9 +85,29 @@ export function fromAst(ast) {
         return createAsyncFunctionExpr(ast.type.inputs, ast.type.output, ast, fromAst);
     }
     else {
-        throw new Error(`fromAst not implemented for type ${printType(ast.type)} at ${printLocation(ast.location)}`);
+        throw new Error(`fromAst not implemented for type ${printType(ast.type)} at ${printLocations(ast.location)}`);
     }
 }
+/**
+ * Compile a function expression into a JavaScript function.
+ *
+ * @param f the function expression to compile
+ * @param platform the platform functions available during compilation
+ * @returns the compiled function
+ */
+export function compile(f, platform) {
+    return f.toIR().compile(platform);
+}
+/**
+ * Compile an async function expression into a JavaScript function.
+ *
+ * @param f the async function expression to compile
+ * @param platform the platform functions available during compilation
+ * @returns the compiled async function
+ */
+export function compileAsync(f, platform) {
+    return f.toIR().compile(platform);
+}
 export function from(value, type) {
     if (value instanceof Expr) {
         if (type) {
@@ -110,7 +127,7 @@ export function from(value, type) {
         const input_variables = inputs.map(i => ({
             ast_type: "Variable",
             type: i,
-            location: get_location(3),
+            location: get_location(),
             mutable: false,
         }));
         const $ = BlockBuilder(output);
@@ -134,19 +151,19 @@ export function from(value, type) {
         let body_ast;
         if (isTypeEqual(output, NullType)) {
             if (statements.length === 0) {
-                body_ast = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+                body_ast = { ast_type: "Value", type: NullType, location: get_location(), 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 });
+                    statements.push({ ast_type: "Value", type: NullType, location: get_location(), value: null });
                 }
                 body_ast = {
                     ast_type: "Block",
                     type: statements[statements.length - 1].type,
-                    location: get_location(3),
+                    location: get_location(),
                     statements: statements,
                 };
             }
@@ -168,7 +185,7 @@ export function from(value, type) {
                 body_ast = {
                     ast_type: "Block",
                     type: statements[statements.length - 1].type,
-                    location: get_location(3),
+                    location: get_location(),
                     statements: statements,
                 };
             }
@@ -179,7 +196,7 @@ export function from(value, type) {
         const ast = {
             ast_type: "Function",
             type: FunctionType(inputs, output),
-            location: get_location(3),
+            location: get_location(),
             parameters: input_variables,
             body: body_ast,
         };
@@ -193,7 +210,7 @@ export function from(value, type) {
         const input_variables = inputs.map(i => ({
             ast_type: "Variable",
             type: i,
-            location: get_location(3),
+            location: get_location(),
             mutable: false,
         }));
         const $ = BlockBuilder(output);
@@ -217,19 +234,19 @@ export function from(value, type) {
         let body_ast;
         if (isTypeEqual(output, NullType)) {
             if (statements.length === 0) {
-                body_ast = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+                body_ast = { ast_type: "Value", type: NullType, location: get_location(), 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 });
+                    statements.push({ ast_type: "Value", type: NullType, location: get_location(), value: null });
                 }
                 body_ast = {
                     ast_type: "Block",
                     type: statements[statements.length - 1].type,
-                    location: get_location(3),
+                    location: get_location(),
                     statements: statements,
                 };
             }
@@ -251,7 +268,7 @@ export function from(value, type) {
                 body_ast = {
                     ast_type: "Block",
                     type: statements[statements.length - 1].type,
-                    location: get_location(3),
+                    location: get_location(),
                     statements: statements,
                 };
             }
@@ -262,7 +279,7 @@ export function from(value, type) {
         const ast = {
             ast_type: "AsyncFunction",
             type: FunctionType(inputs, output),
-            location: get_location(3),
+            location: get_location(),
             parameters: input_variables,
             body: body_ast,
         };
@@ -275,7 +292,7 @@ export function func(input_types, output_type, body) {
     const parameters = input_types.map(i => ({
         ast_type: "Variable",
         type: i,
-        location: get_location(2),
+        location: get_location(),
         mutable: false,
     }));
     const $ = BlockBuilder(output_type ?? NeverType);
@@ -292,7 +309,7 @@ export function func(input_types, output_type, body) {
         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 };
+            body_ast = { ast_type: "Value", type: NullType, location: get_location(), value: null };
         }
         else if (statements.length === 1) {
             body_ast = statements[0];
@@ -301,7 +318,7 @@ export function func(input_types, output_type, body) {
             body_ast = {
                 ast_type: "Block",
                 type: statements[statements.length - 1].type,
-                location: get_location(2),
+                location: get_location(),
                 statements: statements,
             };
         }
@@ -311,7 +328,7 @@ export function func(input_types, output_type, body) {
         const ast = {
             ast_type: "Function",
             type: FunctionType(input_types, ret_type),
-            location: get_location(2),
+            location: get_location(),
             parameters: parameters,
             body: body_ast,
         };
@@ -326,7 +343,7 @@ export function func(input_types, output_type, body) {
         }
         let body_ast;
         if (statements.length === 0) {
-            body_ast = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+            body_ast = { ast_type: "Value", type: NullType, location: get_location(), value: null };
         }
         else if (statements.length === 1) {
             body_ast = statements[0];
@@ -335,7 +352,7 @@ export function func(input_types, output_type, body) {
             body_ast = {
                 ast_type: "Block",
                 type: statements[statements.length - 1].type,
-                location: get_location(2),
+                location: get_location(),
                 statements: statements,
             };
         }
@@ -346,7 +363,7 @@ export function func(input_types, output_type, body) {
         const ast = {
             ast_type: "Function",
             type: FunctionType(input_types, output_type),
-            location: get_location(2),
+            location: get_location(),
             parameters: parameters,
             body: body_ast,
         };
@@ -357,7 +374,7 @@ export function asyncFunction(input_types, output_type, body) {
     const parameters = input_types.map(i => ({
         ast_type: "Variable",
         type: i,
-        location: get_location(2),
+        location: get_location(),
         mutable: false,
     }));
     const $ = BlockBuilder(output_type ?? NeverType);
@@ -374,7 +391,7 @@ export function asyncFunction(input_types, output_type, body) {
         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 };
+            body_ast = { ast_type: "Value", type: NullType, location: get_location(), value: null };
         }
         else if (statements.length === 1) {
             body_ast = statements[0];
@@ -383,7 +400,7 @@ export function asyncFunction(input_types, output_type, body) {
             body_ast = {
                 ast_type: "Block",
                 type: statements[statements.length - 1].type,
-                location: get_location(2),
+                location: get_location(),
                 statements: statements,
             };
         }
@@ -393,7 +410,7 @@ export function asyncFunction(input_types, output_type, body) {
         const ast = {
             ast_type: "AsyncFunction",
             type: AsyncFunctionType(input_types, ret_type),
-            location: get_location(2),
+            location: get_location(),
             parameters: parameters,
             body: body_ast,
         };
@@ -408,7 +425,7 @@ export function asyncFunction(input_types, output_type, body) {
         }
         let body_ast;
         if (statements.length === 0) {
-            body_ast = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+            body_ast = { ast_type: "Value", type: NullType, location: get_location(), value: null };
         }
         else if (statements.length === 1) {
             body_ast = statements[0];
@@ -417,7 +434,7 @@ export function asyncFunction(input_types, output_type, body) {
             body_ast = {
                 ast_type: "Block",
                 type: statements[statements.length - 1].type,
-                location: get_location(2),
+                location: get_location(),
                 statements: statements,
             };
         }
@@ -428,7 +445,7 @@ export function asyncFunction(input_types, output_type, body) {
         const ast = {
             ast_type: "AsyncFunction",
             type: AsyncFunctionType(input_types, output_type),
-            location: get_location(2),
+            location: get_location(),
             parameters: parameters,
             body: body_ast,
         };
@@ -443,7 +460,7 @@ export function asyncFunction(input_types, output_type, body) {
  * ```
 */
 export function str(strings, ...expressions) {
-    const location = get_location(2);
+    const location = get_location();
     // For simple strings, e.g: str`abc`
     if (strings.length === 1) {
         return fromAst({
@@ -559,7 +576,7 @@ export function str(strings, ...expressions) {
         let ret = {
             ast_type: "Value",
             type: StringType,
-            location: get_location(2),
+            location: get_location(),
             value: strings[0],
         };
         for (let i = 1; i < strings.length; i++) {
@@ -654,7 +671,7 @@ export function block(body) {
     if (statements.length === 0) {
         return fromAst({
             ast_type: "Value",
-            location: get_location(2),
+            location: get_location(),
             type: ret_type,
             value: null,
         });
@@ -665,7 +682,7 @@ export function block(body) {
     else {
         return fromAst({
             ast_type: "Block",
-            location: get_location(2),
+            location: get_location(),
             type: ret_type,
             statements: statements,
         });
@@ -674,7 +691,7 @@ export function block(body) {
 /**
  * Create an East error expression
  */
-export function error(message, location = get_location(2)) {
+export function error(message, location = get_location()) {
     const messageAst = message instanceof Expr ? Expr.ast(message) : valueOrExprToAstTyped(message, StringType);
     return fromAst({
         ast_type: "Error",
@@ -695,7 +712,7 @@ export function matchExpr(variant, handlers) {
         const data_variable = {
             ast_type: "Variable",
             type: t,
-            location: get_location(2),
+            location: get_location(),
             mutable: false,
         };
         const ast = handler === undefined ? valueOrExprToAstTyped(null, NullType) : block($ => handler($, fromAst(data_variable)))[AstSymbol];
@@ -706,7 +723,7 @@ export function matchExpr(variant, handlers) {
     return fromAst({
         ast_type: "Match",
         type: out_type,
-        location: get_location(2),
+        location: get_location(),
         variant: Expr.ast(variant),
         cases: cases_out,
     });
@@ -720,13 +737,13 @@ export function tryCatch(try_body, catch_body) {
     const message_variable = {
         ast_type: "Variable",
         type: StringType,
-        location: get_location(2),
+        location: get_location(),
         mutable: false,
     };
     const stack_variable = {
         ast_type: "Variable",
         type: ArrayType(StructType({ filename: StringType, line: IntegerType, column: IntegerType })),
-        location: get_location(2),
+        location: get_location(),
         mutable: false,
     };
     if (typeof catch_body !== "function") {
@@ -739,7 +756,7 @@ export function tryCatch(try_body, catch_body) {
     return fromAst({
         ast_type: "TryCatch",
         type: ret_type,
-        location: get_location(2),
+        location: get_location(),
         try_body: Expr.ast(try_body),
         catch_body: catch_body_ast,
         message: message_variable,
@@ -752,7 +769,7 @@ export function equal(left, right) {
     return fromAst({
         ast_type: "Builtin",
         type: BooleanType,
-        location: get_location(2),
+        location: get_location(),
         builtin: "Equal",
         type_parameters: [Expr.type(left)],
         arguments: [Expr.ast(left), rightAst],
@@ -764,7 +781,7 @@ export function notEqual(left, right) {
     return fromAst({
         ast_type: "Builtin",
         type: BooleanType,
-        location: get_location(2),
+        location: get_location(),
         builtin: "NotEqual",
         type_parameters: [Expr.type(left)],
         arguments: [Expr.ast(left), rightAst],
@@ -776,7 +793,7 @@ export function less(left, right) {
     return fromAst({
         ast_type: "Builtin",
         type: BooleanType,
-        location: get_location(2),
+        location: get_location(),
         builtin: "Less",
         type_parameters: [Expr.type(left)],
         arguments: [Expr.ast(left), rightAst],
@@ -788,7 +805,7 @@ export function lessEqual(left, right) {
     return fromAst({
         ast_type: "Builtin",
         type: BooleanType,
-        location: get_location(2),
+        location: get_location(),
         builtin: "LessEqual",
         type_parameters: [Expr.type(left)],
         arguments: [Expr.ast(left), rightAst],
@@ -800,7 +817,7 @@ export function greater(left, right) {
     return fromAst({
         ast_type: "Builtin",
         type: BooleanType,
-        location: get_location(2),
+        location: get_location(),
         builtin: "Greater",
         type_parameters: [Expr.type(left)],
         arguments: [Expr.ast(left), rightAst],
@@ -812,12 +829,43 @@ export function greaterEqual(left, right) {
     return fromAst({
         ast_type: "Builtin",
         type: BooleanType,
-        location: get_location(2),
+        location: get_location(),
         builtin: "GreaterEqual",
         type_parameters: [Expr.type(left)],
         arguments: [Expr.ast(left), rightAst],
     });
 }
+// ============================================================================
+// Aliases for standalone comparison functions
+// ============================================================================
+/** Alias for {@link equal} */
+export const equals = equal;
+/** Alias for {@link equal} */
+export const eq = equal;
+/** Alias for {@link notEqual} */
+export const notEquals = notEqual;
+/** Alias for {@link notEqual} */
+export const ne = notEqual;
+/** Alias for {@link less} */
+export const lessThan = less;
+/** Alias for {@link less} */
+export const lt = less;
+/** Alias for {@link lessEqual} */
+export const lessThanOrEqual = lessEqual;
+/** Alias for {@link lessEqual} */
+export const lte = lessEqual;
+/** Alias for {@link lessEqual} */
+export const le = lessEqual;
+/** Alias for {@link greater} */
+export const greaterThan = greater;
+/** Alias for {@link greater} */
+export const gt = greater;
+/** Alias for {@link greaterEqual} */
+export const greaterThanOrEqual = greaterEqual;
+/** Alias for {@link greaterEqual} */
+export const gte = greaterEqual;
+/** Alias for {@link greaterEqual} */
+export const ge = greaterEqual;
 /** 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.
@@ -827,7 +875,7 @@ export function is(left, right) {
     return fromAst({
         ast_type: "Builtin",
         type: BooleanType,
-        location: get_location(2),
+        location: get_location(),
         builtin: "Is",
         type_parameters: [Expr.type(left)],
         arguments: [Expr.ast(left), rightAst],
@@ -839,12 +887,83 @@ export function print(value) {
     return fromAst({
         ast_type: "Builtin",
         type: StringType,
-        location: get_location(2),
+        location: get_location(),
         builtin: "Print",
         type_parameters: [valueAst.type],
         arguments: [valueAst],
     });
 }
+// ============================================================================
+// Patch Operations
+// ============================================================================
+/** Compute the difference between two values of the same type.
+ * Returns a patch that, when applied to `before`, produces `after`.
+ */
+export function diff(before, after) {
+    const beforeAst = Expr.ast(before);
+    const afterAst = Expr.ast(after);
+    const valueType = beforeAst.type;
+    const patchType = PatchType(valueType);
+    return fromAst({
+        ast_type: "Builtin",
+        type: patchType,
+        location: get_location(),
+        builtin: "Diff",
+        type_parameters: [valueType, patchType],
+        arguments: [beforeAst, afterAst],
+    });
+}
+/** Apply a patch to a value, producing the modified value.
+ * @throws East runtime error if the patch conflicts with the value (e.g., deleting a non-existent key)
+ */
+export function applyPatch(value, patch) {
+    const valueAst = Expr.ast(value);
+    const patchAst = Expr.ast(patch);
+    const valueType = valueAst.type;
+    const patchType = patchAst.type;
+    return fromAst({
+        ast_type: "Builtin",
+        type: valueType,
+        location: get_location(),
+        builtin: "ApplyPatch",
+        type_parameters: [valueType, patchType],
+        arguments: [valueAst, patchAst],
+    });
+}
+/** Compose two patches into a single patch.
+ * The result is a patch that has the same effect as applying `first` then `second`.
+ * @throws East runtime error if the patches are incompatible (second expects different intermediate state)
+ */
+export function composePatch(first, second, type) {
+    const firstAst = Expr.ast(first);
+    const secondAst = Expr.ast(second);
+    const valueType = type;
+    const patchType = PatchType(valueType);
+    return fromAst({
+        ast_type: "Builtin",
+        type: patchType,
+        location: get_location(),
+        builtin: "ComposePatch",
+        type_parameters: [valueType, patchType],
+        arguments: [firstAst, secondAst],
+    });
+}
+/** Invert a patch, producing a patch that undoes the original.
+ * Applying the inverted patch to the "after" value produces the "before" value.
+ */
+export function invertPatch(patch, type) {
+    const patchAst = Expr.ast(patch);
+    const valueType = type;
+    const patchType = PatchType(valueType);
+    return fromAst({
+        ast_type: "Builtin",
+        type: patchType,
+        location: get_location(),
+        builtin: "InvertPatch",
+        type_parameters: [valueType, patchType],
+        arguments: [patchAst],
+    });
+}
 /** Create a callable helper to invoke a synchronous platform function.
  *
  * Platform functions provide access to external capabilities (logging, I/O, database access, etc.)
@@ -853,6 +972,7 @@ export function print(value) {
  * @param name - The name of the platform function
  * @param input_types - Array of input parameter types for the platform function
  * @param output_type - The return type of the platform function
+ * @param options - Optional configuration for the platform function
  * @returns A callable function that creates Platform AST nodes when invoked
  *
  * @see {@link asyncPlatform} for defining asynchronous platform functions (that return `Promise`s)
@@ -870,13 +990,23 @@ const myFunction = East.function([], NullType, ($) => {
 
 // Provide the implementation when compiling
 const platform = [
-  log.implement(false, (message: string) => console.log(message)),
+  log.implement((message: string) => console.log(message)),
 ];
 const compiled = myFunction.toIR().compile(platform);
 compiled(); // Logs "Hello, world!" to the console
+ * ```
+ *
+ * @example
+ * ```ts
+// Define an optional platform function that may not be available
+const analytics = East.platform("analytics", [StringType], NullType, { optional: true });
+
+// This compiles even without providing an analytics implementation
+// If called at runtime without implementation, it throws an error
  * ```
  */
-export function platform(name, input_types, output_type) {
+export function platform(name, input_types, output_type, options = {}) {
+    const isOptional = options.optional ?? false;
     const fn = (...args) => {
         if (args.length !== input_types.length) {
             throw new Error(`Platform function ${name} expected ${input_types.length} arguments, got ${args.length}`);
@@ -895,7 +1025,7 @@ export function platform(name, input_types, output_type) {
                 ast = {
                     ast_type: "As",
                     type: expectedType,
-                    location: get_location(2),
+                    location: get_location(),
                     value: ast,
                 };
             }
@@ -904,10 +1034,12 @@ export function platform(name, input_types, output_type) {
         return fromAst({
             ast_type: "Platform",
             type: output_type,
-            location: get_location(2),
+            location: get_location(),
             name: name,
+            type_parameters: [],
             arguments: argAsts,
             async: false,
+            optional: isOptional,
         });
     };
     fn.implement = (fnImpl) => {
@@ -943,6 +1075,7 @@ export function platform(name, input_types, output_type) {
  * @param name - The name of the asynchronous platform function
  * @param input_types - Array of input parameter types for the platform function
  * @param output_type - The return type of the platform function
+ * @param options - Optional configuration for the platform function
  * @returns A callable function that creates Platform AST nodes when invoked
  *
  * @see {@link platform} for defining synchronous platform functions
@@ -962,10 +1095,11 @@ const platform = [
   readFile.implement((filename: string) => fs.promises.readFile(filename, 'utf-8')),
 ];
 const compiled = myFunction.toIR().compile(platform);
-compiled(); // Logs "Hello, world!" to the console
+compiled(); // Returns file contents
  * ```
  */
-export function asyncPlatform(name, input_types, output_type) {
+export function asyncPlatform(name, input_types, output_type, options = {}) {
+    const isOptional = options.optional ?? false;
     const fn = (...args) => {
         if (args.length !== input_types.length) {
             throw new Error(`Platform function ${name} expected ${input_types.length} arguments, got ${args.length}`);
@@ -984,7 +1118,7 @@ export function asyncPlatform(name, input_types, output_type) {
                 ast = {
                     ast_type: "As",
                     type: expectedType,
-                    location: get_location(2),
+                    location: get_location(),
                     value: ast,
                 };
             }
@@ -993,10 +1127,12 @@ export function asyncPlatform(name, input_types, output_type) {
         return fromAst({
             ast_type: "Platform",
             type: output_type,
-            location: get_location(2),
+            location: get_location(),
             name: name,
+            type_parameters: [],
             arguments: argAsts,
             async: true,
+            optional: isOptional,
         });
     };
     fn.implement = (fnImpl) => {
@@ -1024,12 +1160,356 @@ export function asyncPlatform(name, input_types, output_type) {
     };
     return fn;
 }
+// Runtime type substitution function
+function applyTypeArgs(typeArgs, t) {
+    if (typeof t === 'string') {
+        const ret = typeArgs[t];
+        if (ret === undefined) {
+            throw new Error(`Unexpected type argument ${t}`);
+        }
+        return ret;
+    }
+    else if (t.type === "Ref") {
+        return { type: "Ref", value: applyTypeArgs(typeArgs, t.value) };
+    }
+    else if (t.type === "Array") {
+        return { type: "Array", value: applyTypeArgs(typeArgs, t.value) };
+    }
+    else if (t.type === "Set") {
+        return { type: "Set", key: applyTypeArgs(typeArgs, t.key) };
+    }
+    else if (t.type === "Dict") {
+        return { type: "Dict", key: applyTypeArgs(typeArgs, t.key), value: applyTypeArgs(typeArgs, t.value) };
+    }
+    else if (t.type === "Struct") {
+        const newFields = {};
+        for (const k in t.fields) {
+            newFields[k] = applyTypeArgs(typeArgs, t.fields[k]);
+        }
+        return { type: "Struct", fields: newFields };
+    }
+    else if (t.type === "Variant") {
+        const newCases = {};
+        for (const k in t.cases) {
+            newCases[k] = applyTypeArgs(typeArgs, t.cases[k]);
+        }
+        return { type: "Variant", cases: newCases };
+    }
+    else if (t.type === "Function") {
+        const newInputs = t.inputs.map((inputType) => applyTypeArgs(typeArgs, inputType));
+        const newOutput = applyTypeArgs(typeArgs, t.output);
+        return { type: "Function", inputs: newInputs, output: newOutput };
+    }
+    else if (t.type === "Recursive") {
+        if (t.node === undefined) {
+            // RecursiveTypeMarker (self-reference) - leave alone
+            return t;
+        }
+        return { type: "Recursive", node: applyTypeArgs(typeArgs, t.node) };
+    }
+    else {
+        return t;
+    }
+}
+/** Create a callable helper to invoke a generic (polymorphic) platform function.
+ *
+ * Generic platform functions allow you to define platform functions with type parameters,
+ * similar to how builtins work. The type parameters are passed at call time and flow
+ * through to the implementation.
+ *
+ * @param name - The name of the platform function
+ * @param typeParams - Array of type parameter names (e.g., `["T", "U"]`)
+ * @param inputs - Array of input types, can contain string placeholders like `"T"`
+ * @param output - Output type, can be a string placeholder like `"T"`
+ * @returns A callable function that creates Platform AST nodes when invoked
+ *
+ * @example
+ * ```ts
+ * // Define a generic log function
+ * const log = East.genericPlatform(
+ *   "log",
+ *   ["T"],
+ *   ["T"],      // Input is type parameter T
+ *   NullType
+ * );
+ *
+ * // Use it in East code - type args as array, then value args
+ * const myFunction = East.function([StringType], NullType, ($, s) => {
+ *   $(log([StringType], s));
+ * });
+ *
+ * // Implementation receives type params as a factory
+ * const platform = [
+ *   log.implement((T) => (value) => {
+ *     console.log(printFor(T)(value));
+ *     return null;
+ *   }),
+ * ];
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Define a generic map function with 2 type parameters
+ * const map = East.genericPlatform(
+ *   "map",
+ *   ["T", "U"],
+ *   ["T", FunctionType(["T"], "U")],  // String placeholders in nested types
+ *   "U"
+ * );
+ *
+ * // Call with type args array, then value arguments
+ * map([StringType, IntegerType], myString, myMapperFn)
+ * ```
+ */
+export function genericPlatform(name, typeParams, inputs, output, options = {}) {
+    const numTypeParams = typeParams.length;
+    const isOptional = options.optional ?? false;
+    const fn = (type_args, ...valueArgs) => {
+        // Validate type args array
+        if (!Array.isArray(type_args)) {
+            throw new Error(`Generic platform function '${name}' expects type arguments as an array, ` +
+                `got ${typeof type_args}`);
+        }
+        // Validate type args count
+        if (type_args.length !== numTypeParams) {
+            throw new Error(`Generic platform function '${name}' expects ${numTypeParams} type parameters, ` +
+                `got ${type_args.length}`);
+        }
+        // Validate type args are EastTypes
+        for (let i = 0; i < numTypeParams; i++) {
+            const typeArg = type_args[i];
+            if (!typeArg || typeof typeArg !== 'object' || !('type' in typeArg)) {
+                throw new Error(`Generic platform function '${name}' expects type parameter ${i + 1} ` +
+                    `(${typeParams[i]}) to be an EastType`);
+            }
+        }
+        // Build type argument map
+        const typeArgMap = {};
+        typeParams.forEach((param, idx) => {
+            typeArgMap[param] = type_args[idx];
+        });
+        // Apply type substitution to get concrete input/output types
+        const inputTypes = inputs.map(t => applyTypeArgs(typeArgMap, t));
+        const outputType = applyTypeArgs(typeArgMap, output);
+        // Validate value args count
+        if (valueArgs.length !== inputTypes.length) {
+            throw new Error(`Generic platform function '${name}' expects ${inputTypes.length} ` +
+                `value arguments, got ${valueArgs.length}`);
+        }
+        // Convert value args to AST with type validation and implicit casts
+        const argAsts = valueArgs.map((arg, index) => {
+            const expectedType = inputTypes[index];
+            let ast = valueOrExprToAstTyped(arg, expectedType);
+            if (ast.type.type === "Never") {
+                throw new Error(`Generic platform function ${name} argument ${index + 1} expected type ${printType(expectedType)}, got Never type`);
+            }
+            if (!isTypeEqual(ast.type, expectedType)) {
+                if (!isSubtype(ast.type, expectedType)) {
+                    throw new Error(`Generic platform function ${name} argument ${index + 1} expected type ${printType(expectedType)}, got ${printType(ast.type)}`);
+                }
+                // Insert implicit cast
+                ast = {
+                    ast_type: "As",
+                    type: expectedType,
+                    location: get_location(),
+                    value: ast,
+                };
+            }
+            return ast;
+        });
+        // Create PlatformAST with type_parameters
+        return fromAst({
+            ast_type: "Platform",
+            type: outputType,
+            location: get_location(),
+            name: name,
+            type_parameters: type_args,
+            arguments: argAsts,
+            async: false,
+            optional: isOptional,
+        });
+    };
+    fn.implement = (factory) => {
+        return {
+            name,
+            type_parameters: [...typeParams],
+            inputs: [], // Computed at call time via inputsFn
+            output: toEastTypeValue(NullType), // Placeholder
+            inputsFn: (...tps) => {
+                const typeArgMap = {};
+                typeParams.forEach((param, idx) => {
+                    typeArgMap[param] = tps[idx];
+                });
+                return inputs.map(t => {
+                    if (typeof t === 'string')
+                        return typeArgMap[t];
+                    let result = applyTypeArgs(typeArgMap, t);
+                    if (!isVariant(result))
+                        result = toEastTypeValue(result);
+                    return result;
+                });
+            },
+            outputsFn: (...tps) => {
+                const typeArgMap = {};
+                typeParams.forEach((param, idx) => {
+                    typeArgMap[param] = tps[idx];
+                });
+                if (typeof output === 'string')
+                    return typeArgMap[output];
+                let result = applyTypeArgs(typeArgMap, output);
+                if (!isVariant(result))
+                    result = toEastTypeValue(result);
+                return result;
+            },
+            type: 'sync',
+            fn: factory,
+        };
+    };
+    return fn;
+}
+/** Create a callable helper to invoke an asynchronous generic (polymorphic) platform function.
+ *
+ * This is the async variant of `genericPlatform`. The implementation factory should return
+ * an async function.
+ *
+ * @param name - The name of the platform function
+ * @param typeParams - Array of type parameter names (e.g., `["T", "U"]`)
+ * @param inputs - Array of input types, can contain string placeholders like `"T"`
+ * @param output - Output type, can be a string placeholder like `"T"`
+ * @returns A callable function that creates Platform AST nodes when invoked
+ *
+ * @see {@link genericPlatform} for synchronous generic platform functions
+ *
+ * @example
+ * ```ts
+ * // Define an async generic fetch function
+ * const fetchAs = East.asyncGenericPlatform(
+ *   "fetchAs",
+ *   ["T"],
+ *   [StringType],  // URL input
+ *   "T"            // Returns parsed value of type T
+ * );
+ *
+ * // Implementation receives type params and returns async function
+ * const platform = [
+ *   fetchAs.implement((T) => async (url) => {
+ *     const response = await fetch(url);
+ *     return parseFor(T)(await response.text());
+ *   }),
+ * ];
+ * ```
+ */
+export function asyncGenericPlatform(name, typeParams, inputs, output, options = {}) {
+    const numTypeParams = typeParams.length;
+    const isOptional = options.optional ?? false;
+    const fn = (type_args, ...valueArgs) => {
+        // Validate type args array
+        if (!Array.isArray(type_args)) {
+            throw new Error(`Generic platform function '${name}' expects type arguments as an array, ` +
+                `got ${typeof type_args}`);
+        }
+        // Validate type args count
+        if (type_args.length !== numTypeParams) {
+            throw new Error(`Generic platform function '${name}' expects ${numTypeParams} type parameters, ` +
+                `got ${type_args.length}`);
+        }
+        // Validate type args are EastTypes
+        for (let i = 0; i < numTypeParams; i++) {
+            const typeArg = type_args[i];
+            if (!typeArg || typeof typeArg !== 'object' || !('type' in typeArg)) {
+                throw new Error(`Generic platform function '${name}' expects type parameter ${i + 1} ` +
+                    `(${typeParams[i]}) to be an EastType`);
+            }
+        }
+        // Build type argument map
+        const typeArgMap = {};
+        typeParams.forEach((param, idx) => {
+            typeArgMap[param] = type_args[idx];
+        });
+        // Apply type substitution to get concrete input/output types
+        const inputTypes = inputs.map(t => applyTypeArgs(typeArgMap, t));
+        const outputType = applyTypeArgs(typeArgMap, output);
+        // Validate value args count
+        if (valueArgs.length !== inputTypes.length) {
+            throw new Error(`Generic platform function '${name}' expects ${inputTypes.length} ` +
+                `value arguments, got ${valueArgs.length}`);
+        }
+        // Convert value args to AST with type validation and implicit casts
+        const argAsts = valueArgs.map((arg, index) => {
+            const expectedType = inputTypes[index];
+            let ast = valueOrExprToAstTyped(arg, expectedType);
+            if (ast.type.type === "Never") {
+                throw new Error(`Generic platform function ${name} argument ${index + 1} expected type ${printType(expectedType)}, got Never type`);
+            }
+            if (!isTypeEqual(ast.type, expectedType)) {
+                if (!isSubtype(ast.type, expectedType)) {
+                    throw new Error(`Generic platform function ${name} argument ${index + 1} expected type ${printType(expectedType)}, got ${printType(ast.type)}`);
+                }
+                // Insert implicit cast
+                ast = {
+                    ast_type: "As",
+                    type: expectedType,
+                    location: get_location(),
+                    value: ast,
+                };
+            }
+            return ast;
+        });
+        // Create PlatformAST with type_parameters and async: true
+        return fromAst({
+            ast_type: "Platform",
+            type: outputType,
+            location: get_location(),
+            name: name,
+            type_parameters: type_args,
+            arguments: argAsts,
+            async: true,
+            optional: isOptional,
+        });
+    };
+    fn.implement = (factory) => {
+        return {
+            name,
+            type_parameters: [...typeParams],
+            inputs: [], // Computed at call time via inputsFn
+            output: toEastTypeValue(NullType), // Placeholder
+            inputsFn: (...tps) => {
+                const typeArgMap = {};
+                typeParams.forEach((param, idx) => {
+                    typeArgMap[param] = tps[idx];
+                });
+                return inputs.map(t => {
+                    if (typeof t === 'string')
+                        return typeArgMap[t];
+                    let result = applyTypeArgs(typeArgMap, t);
+                    if (!isVariant(result))
+                        result = toEastTypeValue(result);
+                    return result;
+                });
+            },
+            outputsFn: (...tps) => {
+                const typeArgMap = {};
+                typeParams.forEach((param, idx) => {
+                    typeArgMap[param] = tps[idx];
+                });
+                if (typeof output === 'string')
+                    return typeArgMap[output];
+                let result = applyTypeArgs(typeArgMap, output);
+                if (!isVariant(result))
+                    result = toEastTypeValue(result);
+                return result;
+            },
+            type: 'async',
+            fn: factory,
+        };
+    };
+    return fn;
+}
 export const BlockBuilder = (return_type) => {
     const statements = [];
     const $ = ((expr) => {
         const ast = Expr.ast(expr);
         statements.push(ast);
-        return expr;
     });
     $.statements = statements;
     $.type = () => {
@@ -1042,7 +1522,7 @@ export const BlockBuilder = (return_type) => {
     };
     $.const = ((value, type) => {
         if (isTypeEqual($.type(), NeverType)) {
-            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+            throw new Error(`Unreachable statement detected at ${printLocations(get_location())}`);
         }
         let ast;
         if (value instanceof Expr) {
@@ -1057,13 +1537,13 @@ export const BlockBuilder = (return_type) => {
         const variable = {
             ast_type: "Variable",
             type: type ?? ast.type,
-            location: get_location(2),
+            location: get_location(),
             mutable: false,
         };
         statements.push({
             ast_type: "Let",
             type: NullType,
-            location: get_location(2),
+            location: get_location(),
             variable,
             value: ast,
         });
@@ -1071,7 +1551,7 @@ export const BlockBuilder = (return_type) => {
     });
     $.let = ((value, type) => {
         if (isTypeEqual($.type(), NeverType)) {
-            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+            throw new Error(`Unreachable statement detected at ${printLocations(get_location())}`);
         }
         let ast;
         if (value instanceof Expr) {
@@ -1086,13 +1566,13 @@ export const BlockBuilder = (return_type) => {
         const variable = {
             ast_type: "Variable",
             type: type ?? ast.type,
-            location: get_location(2),
+            location: get_location(),
             mutable: true,
         };
         statements.push({
             ast_type: "Let",
             type: NullType,
-            location: get_location(2),
+            location: get_location(),
             variable,
             value: ast,
         });
@@ -1100,7 +1580,7 @@ export const BlockBuilder = (return_type) => {
     });
     $.assign = ((variable, value) => {
         if (isTypeEqual($.type(), NeverType)) {
-            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+            throw new Error(`Unreachable statement detected at ${printLocations(get_location())}`);
         }
         let v = Expr.ast(variable);
         // Handle RecursiveType variables which are auto-unwrapped by fromAst
@@ -1111,13 +1591,13 @@ export const BlockBuilder = (return_type) => {
             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`);
+            throw new Error(`Cannot assign to variable defined at ${printLocations(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),
+            location: get_location(),
             variable: v,
             value: ast_value,
         };
@@ -1127,16 +1607,22 @@ export const BlockBuilder = (return_type) => {
     // 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))}`);
+            throw new Error(`Unreachable statement detected at ${printLocations(get_location())}`);
         }
         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)}`);
         }
+        // Deduplicate: if the expression is already the last statement (e.g., from $()),
+        // don't push it again - just wrap it in the Return
+        const exprAstRef = expr instanceof Expr ? Expr.ast(expr) : null;
+        if (exprAstRef !== null && statements.length > 0 && statements[statements.length - 1] === exprAstRef) {
+            statements.pop();
+        }
         const ast = {
             ast_type: "Return",
             type: NeverType,
-            location: get_location(2),
+            location: get_location(),
             value: expAst
         };
         statements.push(ast);
@@ -1144,12 +1630,12 @@ export const BlockBuilder = (return_type) => {
     };
     $.break = (label) => {
         if (isTypeEqual($.type(), NeverType)) {
-            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+            throw new Error(`Unreachable statement detected at ${printLocations(get_location())}`);
         }
         const ast = {
             ast_type: "Break",
             type: NeverType,
-            location: get_location(2),
+            location: get_location(),
             label,
         };
         statements.push(ast);
@@ -1157,12 +1643,12 @@ export const BlockBuilder = (return_type) => {
     };
     $.continue = (label) => {
         if (isTypeEqual($.type(), NeverType)) {
-            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+            throw new Error(`Unreachable statement detected at ${printLocations(get_location())}`);
         }
         const ast = {
             ast_type: "Continue",
             type: NeverType,
-            location: get_location(2),
+            location: get_location(),
             label,
         };
         statements.push(ast);
@@ -1170,7 +1656,7 @@ export const BlockBuilder = (return_type) => {
     };
     $.if = (predicate, true_branch) => {
         if (isTypeEqual($.type(), NeverType)) {
-            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+            throw new Error(`Unreachable statement detected at ${printLocations(get_location())}`);
         }
         const predicateAst = predicate instanceof Expr ? Expr.ast(predicate) : valueOrExprToAstTyped(predicate, BooleanType);
         if (predicateAst.type.type !== "Boolean") {
@@ -1188,38 +1674,38 @@ export const BlockBuilder = (return_type) => {
         }
         let true_ast;
         if (true_stmts.length === 0) {
-            true_ast = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+            true_ast = { ast_type: "Value", type: NullType, location: get_location(), 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_stmts.push({ ast_type: "Value", type: NullType, location: get_location(), value: null });
             }
             true_ast = {
                 ast_type: "Block",
                 type: true_stmts[true_stmts.length - 1].type,
-                location: get_location(2),
+                location: get_location(),
                 statements: true_stmts,
             };
         }
         const if_else_ast = {
             ast_type: "IfElse",
             type: NullType,
-            location: get_location(2),
+            location: get_location(),
             ifs: [{
                     predicate: Expr.ast(predicate),
                     body: true_ast,
                 }],
-            else_body: { ast_type: "Value", type: NullType, location: get_location(2), value: null },
+            else_body: { ast_type: "Value", type: NullType, location: get_location(), 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))}`);
+            throw new Error(`Unreachable statement detected at ${printLocations(get_location())}`);
         }
         if (Expr.type(variant).type !== "Variant") {
             throw new Error(`match not defined over ${printType(Expr.type(variant))}`);
@@ -1231,11 +1717,11 @@ export const BlockBuilder = (return_type) => {
             const data_variable = {
                 ast_type: "Variable",
                 type: t,
-                location: get_location(2),
+                location: get_location(),
                 mutable: false,
             };
             if (f === undefined) {
-                cases_out[k] = { variable: data_variable, body: { ast_type: "Value", type: NullType, location: get_location(2), value: null } };
+                cases_out[k] = { variable: data_variable, body: { ast_type: "Value", type: NullType, location: get_location(), value: null } };
             }
             else {
                 const data = fromAst(data_variable);
@@ -1250,19 +1736,19 @@ export const BlockBuilder = (return_type) => {
                 }
                 let expr;
                 if (stmts.length === 0) {
-                    expr = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+                    expr = { ast_type: "Value", type: NullType, location: get_location(), 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 });
+                        stmts.push({ ast_type: "Value", type: NullType, location: get_location(), value: null });
                     }
                     expr = {
                         ast_type: "Block",
                         type: stmts[stmts.length - 1].type,
-                        location: get_location(2),
+                        location: get_location(),
                         statements: stmts,
                     };
                 }
@@ -1273,7 +1759,7 @@ export const BlockBuilder = (return_type) => {
         const ast = {
             ast_type: "Match",
             type: out_type,
-            location: get_location(2),
+            location: get_location(),
             variant: Expr.ast(variant),
             cases: cases_out,
         };
@@ -1282,13 +1768,13 @@ export const BlockBuilder = (return_type) => {
     };
     $.while = (predicate, body) => {
         if (isTypeEqual($.type(), NeverType)) {
-            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+            throw new Error(`Unreachable statement detected at ${printLocations(get_location())}`);
         }
         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 label = { location: get_location() };
         const $_body = BlockBuilder(return_type);
         const ret = body($_body, label);
         const stmts = $_body.statements;
@@ -1300,19 +1786,19 @@ export const BlockBuilder = (return_type) => {
         }
         let expr;
         if (stmts.length === 0) {
-            expr = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+            expr = { ast_type: "Value", type: NullType, location: get_location(), 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 });
+                stmts.push({ ast_type: "Value", type: NullType, location: get_location(), value: null });
             }
             expr = {
                 ast_type: "Block",
                 type: stmts[stmts.length - 1].type,
-                location: get_location(2),
+                location: get_location(),
                 statements: stmts,
             };
         }
@@ -1322,7 +1808,7 @@ export const BlockBuilder = (return_type) => {
         const ast = {
             ast_type: "While",
             type: NullType,
-            location: get_location(2),
+            location: get_location(),
             predicate: predicateAst,
             label,
             body: expr,
@@ -1332,24 +1818,24 @@ export const BlockBuilder = (return_type) => {
     };
     $.for = ((collection, body) => {
         if (isTypeEqual($.type(), NeverType)) {
-            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+            throw new Error(`Unreachable statement detected at ${printLocations(get_location())}`);
         }
         if (collection instanceof ArrayExpr) {
             const value_variable = {
                 ast_type: "Variable",
                 type: Expr.type(collection).value,
-                location: get_location(2),
+                location: get_location(),
                 mutable: false,
             };
             const value = fromAst(value_variable);
             const key_variable = {
                 ast_type: "Variable",
                 type: IntegerType,
-                location: get_location(2),
+                location: get_location(),
                 mutable: false,
             };
             const key = fromAst(key_variable);
-            const label = { location: get_location(2) };
+            const label = { location: get_location() };
             const $ = BlockBuilder(return_type);
             const ret = body($, value, key, label);
             const stmts = $.statements;
@@ -1361,26 +1847,26 @@ export const BlockBuilder = (return_type) => {
             }
             let expr;
             if (stmts.length === 0) {
-                expr = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+                expr = { ast_type: "Value", type: NullType, location: get_location(), 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 });
+                    stmts.push({ ast_type: "Value", type: NullType, location: get_location(), value: null });
                 }
                 expr = {
                     ast_type: "Block",
                     type: stmts[stmts.length - 1].type,
-                    location: get_location(2),
+                    location: get_location(),
                     statements: stmts,
                 };
             }
             const ast = {
                 ast_type: "ForArray",
                 type: NullType,
-                location: get_location(2),
+                location: get_location(),
                 label,
                 array: Expr.ast(collection),
                 key: key_variable,
@@ -1394,11 +1880,11 @@ export const BlockBuilder = (return_type) => {
             const key_variable = {
                 ast_type: "Variable",
                 type: Expr.type(collection).key,
-                location: get_location(2),
+                location: get_location(),
                 mutable: false,
             };
             const key = fromAst(key_variable);
-            const label = { location: get_location(2) };
+            const label = { location: get_location() };
             const $ = BlockBuilder(return_type);
             const ret = body($, key, label);
             const stmts = $.statements;
@@ -1410,26 +1896,26 @@ export const BlockBuilder = (return_type) => {
             }
             let expr;
             if (stmts.length === 0) {
-                expr = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+                expr = { ast_type: "Value", type: NullType, location: get_location(), 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 });
+                    stmts.push({ ast_type: "Value", type: NullType, location: get_location(), value: null });
                 }
                 expr = {
                     ast_type: "Block",
                     type: stmts[stmts.length - 1].type,
-                    location: get_location(2),
+                    location: get_location(),
                     statements: stmts,
                 };
             }
             const ast = {
                 ast_type: "ForSet",
                 type: NullType,
-                location: get_location(2),
+                location: get_location(),
                 label,
                 set: Expr.ast(collection),
                 key: key_variable,
@@ -1442,18 +1928,18 @@ export const BlockBuilder = (return_type) => {
             const value_variable = {
                 ast_type: "Variable",
                 type: Expr.type(collection).value,
-                location: get_location(2),
+                location: get_location(),
                 mutable: false,
             };
             const value = fromAst(value_variable);
             const key_variable = {
                 ast_type: "Variable",
                 type: Expr.type(collection).key,
-                location: get_location(2),
+                location: get_location(),
                 mutable: false,
             };
             const key = fromAst(key_variable);
-            const label = { location: get_location(2) };
+            const label = { location: get_location() };
             const $ = BlockBuilder(return_type);
             const ret = body($, value, key, label);
             const stmts = $.statements;
@@ -1465,26 +1951,26 @@ export const BlockBuilder = (return_type) => {
             }
             let expr;
             if (stmts.length === 0) {
-                expr = { ast_type: "Value", type: NullType, location: get_location(2), value: null };
+                expr = { ast_type: "Value", type: NullType, location: get_location(), 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 });
+                    stmts.push({ ast_type: "Value", type: NullType, location: get_location(), value: null });
                 }
                 expr = {
                     ast_type: "Block",
                     type: stmts[stmts.length - 1].type,
-                    location: get_location(2),
+                    location: get_location(),
                     statements: stmts,
                 };
             }
             const ast = {
                 ast_type: "ForDict",
                 type: NullType,
-                location: get_location(2),
+                location: get_location(),
                 label,
                 dict: Expr.ast(collection),
                 key: key_variable,
@@ -1500,10 +1986,10 @@ export const BlockBuilder = (return_type) => {
     });
     $.error = (message, location) => {
         if (isTypeEqual($.type(), NeverType)) {
-            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+            throw new Error(`Unreachable statement detected at ${printLocations(get_location())}`);
         }
         if (location === undefined) {
-            location = get_location(2);
+            location = get_location();
         }
         const ast = {
             ast_type: "Error",
@@ -1516,7 +2002,7 @@ export const BlockBuilder = (return_type) => {
     };
     $.try = (body) => {
         if (isTypeEqual($.type(), NeverType)) {
-            throw new Error(`Unreachable statement detected at ${printLocation(get_location(2))}`);
+            throw new Error(`Unreachable statement detected at ${printLocations(get_location())}`);
         }
         const $try = BlockBuilder(return_type);
         const ret = body($try);
@@ -1528,7 +2014,7 @@ export const BlockBuilder = (return_type) => {
             }
         }
         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 });
+            try_stmts.push({ ast_type: "Value", type: NullType, location: get_location(), value: null });
         }
         let try_expr;
         if (try_stmts.length === 1) {
@@ -1538,7 +2024,7 @@ export const BlockBuilder = (return_type) => {
             try_expr = {
                 ast_type: "Block",
                 type: try_stmts[try_stmts.length - 1].type,
-                location: get_location(2),
+                location: get_location(),
                 statements: try_stmts,
             };
         }
@@ -1546,21 +2032,21 @@ export const BlockBuilder = (return_type) => {
         const message_variable = {
             ast_type: "Variable",
             type: StringType,
-            location: get_location(2),
+            location: get_location(),
             mutable: false,
         };
         const stack_variable = {
             ast_type: "Variable",
             type: ArrayType(StructType({ filename: StringType, line: IntegerType, column: IntegerType })),
-            location: get_location(2),
+            location: get_location(),
             mutable: false,
         };
         const try_catch_ast = {
             ast_type: "TryCatch",
             type: NullType,
-            location: get_location(2),
+            location: get_location(),
             try_body: try_expr,
-            catch_body: { ast_type: "Value", type: NullType, location: get_location(2), value: null }, // will be updated later
+            catch_body: { ast_type: "Value", type: NullType, location: get_location(), value: null }, // will be updated later
             message: message_variable,
             stack: stack_variable,
         };
@@ -1591,12 +2077,12 @@ class IfElseExpr extends NullExpr {
             }
         }
         if (stmts.length === 0 || !isSubtype(stmts[stmts.length - 1].type, NullType)) {
-            stmts.push({ ast_type: "Value", type: NullType, location: get_location(2), value: null });
+            stmts.push({ ast_type: "Value", type: NullType, location: get_location(), value: null });
         }
         this[AstSymbol].else_body = stmts.length === 1 ? stmts[0] : {
             ast_type: "Block",
             type: stmts[stmts.length - 1].type,
-            location: get_location(2),
+            location: get_location(),
             statements: stmts,
         };
         // propagate unreachable information
@@ -1637,14 +2123,14 @@ class IfElseExpr extends NullExpr {
             }
         }
         if (stmts.length === 0 || !isSubtype(stmts[stmts.length - 1].type, NullType)) {
-            stmts.push({ ast_type: "Value", type: NullType, location: get_location(2), value: null });
+            stmts.push({ ast_type: "Value", type: NullType, location: get_location(), 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),
+                location: get_location(),
                 statements: stmts,
             },
         });
@@ -1669,7 +2155,7 @@ class TryCatchExpr extends NullExpr {
     /** 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))}`);
+            throw new Error(`Cannot call .catch() more than once on the same try block at ${printLocations(get_location())}`);
         }
         this.catchCalled = true;
         const $ = BlockBuilder(this.return_type);
@@ -1682,12 +2168,12 @@ class TryCatchExpr extends NullExpr {
             }
         }
         if (stmts.length === 0 || !isSubtype(stmts[stmts.length - 1].type, NullType)) {
-            stmts.push({ ast_type: "Value", type: NullType, location: get_location(2), value: null });
+            stmts.push({ ast_type: "Value", type: NullType, location: get_location(), value: null });
         }
         this[AstSymbol].catch_body = stmts.length === 1 ? stmts[0] : {
             ast_type: "Block",
             type: stmts[stmts.length - 1].type,
-            location: get_location(2),
+            location: get_location(),
             statements: stmts,
         };
         // Propagate unreachable information
@@ -1708,12 +2194,12 @@ class TryCatchExpr extends NullExpr {
             }
         }
         if (stmts.length === 0 || !isSubtype(stmts[stmts.length - 1].type, NullType)) {
-            stmts.push({ ast_type: "Value", type: NullType, location: get_location(2), value: null });
+            stmts.push({ ast_type: "Value", type: NullType, location: get_location(), value: null });
         }
         this[AstSymbol].finally_body = stmts.length === 1 ? stmts[0] : {
             ast_type: "Block",
             type: stmts[stmts.length - 1].type,
-            location: get_location(2),
+            location: get_location(),
             statements: stmts,
         };
     }
@@ -1737,6 +2223,26 @@ Object.assign(Expr, {
     greater,
     greaterEqual,
     is,
-    match: matchExpr
+    match: matchExpr,
+    // Comparison aliases
+    equals,
+    eq,
+    notEquals,
+    ne,
+    lessThan,
+    lt,
+    lessThanOrEqual,
+    lte,
+    le,
+    greaterThan,
+    gt,
+    greaterThanOrEqual,
+    gte,
+    ge,
+    // Patch operations
+    diff,
+    applyPatch,
+    composePatch,
+    invertPatch,
 });
 //# sourceMappingURL=block.js.map