@magnusopera/fscript 0.75.0

package/dist/FScript.Language/Eval.js

@@ -0,0 +1,2404 @@
+
+import { toString, FSharpRef, Record } from "../fable_modules/fable-library-js.5.2.0/Types.js";
+import { option_type, array_type, obj_type, record_type, class_type, string_type } from "../fable_modules/fable-library-js.5.2.0/Reflection.js";
+import { Type, Types_typeToString, Type_$reflection } from "./Types.js";
+import { ExternalCallContext, MapKey, Value, TaskHandle_$reflection, Value_$reflection } from "./Value.js";
+import { EvalException, EvalError$, EvalError$_$reflection } from "./Error.js";
+import { Span, Position } from "./Span.js";
+import { printf, toText, join, concat } from "../fable_modules/fable-library-js.5.2.0/String.js";
+import { curry2, disposeSafe, getEnumerator, equals as equals_1, compare, comparePrimitives, int64ToString } from "../fable_modules/fable-library-js.5.2.0/Util.js";
+import { ofArray, collect, tryFindIndex, choose, tryPick as tryPick_1, tryFind as tryFind_1, append, reverse, zip, fold as fold_1, singleton, forAll as forAll_1, empty, cons, tail as tail_2, head as head_2, isEmpty, forAll2, length, map } from "../fable_modules/fable-library-js.5.2.0/List.js";
+import { map as map_2, containsKey, FSharpMap__Add, fold, empty as empty_1, FSharpMap__Remove, FSharpMap__get_IsEmpty, FSharpMap__ContainsKey, add, FSharpMap__TryFind, tryFind, toSeq, ofList, FSharpMap__get_Item, forAll, FSharpMap__get_Keys, FSharpMap__get_Count, toList } from "../fable_modules/fable-library-js.5.2.0/Map.js";
+import { op_Modulus, op_Division, op_Multiply, op_Subtraction, op_Addition, toInt64_unchecked, compare as compare_1, equals } from "../fable_modules/fable-library-js.5.2.0/BigInt.js";
+import { contains, ofSeq } from "../fable_modules/fable-library-js.5.2.0/Set.js";
+import { toArray, some, bind, map as map_1 } from "../fable_modules/fable-library-js.5.2.0/Option.js";
+import { filter, length as length_1, iterate, foldBack, head as head_3, tryPick } from "../fable_modules/fable-library-js.5.2.0/Seq.js";
+import { Ast_spanOfExpr, Expr, Ast_spanOfPattern, TypeRef } from "./Ast.js";
+import { StringBuilder__Append_Z721C83C5, StringBuilder_$ctor } from "../fable_modules/fable-library-js.5.2.0/System.Text.js";
+import { builtinReservedNames } from "./BuiltinSignatures.js";
+import { typeDefs as typeDefs_3 } from "./BuiltinTypes.js";
+import { builtinExterns } from "./BuiltinFunctions.js";
+
+export class ProgramState extends Record {
+    constructor(TypeDefs, Env, LastValue) {
+        super();
+        this.TypeDefs = TypeDefs;
+        this.Env = Env;
+        this.LastValue = LastValue;
+    }
+}
+
+export function ProgramState_$reflection() {
+    return record_type("FScript.Language.Eval.ProgramState", [], ProgramState, () => [["TypeDefs", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, Type_$reflection()])], ["Env", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, Value_$reflection()])], ["LastValue", Value_$reflection()]]);
+}
+
+class RuntimeState extends Record {
+    constructor(SyncRoot, PendingTasks, BackgroundFailure) {
+        super();
+        this.SyncRoot = SyncRoot;
+        this.PendingTasks = PendingTasks;
+        this.BackgroundFailure = BackgroundFailure;
+    }
+}
+
+function RuntimeState_$reflection() {
+    return record_type("FScript.Language.Eval.RuntimeState", [], RuntimeState, () => [["SyncRoot", obj_type], ["PendingTasks", array_type(TaskHandle_$reflection())], ["BackgroundFailure", option_type(EvalError$_$reflection())]]);
+}
+
+const unknownSpan = new Span(new Position(undefined, 0, 0), new Position(undefined, 0, 0));
+
+function wrapTaskFailure(error) {
+    return new EvalError$(concat("Task failed: ", error.Message), error.Span);
+}
+
+function wrapUnexpectedTaskFailure(ex) {
+    return new EvalError$(concat("Task failed: ", ex.message), unknownSpan);
+}
+
+function withRuntimeLock(runtime, f) {
+    return f();
+}
+
+function raiseIfBackgroundFailed(runtime) {
+    withRuntimeLock(runtime, () => {
+        const matchValue = runtime.BackgroundFailure;
+        if (matchValue == null) {
+        }
+        else {
+            throw new EvalException(matchValue);
+        }
+    });
+}
+
+function literalToValue(lit) {
+    switch (lit.tag) {
+        case 1:
+            return new Value(2, [lit.fields[0]]);
+        case 2:
+            return new Value(3, [lit.fields[0]]);
+        case 3:
+            return new Value(4, [lit.fields[0]]);
+        default:
+            return new Value(1, [lit.fields[0]]);
+    }
+}
+
+function valueToInterpolationString(v) {
+    switch (v.tag) {
+        case 1:
+            return int64ToString(v.fields[0]);
+        case 2:
+            return v.fields[0].toString();
+        case 3:
+            if (v.fields[0]) {
+                return "true";
+            }
+            else {
+                return "false";
+            }
+        case 4:
+            return v.fields[0];
+        case 5: {
+            const arg = join(";", map(valueToInterpolationString, v.fields[0]));
+            return toText(printf("[%s]"))(arg);
+        }
+        case 6: {
+            const arg_1 = join(", ", map(valueToInterpolationString, v.fields[0]));
+            return toText(printf("(%s)"))(arg_1);
+        }
+        case 7: {
+            const arg_4 = join("; ", map((tupledArg) => {
+                const arg_3 = valueToInterpolationString(tupledArg[1]);
+                return toText(printf("%s = %s"))(tupledArg[0])(arg_3);
+            }, toList(v.fields[0])));
+            return toText(printf("{ %s }"))(arg_4);
+        }
+        case 8: {
+            const arg_7 = join("; ", map((tupledArg_1) => {
+                let arg_5;
+                const key = tupledArg_1[0];
+                arg_5 = ((key.tag === 1) ? int64ToString(key.fields[0]) : concat("\"", key.fields[0], "\""));
+                const arg_6 = valueToInterpolationString(tupledArg_1[1]);
+                return toText(printf("%s => %s"))(arg_5)(arg_6);
+            }, toList(v.fields[0])));
+            return toText(printf("map { %s }"))(arg_7);
+        }
+        case 9:
+            if (v.fields[0] != null) {
+                const value_2 = v.fields[0];
+                const arg_8 = valueToInterpolationString(value_2);
+                return toText(printf("Some %s"))(arg_8);
+            }
+            else {
+                return "None";
+            }
+        case 10:
+            if (v.fields[2] != null) {
+                const value_3 = v.fields[2];
+                const arg_10 = valueToInterpolationString(value_3);
+                return toText(printf("%s %s"))(v.fields[1])(arg_10);
+            }
+            else {
+                return v.fields[1];
+            }
+        case 12: {
+            const arg_11 = Types_typeToString(v.fields[0]);
+            return toText(printf("<type %s>"))(arg_11);
+        }
+        case 13:
+            return "<task>";
+        case 14:
+            return "<fun>";
+        case 11:
+            return toText(printf("<ctor %s>"))(v.fields[1]);
+        case 15:
+            return "<extern>";
+        default:
+            return "()";
+    }
+}
+
+function valueEquals(a_mut, b_mut) {
+    valueEquals:
+    while (true) {
+        const a = a_mut, b = b_mut;
+        let matchResult, x, y, x_1, y_1, x_2, y_2, x_3, y_3, xs, ys, xs_1, ys_1, xf, yf, xf_1, yf_1, x_8, y_8, cx, cy, px, py, tx, ty, tx_1, ty_1, tx_2, ty_2;
+        switch (a.tag) {
+            case 0: {
+                if (b.tag === 0) {
+                    matchResult = 0;
+                }
+                else {
+                    matchResult = 14;
+                }
+                break;
+            }
+            case 1: {
+                if (b.tag === 1) {
+                    matchResult = 1;
+                    x = a.fields[0];
+                    y = b.fields[0];
+                }
+                else {
+                    matchResult = 14;
+                }
+                break;
+            }
+            case 2: {
+                if (b.tag === 2) {
+                    matchResult = 2;
+                    x_1 = a.fields[0];
+                    y_1 = b.fields[0];
+                }
+                else {
+                    matchResult = 14;
+                }
+                break;
+            }
+            case 3: {
+                if (b.tag === 3) {
+                    matchResult = 3;
+                    x_2 = a.fields[0];
+                    y_2 = b.fields[0];
+                }
+                else {
+                    matchResult = 14;
+                }
+                break;
+            }
+            case 4: {
+                if (b.tag === 4) {
+                    matchResult = 4;
+                    x_3 = a.fields[0];
+                    y_3 = b.fields[0];
+                }
+                else {
+                    matchResult = 14;
+                }
+                break;
+            }
+            case 5: {
+                if (b.tag === 5) {
+                    matchResult = 5;
+                    xs = a.fields[0];
+                    ys = b.fields[0];
+                }
+                else {
+                    matchResult = 14;
+                }
+                break;
+            }
+            case 6: {
+                if (b.tag === 6) {
+                    matchResult = 6;
+                    xs_1 = a.fields[0];
+                    ys_1 = b.fields[0];
+                }
+                else {
+                    matchResult = 14;
+                }
+                break;
+            }
+            case 7: {
+                if (b.tag === 7) {
+                    matchResult = 7;
+                    xf = a.fields[0];
+                    yf = b.fields[0];
+                }
+                else {
+                    matchResult = 14;
+                }
+                break;
+            }
+            case 8: {
+                if (b.tag === 8) {
+                    matchResult = 8;
+                    xf_1 = a.fields[0];
+                    yf_1 = b.fields[0];
+                }
+                else {
+                    matchResult = 14;
+                }
+                break;
+            }
+            case 9: {
+                if (a.fields[0] != null) {
+                    if (b.tag === 9) {
+                        if (b.fields[0] != null) {
+                            matchResult = 10;
+                            x_8 = a.fields[0];
+                            y_8 = b.fields[0];
+                        }
+                        else {
+                            matchResult = 14;
+                        }
+                    }
+                    else {
+                        matchResult = 14;
+                    }
+                }
+                else if (b.tag === 9) {
+                    if (b.fields[0] == null) {
+                        matchResult = 9;
+                    }
+                    else {
+                        matchResult = 14;
+                    }
+                }
+                else {
+                    matchResult = 14;
+                }
+                break;
+            }
+            case 10: {
+                if (b.tag === 10) {
+                    matchResult = 11;
+                    cx = a.fields[1];
+                    cy = b.fields[1];
+                    px = a.fields[2];
+                    py = b.fields[2];
+                    tx = a.fields[0];
+                    ty = b.fields[0];
+                }
+                else {
+                    matchResult = 14;
+                }
+                break;
+            }
+            case 12: {
+                if (b.tag === 12) {
+                    matchResult = 12;
+                    tx_1 = a.fields[0];
+                    ty_1 = b.fields[0];
+                }
+                else {
+                    matchResult = 14;
+                }
+                break;
+            }
+            case 13: {
+                if (b.tag === 13) {
+                    matchResult = 13;
+                    tx_2 = a.fields[0];
+                    ty_2 = b.fields[0];
+                }
+                else {
+                    matchResult = 14;
+                }
+                break;
+            }
+            default:
+                matchResult = 14;
+        }
+        switch (matchResult) {
+            case 0:
+                return true;
+            case 1:
+                return equals(x, y);
+            case 2:
+                return x_1 === y_1;
+            case 3:
+                return x_2 === y_2;
+            case 4:
+                return x_3 === y_3;
+            case 5:
+                if (length(xs) === length(ys)) {
+                    return forAll2(valueEquals, xs, ys);
+                }
+                else {
+                    return false;
+                }
+            case 6:
+                if (length(xs_1) === length(ys_1)) {
+                    return forAll2(valueEquals, xs_1, ys_1);
+                }
+                else {
+                    return false;
+                }
+            case 7:
+                if ((FSharpMap__get_Count(xf) === FSharpMap__get_Count(yf)) && ofSeq(FSharpMap__get_Keys(xf), {
+                    Compare: (x_4, y_4) => (comparePrimitives(x_4, y_4) | 0),
+                }).Equals(ofSeq(FSharpMap__get_Keys(yf), {
+                    Compare: (x_5, y_5) => (comparePrimitives(x_5, y_5) | 0),
+                }))) {
+                    return forAll((k, xv) => valueEquals(xv, FSharpMap__get_Item(yf, k)), xf);
+                }
+                else {
+                    return false;
+                }
+            case 8:
+                if ((FSharpMap__get_Count(xf_1) === FSharpMap__get_Count(yf_1)) && ofSeq(FSharpMap__get_Keys(xf_1), {
+                    Compare: (x_6, y_6) => (compare(x_6, y_6) | 0),
+                }).Equals(ofSeq(FSharpMap__get_Keys(yf_1), {
+                    Compare: (x_7, y_7) => (compare(x_7, y_7) | 0),
+                }))) {
+                    return forAll((k_1, xv_1) => valueEquals(xv_1, FSharpMap__get_Item(yf_1, k_1)), xf_1);
+                }
+                else {
+                    return false;
+                }
+            case 9:
+                return true;
+            case 10: {
+                a_mut = x_8;
+                b_mut = y_8;
+                continue valueEquals;
+            }
+            case 11:
+                if ((tx === ty) && (cx === cy)) {
+                    let matchResult_1, xv_2, yv;
+                    if (px != null) {
+                        if (py != null) {
+                            matchResult_1 = 1;
+                            xv_2 = px;
+                            yv = py;
+                        }
+                        else {
+                            matchResult_1 = 2;
+                        }
+                    }
+                    else if (py == null) {
+                        matchResult_1 = 0;
+                    }
+                    else {
+                        matchResult_1 = 2;
+                    }
+                    switch (matchResult_1) {
+                        case 0:
+                            return true;
+                        case 1: {
+                            a_mut = xv_2;
+                            b_mut = yv;
+                            continue valueEquals;
+                        }
+                        default:
+                            return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+            case 12:
+                return equals_1(tx_1, ty_1);
+            case 13:
+                return tx_2 === ty_2;
+            default:
+                return false;
+        }
+        break;
+    }
+}
+
+function mapKeyToValue(key) {
+    if (key.tag === 1) {
+        return new Value(1, [key.fields[0]]);
+    }
+    else {
+        return new Value(4, [key.fields[0]]);
+    }
+}
+
+function valueToMapKey(span, value) {
+    switch (value.tag) {
+        case 4:
+            return new MapKey(0, [value.fields[0]]);
+        case 1:
+            return new MapKey(1, [value.fields[0]]);
+        default:
+            throw new EvalException(new EvalError$("Map key must be string or int", span));
+    }
+}
+
+function valueMatchesTypeRef(typeDefs, tref, value) {
+    const resolve = (tref_1) => {
+        switch (tref_1.tag) {
+            case 1:
+                return map_1((Item) => (new Type(7, [Item])), resolveTypeList(tref_1.fields[0]));
+            case 2:
+                return undefined;
+            case 3:
+                switch (tref_1.fields[1]) {
+                    case "list":
+                        return map_1((Item_1) => (new Type(5, [Item_1])), resolve(tref_1.fields[0]));
+                    case "task":
+                        return map_1((Item_2) => (new Type(6, [Item_2])), resolve(tref_1.fields[0]));
+                    case "option":
+                        return map_1((Item_3) => (new Type(10, [Item_3])), resolve(tref_1.fields[0]));
+                    case "map":
+                        return map_1((t) => (new Type(9, [new Type(4, []), t])), resolve(tref_1.fields[0]));
+                    default:
+                        return undefined;
+                }
+            case 4: {
+                const shape = map_1((elements) => ofList(elements, {
+                    Compare: (x, y) => (comparePrimitives(x, y) | 0),
+                }), resolveFieldList(tref_1.fields[0]));
+                if (shape != null) {
+                    const s = shape;
+                    return tryPick((tupledArg) => {
+                        const t_1 = tupledArg[1];
+                        let matchResult, f_1;
+                        if (t_1.tag === 8) {
+                            if (t_1.fields[0].Equals(s)) {
+                                matchResult = 0;
+                                f_1 = t_1.fields[0];
+                            }
+                            else {
+                                matchResult = 1;
+                            }
+                        }
+                        else {
+                            matchResult = 1;
+                        }
+                        switch (matchResult) {
+                            case 0:
+                                return new Type(12, [tupledArg[0]]);
+                            default:
+                                return undefined;
+                        }
+                    }, toSeq(typeDefs));
+                }
+                else {
+                    return undefined;
+                }
+            }
+            case 5:
+                return map_1((arg) => (new Type(8, [ofList(arg, {
+                    Compare: (x_1, y_1) => (comparePrimitives(x_1, y_1) | 0),
+                })])), resolveFieldList(tref_1.fields[0]));
+            default:
+                switch (tref_1.fields[0]) {
+                    case "unit":
+                        return new Type(0, []);
+                    case "int":
+                        return new Type(1, []);
+                    case "float":
+                        return new Type(2, []);
+                    case "bool":
+                        return new Type(3, []);
+                    case "string":
+                        return new Type(4, []);
+                    default:
+                        return tryFind(tref_1.fields[0], typeDefs);
+                }
+        }
+    };
+    const resolveTypeList = (items) => {
+        if (!isEmpty(items)) {
+            const matchValue = resolve(head_2(items));
+            const matchValue_1 = resolveTypeList(tail_2(items));
+            let matchResult_1, h, t_2;
+            if (matchValue != null) {
+                if (matchValue_1 != null) {
+                    matchResult_1 = 0;
+                    h = matchValue;
+                    t_2 = matchValue_1;
+                }
+                else {
+                    matchResult_1 = 1;
+                }
+            }
+            else {
+                matchResult_1 = 1;
+            }
+            switch (matchResult_1) {
+                case 0:
+                    return cons(h, t_2);
+                default:
+                    return undefined;
+            }
+        }
+        else {
+            return empty();
+        }
+    };
+    const resolveFieldList = (fields_2) => {
+        if (!isEmpty(fields_2)) {
+            const matchValue_3 = resolve(head_2(fields_2)[1]);
+            const matchValue_4 = resolveFieldList(tail_2(fields_2));
+            let matchResult_2, rest, t_3;
+            if (matchValue_3 != null) {
+                if (matchValue_4 != null) {
+                    matchResult_2 = 0;
+                    rest = matchValue_4;
+                    t_3 = matchValue_3;
+                }
+                else {
+                    matchResult_2 = 1;
+                }
+            }
+            else {
+                matchResult_2 = 1;
+            }
+            switch (matchResult_2) {
+                case 0:
+                    return cons([head_2(fields_2)[0], t_3], rest);
+                default:
+                    return undefined;
+            }
+        }
+        else {
+            return empty();
+        }
+    };
+    const valueHasType = (value_1_mut, t_4_mut) => {
+        valueHasType:
+        while (true) {
+            const value_1 = value_1_mut, t_4 = t_4_mut;
+            let matchResult_3, inner_4, items_1, inner_5, items_2, inner_6, inner_7, v_1, fields_3, values, name_4, v_2;
+            switch (t_4.tag) {
+                case 0: {
+                    if (value_1.tag === 0) {
+                        matchResult_3 = 0;
+                    }
+                    else {
+                        matchResult_3 = 13;
+                    }
+                    break;
+                }
+                case 1: {
+                    if (value_1.tag === 1) {
+                        matchResult_3 = 1;
+                    }
+                    else {
+                        matchResult_3 = 13;
+                    }
+                    break;
+                }
+                case 2: {
+                    if (value_1.tag === 2) {
+                        matchResult_3 = 2;
+                    }
+                    else {
+                        matchResult_3 = 13;
+                    }
+                    break;
+                }
+                case 3: {
+                    if (value_1.tag === 3) {
+                        matchResult_3 = 3;
+                    }
+                    else {
+                        matchResult_3 = 13;
+                    }
+                    break;
+                }
+                case 4: {
+                    if (value_1.tag === 4) {
+                        matchResult_3 = 4;
+                    }
+                    else {
+                        matchResult_3 = 13;
+                    }
+                    break;
+                }
+                case 5: {
+                    if (value_1.tag === 5) {
+                        matchResult_3 = 5;
+                        inner_4 = t_4.fields[0];
+                        items_1 = value_1.fields[0];
+                    }
+                    else {
+                        matchResult_3 = 13;
+                    }
+                    break;
+                }
+                case 6: {
+                    if (value_1.tag === 13) {
+                        matchResult_3 = 6;
+                    }
+                    else {
+                        matchResult_3 = 13;
+                    }
+                    break;
+                }
+                case 7: {
+                    if (value_1.tag === 6) {
+                        matchResult_3 = 7;
+                        inner_5 = t_4.fields[0];
+                        items_2 = value_1.fields[0];
+                    }
+                    else {
+                        matchResult_3 = 13;
+                    }
+                    break;
+                }
+                case 10: {
+                    if (value_1.tag === 9) {
+                        if (value_1.fields[0] != null) {
+                            matchResult_3 = 9;
+                            inner_7 = t_4.fields[0];
+                            v_1 = value_1.fields[0];
+                        }
+                        else {
+                            matchResult_3 = 8;
+                            inner_6 = t_4.fields[0];
+                        }
+                    }
+                    else {
+                        matchResult_3 = 13;
+                    }
+                    break;
+                }
+                case 9: {
+                    if (value_1.tag === 8) {
+                        matchResult_3 = 10;
+                    }
+                    else {
+                        matchResult_3 = 13;
+                    }
+                    break;
+                }
+                case 8: {
+                    if (value_1.tag === 7) {
+                        matchResult_3 = 11;
+                        fields_3 = t_4.fields[0];
+                        values = value_1.fields[0];
+                    }
+                    else {
+                        matchResult_3 = 13;
+                    }
+                    break;
+                }
+                case 12: {
+                    matchResult_3 = 12;
+                    name_4 = t_4.fields[0];
+                    v_2 = value_1;
+                    break;
+                }
+                default:
+                    matchResult_3 = 13;
+            }
+            switch (matchResult_3) {
+                case 0:
+                    return true;
+                case 1:
+                    return true;
+                case 2:
+                    return true;
+                case 3:
+                    return true;
+                case 4:
+                    return true;
+                case 5:
+                    return forAll_1((v) => valueHasType(v, inner_4), items_1);
+                case 6:
+                    return true;
+                case 7:
+                    if (length(inner_5) === length(items_2)) {
+                        return forAll2(valueHasType, items_2, inner_5);
+                    }
+                    else {
+                        return false;
+                    }
+                case 8:
+                    return true;
+                case 9: {
+                    value_1_mut = v_1;
+                    t_4_mut = inner_7;
+                    continue valueHasType;
+                }
+                case 10:
+                    return true;
+                case 11:
+                    return forAll((name_3, ft) => {
+                        const matchValue_7 = FSharpMap__TryFind(values, name_3);
+                        if (matchValue_7 == null) {
+                            return false;
+                        }
+                        else {
+                            return valueHasType(matchValue_7, ft);
+                        }
+                    }, fields_3);
+                case 12: {
+                    const matchValue_8 = FSharpMap__TryFind(typeDefs, name_4);
+                    if (matchValue_8 == null) {
+                        return false;
+                    }
+                    else {
+                        value_1_mut = v_2;
+                        t_4_mut = matchValue_8;
+                        continue valueHasType;
+                    }
+                }
+                default:
+                    return false;
+            }
+            break;
+        }
+    };
+    switch (tref.tag) {
+        case 4: {
+            const matchValue_9 = resolve(tref);
+            if (matchValue_9 == null) {
+                return false;
+            }
+            else {
+                return valueHasType(value, matchValue_9);
+            }
+        }
+        case 5: {
+            const matchValue_10 = resolve(new TypeRef(5, [tref.fields[0]]));
+            if (matchValue_10 == null) {
+                return false;
+            }
+            else {
+                return valueHasType(value, matchValue_10);
+            }
+        }
+        default: {
+            const matchValue_11 = resolve(tref);
+            if (matchValue_11 == null) {
+                return false;
+            }
+            else {
+                return valueHasType(value, matchValue_11);
+            }
+        }
+    }
+}
+
+function patternMatch(typeDefs_mut, pat_mut, value_mut) {
+    patternMatch:
+    while (true) {
+        const typeDefs = typeDefs_mut, pat = pat_mut, value = value_mut;
+        const mergeBindings = (left, right) => {
+            let ok = true;
+            let merged = left;
+            const enumerator = getEnumerator(right);
+            try {
+                while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                    const activePatternResult = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const v = activePatternResult[1];
+                    const k = activePatternResult[0];
+                    const matchValue = FSharpMap__TryFind(merged, k);
+                    if (matchValue == null) {
+                        merged = add(k, v, merged);
+                    }
+                    else if (!valueEquals(matchValue, v)) {
+                        const existing_1 = matchValue;
+                        ok = false;
+                    }
+                }
+            }
+            finally {
+                disposeSafe(enumerator);
+            }
+            if (ok) {
+                return merged;
+            }
+            else {
+                return undefined;
+            }
+        };
+        const matchMapClauses = (hasExplicitClauses_mut, clauses_mut, tailPattern_mut, remaining_mut, envAcc_mut) => {
+            matchMapClauses:
+            while (true) {
+                const hasExplicitClauses = hasExplicitClauses_mut, clauses = clauses_mut, tailPattern = tailPattern_mut, remaining = remaining_mut, envAcc = envAcc_mut;
+                if (!isEmpty(clauses)) {
+                    const valuePattern = head_2(clauses)[1];
+                    const rest = tail_2(clauses);
+                    const keyPattern = head_2(clauses)[0];
+                    if (keyPattern.tag === 1) {
+                        if (!FSharpMap__ContainsKey(envAcc, keyPattern.fields[0])) {
+                            if (FSharpMap__get_IsEmpty(remaining)) {
+                                return undefined;
+                            }
+                            else {
+                                const head = head_3(remaining);
+                                const key = head[0];
+                                const nextRemaining = FSharpMap__Remove(remaining, key);
+                                const matchValue_2 = patternMatch(typeDefs, keyPattern, mapKeyToValue(key));
+                                const matchValue_3 = patternMatch(typeDefs, valuePattern, head[1]);
+                                let matchResult, keyEnv, valueEnv;
+                                if (matchValue_2 != null) {
+                                    if (matchValue_3 != null) {
+                                        matchResult = 0;
+                                        keyEnv = matchValue_2;
+                                        valueEnv = matchValue_3;
+                                    }
+                                    else {
+                                        matchResult = 1;
+                                    }
+                                }
+                                else {
+                                    matchResult = 1;
+                                }
+                                switch (matchResult) {
+                                    case 0: {
+                                        const matchValue_5 = mergeBindings(envAcc, keyEnv);
+                                        if (matchValue_5 == null) {
+                                            return undefined;
+                                        }
+                                        else {
+                                            const matchValue_6 = mergeBindings(matchValue_5, valueEnv);
+                                            if (matchValue_6 == null) {
+                                                return undefined;
+                                            }
+                                            else {
+                                                hasExplicitClauses_mut = hasExplicitClauses;
+                                                clauses_mut = rest;
+                                                tailPattern_mut = tailPattern;
+                                                remaining_mut = nextRemaining;
+                                                envAcc_mut = matchValue_6;
+                                                continue matchMapClauses;
+                                            }
+                                        }
+                                    }
+                                    default:
+                                        return undefined;
+                                }
+                            }
+                        }
+                        else {
+                            const matchValue_7 = FSharpMap__TryFind(envAcc, keyPattern.fields[0]);
+                            if (matchValue_7 != null) {
+                                const targetKeyValue = matchValue_7;
+                                let targetKey;
+                                switch (targetKeyValue.tag) {
+                                    case 4: {
+                                        targetKey = (new MapKey(0, [targetKeyValue.fields[0]]));
+                                        break;
+                                    }
+                                    case 1: {
+                                        targetKey = (new MapKey(1, [targetKeyValue.fields[0]]));
+                                        break;
+                                    }
+                                    default:
+                                        throw new EvalException(new EvalError$("Map key must be string or int", Ast_spanOfPattern(keyPattern)));
+                                }
+                                if (!FSharpMap__ContainsKey(remaining, targetKey)) {
+                                    return undefined;
+                                }
+                                else {
+                                    const matchValue_8 = patternMatch(typeDefs, valuePattern, FSharpMap__get_Item(remaining, targetKey));
+                                    if (matchValue_8 == null) {
+                                        return undefined;
+                                    }
+                                    else {
+                                        const matchValue_9 = mergeBindings(envAcc, matchValue_8);
+                                        if (matchValue_9 == null) {
+                                            return undefined;
+                                        }
+                                        else {
+                                            const merged_1 = matchValue_9;
+                                            hasExplicitClauses_mut = hasExplicitClauses;
+                                            clauses_mut = rest;
+                                            tailPattern_mut = tailPattern;
+                                            remaining_mut = FSharpMap__Remove(remaining, targetKey);
+                                            envAcc_mut = merged_1;
+                                            continue matchMapClauses;
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                return undefined;
+                            }
+                        }
+                    }
+                    else {
+                        return bind((tupledArg) => matchMapClauses(hasExplicitClauses, rest, tailPattern, FSharpMap__Remove(remaining, tupledArg[0]), tupledArg[1]), tryPick((kv) => {
+                            const matchValue_10 = patternMatch(typeDefs, keyPattern, mapKeyToValue(kv[0]));
+                            if (matchValue_10 == null) {
+                                return undefined;
+                            }
+                            else {
+                                const matchValue_11 = mergeBindings(envAcc, matchValue_10);
+                                if (matchValue_11 == null) {
+                                    return undefined;
+                                }
+                                else {
+                                    const merged1_1 = matchValue_11;
+                                    const matchValue_12 = patternMatch(typeDefs, valuePattern, kv[1]);
+                                    if (matchValue_12 == null) {
+                                        return undefined;
+                                    }
+                                    else {
+                                        const matchValue_13 = mergeBindings(merged1_1, matchValue_12);
+                                        if (matchValue_13 == null) {
+                                            return undefined;
+                                        }
+                                        else {
+                                            return [kv[0], matchValue_13];
+                                        }
+                                    }
+                                }
+                            }
+                        }, remaining));
+                    }
+                }
+                else if (tailPattern == null) {
+                    if (hasExplicitClauses ? true : FSharpMap__get_IsEmpty(remaining)) {
+                        return envAcc;
+                    }
+                    else {
+                        return undefined;
+                    }
+                }
+                else {
+                    const matchValue_1 = patternMatch(typeDefs, tailPattern, new Value(8, [remaining]));
+                    if (matchValue_1 == null) {
+                        return undefined;
+                    }
+                    else {
+                        return mergeBindings(envAcc, matchValue_1);
+                    }
+                }
+                break;
+            }
+        };
+        let matchResult_1, name_3, v_1, lit, v_2, h, p1, p2, t, patterns_1, values_1, fields, values_2, clauses_1, tailPattern_1, values_3, p_2, v_6, caseName, payload, qualifier, valueCaseName, valuePayload, valueTypeName, tref, v_8;
+        switch (pat.tag) {
+            case 1: {
+                matchResult_1 = 1;
+                name_3 = pat.fields[0];
+                v_1 = value;
+                break;
+            }
+            case 2: {
+                matchResult_1 = 2;
+                lit = pat.fields[0];
+                v_2 = value;
+                break;
+            }
+            case 3: {
+                if (value.tag === 5) {
+                    if (isEmpty(value.fields[0])) {
+                        matchResult_1 = 3;
+                    }
+                    else {
+                        matchResult_1 = 12;
+                    }
+                }
+                else {
+                    matchResult_1 = 12;
+                }
+                break;
+            }
+            case 4: {
+                if (value.tag === 5) {
+                    if (!isEmpty(value.fields[0])) {
+                        matchResult_1 = 4;
+                        h = head_2(value.fields[0]);
+                        p1 = pat.fields[0];
+                        p2 = pat.fields[1];
+                        t = tail_2(value.fields[0]);
+                    }
+                    else {
+                        matchResult_1 = 12;
+                    }
+                }
+                else {
+                    matchResult_1 = 12;
+                }
+                break;
+            }
+            case 5: {
+                if (value.tag === 6) {
+                    if (length(pat.fields[0]) === length(value.fields[0])) {
+                        matchResult_1 = 5;
+                        patterns_1 = pat.fields[0];
+                        values_1 = value.fields[0];
+                    }
+                    else {
+                        matchResult_1 = 12;
+                    }
+                }
+                else {
+                    matchResult_1 = 12;
+                }
+                break;
+            }
+            case 6: {
+                if (value.tag === 7) {
+                    matchResult_1 = 6;
+                    fields = pat.fields[0];
+                    values_2 = value.fields[0];
+                }
+                else {
+                    matchResult_1 = 12;
+                }
+                break;
+            }
+            case 7: {
+                if (value.tag === 8) {
+                    matchResult_1 = 7;
+                    clauses_1 = pat.fields[0];
+                    tailPattern_1 = pat.fields[1];
+                    values_3 = value.fields[0];
+                }
+                else {
+                    matchResult_1 = 12;
+                }
+                break;
+            }
+            case 8: {
+                if (value.tag === 9) {
+                    if (value.fields[0] != null) {
+                        matchResult_1 = 8;
+                        p_2 = pat.fields[0];
+                        v_6 = value.fields[0];
+                    }
+                    else {
+                        matchResult_1 = 12;
+                    }
+                }
+                else {
+                    matchResult_1 = 12;
+                }
+                break;
+            }
+            case 9: {
+                if (value.tag === 9) {
+                    if (value.fields[0] == null) {
+                        matchResult_1 = 9;
+                    }
+                    else {
+                        matchResult_1 = 12;
+                    }
+                }
+                else {
+                    matchResult_1 = 12;
+                }
+                break;
+            }
+            case 10: {
+                if (value.tag === 10) {
+                    matchResult_1 = 10;
+                    caseName = pat.fields[1];
+                    payload = pat.fields[2];
+                    qualifier = pat.fields[0];
+                    valueCaseName = value.fields[1];
+                    valuePayload = value.fields[2];
+                    valueTypeName = value.fields[0];
+                }
+                else {
+                    matchResult_1 = 12;
+                }
+                break;
+            }
+            case 11: {
+                matchResult_1 = 11;
+                tref = pat.fields[0];
+                v_8 = value;
+                break;
+            }
+            default:
+                matchResult_1 = 0;
+        }
+        switch (matchResult_1) {
+            case 0:
+                return empty_1({
+                    Compare: (x, y) => (comparePrimitives(x, y) | 0),
+                });
+            case 1:
+                return ofList(singleton([name_3, v_1]), {
+                    Compare: (x_1, y_1) => (comparePrimitives(x_1, y_1) | 0),
+                });
+            case 2:
+                if (valueEquals(literalToValue(lit), v_2)) {
+                    return empty_1({
+                        Compare: (x_2, y_2) => (comparePrimitives(x_2, y_2) | 0),
+                    });
+                }
+                else {
+                    return undefined;
+                }
+            case 3:
+                return empty_1({
+                    Compare: (x_3, y_3) => (comparePrimitives(x_3, y_3) | 0),
+                });
+            case 4: {
+                const matchValue_15 = patternMatch(typeDefs, p1, h);
+                const matchValue_16 = patternMatch(typeDefs, p2, new Value(5, [t]));
+                let matchResult_2, env1, env2;
+                if (matchValue_15 != null) {
+                    if (matchValue_16 != null) {
+                        matchResult_2 = 0;
+                        env1 = matchValue_15;
+                        env2 = matchValue_16;
+                    }
+                    else {
+                        matchResult_2 = 1;
+                    }
+                }
+                else {
+                    matchResult_2 = 1;
+                }
+                switch (matchResult_2) {
+                    case 0:
+                        return fold((acc, k_1, v_3) => add(k_1, v_3, acc), env1, env2);
+                    default:
+                        return undefined;
+                }
+            }
+            case 5:
+                return fold_1((accOpt, tupledArg_1) => {
+                    const matchValue_18 = patternMatch(typeDefs, tupledArg_1[0], tupledArg_1[1]);
+                    let matchResult_3, acc_1, next;
+                    if (accOpt != null) {
+                        if (matchValue_18 != null) {
+                            matchResult_3 = 0;
+                            acc_1 = accOpt;
+                            next = matchValue_18;
+                        }
+                        else {
+                            matchResult_3 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_3 = 1;
+                    }
+                    switch (matchResult_3) {
+                        case 0:
+                            return fold((state, k_2, value_3) => add(k_2, value_3, state), acc_1, next);
+                        default:
+                            return undefined;
+                    }
+                }, empty_1({
+                    Compare: (x_4, y_4) => (comparePrimitives(x_4, y_4) | 0),
+                }), zip(patterns_1, values_1));
+            case 6:
+                return fold_1((accOpt_1, tupledArg_2) => {
+                    const matchValue_20 = FSharpMap__TryFind(values_2, tupledArg_2[0]);
+                    let matchResult_4, acc_2, value_4;
+                    if (accOpt_1 != null) {
+                        if (matchValue_20 != null) {
+                            matchResult_4 = 0;
+                            acc_2 = accOpt_1;
+                            value_4 = matchValue_20;
+                        }
+                        else {
+                            matchResult_4 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_4 = 1;
+                    }
+                    switch (matchResult_4) {
+                        case 0: {
+                            const matchValue_22 = patternMatch(typeDefs, tupledArg_2[1], value_4);
+                            if (matchValue_22 == null) {
+                                return undefined;
+                            }
+                            else {
+                                return fold((state_2, k_3, v_5) => add(k_3, v_5, state_2), acc_2, matchValue_22);
+                            }
+                        }
+                        default:
+                            return undefined;
+                    }
+                }, empty_1({
+                    Compare: (x_5, y_5) => (comparePrimitives(x_5, y_5) | 0),
+                }), fields);
+            case 7:
+                return matchMapClauses(!isEmpty(clauses_1), clauses_1, tailPattern_1, values_3, empty_1({
+                    Compare: (x_6, y_6) => (comparePrimitives(x_6, y_6) | 0),
+                }));
+            case 8: {
+                typeDefs_mut = typeDefs;
+                pat_mut = p_2;
+                value_mut = v_6;
+                continue patternMatch;
+            }
+            case 9:
+                return empty_1({
+                    Compare: (x_7, y_7) => (comparePrimitives(x_7, y_7) | 0),
+                });
+            case 10:
+                if ((caseName === valueCaseName) && ((qualifier == null) ? true : (qualifier === valueTypeName))) {
+                    let matchResult_5, p_3, v_7;
+                    if (payload != null) {
+                        if (valuePayload != null) {
+                            matchResult_5 = 1;
+                            p_3 = payload;
+                            v_7 = valuePayload;
+                        }
+                        else {
+                            matchResult_5 = 2;
+                        }
+                    }
+                    else if (valuePayload == null) {
+                        matchResult_5 = 0;
+                    }
+                    else {
+                        matchResult_5 = 2;
+                    }
+                    switch (matchResult_5) {
+                        case 0:
+                            return empty_1({
+                                Compare: (x_8, y_8) => (comparePrimitives(x_8, y_8) | 0),
+                            });
+                        case 1: {
+                            typeDefs_mut = typeDefs;
+                            pat_mut = p_3;
+                            value_mut = v_7;
+                            continue patternMatch;
+                        }
+                        default:
+                            return undefined;
+                    }
+                }
+                else {
+                    return undefined;
+                }
+            case 11:
+                if (valueMatchesTypeRef(typeDefs, tref, v_8)) {
+                    return empty_1({
+                        Compare: (x_9, y_9) => (comparePrimitives(x_9, y_9) | 0),
+                    });
+                }
+                else {
+                    return undefined;
+                }
+            default:
+                return undefined;
+        }
+        break;
+    }
+}
+
+function createExternContext(runtime, typeDefs, span) {
+    return new ExternalCallContext((fnValue, argValue) => applyFunctionValue(runtime, evalExpr, typeDefs, span, fnValue, argValue), (thunk) => spawnTaskValue(runtime, typeDefs, thunk), (taskValue) => awaitTaskValue(runtime, taskValue), () => {
+        raiseIfBackgroundFailed(runtime);
+    });
+}
+
+function spawnTaskValue(runtime, typeDefs, thunk) {
+    raiseIfBackgroundFailed(runtime);
+    throw new EvalException(new EvalError$("Task.spawn is not supported in Fable builds", unknownSpan));
+}
+
+function awaitTaskValue(runtime, taskValue) {
+    raiseIfBackgroundFailed(runtime);
+    throw new EvalException(new EvalError$("Task.await is not supported in Fable builds", unknownSpan));
+}
+
+function applyFunctionValue(runtime, eval$, typeDefs, span, fnValue, argValue) {
+    raiseIfBackgroundFailed(runtime);
+    switch (fnValue.tag) {
+        case 14:
+            return eval$(runtime, typeDefs, add(fnValue.fields[0], argValue, fnValue.fields[2].contents), fnValue.fields[1]);
+        case 11:
+            return new Value(10, [fnValue.fields[0], fnValue.fields[1], argValue]);
+        case 15: {
+            const ext = fnValue.fields[0];
+            const args$0027 = cons(argValue, fnValue.fields[1]);
+            if (length(args$0027) === ext.Arity) {
+                return ext.Impl(createExternContext(runtime, typeDefs, span), reverse(args$0027));
+            }
+            else if (length(args$0027) < ext.Arity) {
+                return new Value(15, [ext, args$0027]);
+            }
+            else {
+                throw new EvalException(new EvalError$(toText(printf("External function \'%s\' received too many arguments"))(ext.Name), span));
+            }
+        }
+        default:
+            throw new EvalException(new EvalError$("Attempted to apply non-function", span));
+    }
+}
+
+function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
+    evalExpr:
+    while (true) {
+        const runtime = runtime_mut, typeDefs = typeDefs_mut, env = env_mut, expr = expr_mut;
+        raiseIfBackgroundFailed(runtime);
+        switch (expr.tag) {
+            case 1:
+                return literalToValue(expr.fields[0]);
+            case 2: {
+                const name = expr.fields[0];
+                const matchValue = tryFind(name, env);
+                if (matchValue == null) {
+                    throw new EvalException(new EvalError$(toText(printf("Unbound variable \'%s\'"))(name), expr.fields[1]));
+                }
+                else {
+                    return matchValue;
+                }
+            }
+            case 3: {
+                runtime_mut = runtime;
+                typeDefs_mut = typeDefs;
+                env_mut = env;
+                expr_mut = expr.fields[0];
+                continue evalExpr;
+            }
+            case 4:
+                return new Value(14, [expr.fields[0].Name, expr.fields[1], new FSharpRef(env)]);
+            case 5:
+                return applyFunctionValue(runtime, evalExpr, typeDefs, expr.fields[2], evalExpr(runtime, typeDefs, env, expr.fields[0]), evalExpr(runtime, typeDefs, env, expr.fields[1]));
+            case 6: {
+                const matchValue_1 = evalExpr(runtime, typeDefs, env, expr.fields[0]);
+                if (matchValue_1.tag === 3) {
+                    if (matchValue_1.fields[0]) {
+                        runtime_mut = runtime;
+                        typeDefs_mut = typeDefs;
+                        env_mut = env;
+                        expr_mut = expr.fields[1];
+                        continue evalExpr;
+                    }
+                    else {
+                        runtime_mut = runtime;
+                        typeDefs_mut = typeDefs;
+                        env_mut = env;
+                        expr_mut = expr.fields[2];
+                        continue evalExpr;
+                    }
+                }
+                else {
+                    throw new EvalException(new EvalError$("Condition must be bool", expr.fields[3]));
+                }
+            }
+            case 7: {
+                const span_3 = expr.fields[1];
+                const matchValue_2 = evalExpr(runtime, typeDefs, env, expr.fields[0]);
+                if (matchValue_2.tag === 4) {
+                    throw new EvalException(new EvalError$(matchValue_2.fields[0], span_3));
+                }
+                else {
+                    throw new EvalException(new EvalError$("raise expects a string", span_3));
+                }
+            }
+            case 8: {
+                const matchValue_3 = evalExpr(runtime, typeDefs, env, expr.fields[1]);
+                if (matchValue_3.tag === 5) {
+                    const enumerator = getEnumerator(matchValue_3.fields[0]);
+                    try {
+                        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                            evalExpr(runtime, typeDefs, add(expr.fields[0], enumerator["System.Collections.Generic.IEnumerator`1.get_Current"](), env), expr.fields[2]);
+                        }
+                    }
+                    finally {
+                        disposeSafe(enumerator);
+                    }
+                    return new Value(0, []);
+                }
+                else {
+                    throw new EvalException(new EvalError$("For loop source must be list", expr.fields[3]));
+                }
+            }
+            case 10: {
+                const value_1 = expr.fields[1];
+                const name_2 = expr.fields[0];
+                const body_2 = expr.fields[2];
+                if (expr.fields[3]) {
+                    if (value_1.tag === 4) {
+                        const recEnv = new FSharpRef(env);
+                        recEnv.contents = add(name_2, new Value(14, [value_1.fields[0].Name, value_1.fields[1], recEnv]), env);
+                        runtime_mut = runtime;
+                        typeDefs_mut = typeDefs;
+                        env_mut = recEnv.contents;
+                        expr_mut = body_2;
+                        continue evalExpr;
+                    }
+                    else {
+                        throw new EvalException(new EvalError$("let rec requires a function binding", expr.fields[5]));
+                    }
+                }
+                else {
+                    runtime_mut = runtime;
+                    typeDefs_mut = typeDefs;
+                    env_mut = add(name_2, evalExpr(runtime, typeDefs, env, value_1), env);
+                    expr_mut = body_2;
+                    continue evalExpr;
+                }
+            }
+            case 11: {
+                const matchValue_4 = patternMatch(typeDefs, expr.fields[0], evalExpr(runtime, typeDefs, env, expr.fields[1]));
+                if (matchValue_4 == null) {
+                    throw new EvalException(new EvalError$("Let pattern did not match value", expr.fields[3]));
+                }
+                else {
+                    runtime_mut = runtime;
+                    typeDefs_mut = typeDefs;
+                    env_mut = fold((acc, k, value_3) => add(k, value_3, acc), env, matchValue_4);
+                    expr_mut = expr.fields[2];
+                    continue evalExpr;
+                }
+            }
+            case 12: {
+                const body_4 = expr.fields[1];
+                const bindings_1 = expr.fields[0];
+                if (isEmpty(bindings_1)) {
+                    runtime_mut = runtime;
+                    typeDefs_mut = typeDefs;
+                    env_mut = env;
+                    expr_mut = body_4;
+                    continue evalExpr;
+                }
+                else {
+                    const recEnv_1 = new FSharpRef(env);
+                    const finalEnv = fold_1((acc_1, tupledArg_1) => add(tupledArg_1[0], tupledArg_1[1], acc_1), env, map((tupledArg) => {
+                        const args = tupledArg[1];
+                        const bindingSpan = tupledArg[4];
+                        if (isEmpty(args)) {
+                            throw new EvalException(new EvalError$("\'let rec ... and ...\' requires function arguments for each binding", bindingSpan));
+                        }
+                        const folded = foldBack((arg_2, accExpr) => (new Expr(4, [arg_2, accExpr, bindingSpan])), args, tupledArg[3]);
+                        if (folded.tag === 4) {
+                            return [tupledArg[0], new Value(14, [folded.fields[0].Name, folded.fields[1], recEnv_1])];
+                        }
+                        else {
+                            throw new EvalException(new EvalError$("let rec requires a function binding", expr.fields[2]));
+                        }
+                    }, bindings_1));
+                    recEnv_1.contents = finalEnv;
+                    runtime_mut = runtime;
+                    typeDefs_mut = typeDefs;
+                    env_mut = finalEnv;
+                    expr_mut = body_4;
+                    continue evalExpr;
+                }
+            }
+            case 9: {
+                const span_8 = expr.fields[2];
+                const v_3 = evalExpr(runtime, typeDefs, env, expr.fields[0]);
+                const tryCases = (cs_mut) => {
+                    tryCases:
+                    while (true) {
+                        const cs = cs_mut;
+                        if (!isEmpty(cs)) {
+                            const rest = tail_2(cs);
+                            const guard = head_2(cs)[1];
+                            const body_5 = head_2(cs)[2];
+                            const matchValue_5 = patternMatch(typeDefs, head_2(cs)[0], v_3);
+                            if (matchValue_5 == null) {
+                                cs_mut = rest;
+                                continue tryCases;
+                            }
+                            else {
+                                const env$0027_3 = fold((acc_2, k_1, v_4) => add(k_1, v_4, acc_2), env, matchValue_5);
+                                if (guard == null) {
+                                    return evalExpr(runtime, typeDefs, env$0027_3, body_5);
+                                }
+                                else {
+                                    const matchValue_6 = evalExpr(runtime, typeDefs, env$0027_3, guard);
+                                    if (matchValue_6.tag === 3) {
+                                        if (matchValue_6.fields[0]) {
+                                            return evalExpr(runtime, typeDefs, env$0027_3, body_5);
+                                        }
+                                        else {
+                                            cs_mut = rest;
+                                            continue tryCases;
+                                        }
+                                    }
+                                    else {
+                                        throw new EvalException(new EvalError$("Match guard must evaluate to bool", span_8));
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            throw new EvalException(new EvalError$("No match cases matched", span_8));
+                        }
+                        break;
+                    }
+                };
+                return tryCases(expr.fields[1]);
+            }
+            case 13:
+                return new Value(5, [map((expr_2) => evalExpr(runtime, typeDefs, env, expr_2), expr.fields[0])]);
+            case 14: {
+                const startValue = evalExpr(runtime, typeDefs, env, expr.fields[0]);
+                const endValue = evalExpr(runtime, typeDefs, env, expr.fields[1]);
+                let matchResult, e, s;
+                if (startValue.tag === 1) {
+                    if (endValue.tag === 1) {
+                        matchResult = 0;
+                        e = endValue.fields[0];
+                        s = startValue.fields[0];
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+                switch (matchResult) {
+                    case 0: {
+                        const step = (compare_1(s, e) <= 0) ? (1n) : (-1n);
+                        const build = (acc_3_mut, current_mut) => {
+                            build:
+                            while (true) {
+                                const acc_3 = acc_3_mut, current = current_mut;
+                                if (((compare_1(step, 0n) > 0) && (compare_1(current, e) > 0)) ? true : ((compare_1(step, 0n) < 0) && (compare_1(current, e) < 0))) {
+                                    return reverse(acc_3);
+                                }
+                                else {
+                                    acc_3_mut = cons(new Value(1, [current]), acc_3);
+                                    current_mut = toInt64_unchecked(op_Addition(current, step));
+                                    continue build;
+                                }
+                                break;
+                            }
+                        };
+                        return new Value(5, [build(empty(), s)]);
+                    }
+                    default:
+                        throw new EvalException(new EvalError$("Range endpoints must be int", expr.fields[2]));
+                }
+            }
+            case 15:
+                return new Value(6, [map((expr_3) => evalExpr(runtime, typeDefs, env, expr_3), expr.fields[0])]);
+            case 16:
+                return new Value(7, [ofList(map((tupledArg_2) => [tupledArg_2[0], evalExpr(runtime, typeDefs, env, tupledArg_2[1])], expr.fields[0]), {
+                    Compare: (x, y) => (comparePrimitives(x, y) | 0),
+                })]);
+            case 17:
+                return new Value(7, [ofList(map((tupledArg_3) => [tupledArg_3[0], evalExpr(runtime, typeDefs, env, tupledArg_3[1])], expr.fields[0]), {
+                    Compare: (x_1, y_1) => (comparePrimitives(x_1, y_1) | 0),
+                })]);
+            case 18:
+                return new Value(8, [fold_1((acc_4, entry) => {
+                    if (entry.tag === 1) {
+                        const spreadExpr = entry.fields[0];
+                        const matchValue_8 = evalExpr(runtime, typeDefs, env, spreadExpr);
+                        if (matchValue_8.tag === 8) {
+                            return fold((state, key, value_5) => {
+                                if (FSharpMap__ContainsKey(state, key)) {
+                                    return state;
+                                }
+                                else {
+                                    return add(key, value_5, state);
+                                }
+                            }, acc_4, matchValue_8.fields[0]);
+                        }
+                        else {
+                            throw new EvalException(new EvalError$("Map spread value must be a map", Ast_spanOfExpr(spreadExpr)));
+                        }
+                    }
+                    else {
+                        const keyExpr = entry.fields[0];
+                        const keyValue = evalExpr(runtime, typeDefs, env, keyExpr);
+                        switch (keyValue.tag) {
+                            case 4:
+                            case 1:
+                                return FSharpMap__Add(acc_4, valueToMapKey(Ast_spanOfExpr(keyExpr), keyValue), evalExpr(runtime, typeDefs, env, entry.fields[1]));
+                            default:
+                                throw new EvalException(new EvalError$("Map literal keys must be string or int", Ast_spanOfExpr(keyExpr)));
+                        }
+                    }
+                }, empty_1({
+                    Compare: (x_2, y_2) => (compare(x_2, y_2) | 0),
+                }), expr.fields[0])]);
+            case 19: {
+                const span_10 = expr.fields[2];
+                const matchValue_9 = evalExpr(runtime, typeDefs, env, expr.fields[0]);
+                if (matchValue_9.tag === 7) {
+                    return new Value(7, [fold_1((acc_5, tupledArg_4) => {
+                        const name_7 = tupledArg_4[0];
+                        if (containsKey(name_7, acc_5)) {
+                            return add(name_7, evalExpr(runtime, typeDefs, env, tupledArg_4[1]), acc_5);
+                        }
+                        else {
+                            throw new EvalException(new EvalError$(toText(printf("Record field \'%s\' not found"))(name_7), span_10));
+                        }
+                    }, matchValue_9.fields[0], expr.fields[1])]);
+                }
+                else {
+                    throw new EvalException(new EvalError$("Record update requires a record value", span_10));
+                }
+            }
+            case 20: {
+                const matchValue_10 = evalExpr(runtime, typeDefs, env, expr.fields[0]);
+                if (matchValue_10.tag === 7) {
+                    return new Value(7, [fold_1((acc_6, tupledArg_5) => add(tupledArg_5[0], evalExpr(runtime, typeDefs, env, tupledArg_5[1]), acc_6), matchValue_10.fields[0], expr.fields[1])]);
+                }
+                else {
+                    throw new EvalException(new EvalError$("Structural record update requires a record value", expr.fields[2]));
+                }
+            }
+            case 21: {
+                const target_2 = expr.fields[0];
+                const span_12 = expr.fields[2];
+                const fieldName = expr.fields[1];
+                let matchResult_1, moduleName_1;
+                if (target_2.tag === 2) {
+                    if (!FSharpMap__ContainsKey(env, target_2.fields[0])) {
+                        matchResult_1 = 0;
+                        moduleName_1 = target_2.fields[0];
+                    }
+                    else {
+                        matchResult_1 = 1;
+                    }
+                }
+                else {
+                    matchResult_1 = 1;
+                }
+                switch (matchResult_1) {
+                    case 0: {
+                        const matchValue_11 = FSharpMap__TryFind(env, concat(moduleName_1, ".", fieldName));
+                        if (matchValue_11 == null) {
+                            const matchValue_12 = evalExpr(runtime, typeDefs, env, target_2);
+                            if (matchValue_12.tag === 7) {
+                                const matchValue_13 = FSharpMap__TryFind(matchValue_12.fields[0], fieldName);
+                                if (matchValue_13 == null) {
+                                    throw new EvalException(new EvalError$(toText(printf("Record field \'%s\' not found"))(fieldName), span_12));
+                                }
+                                else {
+                                    return matchValue_13;
+                                }
+                            }
+                            else {
+                                throw new EvalException(new EvalError$("Field access requires a record value", span_12));
+                            }
+                        }
+                        else {
+                            return matchValue_11;
+                        }
+                    }
+                    default: {
+                        const matchValue_14 = evalExpr(runtime, typeDefs, env, target_2);
+                        if (matchValue_14.tag === 7) {
+                            const matchValue_15 = FSharpMap__TryFind(matchValue_14.fields[0], fieldName);
+                            if (matchValue_15 == null) {
+                                throw new EvalException(new EvalError$(toText(printf("Record field \'%s\' not found"))(fieldName), span_12));
+                            }
+                            else {
+                                return matchValue_15;
+                            }
+                        }
+                        else {
+                            throw new EvalException(new EvalError$("Field access requires a record value", span_12));
+                        }
+                    }
+                }
+            }
+            case 22: {
+                const span_13 = expr.fields[2];
+                const targetValue = evalExpr(runtime, typeDefs, env, expr.fields[0]);
+                const keyValue_1 = evalExpr(runtime, typeDefs, env, expr.fields[1]);
+                let matchResult_2, index, values, mapValue;
+                switch (targetValue.tag) {
+                    case 5: {
+                        if (keyValue_1.tag === 1) {
+                            matchResult_2 = 0;
+                            index = keyValue_1.fields[0];
+                            values = targetValue.fields[0];
+                        }
+                        else {
+                            matchResult_2 = 3;
+                        }
+                        break;
+                    }
+                    case 8: {
+                        switch (keyValue_1.tag) {
+                            case 4: {
+                                matchResult_2 = 1;
+                                mapValue = targetValue.fields[0];
+                                break;
+                            }
+                            case 1: {
+                                matchResult_2 = 1;
+                                mapValue = targetValue.fields[0];
+                                break;
+                            }
+                            default:
+                                matchResult_2 = 2;
+                        }
+                        break;
+                    }
+                    default:
+                        matchResult_2 = 4;
+                }
+                switch (matchResult_2) {
+                    case 0: {
+                        const loop = (remaining_mut, current_1_mut) => {
+                            loop:
+                            while (true) {
+                                const remaining = remaining_mut, current_1 = current_1_mut;
+                                if (!isEmpty(remaining)) {
+                                    if (equals(current_1, index)) {
+                                        return some(head_2(remaining));
+                                    }
+                                    else {
+                                        remaining_mut = tail_2(remaining);
+                                        current_1_mut = toInt64_unchecked(op_Addition(current_1, 1n));
+                                        continue loop;
+                                    }
+                                }
+                                else {
+                                    return undefined;
+                                }
+                                break;
+                            }
+                        };
+                        if (compare_1(index, 0n) < 0) {
+                            return new Value(9, [undefined]);
+                        }
+                        else {
+                            return new Value(9, [loop(values, 0n)]);
+                        }
+                    }
+                    case 1:
+                        return new Value(9, [FSharpMap__TryFind(mapValue, valueToMapKey(span_13, keyValue_1))]);
+                    case 2:
+                        throw new EvalException(new EvalError$("Map index key must be string or int", span_13));
+                    case 3:
+                        throw new EvalException(new EvalError$("List index must be int", span_13));
+                    default:
+                        throw new EvalException(new EvalError$("Index access requires a list or map value", span_13));
+                }
+            }
+            case 23: {
+                const h = evalExpr(runtime, typeDefs, env, expr.fields[0]);
+                const t = evalExpr(runtime, typeDefs, env, expr.fields[1]);
+                if (t.tag === 5) {
+                    return new Value(5, [cons(h, t.fields[0])]);
+                }
+                else {
+                    throw new EvalException(new EvalError$("Right side of \'::\' must be list", expr.fields[2]));
+                }
+            }
+            case 24: {
+                const av = evalExpr(runtime, typeDefs, env, expr.fields[0]);
+                const bv = evalExpr(runtime, typeDefs, env, expr.fields[1]);
+                let matchResult_3, xs_1, ys;
+                if (av.tag === 5) {
+                    if (bv.tag === 5) {
+                        matchResult_3 = 0;
+                        xs_1 = av.fields[0];
+                        ys = bv.fields[0];
+                    }
+                    else {
+                        matchResult_3 = 1;
+                    }
+                }
+                else {
+                    matchResult_3 = 1;
+                }
+                switch (matchResult_3) {
+                    case 0:
+                        return new Value(5, [append(xs_1, ys)]);
+                    default:
+                        throw new EvalException(new EvalError$("Both sides of \'@\' must be lists", expr.fields[2]));
+                }
+            }
+            case 25: {
+                const span_16 = expr.fields[3];
+                const op = expr.fields[0];
+                const av_1 = evalExpr(runtime, typeDefs, env, expr.fields[1]);
+                const bv_1 = evalExpr(runtime, typeDefs, env, expr.fields[2]);
+                const arith = (fInt, fFloat) => {
+                    let matchResult_4, x_3, y_3, x_4, y_4;
+                    switch (av_1.tag) {
+                        case 1: {
+                            if (bv_1.tag === 1) {
+                                matchResult_4 = 0;
+                                x_3 = av_1.fields[0];
+                                y_3 = bv_1.fields[0];
+                            }
+                            else {
+                                matchResult_4 = 2;
+                            }
+                            break;
+                        }
+                        case 2: {
+                            if (bv_1.tag === 2) {
+                                matchResult_4 = 1;
+                                x_4 = av_1.fields[0];
+                                y_4 = bv_1.fields[0];
+                            }
+                            else {
+                                matchResult_4 = 2;
+                            }
+                            break;
+                        }
+                        default:
+                            matchResult_4 = 2;
+                    }
+                    switch (matchResult_4) {
+                        case 0:
+                            return new Value(1, [fInt(x_3)(y_3)]);
+                        case 1:
+                            return new Value(2, [fFloat(x_4)(y_4)]);
+                        default:
+                            throw new EvalException(new EvalError$("Numeric operands required", span_16));
+                    }
+                };
+                switch (op) {
+                    case "|>":
+                        return applyFunctionValue(runtime, evalExpr, typeDefs, span_16, bv_1, av_1);
+                    case "+":
+                        return arith((x_5) => ((y_5) => toInt64_unchecked(op_Addition(x_5, y_5))), (x_6) => ((y_6) => (x_6 + y_6)));
+                    case "-":
+                        return arith((x_7) => ((y_7) => toInt64_unchecked(op_Subtraction(x_7, y_7))), (x_8) => ((y_8) => (x_8 - y_8)));
+                    case "*":
+                        return arith((x_9) => ((y_9) => toInt64_unchecked(op_Multiply(x_9, y_9))), (x_10) => ((y_10) => (x_10 * y_10)));
+                    case "/": {
+                        let matchResult_5, x_11, y_11, x_12, y_12;
+                        switch (av_1.tag) {
+                            case 1: {
+                                if (bv_1.tag === 1) {
+                                    matchResult_5 = 0;
+                                    x_11 = av_1.fields[0];
+                                    y_11 = bv_1.fields[0];
+                                }
+                                else {
+                                    matchResult_5 = 2;
+                                }
+                                break;
+                            }
+                            case 2: {
+                                if (bv_1.tag === 2) {
+                                    matchResult_5 = 1;
+                                    x_12 = av_1.fields[0];
+                                    y_12 = bv_1.fields[0];
+                                }
+                                else {
+                                    matchResult_5 = 2;
+                                }
+                                break;
+                            }
+                            default:
+                                matchResult_5 = 2;
+                        }
+                        switch (matchResult_5) {
+                            case 0:
+                                return new Value(1, [toInt64_unchecked(op_Division(x_11, y_11))]);
+                            case 1:
+                                return new Value(2, [x_12 / y_12]);
+                            default:
+                                throw new EvalException(new EvalError$("Numeric operands required", span_16));
+                        }
+                    }
+                    case "%": {
+                        let matchResult_6, x_13, y_13;
+                        if (av_1.tag === 1) {
+                            if (bv_1.tag === 1) {
+                                matchResult_6 = 0;
+                                x_13 = av_1.fields[0];
+                                y_13 = bv_1.fields[0];
+                            }
+                            else {
+                                matchResult_6 = 1;
+                            }
+                        }
+                        else {
+                            matchResult_6 = 1;
+                        }
+                        switch (matchResult_6) {
+                            case 0:
+                                return new Value(1, [toInt64_unchecked(op_Modulus(x_13, y_13))]);
+                            default:
+                                throw new EvalException(new EvalError$("Integer operands required", span_16));
+                        }
+                    }
+                    case "=":
+                        return new Value(3, [valueEquals(av_1, bv_1)]);
+                    case "<":
+                    case ">":
+                    case "<=":
+                    case ">=": {
+                        let matchResult_7, x_14, y_14, x_15, y_15;
+                        switch (av_1.tag) {
+                            case 1: {
+                                if (bv_1.tag === 1) {
+                                    matchResult_7 = 0;
+                                    x_14 = av_1.fields[0];
+                                    y_14 = bv_1.fields[0];
+                                }
+                                else {
+                                    matchResult_7 = 2;
+                                }
+                                break;
+                            }
+                            case 2: {
+                                if (bv_1.tag === 2) {
+                                    matchResult_7 = 1;
+                                    x_15 = av_1.fields[0];
+                                    y_15 = bv_1.fields[0];
+                                }
+                                else {
+                                    matchResult_7 = 2;
+                                }
+                                break;
+                            }
+                            default:
+                                matchResult_7 = 2;
+                        }
+                        switch (matchResult_7) {
+                            case 0:
+                                return new Value(3, [(op === "<") ? (compare_1(x_14, y_14) < 0) : ((op === ">") ? (compare_1(x_14, y_14) > 0) : ((op === "<=") ? (compare_1(x_14, y_14) <= 0) : ((op === ">=") && (compare_1(x_14, y_14) >= 0))))]);
+                            case 1:
+                                return new Value(3, [(op === "<") ? (x_15 < y_15) : ((op === ">") ? (x_15 > y_15) : ((op === "<=") ? (x_15 <= y_15) : ((op === ">=") && (x_15 >= y_15))))]);
+                            default:
+                                throw new EvalException(new EvalError$("Numeric operands required", span_16));
+                        }
+                    }
+                    case "&&":
+                    case "||": {
+                        let matchResult_8, x_16, y_16;
+                        if (av_1.tag === 3) {
+                            if (bv_1.tag === 3) {
+                                matchResult_8 = 0;
+                                x_16 = av_1.fields[0];
+                                y_16 = bv_1.fields[0];
+                            }
+                            else {
+                                matchResult_8 = 1;
+                            }
+                        }
+                        else {
+                            matchResult_8 = 1;
+                        }
+                        switch (matchResult_8) {
+                            case 0:
+                                return new Value(3, [(op === "&&") ? (x_16 && y_16) : (x_16 ? true : y_16)]);
+                            default:
+                                throw new EvalException(new EvalError$("Boolean operands required", span_16));
+                        }
+                    }
+                    case "::":
+                        if (bv_1.tag === 5) {
+                            return new Value(5, [cons(av_1, bv_1.fields[0])]);
+                        }
+                        else {
+                            throw new EvalException(new EvalError$("Right side of \'::\' must be list", span_16));
+                        }
+                    case "@": {
+                        let matchResult_9, xs_3, ys_1;
+                        if (av_1.tag === 5) {
+                            if (bv_1.tag === 5) {
+                                matchResult_9 = 0;
+                                xs_3 = av_1.fields[0];
+                                ys_1 = bv_1.fields[0];
+                            }
+                            else {
+                                matchResult_9 = 1;
+                            }
+                        }
+                        else {
+                            matchResult_9 = 1;
+                        }
+                        switch (matchResult_9) {
+                            case 0:
+                                return new Value(5, [append(xs_3, ys_1)]);
+                            default:
+                                throw new EvalException(new EvalError$("Both sides of \'@\' must be lists", span_16));
+                        }
+                    }
+                    default:
+                        throw new EvalException(new EvalError$(toText(printf("Unknown operator %s"))(op), span_16));
+                }
+            }
+            case 26:
+                return new Value(9, [evalExpr(runtime, typeDefs, env, expr.fields[0])]);
+            case 27:
+                return new Value(9, [undefined]);
+            case 28: {
+                const name_9 = expr.fields[0];
+                const matchValue_24 = FSharpMap__TryFind(typeDefs, name_9);
+                if (matchValue_24 == null) {
+                    throw new EvalException(new EvalError$(concat("Unknown type \'", name_9, "\'"), expr.fields[1]));
+                }
+                else {
+                    return new Value(12, [matchValue_24]);
+                }
+            }
+            case 29: {
+                const name_10 = expr.fields[0];
+                if (FSharpMap__ContainsKey(env, name_10)) {
+                    return new Value(4, [name_10]);
+                }
+                else {
+                    throw new EvalException(new EvalError$(concat("Unbound variable \'", name_10, "\'"), expr.fields[1]));
+                }
+            }
+            case 30: {
+                const sb = StringBuilder_$ctor();
+                const enumerator_1 = getEnumerator(expr.fields[0]);
+                try {
+                    while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+                        const part = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                        if (part.tag === 1) {
+                            StringBuilder__Append_Z721C83C5(sb, valueToInterpolationString(evalExpr(runtime, typeDefs, env, part.fields[0])));
+                        }
+                        else {
+                            StringBuilder__Append_Z721C83C5(sb, part.fields[0]);
+                        }
+                    }
+                }
+                finally {
+                    disposeSafe(enumerator_1);
+                }
+                return new Value(4, [toString(sb)]);
+            }
+            default:
+                return new Value(0, []);
+        }
+        break;
+    }
+}
+
+export function invokeValue(typeDefs, fnValue, args) {
+    const runtime = new RuntimeState({}, [], undefined);
+    const applyMany = (currentValue_mut, remainingArgs_mut) => {
+        applyMany:
+        while (true) {
+            const currentValue = currentValue_mut, remainingArgs = remainingArgs_mut;
+            if (!isEmpty(remainingArgs)) {
+                switch (currentValue.tag) {
+                    case 15: {
+                        const ext = currentValue.fields[0];
+                        const allArgs = append(reverse(currentValue.fields[1]), remainingArgs);
+                        if (length(allArgs) === ext.Arity) {
+                            return ext.Impl(createExternContext(runtime, typeDefs, unknownSpan), allArgs);
+                        }
+                        else if (length(allArgs) < ext.Arity) {
+                            return new Value(15, [ext, reverse(allArgs)]);
+                        }
+                        else {
+                            throw new EvalException(new EvalError$(toText(printf("External function \'%s\' received too many arguments"))(ext.Name), unknownSpan));
+                        }
+                    }
+                    case 14: {
+                        const bindLambdaChain = (envAcc_mut, exprAcc_mut, argsAcc_mut) => {
+                            bindLambdaChain:
+                            while (true) {
+                                const envAcc = envAcc_mut, exprAcc = exprAcc_mut, argsAcc = argsAcc_mut;
+                                let matchResult, nextArg, nextBody, param, rest;
+                                if (exprAcc.tag === 4) {
+                                    if (!isEmpty(argsAcc)) {
+                                        matchResult = 0;
+                                        nextArg = head_2(argsAcc);
+                                        nextBody = exprAcc.fields[1];
+                                        param = exprAcc.fields[0];
+                                        rest = tail_2(argsAcc);
+                                    }
+                                    else {
+                                        matchResult = 1;
+                                    }
+                                }
+                                else {
+                                    matchResult = 1;
+                                }
+                                switch (matchResult) {
+                                    case 0: {
+                                        envAcc_mut = add(param.Name, nextArg, envAcc);
+                                        exprAcc_mut = nextBody;
+                                        argsAcc_mut = rest;
+                                        continue bindLambdaChain;
+                                    }
+                                    default:
+                                        return [envAcc, exprAcc, argsAcc];
+                                }
+                                break;
+                            }
+                        };
+                        const patternInput = bindLambdaChain(add(currentValue.fields[0], head_2(remainingArgs), currentValue.fields[2].contents), currentValue.fields[1], tail_2(remainingArgs));
+                        currentValue_mut = evalExpr(runtime, typeDefs, patternInput[0], patternInput[1]);
+                        remainingArgs_mut = patternInput[2];
+                        continue applyMany;
+                    }
+                    default: {
+                        currentValue_mut = applyFunctionValue(runtime, evalExpr, typeDefs, unknownSpan, currentValue, head_2(remainingArgs));
+                        remainingArgs_mut = tail_2(remainingArgs);
+                        continue applyMany;
+                    }
+                }
+            }
+            else {
+                return currentValue;
+            }
+            break;
+        }
+    };
+    return applyMany(fnValue, args);
+}
+
+export function evalProgramWithExternsState(externs, program) {
+    const runtime = new RuntimeState({}, [], undefined);
+    iterate((ext_1) => {
+        throw new EvalException(new EvalError$(concat("Host extern \'", ext_1.Name, "\' collides with reserved stdlib symbol"), unknownSpan));
+    }, toArray(tryFind_1((ext) => contains(ext.Name, builtinReservedNames), externs)));
+    iterate((name_5) => {
+        throw new EvalException(new EvalError$(concat("Top-level binding \'", name_5, "\' collides with reserved stdlib symbol"), unknownSpan));
+    }, toArray(tryPick_1((_arg) => {
+        let matchResult, name_1, bindings, bindings_1;
+        switch (_arg.tag) {
+            case 1: {
+                if (contains(_arg.fields[0], builtinReservedNames)) {
+                    matchResult = 0;
+                    name_1 = _arg.fields[0];
+                }
+                else {
+                    matchResult = 3;
+                }
+                break;
+            }
+            case 2: {
+                matchResult = 1;
+                bindings = _arg.fields[2];
+                break;
+            }
+            case 3: {
+                matchResult = 2;
+                bindings_1 = _arg.fields[0];
+                break;
+            }
+            default:
+                matchResult = 3;
+        }
+        switch (matchResult) {
+            case 0:
+                return name_1;
+            case 1:
+                return map_1((tuple) => tuple[0], tryFind_1((tupledArg) => contains(tupledArg[0], builtinReservedNames), toList(bindings)));
+            case 2:
+                return map_1((tupledArg_2) => tupledArg_2[0], tryFind_1((tupledArg_1) => contains(tupledArg_1[0], builtinReservedNames), bindings_1));
+            default:
+                return undefined;
+        }
+    }, program)));
+    const decls = ofList(append(map((def) => [def.Name, def], typeDefs_3), choose((_arg_8) => {
+        if (_arg_8.tag === 0) {
+            const def_1 = _arg_8.fields[0];
+            return [def_1.Name, def_1];
+        }
+        else {
+            return undefined;
+        }
+    }, program)), {
+        Compare: (x, y) => (comparePrimitives(x, y) | 0),
+    });
+    const fromRef = (stack, tref) => {
+        switch (tref.tag) {
+            case 1:
+                return new Type(7, [map(curry2(fromRef)(stack), tref.fields[0])]);
+            case 2:
+                return new Type(11, [fromRef(stack, tref.fields[0]), fromRef(stack, tref.fields[1])]);
+            case 3:
+                switch (tref.fields[1]) {
+                    case "list":
+                        return new Type(5, [fromRef(stack, tref.fields[0])]);
+                    case "task":
+                        return new Type(6, [fromRef(stack, tref.fields[0])]);
+                    case "option":
+                        return new Type(10, [fromRef(stack, tref.fields[0])]);
+                    case "map":
+                        return new Type(9, [new Type(4, []), fromRef(stack, tref.fields[0])]);
+                    default:
+                        throw new EvalException(new EvalError$(concat("Unsupported type suffix ", tref.fields[1]), unknownSpan));
+                }
+            case 4:
+                return new Type(8, [ofList(map((tupledArg_5) => [tupledArg_5[0], fromRef(stack, tupledArg_5[1])], tref.fields[0]), {
+                    Compare: (x_3, y_4) => (comparePrimitives(x_3, y_4) | 0),
+                })]);
+            case 5:
+                return new Type(8, [ofList(map((tupledArg_6) => [tupledArg_6[0], fromRef(stack, tupledArg_6[1])], tref.fields[0]), {
+                    Compare: (x_4, y_5) => (comparePrimitives(x_4, y_5) | 0),
+                })]);
+            default:
+                switch (tref.fields[0]) {
+                    case "unit":
+                        return new Type(0, []);
+                    case "int":
+                        return new Type(1, []);
+                    case "float":
+                        return new Type(2, []);
+                    case "bool":
+                        return new Type(3, []);
+                    case "string":
+                        return new Type(4, []);
+                    default: {
+                        const matchValue = FSharpMap__TryFind(decls, tref.fields[0]);
+                        if (matchValue == null) {
+                            return new Type(12, [tref.fields[0]]);
+                        }
+                        else {
+                            const d = matchValue;
+                            const matchValue_1 = tryFindIndex((y_1) => (tref.fields[0] === y_1), stack);
+                            if (matchValue_1 == null) {
+                                if (!isEmpty(d.Cases)) {
+                                    return new Type(13, [tref.fields[0], ofList(map((tupledArg_3) => [tupledArg_3[0], map_1(curry2(fromRef)(cons(tref.fields[0], stack)), tupledArg_3[1])], d.Cases), {
+                                        Compare: (x_1, y_2) => (comparePrimitives(x_1, y_2) | 0),
+                                    })]);
+                                }
+                                else {
+                                    return new Type(8, [ofList(map((tupledArg_4) => [tupledArg_4[0], fromRef(cons(tref.fields[0], stack), tupledArg_4[1])], d.Fields), {
+                                        Compare: (x_2, y_3) => (comparePrimitives(x_2, y_3) | 0),
+                                    })]);
+                                }
+                            }
+                            else if (matchValue_1 === 0) {
+                                if (d.IsRecursive) {
+                                    return new Type(12, [tref.fields[0]]);
+                                }
+                                else {
+                                    throw new EvalException(new EvalError$(concat("Recursive type \'", tref.fields[0], "\' requires \'type rec\'"), unknownSpan));
+                                }
+                            }
+                            else {
+                                throw new EvalException(new EvalError$("Mutual recursive types are not supported", unknownSpan));
+                            }
+                        }
+                    }
+                }
+        }
+    };
+    const typeDefs = map_2((name_8, def_2) => {
+        if (!isEmpty(def_2.Cases)) {
+            return new Type(13, [name_8, ofList(map((tupledArg_7) => [tupledArg_7[0], map_1(curry2(fromRef)(singleton(name_8)), tupledArg_7[1])], def_2.Cases), {
+                Compare: (x_5, y_6) => (comparePrimitives(x_5, y_6) | 0),
+            })]);
+        }
+        else {
+            return new Type(8, [ofList(map((tupledArg_8) => [tupledArg_8[0], fromRef(singleton(name_8), tupledArg_8[1])], def_2.Fields), {
+                Compare: (x_6, y_7) => (comparePrimitives(x_6, y_7) | 0),
+            })]);
+        }
+    }, decls);
+    const constructorValues = collect((tupledArg_9) => {
+        const typeName = tupledArg_9[0];
+        return collect((tupledArg_10) => {
+            const caseName_2 = tupledArg_10[0];
+            const value = (tupledArg_10[1] != null) ? (new Value(11, [typeName, caseName_2])) : (new Value(10, [typeName, caseName_2, undefined]));
+            return ofArray([[caseName_2, value], [concat(typeName, ".", caseName_2), value]]);
+        }, tupledArg_9[1].Cases);
+    }, toList(decls));
+    const externContext = createExternContext(runtime, typeDefs, unknownSpan);
+    let env;
+    const list_16 = append(builtinExterns, externs);
+    env = fold_1((acc, ext_2) => {
+        if (ext_2.Arity === 0) {
+            return FSharpMap__Add(acc, ext_2.Name, ext_2.Impl(externContext, empty()));
+        }
+        else {
+            return FSharpMap__Add(acc, ext_2.Name, new Value(15, [ext_2, empty()]));
+        }
+    }, empty_1({
+        Compare: (x_7, y_8) => (comparePrimitives(x_7, y_8) | 0),
+    }), list_16);
+    env = fold_1((acc_1, tupledArg_11) => FSharpMap__Add(acc_1, tupledArg_11[0], tupledArg_11[1]), env, constructorValues);
+    let lastValue = new Value(0, []);
+    const enumerator = getEnumerator(program);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const stmt = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            raiseIfBackgroundFailed(runtime);
+            switch (stmt.tag) {
+                case 1: {
+                    const name_10 = stmt.fields[0];
+                    const expr = stmt.fields[1];
+                    if (stmt.fields[3]) {
+                        if (expr.tag === 4) {
+                            const recEnv = new FSharpRef(env);
+                            const finalEnv = add(name_10, new Value(14, [expr.fields[0].Name, expr.fields[1], recEnv]), env);
+                            recEnv.contents = finalEnv;
+                            env = finalEnv;
+                        }
+                        else {
+                            throw new EvalException(new EvalError$("let rec requires a function binding", stmt.fields[5]));
+                        }
+                    }
+                    else {
+                        const v = evalExpr(runtime, typeDefs, env, expr);
+                        env = add(name_10, v, env);
+                    }
+                    break;
+                }
+                case 2: {
+                    const matchValue_2 = patternMatch(typeDefs, stmt.fields[0], evalExpr(runtime, typeDefs, env, stmt.fields[1]));
+                    if (matchValue_2 == null) {
+                        throw new EvalException(new EvalError$("Let pattern did not match value", stmt.fields[4]));
+                    }
+                    else {
+                        const bindings_2 = matchValue_2;
+                        env = fold((acc_2, k, value_3) => add(k, value_3, acc_2), env, bindings_2);
+                    }
+                    break;
+                }
+                case 3: {
+                    const bindings_3 = stmt.fields[0];
+                    if (isEmpty(bindings_3)) {
+                    }
+                    else {
+                        const recEnv_1 = new FSharpRef(env);
+                        let finalEnv_1;
+                        const list_19 = map((tupledArg_12) => {
+                            const expr_2 = tupledArg_12[1];
+                            if (expr_2.tag === 4) {
+                                return [tupledArg_12[0], new Value(14, [expr_2.fields[0].Name, expr_2.fields[1], recEnv_1])];
+                            }
+                            else {
+                                throw new EvalException(new EvalError$("let rec requires a function binding", tupledArg_12[3]));
+                            }
+                        }, bindings_3);
+                        finalEnv_1 = fold_1((acc_3, tupledArg_13) => add(tupledArg_13[0], tupledArg_13[1], acc_3), env, list_19);
+                        recEnv_1.contents = finalEnv_1;
+                        env = finalEnv_1;
+                    }
+                    break;
+                }
+                case 4: {
+                    lastValue = evalExpr(runtime, typeDefs, env, stmt.fields[0].Expr);
+                    break;
+                }
+                default:
+                    undefined;
+            }
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    raiseIfBackgroundFailed(runtime);
+    const unawaitedCount = length_1(filter((handle) => !handle.Awaited, runtime.PendingTasks)) | 0;
+    if (unawaitedCount > 0) {
+        throw new EvalException(new EvalError$(`Program completed with ${unawaitedCount} unawaited ${(unawaitedCount === 1) ? "task" : "tasks"}`, unknownSpan));
+    }
+    return new ProgramState(typeDefs, env, lastValue);
+}
+
+export function evalProgramWithExterns(externs, program) {
+    return evalProgramWithExternsState(externs, program).LastValue;
+}
+
+export function evalProgram(program) {
+    return evalProgramWithExterns(empty(), program);
+}
+