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

package/dist/src/compile.js

@@ -11,13 +11,18 @@ import { EastError } from "./error.js";
 import { SortedSet } from "./containers/sortedset.js";
 import { SortedMap } from "./containers/sortedmap.js";
 import { BufferWriter } from "./serialization/binary-utils.js";
-import { decodeBeast2For, decodeBeastFor, encodeBeast2For, encodeBeastFor, fromJSONFor, toJSONFor } from "./serialization/index.js";
+import { decodeBeast2For, decodeBeastFor, encodeBeast2For, encodeBeastFor, fromJSONFor, toJSONFor, decodeCsvFor, encodeCsvFor } from "./serialization/index.js";
 import { formatDateTime } from "./datetime_format/print.js";
 import { parseDateTimeFormatted } from "./datetime_format/parse.js";
 import { EastTypeValueType, isTypeValueEqual, expandTypeValue } from "./type_of_type.js";
 import { ref } from "./containers/ref.js";
 export { isTypeValueEqual };
 export const printTypeValue = printFor(EastTypeValueType);
+/**
+ * Symbol used to attach source IR to compiled functions.
+ * This enables serialization of free functions (functions with no captures).
+ */
+export const EAST_IR_SYMBOL = Symbol.for("east.ir");
 /** @internal Track iteration locks to prevent concurrent modification */
 const iterationLocks = new WeakMap();
 /** @internal Lock a collection for iteration (prevents size/keyset modifications) */
@@ -63,7 +68,7 @@ class BreakException {
 *
 * @internal
 */
-export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx = true, compilingNodes = new Set()) {
+export function compile_internal(ir, ctx, platform, asyncPlatformFns, platformDef, fresh_ctx = true, compilingNodes = new Set()) {
     // The IR is checked prior to compilation, so we can assume it's valid here.
     // The compiler needs to take care that Promises are properly awaited, so most IR nodes need both sync and async implementations.
     // We assume unnecessary `async` functions degrade performance but unnecessary `await`s are not too bad, so while we could be more "specific" in our awaits we do not bother
@@ -73,7 +78,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         return (_ctx) => v;
     }
     else if (ir.type === "Error") {
-        const message_compiled = compile_internal(ir.value.message, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const message_compiled = compile_internal(ir.value.message, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         const location = ir.value.location;
         if (ir.value.isAsync) {
             return async (ctx) => { throw new EastError(await message_compiled(ctx), { location: location }); };
@@ -83,15 +88,15 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         }
     }
     else if (ir.type === "TryCatch") {
-        const try_body = compile_internal(ir.value.try_body, Object.create(ctx), platform, asyncPlatformFns, true, compilingNodes);
+        const try_body = compile_internal(ir.value.try_body, Object.create(ctx), platform, asyncPlatformFns, platformDef, true, compilingNodes);
         const new_ctx = Object.create(ctx);
         const message_name = ir.value.message.value.name;
         const stack_name = ir.value.stack.value.name;
         new_ctx[message_name] = ir.value.message.value.type;
         new_ctx[stack_name] = ir.value.stack.value.type;
-        const catch_body = compile_internal(ir.value.catch_body, new_ctx, platform, asyncPlatformFns, true, compilingNodes);
+        const catch_body = compile_internal(ir.value.catch_body, new_ctx, platform, asyncPlatformFns, platformDef, true, compilingNodes);
         // Don't include finally unless necessary (Value nodes are effect free)
-        const finally_body = ir.value.finally_body.type === "Value" ? undefined : compile_internal(ir.value.finally_body, Object.create(ctx), platform, asyncPlatformFns, true, compilingNodes);
+        const finally_body = ir.value.finally_body.type === "Value" ? undefined : compile_internal(ir.value.finally_body, Object.create(ctx), platform, asyncPlatformFns, platformDef, true, compilingNodes);
         if (ir.value.isAsync) {
             if (finally_body === undefined) {
                 return async (ctx) => {
@@ -185,7 +190,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         }
     }
     else if (ir.type === "Let") {
-        const compiled_statement = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const compiled_statement = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         const name = ir.value.variable.value.name;
         ctx[name] = ir.value.variable.value.type;
         if (ir.value.variable.value.mutable && ir.value.variable.value.captured) {
@@ -219,7 +224,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "Assign") {
         const name = ir.value.variable.value.name;
-        const compiled_statement = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const compiled_statement = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         if (ir.value.variable.value.mutable && ir.value.variable.value.captured) {
             if (ir.value.isAsync) {
                 return async (ctx) => {
@@ -262,17 +267,17 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     else if (ir.type === "As") {
         // in dynamically typed runtimes like Javascript, this is a no-op
         // (for statically typed runtimes this assists in unifying types in branches)
-        return compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, fresh_ctx, compilingNodes);
+        return compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, fresh_ctx, compilingNodes);
     }
     else if (ir.type === "UnwrapRecursive") {
         // in dynamically typed runtimes like Javascript, this is a no-op
         // (for statically typed runtimes this assists in e.g. typing a reference or pointer)
-        return compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, fresh_ctx, compilingNodes);
+        return compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, fresh_ctx, compilingNodes);
     }
     else if (ir.type === "WrapRecursive") {
         // in dynamically typed runtimes like Javascript, this is a no-op
         // (for statically typed runtimes this assists in e.g. typing a heap allocation)
-        return compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        return compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
     }
     else if (ir.type === "Function") {
         const ctx2 = {};
@@ -283,19 +288,29 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
             const parameter_name = parameter.value.name;
             ctx2[parameter_name] = parameter.value.type;
         }
-        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, platformDef, true, compilingNodes);
         const capture_names = ir.value.captures.map(v => v.value.name);
         const parameter_names = ir.value.parameters.map(v => v.value.name);
+        // Store original IR for potential serialization
+        const originalIR = ir;
         return (ctx) => {
             const ctx2 = {};
             for (const name of capture_names) {
                 ctx2[name] = ctx[name];
             }
-            return (...args) => {
+            const fn = (...args) => {
                 const ctx3 = { ...ctx2 };
                 parameter_names.forEach((name, i) => ctx3[name] = args[i]);
                 return compiled_body(ctx3);
             };
+            // Attach IR to function for serialization support
+            Object.defineProperty(fn, EAST_IR_SYMBOL, {
+                value: originalIR,
+                writable: false,
+                enumerable: false,
+                configurable: false
+            });
+            return fn;
         };
     }
     else if (ir.type === "AsyncFunction") {
@@ -307,24 +322,34 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
             const parameter_name = parameter.value.name;
             ctx2[parameter_name] = parameter.value.type;
         }
-        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, platformDef, true, compilingNodes);
         const capture_names = ir.value.captures.map(v => v.value.name);
         const parameter_names = ir.value.parameters.map(v => v.value.name);
+        // Store original IR for potential serialization
+        const originalIR = ir;
         return (ctx) => {
             const ctx2 = {};
             for (const name of capture_names) {
                 ctx2[name] = ctx[name];
             }
-            return (...args) => {
+            const fn = (...args) => {
                 const ctx3 = { ...ctx2 };
                 parameter_names.forEach((name, i) => ctx3[name] = args[i]);
                 return compiled_body(ctx3); // Promise can pass through in tail position
             };
+            // Attach IR to function for serialization support
+            Object.defineProperty(fn, EAST_IR_SYMBOL, {
+                value: originalIR,
+                writable: false,
+                enumerable: false,
+                configurable: false
+            });
+            return fn;
         };
     }
     else if (ir.type === "Call") {
-        const compiled_f = compile_internal(ir.value.function, ctx, platform, asyncPlatformFns, false, compilingNodes);
-        const compiled_args = ir.value.arguments.map(argument => compile_internal(argument, ctx, platform, asyncPlatformFns, false, compilingNodes));
+        const compiled_f = compile_internal(ir.value.function, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
+        const compiled_args = ir.value.arguments.map(argument => compile_internal(argument, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes));
         const location = ir.value.location;
         if (ir.value.isAsync) {
             // need to await the arguments
@@ -383,8 +408,8 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         }
     }
     else if (ir.type === "CallAsync") {
-        const compiled_f = compile_internal(ir.value.function, ctx, platform, asyncPlatformFns, false, compilingNodes);
-        const compiled_args = ir.value.arguments.map(argument => compile_internal(argument, ctx, platform, asyncPlatformFns, false, compilingNodes));
+        const compiled_f = compile_internal(ir.value.function, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
+        const compiled_args = ir.value.arguments.map(argument => compile_internal(argument, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes));
         const location = ir.value.location;
         return async (ctx) => {
             try {
@@ -422,11 +447,11 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                 asyncPredicate = true;
             }
             ifs.push({
-                predicate: compile_internal(predicate, ctx, platform, asyncPlatformFns, false, compilingNodes),
-                body: compile_internal(body, Object.create(ctx), platform, asyncPlatformFns, true, compilingNodes),
+                predicate: compile_internal(predicate, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes),
+                body: compile_internal(body, Object.create(ctx), platform, asyncPlatformFns, platformDef, true, compilingNodes),
             });
         }
-        const else_body = compile_internal(ir.value.else_body, Object.create(ctx), platform, asyncPlatformFns, true, compilingNodes);
+        const else_body = compile_internal(ir.value.else_body, Object.create(ctx), platform, asyncPlatformFns, platformDef, true, compilingNodes);
         if (ir.value.isAsync) {
             if (asyncPredicate) {
                 return async (ctx) => {
@@ -461,7 +486,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         }
     }
     else if (ir.type === "Match") {
-        const compiled_variant = compile_internal(ir.value.variant, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const compiled_variant = compile_internal(ir.value.variant, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         const compiled_cases = {};
         const data_names = {};
         for (const { case: k, variable, body } of ir.value.cases) {
@@ -469,7 +494,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
             const data_name = variable.value.name;
             data_names[k] = data_name;
             ctx2[data_name] = variable.value.type;
-            compiled_cases[k] = compile_internal(body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+            compiled_cases[k] = compile_internal(body, ctx2, platform, asyncPlatformFns, platformDef, true, compilingNodes);
         }
         if (ir.value.isAsync) {
             if (ir.value.variant.value.isAsync) {
@@ -499,9 +524,9 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         }
     }
     else if (ir.type === "While") {
-        const compiled_predicate = compile_internal(ir.value.predicate, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const compiled_predicate = compile_internal(ir.value.predicate, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         const ctx2 = Object.create(ctx);
-        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, platformDef, true, compilingNodes);
         const label = ir.value.label.name;
         if (ir.value.isAsync) {
             return async (ctx) => {
@@ -550,13 +575,13 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "ForArray") {
         const value_type = expandTypeValue(ir.value.array.value.type).value;
-        const compiled_array = compile_internal(ir.value.array, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const compiled_array = compile_internal(ir.value.array, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         const ctx2 = Object.create(ctx);
         const key_name = ir.value.key.value.name;
         const value_name = ir.value.value.value.name;
         ctx2[key_name] = variant("Integer", null);
         ctx2[value_name] = value_type;
-        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, platformDef, true, compilingNodes);
         const label = ir.value.label.name;
         if (ir.value.isAsync) {
             return async (ctx) => {
@@ -623,11 +648,11 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "ForSet") {
         const key_type = expandTypeValue(ir.value.set.value.type).value;
-        const compiled_set = compile_internal(ir.value.set, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const compiled_set = compile_internal(ir.value.set, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         const ctx2 = Object.create(ctx);
         const key_name = ir.value.key.value.name;
         ctx2[key_name] = key_type;
-        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, platformDef, true, compilingNodes);
         const label = ir.value.label.name;
         if (ir.value.isAsync) {
             return async (ctx) => {
@@ -693,13 +718,13 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     else if (ir.type === "ForDict") {
         const key_type = expandTypeValue(ir.value.dict.value.type).value.key;
         const value_type = expandTypeValue(ir.value.dict.value.type).value.value;
-        const compiled_dict = compile_internal(ir.value.dict, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const compiled_dict = compile_internal(ir.value.dict, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         const ctx2 = Object.create(ctx);
         const key_name = ir.value.key.value.name;
         const value_name = ir.value.value.value.name;
         ctx2[key_name] = key_type;
         ctx2[value_name] = value_type;
-        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+        const compiled_body = compile_internal(ir.value.body, ctx2, platform, asyncPlatformFns, platformDef, true, compilingNodes);
         const label = ir.value.label.name;
         if (ir.value.isAsync) {
             return async (ctx) => {
@@ -770,7 +795,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         if (fresh_ctx) {
             const compiled_statements = [];
             for (const statement of ir.value.statements) {
-                const compiled_statement = compile_internal(statement, ctx, platform, asyncPlatformFns, true, compilingNodes);
+                const compiled_statement = compile_internal(statement, ctx, platform, asyncPlatformFns, platformDef, true, compilingNodes);
                 compiled_statements.push(compiled_statement);
             }
             if (ir.value.isAsync) {
@@ -796,7 +821,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
             const ctx2 = Object.create(ctx);
             const compiled_statements = [];
             for (const statement of ir.value.statements) {
-                const compiled_statement = compile_internal(statement, ctx2, platform, asyncPlatformFns, true, compilingNodes);
+                const compiled_statement = compile_internal(statement, ctx2, platform, asyncPlatformFns, platformDef, true, compilingNodes);
                 compiled_statements.push(compiled_statement);
             }
             if (ir.value.isAsync) {
@@ -822,7 +847,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         }
     }
     else if (ir.type === "GetField") {
-        const struct = compile_internal(ir.value.struct, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const struct = compile_internal(ir.value.struct, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         const field = ir.value.field;
         if (ir.value.isAsync) {
             return async (ctx) => (await struct(ctx))[field];
@@ -833,7 +858,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "Struct") {
         const fields = ir.value.fields.map(f => {
-            return compile_internal(f.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+            return compile_internal(f.value, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         });
         const keys = ir.value.fields.map(f => f.name);
         if (ir.value.isAsync) {
@@ -851,7 +876,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "Variant") {
         const k = ir.value.case;
-        const v = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const v = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         if (ir.value.isAsync) {
             return async (ctx) => variant(k, await v(ctx));
         }
@@ -860,7 +885,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         }
     }
     else if (ir.type === "NewRef") {
-        const value = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const value = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         if (ir.value.isAsync) {
             return async (ctx) => ref(await value(ctx));
         }
@@ -870,7 +895,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "NewArray") {
         const values = ir.value.values.map(a => {
-            return compile_internal(a, ctx, platform, asyncPlatformFns, false, compilingNodes);
+            return compile_internal(a, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         });
         if (ir.value.isAsync) {
             return async (ctx) => {
@@ -887,7 +912,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "NewSet") {
         const values = ir.value.values.map(a => {
-            return compile_internal(a, ctx, platform, asyncPlatformFns, false, compilingNodes);
+            return compile_internal(a, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         });
         const keyComparer = compareFor(ir.value.type.value);
         if (ir.value.isAsync) {
@@ -905,7 +930,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
     }
     else if (ir.type === "NewDict") {
         const values = ir.value.values.map(({ key, value }) => {
-            return [compile_internal(key, ctx, platform, asyncPlatformFns, false, compilingNodes), compile_internal(value, ctx, platform, asyncPlatformFns, false, compilingNodes)];
+            return [compile_internal(key, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes), compile_internal(value, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes)];
         });
         const keyComparer = compareFor(ir.value.type.value.key);
         if (ir.value.isAsync) {
@@ -922,7 +947,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
         }
     }
     else if (ir.type === "Return") {
-        const compiled_value = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, false, compilingNodes);
+        const compiled_value = compile_internal(ir.value.value, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         if (ir.value.isAsync) {
             return async (ctx) => {
                 throw new ReturnException(await compiled_value(ctx));
@@ -952,7 +977,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
             if (a.value.isAsync) {
                 argsAsync = true;
             }
-            return compile_internal(a, ctx, platform, asyncPlatformFns, false, compilingNodes);
+            return compile_internal(a, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         });
         // Special optimization for regex builtins with literal pattern/flags
         if ((ir.value.builtin === "RegexContains" || ir.value.builtin === "RegexIndexOf" || ir.value.builtin === "RegexReplace") &&
@@ -1127,7 +1152,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
                 }
             }
         }
-        const evaluator = builtin_evaluators[ir.value.builtin](ir.value.location, ...ir.value.type_parameters);
+        const evaluator = builtin_evaluators[ir.value.builtin](ir.value.location, platformDef, ...ir.value.type_parameters);
         if (argsAsync) {
             return async (ctx) => {
                 const args_resolved = [];
@@ -1147,7 +1172,7 @@ export function compile_internal(ir, ctx, platform, asyncPlatformFns, fresh_ctx
             if (a.value.isAsync) {
                 argsAsync = true;
             }
-            return compile_internal(a, ctx, platform, asyncPlatformFns, false, compilingNodes);
+            return compile_internal(a, ctx, platform, asyncPlatformFns, platformDef, false, compilingNodes);
         });
         const evaluator = platform[ir.value.name];
         if (evaluator === undefined) {
@@ -1196,13 +1221,13 @@ function call_function(location, compiled_f, ...args) {
 }
 /** @internal */
 const builtin_evaluators = {
-    Is: (_location, T) => isFor(T),
-    Equal: (_location, T) => equalFor(T),
-    NotEqual: (_location, T) => notEqualFor(T),
-    Less: (_location, T) => lessFor(T),
-    LessEqual: (_location, T) => lessEqualFor(T),
-    Greater: (_location, T) => greaterFor(T),
-    GreaterEqual: (_location, T) => greaterEqualFor(T),
+    Is: (_location, _platformDef, T) => isFor(T),
+    Equal: (_location, _platformDef, T) => equalFor(T),
+    NotEqual: (_location, _platformDef, T) => notEqualFor(T),
+    Less: (_location, _platformDef, T) => lessFor(T),
+    LessEqual: (_location, _platformDef, T) => lessEqualFor(T),
+    Greater: (_location, _platformDef, T) => greaterFor(T),
+    GreaterEqual: (_location, _platformDef, T) => greaterEqualFor(T),
     BooleanNot: (_location) => (x) => !x,
     BooleanOr: (_location) => (x, y) => x || y,
     BooleanAnd: (_location) => (x, y) => x && y,
@@ -1257,10 +1282,10 @@ const builtin_evaluators = {
     FloatSin: (_location) => (value) => Math.sin(value),
     FloatCos: (_location) => (value) => Math.cos(value),
     FloatTan: (_location) => (value) => Math.tan(value),
-    Print: (_location, T) => {
+    Print: (_location, _platformDef, T) => {
         return printFor(T);
     },
-    Parse: (location, T) => {
+    Parse: (location, _platformDef, T) => {
         const p = parseFor(T);
         return (x) => {
             const result = p(x);
@@ -1460,7 +1485,7 @@ const builtin_evaluators = {
             return buffer.toUint8Array();
         };
     },
-    StringParseJSON: (location, type) => {
+    StringParseJSON: (location, _platformDef, type) => {
         const fromJSON = fromJSONFor(type);
         return (x) => {
             let parsed;
@@ -1478,7 +1503,7 @@ const builtin_evaluators = {
             }
         };
     },
-    StringPrintJSON: (_location, type) => {
+    StringPrintJSON: (_location, _platformDef, type) => {
         const toJSON = toJSONFor(type);
         return (x) => JSON.stringify(toJSON(x));
     },
@@ -1555,13 +1580,13 @@ const builtin_evaluators = {
             }
         };
     },
-    BlobEncodeBeast: (_location, type) => {
+    BlobEncodeBeast: (_location, _platformDef, type) => {
         const encodeBeast = encodeBeastFor(type);
         return (value) => {
             return encodeBeast(value);
         };
     },
-    BlobDecodeBeast: (location, type) => {
+    BlobDecodeBeast: (location, _platformDef, type) => {
         const decodeBeast = decodeBeastFor(type);
         return (data) => {
             try {
@@ -1572,14 +1597,14 @@ const builtin_evaluators = {
             }
         };
     },
-    BlobEncodeBeast2: (_location, type) => {
+    BlobEncodeBeast2: (_location, _platformDef, type) => {
         const encodeBeast2 = encodeBeast2For(type);
         return (value) => {
             return encodeBeast2(value);
         };
     },
-    BlobDecodeBeast2: (location, type) => {
-        const decodeBeast2 = decodeBeast2For(type);
+    BlobDecodeBeast2: (location, platformDef, type) => {
+        const decodeBeast2 = decodeBeast2For(type, { platform: platformDef });
         return (data) => {
             try {
                 return decodeBeast2(data);
@@ -1589,17 +1614,39 @@ const builtin_evaluators = {
             }
         };
     },
-    RefGet: (_location, _T) => (ref) => {
+    BlobDecodeCsv: (location, _platformDef, structType, _configType) => {
+        return (data, config) => {
+            try {
+                const decoder = decodeCsvFor(structType, config);
+                return decoder(data);
+            }
+            catch (e) {
+                throw new EastError(`Failed to decode CSV data: ${e.message}`, { location });
+            }
+        };
+    },
+    ArrayEncodeCsv: (location, _platformDef, structType, _configType) => {
+        return (data, config) => {
+            try {
+                const encoder = encodeCsvFor(structType, config);
+                return encoder(data);
+            }
+            catch (e) {
+                throw new EastError(`Failed to encode CSV data: ${e.message}`, { location });
+            }
+        };
+    },
+    RefGet: (_location, _platformDef, _T) => (ref) => {
         return ref.value;
     },
-    RefUpdate: (location, _T) => (ref, value) => {
+    RefUpdate: (location, _platformDef, _T) => (ref, value) => {
         if (Object.isFrozen(ref)) {
             throw new EastError("Cannot modify frozen Ref", { location });
         }
         ref.value = value;
         return null;
     },
-    RefMerge: (location, _T) => (ref, value, merger) => {
+    RefMerge: (location, _platformDef, _T) => (ref, value, merger) => {
         if (Object.isFrozen(ref)) {
             throw new EastError("Cannot modify frozen Ref", { location });
         }
@@ -1607,7 +1654,7 @@ const builtin_evaluators = {
         ref.value = new_value;
         return null;
     },
-    ArrayGenerate: (location, _T) => (size, f) => {
+    ArrayGenerate: (location, _platformDef, _T) => (size, f) => {
         const result = [];
         for (let i = 0n; i < size; i += 1n) {
             const v = call_function(location, f, i);
@@ -1648,12 +1695,12 @@ const builtin_evaluators = {
         }
         return result;
     },
-    ArraySize: (_location, _T) => (array) => BigInt(array.length),
-    ArrayHas: (_location, _T) => (array, key) => {
+    ArraySize: (_location, _platformDef, _T) => (array) => BigInt(array.length),
+    ArrayHas: (_location, _platformDef, _T) => (array, key) => {
         const i = Number(key);
         return i >= 0 && i < array.length;
     },
-    ArrayGet: (location, _T) => (array, key) => {
+    ArrayGet: (location, _platformDef, _T) => (array, key) => {
         const i = Number(key);
         if (i < 0 || i >= array.length) {
             throw new EastError(`Array index ${key} out of bounds`, { location });
@@ -1662,7 +1709,7 @@ const builtin_evaluators = {
             return array[i];
         }
     },
-    ArrayGetOrDefault: (location, _T) => (array, key, defaultFn) => {
+    ArrayGetOrDefault: (location, _platformDef, _T) => (array, key, defaultFn) => {
         const i = Number(key);
         if (i < 0 || i >= array.length) {
             return call_function(location, defaultFn, key);
@@ -1671,7 +1718,7 @@ const builtin_evaluators = {
             return array[i];
         }
     },
-    ArrayTryGet: (_location, _T) => (array, key) => {
+    ArrayTryGet: (_location, _platformDef, _T) => (array, key) => {
         const i = Number(key);
         if (i < 0 || i >= array.length) {
             return variant("none", null);
@@ -1680,7 +1727,7 @@ const builtin_evaluators = {
             return variant("some", array[i]);
         }
     },
-    ArrayUpdate: (location, _T) => (array, key, value) => {
+    ArrayUpdate: (location, _platformDef, _T) => (array, key, value) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1693,7 +1740,7 @@ const builtin_evaluators = {
             return null;
         }
     },
-    ArrayMerge: (location, _T) => (array, key, value, merger) => {
+    ArrayMerge: (location, _platformDef, _T) => (array, key, value, merger) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1707,7 +1754,7 @@ const builtin_evaluators = {
             return null;
         }
     },
-    ArrayPushLast: (location, _T) => (array, value) => {
+    ArrayPushLast: (location, _platformDef, _T) => (array, value) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1717,7 +1764,7 @@ const builtin_evaluators = {
         array.push(value);
         return null;
     },
-    ArrayPopLast: (location, _T) => (array) => {
+    ArrayPopLast: (location, _platformDef, _T) => (array) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1731,7 +1778,7 @@ const builtin_evaluators = {
             return array.pop();
         }
     },
-    ArrayPushFirst: (location, _T) => (array, value) => {
+    ArrayPushFirst: (location, _platformDef, _T) => (array, value) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1741,7 +1788,7 @@ const builtin_evaluators = {
         array.unshift(value);
         return null;
     },
-    ArrayPopFirst: (location, _T) => (array) => {
+    ArrayPopFirst: (location, _platformDef, _T) => (array) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1755,7 +1802,7 @@ const builtin_evaluators = {
             return array.shift();
         }
     },
-    ArrayAppend: (location, _T) => (array, other) => {
+    ArrayAppend: (location, _platformDef, _T) => (array, other) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1765,7 +1812,7 @@ const builtin_evaluators = {
         array.push(...other);
         return null;
     },
-    ArrayPrepend: (location, _T) => (array, other) => {
+    ArrayPrepend: (location, _platformDef, _T) => (array, other) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1775,7 +1822,7 @@ const builtin_evaluators = {
         array.unshift(...other);
         return null;
     },
-    ArrayMergeAll: (location, _T, _T2) => (array, other, merger) => {
+    ArrayMergeAll: (location, _platformDef, _T, _T2) => (array, other, merger) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1799,7 +1846,7 @@ const builtin_evaluators = {
         }
         return null;
     },
-    ArrayClear: (location, _T) => (array) => {
+    ArrayClear: (location, _platformDef, _T) => (array) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1809,7 +1856,7 @@ const builtin_evaluators = {
         array.length = 0;
         return null;
     },
-    ArraySortInPlace: (location, T, T2) => (array, by) => {
+    ArraySortInPlace: (location, _platformDef, T, T2) => (array, by) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1830,7 +1877,7 @@ const builtin_evaluators = {
         }
         return null;
     },
-    ArrayReverseInPlace: (location, _T) => (array) => {
+    ArrayReverseInPlace: (location, _platformDef, _T) => (array) => {
         if (Object.isFrozen(array)) {
             throw new EastError("Cannot modify frozen Array", { location });
         }
@@ -1840,7 +1887,7 @@ const builtin_evaluators = {
         array.reverse();
         return null;
     },
-    ArraySort: (location, T, T2) => (array, by) => {
+    ArraySort: (location, _platformDef, T, T2) => (array, by) => {
         const cmp = compareFor(T2);
         const newArray = [...array];
         newArray.sort((a, b) => {
@@ -1850,12 +1897,12 @@ const builtin_evaluators = {
         });
         return newArray;
     },
-    ArrayReverse: (_location, _T) => (array) => {
+    ArrayReverse: (_location, _platformDef, _T) => (array) => {
         const newArray = [...array];
         newArray.reverse();
         return newArray;
     },
-    ArrayIsSorted: (location, T, T2) => {
+    ArrayIsSorted: (location, _platformDef, T, T2) => {
         const cmp = compareFor(T2);
         return (array, by) => {
             if (array.length < 2)
@@ -1877,7 +1924,7 @@ const builtin_evaluators = {
             return true;
         };
     },
-    ArrayFindSortedFirst: (location, T, T2) => {
+    ArrayFindSortedFirst: (location, _platformDef, T, T2) => {
         const cmp = compareFor(T2);
         return (array, key, by) => {
             let low = 0;
@@ -1901,7 +1948,7 @@ const builtin_evaluators = {
             return BigInt(low);
         };
     },
-    ArrayFindSortedLast: (location, T, T2) => {
+    ArrayFindSortedLast: (location, _platformDef, T, T2) => {
         const cmp = compareFor(T2);
         return (array, key, by) => {
             let low = 0;
@@ -1925,7 +1972,7 @@ const builtin_evaluators = {
             return BigInt(low);
         };
     },
-    ArrayFindSortedRange: (location, T, T2) => {
+    ArrayFindSortedRange: (location, _platformDef, T, T2) => {
         const cmp = compareFor(T2);
         return (array, key, by) => {
             let lo = -1;
@@ -1983,7 +2030,7 @@ const builtin_evaluators = {
             return { start: BigInt(lo + 1), end: BigInt(lo + 1) };
         };
     },
-    ArrayFindFirst: (location, T, T2) => {
+    ArrayFindFirst: (location, _platformDef, T, T2) => {
         const cmp = compareFor(T2);
         return (array, value, by) => {
             lockForIteration(array);
@@ -2001,15 +2048,15 @@ const builtin_evaluators = {
             }
         };
     },
-    ArrayConcat: (_location, _T) => (a1, a2) => {
+    ArrayConcat: (_location, _platformDef, _T) => (a1, a2) => {
         return [...a1, ...a2];
     },
-    ArraySlice: (_location, _T) => (array, start, end) => {
+    ArraySlice: (_location, _platformDef, _T) => (array, start, end) => {
         const startNum = Number(start);
         const endNum = Number(end);
         return array.slice(startNum, endNum);
     },
-    ArrayGetKeys: (location, _T) => (array, keys, onMissing) => {
+    ArrayGetKeys: (location, _platformDef, _T) => (array, keys, onMissing) => {
         return keys.map(k => {
             const i = Number(k);
             if (i < 0 || i >= array.length) {
@@ -2020,7 +2067,7 @@ const builtin_evaluators = {
             }
         });
     },
-    ArrayForEach: (location, _T, _T2) => (array, f) => {
+    ArrayForEach: (location, _platformDef, _T, _T2) => (array, f) => {
         lockForIteration(array);
         try {
             array.forEach((x, i) => {
@@ -2032,10 +2079,10 @@ const builtin_evaluators = {
             unlockForIteration(array);
         }
     },
-    ArrayCopy: (_location, _T) => (array) => {
+    ArrayCopy: (_location, _platformDef, _T) => (array) => {
         return [...array];
     },
-    ArrayMap: (location, _T, _T2) => (array, f) => {
+    ArrayMap: (location, _platformDef, _T, _T2) => (array, f) => {
         lockForIteration(array);
         try {
             return array.map((x, i) => {
@@ -2046,7 +2093,7 @@ const builtin_evaluators = {
             unlockForIteration(array);
         }
     },
-    ArrayFilter: (location, _T, _T2) => (array, f) => {
+    ArrayFilter: (location, _platformDef, _T, _T2) => (array, f) => {
         lockForIteration(array);
         try {
             return array.filter((x, i) => {
@@ -2057,7 +2104,7 @@ const builtin_evaluators = {
             unlockForIteration(array);
         }
     },
-    ArrayFilterMap: (location, _T, _T2) => (array, f) => {
+    ArrayFilterMap: (location, _platformDef, _T, _T2) => (array, f) => {
         lockForIteration(array);
         try {
             const result = [];
@@ -2073,7 +2120,7 @@ const builtin_evaluators = {
             unlockForIteration(array);
         }
     },
-    ArrayFirstMap: (location, _T, _T2) => (array, f) => {
+    ArrayFirstMap: (location, _platformDef, _T, _T2) => (array, f) => {
         lockForIteration(array);
         try {
             for (let i = 0; i < array.length; i++) {
@@ -2088,7 +2135,7 @@ const builtin_evaluators = {
             unlockForIteration(array);
         }
     },
-    ArrayFold: (location, _T, _T2) => (array, init, f) => {
+    ArrayFold: (location, _platformDef, _T, _T2) => (array, init, f) => {
         lockForIteration(array);
         try {
             return array.reduce((acc, x, i) => {
@@ -2099,7 +2146,7 @@ const builtin_evaluators = {
             unlockForIteration(array);
         }
     },
-    ArrayMapReduce: (location, _T, _T2) => (array, mapFn, reduceFn) => {
+    ArrayMapReduce: (location, _platformDef, _T, _T2) => (array, mapFn, reduceFn) => {
         if (array.length === 0) {
             throw new EastError("Cannot reduce empty array with no initial value", { location });
         }
@@ -2116,8 +2163,8 @@ const builtin_evaluators = {
             unlockForIteration(array);
         }
     },
-    ArrayStringJoin: (_location) => (x, y) => x.join(y),
-    ArrayToSet: (location, _T, T2) => {
+    ArrayStringJoin: (_location, _platformDef) => (x, y) => x.join(y),
+    ArrayToSet: (location, _platformDef, _T, T2) => {
         const compare = compareFor(T2);
         return (array, f) => {
             lockForIteration(array);
@@ -2134,7 +2181,7 @@ const builtin_evaluators = {
             }
         };
     },
-    ArrayToDict: (location, _T, K2, _T2) => {
+    ArrayToDict: (location, _platformDef, _T, K2, _T2) => {
         const compare = compareFor(K2);
         return (array, keyFn, valueFn, onConflict) => {
             const result = new SortedMap([], compare);
@@ -2160,12 +2207,12 @@ const builtin_evaluators = {
             }
         };
     },
-    ArrayFlattenToArray: (location, _T) => (array, fn) => {
+    ArrayFlattenToArray: (location, _platformDef, _T) => (array, fn) => {
         return array.flatMap(v => {
             return call_function(location, fn, v);
         });
     },
-    ArrayFlattenToSet: (location, _T, K2) => {
+    ArrayFlattenToSet: (location, _platformDef, _T, K2) => {
         const compare = compareFor(K2);
         return (array, fn) => {
             const result = new SortedSet([], compare);
@@ -2184,7 +2231,7 @@ const builtin_evaluators = {
             }
         };
     },
-    ArrayFlattenToDict: (location, _T, K2, _T2) => {
+    ArrayFlattenToDict: (location, _platformDef, _T, K2, _T2) => {
         const compare = compareFor(K2);
         return (array, fn, onConflict) => {
             const result = new SortedMap([], compare);
@@ -2210,7 +2257,7 @@ const builtin_evaluators = {
             }
         };
     },
-    ArrayGroupFold: (location, _T, K2, _V2) => {
+    ArrayGroupFold: (location, _platformDef, _T, K2, _V2) => {
         const compare = compareFor(K2);
         return (array, keyFn, init, folder) => {
             const result = new SortedMap([], compare);
@@ -2233,7 +2280,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetGenerate: (location, K) => {
+    SetGenerate: (location, _platformDef, K) => {
         const keyComparer = compareFor(K);
         return (size, keyFn, onConflict) => {
             const result = new SortedSet([], keyComparer);
@@ -2249,9 +2296,9 @@ const builtin_evaluators = {
             return result;
         };
     },
-    SetSize: (_location, _K) => (s) => BigInt(s.size),
-    SetHas: (_location, _K) => (s, key) => s.has(key),
-    SetInsert: (location, K) => {
+    SetSize: (_location, _platformDef, _K) => (s) => BigInt(s.size),
+    SetHas: (_location, _platformDef, _K) => (s, key) => s.has(key),
+    SetInsert: (location, _platformDef, K) => {
         const print = printFor(K);
         return (s, key) => {
             if (Object.isFrozen(s)) {
@@ -2268,7 +2315,7 @@ const builtin_evaluators = {
             return null;
         };
     },
-    SetTryInsert: (location, _K) => (s, key) => {
+    SetTryInsert: (location, _platformDef, _K) => (s, key) => {
         if (Object.isFrozen(s)) {
             throw new EastError("Cannot modify frozen Set", { location });
         }
@@ -2279,7 +2326,7 @@ const builtin_evaluators = {
         s.add(key);
         return s.size > size_before;
     },
-    SetDelete: (location, K) => {
+    SetDelete: (location, _platformDef, K) => {
         const print = printFor(K);
         return (s, key) => {
             if (Object.isFrozen(s)) {
@@ -2294,7 +2341,7 @@ const builtin_evaluators = {
             return null;
         };
     },
-    SetTryDelete: (location, _K) => (s, key) => {
+    SetTryDelete: (location, _platformDef, _K) => (s, key) => {
         if (Object.isFrozen(s)) {
             throw new EastError("Cannot modify frozen Set", { location });
         }
@@ -2303,7 +2350,7 @@ const builtin_evaluators = {
         }
         return s.delete(key);
     },
-    SetClear: (location, _K) => (s) => {
+    SetClear: (location, _platformDef, _K) => (s) => {
         if (Object.isFrozen(s)) {
             throw new EastError("Cannot modify frozen Set", { location });
         }
@@ -2313,7 +2360,7 @@ const builtin_evaluators = {
         s.clear();
         return null;
     },
-    SetUnionInPlace: (location, _K) => (s1, s2) => {
+    SetUnionInPlace: (location, _platformDef, _K) => (s1, s2) => {
         if (Object.isFrozen(s1)) {
             throw new EastError("Cannot modify frozen Set", { location });
         }
@@ -2323,19 +2370,19 @@ const builtin_evaluators = {
         s2.forEach(v => s1.add(v));
         return null;
     },
-    SetUnion: (_location, _K) => (s1, s2) => s1.union(s2),
-    SetIntersect: (_location, _K) => (s1, s2) => s1.intersection(s2),
-    SetDiff: (_location, _K) => (s1, s2) => s1.difference(s2),
-    SetSymDiff: (_location, _K) => (s1, s2) => s1.symmetricDifference(s2),
-    SetIsSubset: (_location, _K) => (s1, s2) => s1.isSubsetOf(s2),
-    SetIsDisjoint: (_location, _K) => (s1, s2) => s1.isDisjointFrom(s2),
-    SetCopy: (_location, K) => {
+    SetUnion: (_location, _platformDef, _K) => (s1, s2) => s1.union(s2),
+    SetIntersect: (_location, _platformDef, _K) => (s1, s2) => s1.intersection(s2),
+    SetDiff: (_location, _platformDef, _K) => (s1, s2) => s1.difference(s2),
+    SetSymDiff: (_location, _platformDef, _K) => (s1, s2) => s1.symmetricDifference(s2),
+    SetIsSubset: (_location, _platformDef, _K) => (s1, s2) => s1.isSubsetOf(s2),
+    SetIsDisjoint: (_location, _platformDef, _K) => (s1, s2) => s1.isDisjointFrom(s2),
+    SetCopy: (_location, _platformDef, K) => {
         const compare = compareFor(K);
         return (s) => {
             return new SortedSet([...s], compare);
         };
     },
-    SetForEach: (location, _K, _T2) => (s, f) => {
+    SetForEach: (location, _platformDef, _K, _T2) => (s, f) => {
         lockForIteration(s);
         try {
             s.forEach(x => {
@@ -2347,7 +2394,7 @@ const builtin_evaluators = {
             unlockForIteration(s);
         }
     },
-    SetFilter: (location, K) => {
+    SetFilter: (location, _platformDef, K) => {
         const compare = compareFor(K);
         return (s, f) => {
             const result = new SortedSet([], compare);
@@ -2366,7 +2413,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetFilterMap: (location, K, _V2) => {
+    SetFilterMap: (location, _platformDef, K, _V2) => {
         const compare = compareFor(K);
         return (s, f) => {
             const result = new SortedMap([], compare);
@@ -2385,7 +2432,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetFirstMap: (location, _K, _T2) => (s, f) => {
+    SetFirstMap: (location, _platformDef, _K, _T2) => (s, f) => {
         lockForIteration(s);
         try {
             for (const k of s) {
@@ -2400,7 +2447,7 @@ const builtin_evaluators = {
             unlockForIteration(s);
         }
     },
-    SetMapReduce: (location, _K, _T2) => (s, mapFn, reduceFn) => {
+    SetMapReduce: (location, _platformDef, _K, _T2) => (s, mapFn, reduceFn) => {
         if (s.size === 0) {
             throw new EastError("Cannot reduce empty set with no initial value", { location });
         }
@@ -2419,7 +2466,7 @@ const builtin_evaluators = {
             unlockForIteration(s);
         }
     },
-    SetMap: (location, K, _T2) => {
+    SetMap: (location, _platformDef, K, _T2) => {
         const compare = compareFor(K);
         return (s, f) => {
             const result = new SortedMap([], compare);
@@ -2436,7 +2483,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetReduce: (location, _K, _T2) => (s, f, init) => {
+    SetReduce: (location, _platformDef, _K, _T2) => (s, f, init) => {
         let acc = init;
         lockForIteration(s);
         try {
@@ -2449,7 +2496,7 @@ const builtin_evaluators = {
             unlockForIteration(s);
         }
     },
-    SetToArray: (location, _K, _T2) => (s, valueFn) => {
+    SetToArray: (location, _platformDef, _K, _T2) => (s, valueFn) => {
         const ret = [];
         lockForIteration(s);
         try {
@@ -2463,7 +2510,7 @@ const builtin_evaluators = {
             unlockForIteration(s);
         }
     },
-    SetToSet: (location, K, K2) => {
+    SetToSet: (location, _platformDef, K, K2) => {
         const compare = compareFor(K2);
         return (s, f) => {
             const result = new SortedSet([], compare);
@@ -2481,7 +2528,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetToDict: (location, K, K2, _V2) => {
+    SetToDict: (location, _platformDef, K, K2, _V2) => {
         const compare = compareFor(K2);
         return (s, keyFn, valueFn, onConflict) => {
             const result = new SortedMap([], compare);
@@ -2506,7 +2553,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetFlattenToArray: (location, _K, _T2) => (s, fn) => {
+    SetFlattenToArray: (location, _platformDef, _K, _T2) => (s, fn) => {
         const ret = [];
         lockForIteration(s);
         try {
@@ -2520,7 +2567,7 @@ const builtin_evaluators = {
             unlockForIteration(s);
         }
     },
-    SetFlattenToSet: (location, _K, K2) => {
+    SetFlattenToSet: (location, _platformDef, _K, K2) => {
         const compare = compareFor(K2);
         return (s, fn) => {
             const result = new SortedSet([], compare);
@@ -2539,7 +2586,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetFlattenToDict: (location, _K, K2, _V2) => {
+    SetFlattenToDict: (location, _platformDef, _K, K2, _V2) => {
         const compare = compareFor(K2);
         return (s, fn, onConflict) => {
             const result = new SortedMap([], compare);
@@ -2565,7 +2612,7 @@ const builtin_evaluators = {
             }
         };
     },
-    SetGroupFold: (location, _K, K2, _T2) => {
+    SetGroupFold: (location, _platformDef, _K, K2, _T2) => {
         const compare = compareFor(K2);
         return (s, keyFn, init, folder) => {
             const result = new SortedMap([], compare);
@@ -2587,7 +2634,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictGenerate: (location, K, _V) => {
+    DictGenerate: (location, _platformDef, K, _V) => {
         const keyComparer = compareFor(K);
         return (size, keyFn, valueFn, onConflict) => {
             const result = new SortedMap([], keyComparer);
@@ -2606,9 +2653,9 @@ const builtin_evaluators = {
             return result;
         };
     },
-    DictSize: (_location, _K, _V) => (d) => BigInt(d.size),
-    DictHas: (_location, _K, _V) => (d, key) => d.has(key),
-    DictGet: (location, K, _V) => {
+    DictSize: (_location, _platformDef, _K, _V) => (d) => BigInt(d.size),
+    DictHas: (_location, _platformDef, _K, _V) => (d, key) => d.has(key),
+    DictGet: (location, _platformDef, K, _V) => {
         const print = printFor(K);
         return (d, key) => {
             const result = d.get(key);
@@ -2620,7 +2667,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictGetOrDefault: (location, _K, _V) => (d, key, onMissingFn) => {
+    DictGetOrDefault: (location, _platformDef, _K, _V) => (d, key, onMissingFn) => {
         const result = d.get(key);
         if (result === undefined) {
             return call_function(location, onMissingFn, key);
@@ -2629,7 +2676,7 @@ const builtin_evaluators = {
             return result;
         }
     },
-    DictTryGet: (_location, _K, _V) => (d, key) => {
+    DictTryGet: (_location, _platformDef, _K, _V) => (d, key) => {
         const result = d.get(key);
         if (result === undefined) {
             return variant("none", null);
@@ -2638,7 +2685,7 @@ const builtin_evaluators = {
             return variant("some", result);
         }
     },
-    DictInsert: (location, K, _V) => {
+    DictInsert: (location, _platformDef, K, _V) => {
         const print = printFor(K);
         return (d, key, value) => {
             if (Object.isFrozen(d)) {
@@ -2657,7 +2704,7 @@ const builtin_evaluators = {
             return null;
         };
     },
-    DictGetOrInsert: (location, _K, _V) => (d, key, onMissing) => {
+    DictGetOrInsert: (location, _platformDef, _K, _V) => (d, key, onMissing) => {
         if (Object.isFrozen(d)) {
             throw new EastError("Cannot modify frozen Dict", { location });
         }
@@ -2674,7 +2721,7 @@ const builtin_evaluators = {
             return existing;
         }
     },
-    DictInsertOrUpdate: (location, _K, _V) => (d, key, value, onConflictFn) => {
+    DictInsertOrUpdate: (location, _platformDef, _K, _V) => (d, key, value, onConflictFn) => {
         if (Object.isFrozen(d)) {
             throw new EastError("Cannot modify frozen Dict", { location });
         }
@@ -2691,7 +2738,7 @@ const builtin_evaluators = {
         }
         return null;
     },
-    DictUpdate: (location, K, _V) => {
+    DictUpdate: (location, _platformDef, K, _V) => {
         const print = printFor(K);
         return (d, key, value) => {
             if (Object.isFrozen(d)) {
@@ -2706,7 +2753,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictSwap: (location, K, _V) => {
+    DictSwap: (location, _platformDef, K, _V) => {
         const print = printFor(K);
         return (d, key, value) => {
             if (Object.isFrozen(d)) {
@@ -2720,7 +2767,7 @@ const builtin_evaluators = {
             return existing;
         };
     },
-    DictMerge: (location, _K, _V) => (d, key, value, mergeFn, initialFn) => {
+    DictMerge: (location, _platformDef, _K, _V) => (d, key, value, mergeFn, initialFn) => {
         if (Object.isFrozen(d)) {
             throw new EastError("Cannot modify frozen Dict", { location });
         }
@@ -2735,7 +2782,7 @@ const builtin_evaluators = {
         d.set(key, new_value);
         return null;
     },
-    DictDelete: (location, K, _V) => {
+    DictDelete: (location, _platformDef, K, _V) => {
         const print = printFor(K);
         return (d, key) => {
             if (Object.isFrozen(d)) {
@@ -2751,7 +2798,7 @@ const builtin_evaluators = {
             return null;
         };
     },
-    DictTryDelete: (location, _K, _V) => (d, key) => {
+    DictTryDelete: (location, _platformDef, _K, _V) => (d, key) => {
         if (Object.isFrozen(d)) {
             throw new EastError("Cannot modify frozen Dict", { location });
         }
@@ -2760,7 +2807,7 @@ const builtin_evaluators = {
         }
         return d.delete(key);
     },
-    DictPop: (location, K, _V) => {
+    DictPop: (location, _platformDef, K, _V) => {
         const print = printFor(K);
         return (d, key) => {
             if (Object.isFrozen(d)) {
@@ -2779,7 +2826,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictClear: (location, _K, _V) => (d) => {
+    DictClear: (location, _platformDef, _K, _V) => (d) => {
         if (Object.isFrozen(d)) {
             throw new EastError("Cannot modify frozen Dict", { location });
         }
@@ -2789,7 +2836,7 @@ const builtin_evaluators = {
         d.clear();
         return null;
     },
-    DictUnionInPlace: (location, _K, _V) => (d1, d2, onConflict) => {
+    DictUnionInPlace: (location, _platformDef, _K, _V) => (d1, d2, onConflict) => {
         if (Object.isFrozen(d1)) {
             throw new EastError("Cannot modify frozen Dict", { location });
         }
@@ -2808,7 +2855,7 @@ const builtin_evaluators = {
         });
         return null;
     },
-    DictMergeAll: (location, _K, _V) => (d1, d2, mergeFn, initialFn) => {
+    DictMergeAll: (location, _platformDef, _K, _V) => (d1, d2, mergeFn, initialFn) => {
         if (Object.isFrozen(d1)) {
             throw new EastError("Cannot modify frozen Dict", { location });
         }
@@ -2825,13 +2872,13 @@ const builtin_evaluators = {
         });
         return null;
     },
-    DictKeys: (_location, K, _V) => {
+    DictKeys: (_location, _platformDef, K, _V) => {
         const compare = compareFor(K);
         return (d) => {
             return new SortedSet([...d.keys()], compare);
         };
     },
-    DictGetKeys: (location, K, _V) => {
+    DictGetKeys: (location, _platformDef, K, _V) => {
         const compare = compareFor(K);
         return (d, keys, onMissing) => {
             const result = new SortedMap([], compare);
@@ -2848,7 +2895,7 @@ const builtin_evaluators = {
             return result;
         };
     },
-    DictForEach: (location, _K, _V, _T2) => (d, f) => {
+    DictForEach: (location, _platformDef, _K, _V, _T2) => (d, f) => {
         lockForIteration(d);
         try {
             d.forEach((v, k) => {
@@ -2860,13 +2907,13 @@ const builtin_evaluators = {
             unlockForIteration(d);
         }
     },
-    DictCopy: (_location, K, _V) => {
+    DictCopy: (_location, _platformDef, K, _V) => {
         const compare = compareFor(K);
         return (d) => {
             return new SortedMap([...d], compare);
         };
     },
-    DictMap: (location, K, _V, _V2) => {
+    DictMap: (location, _platformDef, K, _V, _V2) => {
         const compare = compareFor(K);
         return (d, f) => {
             const result = new SortedMap([], compare);
@@ -2883,7 +2930,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictFilter: (location, K, _V) => {
+    DictFilter: (location, _platformDef, K, _V) => {
         const compare = compareFor(K);
         return (d, f) => {
             const result = new SortedMap([], compare);
@@ -2902,7 +2949,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictFilterMap: (location, K, _V, _V2) => {
+    DictFilterMap: (location, _platformDef, K, _V, _V2) => {
         const compare = compareFor(K);
         return (d, f) => {
             const result = new SortedMap([], compare);
@@ -2921,7 +2968,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictFirstMap: (location, _K, _V, _T2) => (d, f) => {
+    DictFirstMap: (location, _platformDef, _K, _V, _T2) => (d, f) => {
         lockForIteration(d);
         try {
             for (const [k, v] of d) {
@@ -2936,7 +2983,7 @@ const builtin_evaluators = {
             unlockForIteration(d);
         }
     },
-    DictMapReduce: (location, _K, _V, _T2) => (d, mapFn, reduceFn) => {
+    DictMapReduce: (location, _platformDef, _K, _V, _T2) => (d, mapFn, reduceFn) => {
         if (d.size === 0) {
             throw new EastError("Cannot reduce empty dictionary with no initial value", { location });
         }
@@ -2955,7 +3002,7 @@ const builtin_evaluators = {
             unlockForIteration(d);
         }
     },
-    DictReduce: (location, _K, _V, _T2) => (d, f, init) => {
+    DictReduce: (location, _platformDef, _K, _V, _T2) => (d, f, init) => {
         let acc = init;
         lockForIteration(d);
         try {
@@ -2968,7 +3015,7 @@ const builtin_evaluators = {
             unlockForIteration(d);
         }
     },
-    DictToArray: (location, _K, _V, _T2) => (d, valueFn) => {
+    DictToArray: (location, _platformDef, _K, _V, _T2) => (d, valueFn) => {
         const ret = [];
         lockForIteration(d);
         try {
@@ -2982,7 +3029,7 @@ const builtin_evaluators = {
             unlockForIteration(d);
         }
     },
-    DictToSet: (location, _K, _V, K2) => {
+    DictToSet: (location, _platformDef, _K, _V, K2) => {
         const compare = compareFor(K2);
         return (d, fn) => {
             const result = new SortedSet([], compare);
@@ -2999,7 +3046,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictToDict: (location, K, _V, K2, _V2) => {
+    DictToDict: (location, _platformDef, K, _V, K2, _V2) => {
         const compare = compareFor(K2);
         return (d, keyFn, valueFn, onConflict) => {
             const result = new SortedMap([], compare);
@@ -3024,7 +3071,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictFlattenToArray: (location, _K, _V, _T2) => (d, fn) => {
+    DictFlattenToArray: (location, _platformDef, _K, _V, _T2) => (d, fn) => {
         const ret = [];
         lockForIteration(d);
         try {
@@ -3040,7 +3087,7 @@ const builtin_evaluators = {
             unlockForIteration(d);
         }
     },
-    DictFlattenToSet: (location, _K, _V, K2) => {
+    DictFlattenToSet: (location, _platformDef, _K, _V, K2) => {
         const compare = compareFor(K2);
         return (d, fn) => {
             const result = new SortedSet([], compare);
@@ -3059,7 +3106,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictFlattenToDict: (location, _K, _V, K2, _V2) => {
+    DictFlattenToDict: (location, _platformDef, _K, _V, K2, _V2) => {
         const compare = compareFor(K2);
         return (d, fn, onConflict) => {
             const result = new SortedMap([], compare);
@@ -3085,7 +3132,7 @@ const builtin_evaluators = {
             }
         };
     },
-    DictGroupFold: (location, _K, _V, K2, _T2) => {
+    DictGroupFold: (location, _platformDef, _K, _V, K2, _T2) => {
         const compare = compareFor(K2);
         return (d, keyFn, init, folder) => {
             const result = new SortedMap([], compare);