@magnusopera/fscript 0.75.0

package/dist/FScript.Language/TypeInfer.js

@@ -0,0 +1,2561 @@
+
+import { Span_$reflection, Span, Position } from "./Span.js";
+import { iterate as iterate_2, FSharpMap__Add, FSharpMap__ContainsKey, values, keys, FSharpMap__TryFind, ofList, toList, FSharpMap__get_Item, FSharpMap__get_Keys, add, fold as fold_1, remove, map as map_1, tryFind, empty } from "../fable_modules/fable-library-js.5.2.0/Map.js";
+import { disposeSafe, getEnumerator, stringHash, compareArrays, equals, comparePrimitives } from "../fable_modules/fable-library-js.5.2.0/Util.js";
+import { Types_generalize, Type_$reflection, Types_freshVar, Types_typeToString, Types_ftvType, Scheme, Type } from "./Types.js";
+import { tryFind as tryFind_1, indexed, ofArray, collect, append, iterate, reverse, tryFindIndex, choose, tail as tail_2, cons, head as head_1, isEmpty, empty as empty_2, singleton, zip, length, fold, map } from "../fable_modules/fable-library-js.5.2.0/List.js";
+import { toList as toList_2, add as add_1, empty as empty_1, isSubset, ofSeq, FSharpSet__Add, FSharpSet__Contains, contains } from "../fable_modules/fable-library-js.5.2.0/Set.js";
+import { TypeException, TypeError$ } from "./Error.js";
+import { endsWith, split, join, concat, isNullOrWhiteSpace, printf, toText } from "../fable_modules/fable-library-js.5.2.0/String.js";
+import { toArray, map as map_3, defaultArg } from "../fable_modules/fable-library-js.5.2.0/Option.js";
+import { Union, Record } from "../fable_modules/fable-library-js.5.2.0/Types.js";
+import { Expr, Ast_spanOfPattern, Ast_spanOfExpr, Pattern_$reflection, TypeDef_$reflection, Expr_$reflection } from "./Ast.js";
+import { option_type, array_type, union_type, list_type, tuple_type, class_type, bool_type, string_type, record_type } from "../fable_modules/fable-library-js.5.2.0/Reflection.js";
+import { foldBack, iterate as iterate_1, filter, map as map_2, toList as toList_1 } from "../fable_modules/fable-library-js.5.2.0/Seq.js";
+import { last, item as item_2 } from "../fable_modules/fable-library-js.5.2.0/Array.js";
+import { distinct } from "../fable_modules/fable-library-js.5.2.0/Seq2.js";
+import { builtinReservedNames, builtinSchemes } from "./BuiltinSignatures.js";
+import { typeDefs as typeDefs_1 } from "./BuiltinTypes.js";
+
+const unknownSpan = new Span(new Position(undefined, 0, 0), new Position(undefined, 0, 0));
+
+const emptySubst = empty({
+    Compare: (x, y) => (comparePrimitives(x, y) | 0),
+});
+
+function applyType(s_mut, t_mut) {
+    applyType:
+    while (true) {
+        const s = s_mut, t = t_mut;
+        switch (t.tag) {
+            case 15: {
+                const matchValue = tryFind(t.fields[0], s);
+                if (matchValue == null) {
+                    return t;
+                }
+                else {
+                    s_mut = s;
+                    t_mut = matchValue;
+                    continue applyType;
+                }
+            }
+            case 5:
+                return new Type(5, [applyType(s, t.fields[0])]);
+            case 6:
+                return new Type(6, [applyType(s, t.fields[0])]);
+            case 7:
+                return new Type(7, [map((t_1) => applyType(s, t_1), t.fields[0])]);
+            case 8:
+                return new Type(8, [map_1((_arg, t1_2) => applyType(s, t1_2), t.fields[0])]);
+            case 9:
+                return new Type(9, [applyType(s, t.fields[0]), applyType(s, t.fields[1])]);
+            case 10:
+                return new Type(10, [applyType(s, t.fields[0])]);
+            case 11:
+                return new Type(11, [applyType(s, t.fields[0]), applyType(s, t.fields[1])]);
+            default:
+                return t;
+        }
+        break;
+    }
+}
+
+function applyScheme(s, _arg) {
+    const vars = _arg.fields[0];
+    return new Scheme(vars, applyType(fold((acc, v) => remove(v, acc), s, vars), _arg.fields[1]));
+}
+
+function applyEnv(s, env) {
+    return map_1((_arg, sc) => applyScheme(s, sc), env);
+}
+
+function compose(s1, s2) {
+    return fold_1((acc, k, v) => add(k, v, acc), s1, map_1((_arg, t) => applyType(s1, t), s2));
+}
+
+function occurs(v, t) {
+    return contains(v, Types_ftvType(t));
+}
+
+function unify(typeDefs, t1, t2, span) {
+    const uni = (seen_mut, a_mut, b_mut) => {
+        uni:
+        while (true) {
+            const seen = seen_mut, a = a_mut, b = b_mut;
+            let arg, arg_1, arg_2, arg_3, arg_4, arg_5;
+            if (FSharpSet__Contains(seen, [a, b]) ? true : FSharpSet__Contains(seen, [b, a])) {
+                return emptySubst;
+            }
+            else {
+                const seen$0027 = FSharpSet__Add(seen, [a, b]);
+                let matchResult, x_1, y_1, x_2, y_2, x_3, y_3, xs, ys, xf, yf, kx, ky, vx, vy, x_7, y_7, a1, a2, b1, b2, t, v, name_1, t_1, name_2, t_2;
+                switch (a.tag) {
+                    case 0: {
+                        switch (b.tag) {
+                            case 0: {
+                                matchResult = 0;
+                                break;
+                            }
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            case 12: {
+                                matchResult = 11;
+                                name_2 = b.fields[0];
+                                t_2 = a;
+                                break;
+                            }
+                            default:
+                                matchResult = 12;
+                        }
+                        break;
+                    }
+                    case 1: {
+                        switch (b.tag) {
+                            case 1: {
+                                matchResult = 0;
+                                break;
+                            }
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            case 12: {
+                                matchResult = 11;
+                                name_2 = b.fields[0];
+                                t_2 = a;
+                                break;
+                            }
+                            default:
+                                matchResult = 12;
+                        }
+                        break;
+                    }
+                    case 2: {
+                        switch (b.tag) {
+                            case 2: {
+                                matchResult = 0;
+                                break;
+                            }
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            case 12: {
+                                matchResult = 11;
+                                name_2 = b.fields[0];
+                                t_2 = a;
+                                break;
+                            }
+                            default:
+                                matchResult = 12;
+                        }
+                        break;
+                    }
+                    case 3: {
+                        switch (b.tag) {
+                            case 3: {
+                                matchResult = 0;
+                                break;
+                            }
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            case 12: {
+                                matchResult = 11;
+                                name_2 = b.fields[0];
+                                t_2 = a;
+                                break;
+                            }
+                            default:
+                                matchResult = 12;
+                        }
+                        break;
+                    }
+                    case 4: {
+                        switch (b.tag) {
+                            case 4: {
+                                matchResult = 0;
+                                break;
+                            }
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            case 12: {
+                                matchResult = 11;
+                                name_2 = b.fields[0];
+                                t_2 = a;
+                                break;
+                            }
+                            default:
+                                matchResult = 12;
+                        }
+                        break;
+                    }
+                    case 14: {
+                        switch (b.tag) {
+                            case 14: {
+                                matchResult = 0;
+                                break;
+                            }
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            case 12: {
+                                matchResult = 11;
+                                name_2 = b.fields[0];
+                                t_2 = a;
+                                break;
+                            }
+                            default:
+                                matchResult = 12;
+                        }
+                        break;
+                    }
+                    case 12: {
+                        switch (b.tag) {
+                            case 12: {
+                                if (a.fields[0] === b.fields[0]) {
+                                    matchResult = 1;
+                                    x_1 = a.fields[0];
+                                    y_1 = b.fields[0];
+                                }
+                                else {
+                                    matchResult = 10;
+                                    name_1 = a.fields[0];
+                                    t_1 = b;
+                                }
+                                break;
+                            }
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            default: {
+                                matchResult = 10;
+                                name_1 = a.fields[0];
+                                t_1 = b;
+                            }
+                        }
+                        break;
+                    }
+                    case 5: {
+                        switch (b.tag) {
+                            case 5: {
+                                matchResult = 2;
+                                x_2 = a.fields[0];
+                                y_2 = b.fields[0];
+                                break;
+                            }
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            case 12: {
+                                matchResult = 11;
+                                name_2 = b.fields[0];
+                                t_2 = a;
+                                break;
+                            }
+                            default:
+                                matchResult = 12;
+                        }
+                        break;
+                    }
+                    case 6: {
+                        switch (b.tag) {
+                            case 6: {
+                                matchResult = 3;
+                                x_3 = a.fields[0];
+                                y_3 = b.fields[0];
+                                break;
+                            }
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            case 12: {
+                                matchResult = 11;
+                                name_2 = b.fields[0];
+                                t_2 = a;
+                                break;
+                            }
+                            default:
+                                matchResult = 12;
+                        }
+                        break;
+                    }
+                    case 7: {
+                        switch (b.tag) {
+                            case 7: {
+                                matchResult = 4;
+                                xs = a.fields[0];
+                                ys = b.fields[0];
+                                break;
+                            }
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            case 12: {
+                                matchResult = 11;
+                                name_2 = b.fields[0];
+                                t_2 = a;
+                                break;
+                            }
+                            default:
+                                matchResult = 12;
+                        }
+                        break;
+                    }
+                    case 8: {
+                        switch (b.tag) {
+                            case 8: {
+                                matchResult = 5;
+                                xf = a.fields[0];
+                                yf = b.fields[0];
+                                break;
+                            }
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            case 12: {
+                                matchResult = 11;
+                                name_2 = b.fields[0];
+                                t_2 = a;
+                                break;
+                            }
+                            default:
+                                matchResult = 12;
+                        }
+                        break;
+                    }
+                    case 9: {
+                        switch (b.tag) {
+                            case 9: {
+                                matchResult = 6;
+                                kx = a.fields[0];
+                                ky = b.fields[0];
+                                vx = a.fields[1];
+                                vy = b.fields[1];
+                                break;
+                            }
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            case 12: {
+                                matchResult = 11;
+                                name_2 = b.fields[0];
+                                t_2 = a;
+                                break;
+                            }
+                            default:
+                                matchResult = 12;
+                        }
+                        break;
+                    }
+                    case 10: {
+                        switch (b.tag) {
+                            case 10: {
+                                matchResult = 7;
+                                x_7 = a.fields[0];
+                                y_7 = b.fields[0];
+                                break;
+                            }
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            case 12: {
+                                matchResult = 11;
+                                name_2 = b.fields[0];
+                                t_2 = a;
+                                break;
+                            }
+                            default:
+                                matchResult = 12;
+                        }
+                        break;
+                    }
+                    case 11: {
+                        switch (b.tag) {
+                            case 11: {
+                                matchResult = 8;
+                                a1 = a.fields[0];
+                                a2 = b.fields[0];
+                                b1 = a.fields[1];
+                                b2 = b.fields[1];
+                                break;
+                            }
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            case 12: {
+                                matchResult = 11;
+                                name_2 = b.fields[0];
+                                t_2 = a;
+                                break;
+                            }
+                            default:
+                                matchResult = 12;
+                        }
+                        break;
+                    }
+                    case 15: {
+                        matchResult = 9;
+                        t = b;
+                        v = a.fields[0];
+                        break;
+                    }
+                    default:
+                        switch (b.tag) {
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            case 12: {
+                                matchResult = 11;
+                                name_2 = b.fields[0];
+                                t_2 = a;
+                                break;
+                            }
+                            default:
+                                matchResult = 12;
+                        }
+                }
+                switch (matchResult) {
+                    case 0:
+                        return emptySubst;
+                    case 1:
+                        return emptySubst;
+                    case 2: {
+                        seen_mut = seen$0027;
+                        a_mut = x_2;
+                        b_mut = y_2;
+                        continue uni;
+                    }
+                    case 3: {
+                        seen_mut = seen$0027;
+                        a_mut = x_3;
+                        b_mut = y_3;
+                        continue uni;
+                    }
+                    case 4: {
+                        if (length(xs) !== length(ys)) {
+                            throw new TypeException(new TypeError$("Tuple arity mismatch", span));
+                        }
+                        return fold((sAcc, tupledArg) => compose(uni(seen$0027, applyType(sAcc, tupledArg[0]), applyType(sAcc, tupledArg[1])), sAcc), emptySubst, zip(xs, ys));
+                    }
+                    case 5: {
+                        const xKeys = ofSeq(FSharpMap__get_Keys(xf), {
+                            Compare: (x_5, y_5) => (comparePrimitives(x_5, y_5) | 0),
+                        });
+                        const yKeys = ofSeq(FSharpMap__get_Keys(yf), {
+                            Compare: (x_6, y_6) => (comparePrimitives(x_6, y_6) | 0),
+                        });
+                        let patternInput;
+                        if (isSubset(xKeys, yKeys)) {
+                            patternInput = [xf, yf];
+                        }
+                        else if (isSubset(yKeys, xKeys)) {
+                            patternInput = [yf, xf];
+                        }
+                        else {
+                            throw new TypeException(new TypeError$("Record field set mismatch", span));
+                        }
+                        return fold((sAcc_1, tupledArg_1) => {
+                            const yt = FSharpMap__get_Item(patternInput[1], tupledArg_1[0]);
+                            return compose(uni(seen$0027, applyType(sAcc_1, tupledArg_1[1]), applyType(sAcc_1, yt)), sAcc_1);
+                        }, emptySubst, toList(patternInput[0]));
+                    }
+                    case 6: {
+                        const s1_2 = uni(seen$0027, kx, ky);
+                        return compose(uni(seen$0027, applyType(s1_2, vx), applyType(s1_2, vy)), s1_2);
+                    }
+                    case 7: {
+                        seen_mut = seen$0027;
+                        a_mut = x_7;
+                        b_mut = y_7;
+                        continue uni;
+                    }
+                    case 8: {
+                        const s1_3 = uni(seen$0027, a1, a2);
+                        return compose(uni(seen$0027, applyType(s1_3, b1), applyType(s1_3, b2)), s1_3);
+                    }
+                    case 9:
+                        if (equals(t, new Type(15, [v]))) {
+                            return emptySubst;
+                        }
+                        else if (occurs(v, t)) {
+                            throw new TypeException(new TypeError$("Occurs check failed", span));
+                        }
+                        else {
+                            return ofList(singleton([v, t]), {
+                                Compare: (x_8, y_8) => (comparePrimitives(x_8, y_8) | 0),
+                            });
+                        }
+                    case 10: {
+                        const matchValue_1 = FSharpMap__TryFind(typeDefs, name_1);
+                        let matchResult_1, expanded_1;
+                        if (matchValue_1 != null) {
+                            if (!equals(matchValue_1, new Type(12, [name_1]))) {
+                                matchResult_1 = 0;
+                                expanded_1 = matchValue_1;
+                            }
+                            else {
+                                matchResult_1 = 1;
+                            }
+                        }
+                        else {
+                            matchResult_1 = 1;
+                        }
+                        switch (matchResult_1) {
+                            case 0: {
+                                seen_mut = seen$0027;
+                                a_mut = expanded_1;
+                                b_mut = t_1;
+                                continue uni;
+                            }
+                            default: {
+                                let matchResult_2, other_1;
+                                if (t_1.tag === 12) {
+                                    if (t_1.fields[0] === name_1) {
+                                        matchResult_2 = 0;
+                                        other_1 = t_1.fields[0];
+                                    }
+                                    else {
+                                        matchResult_2 = 1;
+                                    }
+                                }
+                                else {
+                                    matchResult_2 = 1;
+                                }
+                                switch (matchResult_2) {
+                                    case 0:
+                                        return emptySubst;
+                                    default:
+                                        throw new TypeException(new TypeError$((arg = Types_typeToString(a), (arg_1 = Types_typeToString(b), toText(printf("Type mismatch: %s vs %s"))(arg)(arg_1))), span));
+                                }
+                            }
+                        }
+                    }
+                    case 11: {
+                        const matchValue_2 = FSharpMap__TryFind(typeDefs, name_2);
+                        let matchResult_3, expanded_3;
+                        if (matchValue_2 != null) {
+                            if (!equals(matchValue_2, new Type(12, [name_2]))) {
+                                matchResult_3 = 0;
+                                expanded_3 = matchValue_2;
+                            }
+                            else {
+                                matchResult_3 = 1;
+                            }
+                        }
+                        else {
+                            matchResult_3 = 1;
+                        }
+                        switch (matchResult_3) {
+                            case 0: {
+                                seen_mut = seen$0027;
+                                a_mut = t_2;
+                                b_mut = expanded_3;
+                                continue uni;
+                            }
+                            default: {
+                                let matchResult_4, other_3;
+                                if (t_2.tag === 12) {
+                                    if (t_2.fields[0] === name_2) {
+                                        matchResult_4 = 0;
+                                        other_3 = t_2.fields[0];
+                                    }
+                                    else {
+                                        matchResult_4 = 1;
+                                    }
+                                }
+                                else {
+                                    matchResult_4 = 1;
+                                }
+                                switch (matchResult_4) {
+                                    case 0:
+                                        return emptySubst;
+                                    default:
+                                        throw new TypeException(new TypeError$((arg_2 = Types_typeToString(a), (arg_3 = Types_typeToString(b), toText(printf("Type mismatch: %s vs %s"))(arg_2)(arg_3))), span));
+                                }
+                            }
+                        }
+                    }
+                    default:
+                        throw new TypeException(new TypeError$((arg_4 = Types_typeToString(a), (arg_5 = Types_typeToString(b), toText(printf("Type mismatch: %s vs %s"))(arg_4)(arg_5))), span));
+                }
+            }
+            break;
+        }
+    };
+    return uni(empty_1({
+        Compare: (x_9, y_9) => (compareArrays(x_9, y_9) | 0),
+    }), t1, t2);
+}
+
+function instantiate(_arg) {
+    const freshMap = ofList(map((v) => [v, Types_freshVar()], _arg.fields[0]), {
+        Compare: (x, y) => (comparePrimitives(x, y) | 0),
+    });
+    const subst = (t_1) => {
+        switch (t_1.tag) {
+            case 15:
+                return defaultArg(tryFind(t_1.fields[0], freshMap), t_1);
+            case 5:
+                return new Type(5, [subst(t_1.fields[0])]);
+            case 6:
+                return new Type(6, [subst(t_1.fields[0])]);
+            case 7:
+                return new Type(7, [map(subst, t_1.fields[0])]);
+            case 8:
+                return new Type(8, [map_1((_arg_1, t1) => subst(t1), t_1.fields[0])]);
+            case 9:
+                return new Type(9, [subst(t_1.fields[0]), subst(t_1.fields[1])]);
+            case 10:
+                return new Type(10, [subst(t_1.fields[0])]);
+            case 11:
+                return new Type(11, [subst(t_1.fields[0]), subst(t_1.fields[1])]);
+            default:
+                return t_1;
+        }
+    };
+    return subst(_arg.fields[1]);
+}
+
+export class TypedExpr extends Record {
+    constructor(Expr, Type, Span) {
+        super();
+        this.Expr = Expr;
+        this.Type = Type;
+        this.Span = Span;
+    }
+}
+
+export function TypedExpr_$reflection() {
+    return record_type("FScript.Language.TypeInfer.TypedExpr", [], TypedExpr, () => [["Expr", Expr_$reflection()], ["Type", Type_$reflection()], ["Span", Span_$reflection()]]);
+}
+
+export class LocalVariableTypeInfo extends Record {
+    constructor(Name, Span, Type) {
+        super();
+        this.Name = Name;
+        this.Span = Span;
+        this.Type = Type;
+    }
+}
+
+export function LocalVariableTypeInfo_$reflection() {
+    return record_type("FScript.Language.TypeInfer.LocalVariableTypeInfo", [], LocalVariableTypeInfo, () => [["Name", string_type], ["Span", Span_$reflection()], ["Type", Type_$reflection()]]);
+}
+
+class LocalVariableTypeCapture extends Record {
+    constructor(Name, Span, Type) {
+        super();
+        this.Name = Name;
+        this.Span = Span;
+        this.Type = Type;
+    }
+}
+
+function LocalVariableTypeCapture_$reflection() {
+    return record_type("FScript.Language.TypeInfer.LocalVariableTypeCapture", [], LocalVariableTypeCapture, () => [["Name", string_type], ["Span", Span_$reflection()], ["Type", Type_$reflection()]]);
+}
+
+export class TypedStmt extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["TSType", "TSLet", "TSLetPattern", "TSLetRecGroup", "TSExpr"];
+    }
+}
+
+export function TypedStmt_$reflection() {
+    return union_type("FScript.Language.TypeInfer.TypedStmt", [], TypedStmt, () => [[["Item", TypeDef_$reflection()]], [["Item1", string_type], ["Item2", Expr_$reflection()], ["Item3", Type_$reflection()], ["Item4", bool_type], ["Item5", bool_type], ["Item6", Span_$reflection()]], [["Item1", Pattern_$reflection()], ["Item2", Expr_$reflection()], ["Item3", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, Type_$reflection()])], ["Item4", bool_type], ["Item5", Span_$reflection()]], [["Item1", list_type(tuple_type(string_type, Expr_$reflection(), Type_$reflection(), Span_$reflection()))], ["Item2", bool_type], ["Item3", Span_$reflection()]], [["Item", TypedExpr_$reflection()]]]);
+}
+
+class InferenceTelemetry extends Record {
+    constructor(ScopeStack, LocalVariableTypes) {
+        super();
+        this.ScopeStack = ScopeStack;
+        this.LocalVariableTypes = LocalVariableTypes;
+    }
+}
+
+function InferenceTelemetry_$reflection() {
+    return record_type("FScript.Language.TypeInfer.InferenceTelemetry", [], InferenceTelemetry, () => [["ScopeStack", list_type(class_type("Microsoft.FSharp.Collections.FSharpSet`1", [string_type]))], ["LocalVariableTypes", array_type(LocalVariableTypeCapture_$reflection())]]);
+}
+
+let telemetry = undefined;
+
+function beginTelemetry() {
+    telemetry = (new InferenceTelemetry(singleton(empty_1({
+        Compare: (x, y) => (comparePrimitives(x, y) | 0),
+    })), []));
+}
+
+function endTelemetry() {
+    const captured = (telemetry == null) ? empty_2() : toList_1(map_2((item) => (new LocalVariableTypeInfo(item.Name, item.Span, item.Type)), telemetry.LocalVariableTypes));
+    telemetry = undefined;
+    return captured;
+}
+
+function withLocalBindings(names, work) {
+    let matchValue;
+    if (telemetry != null) {
+        const t = telemetry;
+        const pushed = fold((acc, name) => {
+            if (isNullOrWhiteSpace(name) ? true : (name === "_")) {
+                return acc;
+            }
+            else {
+                return add_1(name, acc);
+            }
+        }, (matchValue = t.ScopeStack, isEmpty(matchValue) ? empty_1({
+            Compare: (x, y) => (comparePrimitives(x, y) | 0),
+        }) : head_1(matchValue)), names);
+        t.ScopeStack = cons(pushed, t.ScopeStack);
+        try {
+            return work();
+        }
+        finally {
+            const matchValue_1 = t.ScopeStack;
+            if (isEmpty(matchValue_1)) {
+            }
+            else {
+                t.ScopeStack = tail_2(matchValue_1);
+            }
+        }
+    }
+    else {
+        return work();
+    }
+}
+
+function recordLocalVariableUse(name, span, varType) {
+    let matchValue;
+    if (telemetry != null) {
+        const t = telemetry;
+        if (contains(name, (matchValue = t.ScopeStack, isEmpty(matchValue) ? empty_1({
+            Compare: (x, y) => (comparePrimitives(x, y) | 0),
+        }) : head_1(matchValue)))) {
+            void (t.LocalVariableTypes.push(new LocalVariableTypeCapture(name, span, varType)));
+        }
+    }
+}
+
+function recordLocalVariableDeclaration(name, span, varType) {
+    if (isNullOrWhiteSpace(name) ? true : (name === "_")) {
+    }
+    else if (telemetry != null) {
+        const t = telemetry;
+        void (t.LocalVariableTypes.push(new LocalVariableTypeCapture(name, span, varType)));
+    }
+}
+
+function applySubstToCapturedLocals(startIndex, subst) {
+    if (telemetry != null) {
+        const t = telemetry;
+        for (let i = startIndex; i <= (t.LocalVariableTypes.length - 1); i++) {
+            const entry = item_2(i, t.LocalVariableTypes);
+            entry.Type = applyType(subst, entry.Type);
+        }
+    }
+}
+
+function currentTelemetryCaptureCount() {
+    if (telemetry == null) {
+        return 0;
+    }
+    else {
+        const t = telemetry;
+        return t.LocalVariableTypes.length | 0;
+    }
+}
+
+class ConstructorSig extends Record {
+    constructor(UnionName, Payload) {
+        super();
+        this.UnionName = UnionName;
+        this.Payload = Payload;
+    }
+}
+
+function ConstructorSig_$reflection() {
+    return record_type("FScript.Language.TypeInfer.ConstructorSig", [], ConstructorSig, () => [["UnionName", string_type], ["Payload", option_type(Type_$reflection())]]);
+}
+
+function asTyped(expr, t) {
+    return new TypedExpr(expr, t, Ast_spanOfExpr(expr));
+}
+
+function builtinType(name) {
+    switch (name) {
+        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 undefined;
+    }
+}
+
+function resolveNamedRecordByShape(typeDefs, shape, span) {
+    const matches = choose((tupledArg) => {
+        const t = tupledArg[1];
+        let matchResult, fields_1;
+        if (t.tag === 8) {
+            if (t.fields[0].Equals(shape)) {
+                matchResult = 0;
+                fields_1 = t.fields[0];
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return tupledArg[0];
+            default:
+                return undefined;
+        }
+    }, toList(typeDefs));
+    if (isEmpty(matches)) {
+        throw new TypeException(new TypeError$(concat("No declared record type matches shape ", Types_typeToString(new Type(8, [shape]))), span));
+    }
+    else if (isEmpty(tail_2(matches))) {
+        return new Type(12, [head_1(matches)]);
+    }
+    else {
+        throw new TypeException(new TypeError$(concat("Ambiguous declared record type for shape ", Types_typeToString(new Type(8, [shape])), ": ", join(", ", matches)), span));
+    }
+}
+
+function resolveNamedRecordByFieldSet(typeDefs, fields, span) {
+    const matches = choose((tupledArg) => {
+        const t = tupledArg[1];
+        let matchResult, recordFields_1;
+        if (t.tag === 8) {
+            if (ofSeq(keys(t.fields[0]), {
+                Compare: (x, y) => (comparePrimitives(x, y) | 0),
+            }).Equals(fields)) {
+                matchResult = 0;
+                recordFields_1 = t.fields[0];
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return tupledArg[0];
+            default:
+                return undefined;
+        }
+    }, toList(typeDefs));
+    if (isEmpty(matches)) {
+        throw new TypeException(new TypeError$(concat("No declared record type matches fields ", concat("{ ", join("; ", toList_2(fields)), " }")), span));
+    }
+    else if (isEmpty(tail_2(matches))) {
+        return head_1(matches);
+    }
+    else {
+        throw new TypeException(new TypeError$(concat("Ambiguous declared record type for fields ", concat("{ ", join("; ", toList_2(fields)), " }"), ": ", join(", ", matches)), span));
+    }
+}
+
+function resolveReferencedTypeName(knownNames, name, span) {
+    if (FSharpSet__Contains(ofSeq(knownNames, {
+        Compare: (x, y) => (comparePrimitives(x, y) | 0),
+    }), name)) {
+        return name;
+    }
+    else if (name.indexOf(".") >= 0) {
+        const shortName = last(split(name, ["."], undefined, 0));
+        const matches = toList_1(distinct(filter((candidate) => {
+            if (candidate === shortName) {
+                return true;
+            }
+            else {
+                return endsWith(candidate, "." + shortName, 4);
+            }
+        }, knownNames), {
+            Equals: (x_1, y_1) => (x_1 === y_1),
+            GetHashCode: (x_1) => (stringHash(x_1) | 0),
+        }));
+        if (isEmpty(matches)) {
+            return name;
+        }
+        else if (isEmpty(tail_2(matches))) {
+            return head_1(matches);
+        }
+        else {
+            throw new TypeException(new TypeError$(concat("Ambiguous type reference \'", name, "\'. Candidates: ", join(", ", matches)), span));
+        }
+    }
+    else {
+        return name;
+    }
+}
+
+function annotationTypeFromRef(typeDefs, span, tref) {
+    switch (tref.tag) {
+        case 1:
+            return new Type(7, [map((tref_1) => annotationTypeFromRef(typeDefs, span, tref_1), tref.fields[0])]);
+        case 2:
+            return new Type(11, [annotationTypeFromRef(typeDefs, span, tref.fields[0]), annotationTypeFromRef(typeDefs, span, tref.fields[1])]);
+        case 3:
+            switch (tref.fields[1]) {
+                case "list":
+                    return new Type(5, [annotationTypeFromRef(typeDefs, span, tref.fields[0])]);
+                case "task":
+                    return new Type(6, [annotationTypeFromRef(typeDefs, span, tref.fields[0])]);
+                case "option":
+                    return new Type(10, [annotationTypeFromRef(typeDefs, span, tref.fields[0])]);
+                case "map":
+                    return new Type(9, [new Type(4, []), annotationTypeFromRef(typeDefs, span, tref.fields[0])]);
+                default:
+                    throw new TypeException(new TypeError$(concat("Unknown type suffix \'", tref.fields[1], "\'"), span));
+            }
+        case 4:
+            return resolveNamedRecordByShape(typeDefs, ofList(map((tupledArg) => [tupledArg[0], annotationTypeFromRef(typeDefs, span, tupledArg[1])], tref.fields[0]), {
+                Compare: (x, y) => (comparePrimitives(x, y) | 0),
+            }), span);
+        case 5:
+            return new Type(8, [ofList(map((tupledArg_1) => [tupledArg_1[0], annotationTypeFromRef(typeDefs, span, tupledArg_1[1])], tref.fields[0]), {
+                Compare: (x_1, y_1) => (comparePrimitives(x_1, y_1) | 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:
+                    return new Type(12, [resolveReferencedTypeName(FSharpMap__get_Keys(typeDefs), tref.fields[0], span)]);
+            }
+    }
+}
+
+function functionReturnType(t_mut) {
+    functionReturnType:
+    while (true) {
+        const t = t_mut;
+        if (t.tag === 11) {
+            t_mut = t.fields[1];
+            continue functionReturnType;
+        }
+        else {
+            return t;
+        }
+        break;
+    }
+}
+
+function typeFromRef(decls, stack, tref) {
+    switch (tref.tag) {
+        case 1:
+            return new Type(7, [map((tref_1) => typeFromRef(decls, stack, tref_1), tref.fields[0])]);
+        case 2:
+            return new Type(11, [typeFromRef(decls, stack, tref.fields[0]), typeFromRef(decls, stack, tref.fields[1])]);
+        case 3: {
+            const suffix = tref.fields[1];
+            const resolved = typeFromRef(decls, stack, tref.fields[0]);
+            switch (suffix) {
+                case "list":
+                    return new Type(5, [resolved]);
+                case "task":
+                    return new Type(6, [resolved]);
+                case "option":
+                    return new Type(10, [resolved]);
+                case "map":
+                    return new Type(9, [new Type(4, []), resolved]);
+                default:
+                    throw new TypeException(new TypeError$(concat("Unknown type suffix \'", suffix, "\'"), unknownSpan));
+            }
+        }
+        case 4:
+            return new Type(8, [ofList(map((tupledArg_1) => [tupledArg_1[0], typeFromRef(decls, stack, tupledArg_1[1])], tref.fields[0]), {
+                Compare: (x_1, y_2) => (comparePrimitives(x_1, y_2) | 0),
+            })]);
+        case 5:
+            return new Type(8, [ofList(map((tupledArg_2) => [tupledArg_2[0], typeFromRef(decls, stack, tupledArg_2[1])], tref.fields[0]), {
+                Compare: (x_2, y_3) => (comparePrimitives(x_2, y_3) | 0),
+            })]);
+        default: {
+            const name = tref.fields[0];
+            const matchValue = builtinType(name);
+            if (matchValue == null) {
+                const resolvedName = resolveReferencedTypeName(FSharpMap__get_Keys(decls), name, unknownSpan);
+                const matchValue_1 = FSharpMap__TryFind(decls, resolvedName);
+                if (matchValue_1 == null) {
+                    return new Type(12, [resolvedName]);
+                }
+                else {
+                    const def = matchValue_1;
+                    const matchValue_2 = tryFindIndex((y) => (resolvedName === y), stack);
+                    if (matchValue_2 == null) {
+                        if (!isEmpty(def.Cases)) {
+                            return new Type(12, [resolvedName]);
+                        }
+                        else {
+                            return new Type(8, [ofList(map((tupledArg) => [tupledArg[0], typeFromRef(decls, cons(resolvedName, stack), tupledArg[1])], def.Fields), {
+                                Compare: (x, y_1) => (comparePrimitives(x, y_1) | 0),
+                            })]);
+                        }
+                    }
+                    else if (matchValue_2 === 0) {
+                        if (def.IsRecursive) {
+                            return new Type(12, [resolvedName]);
+                        }
+                        else {
+                            throw new TypeException(new TypeError$(concat("Recursive type \'", resolvedName, "\' requires \'type rec\'"), unknownSpan));
+                        }
+                    }
+                    else {
+                        throw new TypeException(new TypeError$("Mutual recursive types are not supported", unknownSpan));
+                    }
+                }
+            }
+            else {
+                return matchValue;
+            }
+        }
+    }
+}
+
+function inferPattern(typeDefs, constructors, pat) {
+    let table_5;
+    switch (pat.tag) {
+        case 1: {
+            const name = pat.fields[0];
+            const tv = Types_freshVar();
+            recordLocalVariableDeclaration(name, Ast_spanOfPattern(pat), tv);
+            return [ofList(singleton([name, tv]), {
+                Compare: (x_1, y_1) => (comparePrimitives(x_1, y_1) | 0),
+            }), tv];
+        }
+        case 2: {
+            const lit = pat.fields[0];
+            const t = (lit.tag === 1) ? (new Type(2, [])) : ((lit.tag === 2) ? (new Type(3, [])) : ((lit.tag === 3) ? (new Type(4, [])) : (new Type(1, []))));
+            return [empty({
+                Compare: (x_2, y_2) => (comparePrimitives(x_2, y_2) | 0),
+            }), t];
+        }
+        case 3: {
+            const tv_1 = Types_freshVar();
+            return [empty({
+                Compare: (x_3, y_3) => (comparePrimitives(x_3, y_3) | 0),
+            }), new Type(5, [tv_1])];
+        }
+        case 4: {
+            const startIndex = currentTelemetryCaptureCount() | 0;
+            const patternInput = inferPattern(typeDefs, constructors, pat.fields[0]);
+            const t1 = patternInput[1];
+            const patternInput_1 = inferPattern(typeDefs, constructors, pat.fields[1]);
+            const s = unify(empty({
+                Compare: (x_4, y_4) => (comparePrimitives(x_4, y_4) | 0),
+            }), patternInput_1[1], new Type(5, [t1]), pat.fields[2]);
+            applySubstToCapturedLocals(startIndex, s);
+            return [map_1((_arg, ty) => applyType(s, ty), fold_1((acc, k, v) => add(k, v, acc), patternInput[0], patternInput_1[0])), applyType(s, new Type(5, [t1]))];
+        }
+        case 5: {
+            const patternInput_3 = fold((tupledArg, p) => {
+                const patternInput_2 = inferPattern(typeDefs, constructors, p);
+                return [fold_1((acc_1, k_1, v_1) => add(k_1, v_1, acc_1), tupledArg[0], patternInput_2[0]), cons(patternInput_2[1], tupledArg[1])];
+            }, [empty({
+                Compare: (x_5, y_5) => (comparePrimitives(x_5, y_5) | 0),
+            }), empty_2()], pat.fields[0]);
+            return [patternInput_3[0], new Type(7, [reverse(patternInput_3[1])])];
+        }
+        case 6: {
+            const patternInput_5 = fold((tupledArg_1, tupledArg_2) => {
+                const patternInput_4 = inferPattern(typeDefs, constructors, tupledArg_2[1]);
+                return [fold_1((acc_2, k_2, v_2) => add(k_2, v_2, acc_2), tupledArg_1[0], patternInput_4[0]), add(tupledArg_2[0], patternInput_4[1], tupledArg_1[1])];
+            }, [empty({
+                Compare: (x_6, y_6) => (comparePrimitives(x_6, y_6) | 0),
+            }), empty({
+                Compare: (x_7, y_7) => (comparePrimitives(x_7, y_7) | 0),
+            })], pat.fields[0]);
+            return [patternInput_5[0], new Type(8, [patternInput_5[1]])];
+        }
+        case 7: {
+            const tailPattern = pat.fields[1];
+            const span_1 = pat.fields[2];
+            const startIndex_1 = currentTelemetryCaptureCount() | 0;
+            const ensureSupportedMapKeyType = (t_1) => {
+                switch (t_1.tag) {
+                    case 4:
+                    case 15: {
+                        break;
+                    }
+                    default:
+                        throw new TypeException(new TypeError$(concat("Map key type must be string, got ", Types_typeToString(t_1)), span_1));
+                }
+            };
+            const mapKeyType = Types_freshVar();
+            const valueType = Types_freshVar();
+            let sAcc = emptySubst;
+            let envAcc_2 = empty({
+                Compare: (x_8, y_8) => (comparePrimitives(x_8, y_8) | 0),
+            });
+            const enumerator = getEnumerator(pat.fields[0]);
+            try {
+                while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                    const forLoopVar = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const patternInput_6 = inferPattern(typeDefs, constructors, forLoopVar[0]);
+                    const patternInput_7 = inferPattern(typeDefs, constructors, forLoopVar[1]);
+                    const sKey = unify(typeDefs, applyType(sAcc, patternInput_6[1]), applyType(sAcc, mapKeyType), span_1);
+                    sAcc = compose(sKey, sAcc);
+                    ensureSupportedMapKeyType(applyType(sAcc, mapKeyType));
+                    const sValue = unify(typeDefs, applyType(sAcc, patternInput_7[1]), applyType(sAcc, valueType), span_1);
+                    sAcc = compose(sValue, sAcc);
+                    const mergedClauseEnv = map_1((_arg_1, t_2) => applyType(sAcc, t_2), fold_1((acc_3, k_3, v_3) => add(k_3, v_3, acc_3), patternInput_7[0], patternInput_6[0]));
+                    envAcc_2 = fold_1((acc_4, k_4, v_4) => add(k_4, v_4, acc_4), envAcc_2, mergedClauseEnv);
+                }
+            }
+            finally {
+                disposeSafe(enumerator);
+            }
+            if (tailPattern == null) {
+            }
+            else {
+                const patternInput_8 = inferPattern(typeDefs, constructors, tailPattern);
+                const expectedTailType = new Type(9, [applyType(sAcc, mapKeyType), applyType(sAcc, valueType)]);
+                const sTail = unify(typeDefs, applyType(sAcc, patternInput_8[1]), expectedTailType, span_1);
+                sAcc = compose(sTail, sAcc);
+                envAcc_2 = ((table_5 = map_1((_arg_2, t_3) => applyType(sAcc, t_3), patternInput_8[0]), fold_1((acc_5, k_5, v_5) => add(k_5, v_5, acc_5), envAcc_2, table_5)));
+            }
+            ensureSupportedMapKeyType(applyType(sAcc, mapKeyType));
+            applySubstToCapturedLocals(startIndex_1, sAcc);
+            return [map_1((_arg_3, t_4) => applyType(sAcc, t_4), envAcc_2), new Type(9, [applyType(sAcc, mapKeyType), applyType(sAcc, valueType)])];
+        }
+        case 8: {
+            const patternInput_9 = inferPattern(typeDefs, constructors, pat.fields[0]);
+            return [patternInput_9[0], new Type(10, [patternInput_9[1]])];
+        }
+        case 9: {
+            const tv_2 = Types_freshVar();
+            return [empty({
+                Compare: (x_9, y_9) => (comparePrimitives(x_9, y_9) | 0),
+            }), new Type(10, [tv_2])];
+        }
+        case 10: {
+            const span_2 = pat.fields[3];
+            const qualifier = pat.fields[0];
+            const payload = pat.fields[2];
+            const caseName = pat.fields[1];
+            const constructorName = (qualifier == null) ? caseName : concat(qualifier, ".", caseName);
+            const matchValue = FSharpMap__TryFind(constructors, constructorName);
+            if (matchValue != null) {
+                const sigInfo = matchValue;
+                const unionType = new Type(12, [sigInfo.UnionName]);
+                const matchValue_1 = sigInfo.Payload;
+                if (matchValue_1 != null) {
+                    if (payload == null) {
+                        throw new TypeException(new TypeError$(toText(printf("Union case \'%s\' requires a payload"))(constructorName), span_2));
+                    }
+                    else {
+                        const expectedPayload = matchValue_1;
+                        const payloadPattern = payload;
+                        const startIndex_2 = currentTelemetryCaptureCount() | 0;
+                        const patternInput_10 = inferPattern(typeDefs, constructors, payloadPattern);
+                        const s_1 = unify(typeDefs, patternInput_10[1], expectedPayload, span_2);
+                        applySubstToCapturedLocals(startIndex_2, s_1);
+                        return [map_1((_arg_4, t_6) => applyType(s_1, t_6), patternInput_10[0]), unionType];
+                    }
+                }
+                else if (payload != null) {
+                    throw new TypeException(new TypeError$(toText(printf("Union case \'%s\' does not take a payload"))(constructorName), span_2));
+                }
+                else {
+                    return [empty({
+                        Compare: (x_10, y_10) => (comparePrimitives(x_10, y_10) | 0),
+                    }), unionType];
+                }
+            }
+            else {
+                throw new TypeException(new TypeError$(toText(printf("Unknown union case \'%s\'"))(constructorName), span_2));
+            }
+        }
+        case 11:
+            return [empty({
+                Compare: (x_11, y_11) => (comparePrimitives(x_11, y_11) | 0),
+            }), annotationTypeFromRef(typeDefs, pat.fields[1], pat.fields[0])];
+        default:
+            return [empty({
+                Compare: (x, y) => (comparePrimitives(x, y) | 0),
+            }), Types_freshVar()];
+    }
+}
+
+function numericResult(t, span) {
+    switch (t.tag) {
+        case 1:
+        case 2:
+            return t;
+        case 15:
+            return new Type(1, []);
+        default:
+            throw new TypeException(new TypeError$("Expected numeric type", span));
+    }
+}
+
+function validateMapKeyTypes(span, t) {
+    const loop = (t_1_mut) => {
+        loop:
+        while (true) {
+            const t_1 = t_1_mut;
+            switch (t_1.tag) {
+                case 9: {
+                    const keyType = t_1.fields[0];
+                    loop(keyType);
+                    loop(t_1.fields[1]);
+                    switch (keyType.tag) {
+                        case 4:
+                        case 15: {
+                            break;
+                        }
+                        default:
+                            throw new TypeException(new TypeError$(concat("Map key type must be string, got ", Types_typeToString(keyType)), span));
+                    }
+                    break;
+                }
+                case 5: {
+                    t_1_mut = t_1.fields[0];
+                    continue loop;
+                    break;
+                }
+                case 6: {
+                    t_1_mut = t_1.fields[0];
+                    continue loop;
+                    break;
+                }
+                case 7: {
+                    iterate(loop, t_1.fields[0]);
+                    break;
+                }
+                case 8: {
+                    iterate_1(loop, values(t_1.fields[0]));
+                    break;
+                }
+                case 10: {
+                    t_1_mut = t_1.fields[0];
+                    continue loop;
+                    break;
+                }
+                case 11: {
+                    loop(t_1.fields[0]);
+                    t_1_mut = t_1.fields[1];
+                    continue loop;
+                    break;
+                }
+                default:
+                    undefined;
+            }
+            break;
+        }
+    };
+    loop(t);
+}
+
+function inferExpr(typeDefs, constructors, env, expr) {
+    let expectedReturn, expectedReturn_1;
+    switch (expr.tag) {
+        case 1: {
+            const lit = expr.fields[0];
+            const t = (lit.tag === 1) ? (new Type(2, [])) : ((lit.tag === 2) ? (new Type(3, [])) : ((lit.tag === 3) ? (new Type(4, [])) : (new Type(1, []))));
+            return [emptySubst, t, asTyped(expr, t)];
+        }
+        case 2: {
+            const span = expr.fields[1];
+            const name = expr.fields[0];
+            const matchValue = tryFind(name, env);
+            if (matchValue == null) {
+                throw new TypeException(new TypeError$(toText(printf("Unbound variable \'%s\'"))(name), span));
+            }
+            else {
+                const t_1 = instantiate(matchValue);
+                recordLocalVariableUse(name, span, t_1);
+                return [emptySubst, t_1, asTyped(expr, t_1)];
+            }
+        }
+        case 3: {
+            const patternInput = inferExpr(typeDefs, constructors, env, expr.fields[0]);
+            const t_2 = patternInput[1];
+            return [patternInput[0], t_2, asTyped(expr, t_2)];
+        }
+        case 28: {
+            const name_1 = expr.fields[0];
+            if (FSharpMap__ContainsKey(typeDefs, name_1)) {
+                return [emptySubst, new Type(14, []), asTyped(expr, new Type(14, []))];
+            }
+            else {
+                throw new TypeException(new TypeError$(toText(printf("Unknown type \'%s\'"))(name_1), expr.fields[1]));
+            }
+        }
+        case 29: {
+            const name_2 = expr.fields[0];
+            if (FSharpMap__ContainsKey(env, name_2)) {
+                return [emptySubst, new Type(4, []), asTyped(expr, new Type(4, []))];
+            }
+            else {
+                throw new TypeException(new TypeError$(toText(printf("Unbound variable \'%s\'"))(name_2), expr.fields[1]));
+            }
+        }
+        case 30: {
+            let sAcc = emptySubst;
+            const enumerator = getEnumerator(expr.fields[0]);
+            try {
+                while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                    const part = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    if (part.tag === 1) {
+                        const patternInput_1 = inferExpr(typeDefs, constructors, applyEnv(sAcc, env), part.fields[0]);
+                        sAcc = compose(patternInput_1[0], sAcc);
+                    }
+                }
+            }
+            finally {
+                disposeSafe(enumerator);
+            }
+            return [sAcc, new Type(4, []), asTyped(expr, new Type(4, []))];
+        }
+        case 4: {
+            const param = expr.fields[0];
+            let tv;
+            const matchValue_1 = param.Annotation;
+            tv = ((matchValue_1 == null) ? Types_freshVar() : annotationTypeFromRef(typeDefs, param.Span, matchValue_1));
+            recordLocalVariableDeclaration(param.Name, param.Span, tv);
+            const env$0027 = add(param.Name, new Scheme(empty_2(), tv), env);
+            const patternInput_2 = withLocalBindings(singleton(param.Name), () => inferExpr(typeDefs, constructors, env$0027, expr.fields[1]));
+            const s1_1 = patternInput_2[0];
+            const tFun = new Type(11, [applyType(s1_1, tv), patternInput_2[1]]);
+            return [s1_1, tFun, asTyped(expr, tFun)];
+        }
+        case 5: {
+            const patternInput_3 = inferExpr(typeDefs, constructors, env, expr.fields[0]);
+            const s1_2 = patternInput_3[0];
+            const patternInput_4 = inferExpr(typeDefs, constructors, applyEnv(s1_2, env), expr.fields[1]);
+            const s2 = patternInput_4[0];
+            const tv_1 = Types_freshVar();
+            const s_1 = compose(unify(typeDefs, applyType(s2, patternInput_3[1]), new Type(11, [patternInput_4[1], tv_1]), expr.fields[2]), compose(s2, s1_2));
+            const tRes = applyType(s_1, tv_1);
+            return [s_1, tRes, asTyped(expr, tRes)];
+        }
+        case 6: {
+            const span_5 = expr.fields[3];
+            const patternInput_5 = inferExpr(typeDefs, constructors, env, expr.fields[0]);
+            const s1_3 = patternInput_5[0];
+            const sBool = unify(typeDefs, patternInput_5[1], new Type(3, []), span_5);
+            const patternInput_6 = inferExpr(typeDefs, constructors, applyEnv(compose(sBool, s1_3), env), expr.fields[1]);
+            const s2_1 = patternInput_6[0];
+            const patternInput_7 = inferExpr(typeDefs, constructors, applyEnv(compose(s2_1, compose(sBool, s1_3)), env), expr.fields[2]);
+            const tElse = patternInput_7[1];
+            const s3_1 = patternInput_7[0];
+            const s_2 = compose(unify(typeDefs, applyType(s3_1, patternInput_6[1]), tElse, span_5), compose(s3_1, compose(s2_1, compose(sBool, s1_3))));
+            const tRes_1 = applyType(s_2, tElse);
+            return [s_2, tRes_1, asTyped(expr, tRes_1)];
+        }
+        case 7: {
+            const patternInput_8 = inferExpr(typeDefs, constructors, env, expr.fields[0]);
+            const s1_4 = patternInput_8[0];
+            const s_3 = compose(unify(typeDefs, applyType(s1_4, patternInput_8[1]), new Type(4, []), expr.fields[1]), s1_4);
+            const tRes_2 = Types_freshVar();
+            return [s_3, tRes_2, asTyped(expr, tRes_2)];
+        }
+        case 8: {
+            const name_3 = expr.fields[0];
+            const body_1 = expr.fields[2];
+            const patternInput_9 = inferExpr(typeDefs, constructors, env, expr.fields[1]);
+            const s1_5 = patternInput_9[0];
+            const tv_2 = Types_freshVar();
+            const sSource = compose(unify(typeDefs, applyType(s1_5, patternInput_9[1]), new Type(5, [tv_2]), expr.fields[3]), s1_5);
+            const envBody = add(name_3, new Scheme(empty_2(), applyType(sSource, tv_2)), applyEnv(sSource, env));
+            const patternInput_10 = withLocalBindings(singleton(name_3), () => inferExpr(typeDefs, constructors, envBody, body_1));
+            const s2_3 = patternInput_10[0];
+            return [compose(unify(typeDefs, applyType(s2_3, patternInput_10[1]), new Type(0, []), Ast_spanOfExpr(body_1)), compose(s2_3, sSource)), new Type(0, []), asTyped(expr, new Type(0, []))];
+        }
+        case 10: {
+            const value_3 = expr.fields[1];
+            const span_8 = expr.fields[5];
+            const returnAnnotation = expr.fields[4];
+            const name_4 = expr.fields[0];
+            const body_2 = expr.fields[2];
+            if (expr.fields[3]) {
+                const tv_3 = Types_freshVar();
+                const envRec = add(name_4, new Scheme(empty_2(), tv_3), env);
+                const patternInput_11 = withLocalBindings(singleton(name_4), () => inferExpr(typeDefs, constructors, envRec, value_3));
+                const t1_2 = patternInput_11[1];
+                const s1_6 = patternInput_11[0];
+                const s2_4 = unify(typeDefs, applyType(s1_6, tv_3), t1_2, span_8);
+                const sValue = compose((returnAnnotation == null) ? emptySubst : ((expectedReturn = annotationTypeFromRef(typeDefs, span_8, returnAnnotation), unify(typeDefs, functionReturnType(applyType(s2_4, t1_2)), expectedReturn, span_8))), compose(s2_4, s1_6));
+                const env1 = applyEnv(sValue, env);
+                const env2_2 = add(name_4, Types_generalize(env1, applyType(sValue, t1_2)), env1);
+                const patternInput_12 = withLocalBindings(singleton(name_4), () => inferExpr(typeDefs, constructors, env2_2, body_2));
+                const tBody_2 = patternInput_12[1];
+                return [compose(patternInput_12[0], sValue), tBody_2, asTyped(expr, tBody_2)];
+            }
+            else {
+                const patternInput_13 = inferExpr(typeDefs, constructors, env, value_3);
+                const t1_3 = patternInput_13[1];
+                const s1_7 = patternInput_13[0];
+                const sDiscard = (name_4 === "_") ? unify(typeDefs, applyType(s1_7, t1_3), new Type(0, []), Ast_spanOfExpr(value_3)) : emptySubst;
+                const sValue_1 = compose((returnAnnotation == null) ? emptySubst : ((expectedReturn_1 = annotationTypeFromRef(typeDefs, span_8, returnAnnotation), unify(typeDefs, functionReturnType(applyType(sDiscard, t1_3)), expectedReturn_1, span_8))), compose(sDiscard, s1_7));
+                const env1_1 = applyEnv(sValue_1, env);
+                const env2_3 = add(name_4, Types_generalize(env1_1, applyType(sValue_1, t1_3)), env1_1);
+                const patternInput_14 = withLocalBindings(singleton(name_4), () => inferExpr(typeDefs, constructors, env2_3, body_2));
+                const t2_1 = patternInput_14[1];
+                return [compose(patternInput_14[0], sValue_1), t2_1, asTyped(expr, t2_1)];
+            }
+        }
+        case 11: {
+            const startIndex = currentTelemetryCaptureCount() | 0;
+            const patternInput_15 = inferExpr(typeDefs, constructors, env, expr.fields[1]);
+            const s1_8 = patternInput_15[0];
+            const patternInput_16 = inferPattern(typeDefs, constructors, expr.fields[0]);
+            const sValue_2 = compose(unify(typeDefs, applyType(s1_8, patternInput_15[1]), patternInput_16[1], expr.fields[3]), s1_8);
+            applySubstToCapturedLocals(startIndex, sValue_2);
+            const env1_2 = applyEnv(sValue_2, env);
+            const envPatTyped = map_1((_arg, ty) => applyType(sValue_2, ty), patternInput_16[0]);
+            const env2_4 = fold_1((state, name_5, bindingType) => add(name_5, Types_generalize(env1_2, bindingType), state), env1_2, envPatTyped);
+            const patternInput_17 = withLocalBindings(map((tuple) => tuple[0], toList(envPatTyped)), () => inferExpr(typeDefs, constructors, env2_4, expr.fields[2]));
+            const tBody_3 = patternInput_17[1];
+            return [compose(patternInput_17[0], sValue_2), tBody_3, asTyped(expr, tBody_3)];
+        }
+        case 12: {
+            const foldedBindings = map((tupledArg) => {
+                const args = tupledArg[1];
+                const bindingSpan = tupledArg[4];
+                if (isEmpty(args)) {
+                    throw new TypeException(new TypeError$("\'let rec ... and ...\' requires function arguments for each binding", bindingSpan));
+                }
+                return [tupledArg[0], tupledArg[2], foldBack((arg_4, acc) => (new Expr(4, [arg_4, acc, bindingSpan])), args, tupledArg[3]), bindingSpan];
+            }, expr.fields[0]);
+            const freshByName = ofList(map((tupledArg_1) => [tupledArg_1[0], Types_freshVar()], foldedBindings), {
+                Compare: (x, y) => (comparePrimitives(x, y) | 0),
+            });
+            const envRec_1 = fold_1((acc_1, name_8, tv_4) => add(name_8, new Scheme(empty_2(), tv_4), acc_1), env, freshByName);
+            let sRec = emptySubst;
+            const recursiveNames = map((tuple_1) => tuple_1[0], toList(freshByName));
+            withLocalBindings(recursiveNames, () => {
+                const enumerator_1 = getEnumerator(foldedBindings);
+                try {
+                    while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+                        const forLoopVar = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                        const patternInput_18 = inferExpr(typeDefs, constructors, applyEnv(sRec, envRec_1), forLoopVar[2]);
+                        const s1_9 = patternInput_18[0];
+                        const s2_7 = unify(typeDefs, applyType(s1_9, applyType(sRec, FSharpMap__get_Item(freshByName, forLoopVar[0]))), patternInput_18[1], forLoopVar[3]);
+                        sRec = compose(s2_7, compose(s1_9, sRec));
+                    }
+                }
+                finally {
+                    disposeSafe(enumerator_1);
+                }
+            });
+            const enumerator_2 = getEnumerator(foldedBindings);
+            try {
+                while (enumerator_2["System.Collections.IEnumerator.MoveNext"]()) {
+                    const forLoopVar_1 = enumerator_2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const returnAnnotation_2 = forLoopVar_1[1];
+                    const bindingSpan_2 = forLoopVar_1[3];
+                    if (returnAnnotation_2 == null) {
+                    }
+                    else {
+                        const expectedReturn_2 = annotationTypeFromRef(typeDefs, bindingSpan_2, returnAnnotation_2);
+                        const sRet_2 = unify(typeDefs, functionReturnType(applyType(sRec, FSharpMap__get_Item(freshByName, forLoopVar_1[0]))), expectedReturn_2, bindingSpan_2);
+                        sRec = compose(sRet_2, sRec);
+                    }
+                }
+            }
+            finally {
+                disposeSafe(enumerator_2);
+            }
+            const envGeneralize = applyEnv(sRec, env);
+            const envBody_1 = fold((acc_2, tupledArg_3) => add(tupledArg_3[0], tupledArg_3[1], acc_2), envGeneralize, map((tupledArg_2) => {
+                const name_11 = tupledArg_2[0];
+                return [name_11, Types_generalize(envGeneralize, applyType(sRec, FSharpMap__get_Item(freshByName, name_11)))];
+            }, foldedBindings));
+            const patternInput_19 = withLocalBindings(recursiveNames, () => inferExpr(typeDefs, constructors, envBody_1, expr.fields[1]));
+            const tBody_4 = patternInput_19[1];
+            return [compose(patternInput_19[0], sRec), tBody_4, asTyped(expr, tBody_4)];
+        }
+        case 9: {
+            const patternInput_20 = inferExpr(typeDefs, constructors, env, expr.fields[0]);
+            const tScrut = patternInput_20[1];
+            let sAcc_1 = patternInput_20[0];
+            let resultTypeOpt = undefined;
+            const enumerator_3 = getEnumerator(expr.fields[1]);
+            try {
+                while (enumerator_3["System.Collections.IEnumerator.MoveNext"]()) {
+                    let tPrev, sEq;
+                    const forLoopVar_2 = enumerator_3["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const pat_1 = forLoopVar_2[0];
+                    const guard = forLoopVar_2[1];
+                    const caseSpan = forLoopVar_2[3];
+                    const patternInput_21 = inferPattern(typeDefs, constructors, pat_1);
+                    const tPat_1 = patternInput_21[1];
+                    const envPat_1 = patternInput_21[0];
+                    let sPat;
+                    const matchValue_2 = applyType(sAcc_1, tScrut);
+                    let matchResult, patFields, scrutFields, patFields_1, typeName;
+                    if (pat_1.tag === 6) {
+                        switch (matchValue_2.tag) {
+                            case 8: {
+                                if (tPat_1.tag === 8) {
+                                    matchResult = 0;
+                                    patFields = tPat_1.fields[0];
+                                    scrutFields = matchValue_2.fields[0];
+                                }
+                                else {
+                                    matchResult = 2;
+                                }
+                                break;
+                            }
+                            case 12: {
+                                if (tPat_1.tag === 8) {
+                                    matchResult = 1;
+                                    patFields_1 = tPat_1.fields[0];
+                                    typeName = matchValue_2.fields[0];
+                                }
+                                else {
+                                    matchResult = 2;
+                                }
+                                break;
+                            }
+                            default:
+                                matchResult = 2;
+                        }
+                    }
+                    else {
+                        matchResult = 3;
+                    }
+                    switch (matchResult) {
+                        case 0: {
+                            sPat = fold_1((sLocal, field, patTy) => {
+                                const matchValue_4 = FSharpMap__TryFind(scrutFields, field);
+                                if (matchValue_4 == null) {
+                                    throw new TypeException(new TypeError$(toText(printf("Record field \'%s\' not found"))(field), caseSpan));
+                                }
+                                else {
+                                    return compose(unify(typeDefs, applyType(sLocal, matchValue_4), applyType(sLocal, patTy), caseSpan), sLocal);
+                                }
+                            }, emptySubst, patFields);
+                            break;
+                        }
+                        case 1: {
+                            const matchValue_5 = FSharpMap__TryFind(typeDefs, typeName);
+                            let matchResult_1, scrutFields_1;
+                            if (matchValue_5 != null) {
+                                if (matchValue_5.tag === 8) {
+                                    matchResult_1 = 0;
+                                    scrutFields_1 = matchValue_5.fields[0];
+                                }
+                                else {
+                                    matchResult_1 = 1;
+                                }
+                            }
+                            else {
+                                matchResult_1 = 1;
+                            }
+                            switch (matchResult_1) {
+                                case 0: {
+                                    sPat = fold_1((sLocal_1, field_1, patTy_1) => {
+                                        const matchValue_6 = FSharpMap__TryFind(scrutFields_1, field_1);
+                                        if (matchValue_6 == null) {
+                                            throw new TypeException(new TypeError$(toText(printf("Record field \'%s\' not found"))(field_1), caseSpan));
+                                        }
+                                        else {
+                                            return compose(unify(typeDefs, applyType(sLocal_1, matchValue_6), applyType(sLocal_1, patTy_1), caseSpan), sLocal_1);
+                                        }
+                                    }, emptySubst, patFields_1);
+                                    break;
+                                }
+                                default:
+                                    throw new TypeException(new TypeError$("Record pattern requires a concrete record scrutinee type", caseSpan));
+                            }
+                            break;
+                        }
+                        case 2: {
+                            throw new TypeException(new TypeError$("Record pattern requires a concrete record scrutinee type", caseSpan));
+                            break;
+                        }
+                        default:
+                            sPat = unify(typeDefs, applyType(sAcc_1, tScrut), tPat_1, caseSpan);
+                    }
+                    const envCase$0027 = fold_1((acc_3, k, v) => add(k, new Scheme(empty_2(), applyType(sPat, v)), acc_3), applyEnv(compose(sPat, sAcc_1), env), envPat_1);
+                    const patternInput_23 = withLocalBindings(map((tuple_2) => tuple_2[0], toList(envPat_1)), () => {
+                        let envBodyCase = envCase$0027;
+                        if (guard == null) {
+                        }
+                        else {
+                            const guardExpr = guard;
+                            const patternInput_22 = inferExpr(typeDefs, constructors, envBodyCase, guardExpr);
+                            const sGuard = patternInput_22[0];
+                            const sGuardBool = unify(typeDefs, applyType(sGuard, patternInput_22[1]), new Type(3, []), caseSpan);
+                            sAcc_1 = compose(sGuardBool, compose(sGuard, sAcc_1));
+                            envBodyCase = applyEnv(compose(sGuardBool, sGuard), envBodyCase);
+                        }
+                        return inferExpr(typeDefs, constructors, envBodyCase, forLoopVar_2[2]);
+                    });
+                    const sBody_2 = patternInput_23[0];
+                    const tBody$0027 = applyType(sBody_2, patternInput_23[1]);
+                    resultTypeOpt = ((resultTypeOpt != null) ? ((tPrev = resultTypeOpt, (sEq = unify(typeDefs, tPrev, tBody$0027, caseSpan), (sAcc_1 = compose(sEq, sAcc_1), applyType(sEq, tPrev))))) : tBody$0027);
+                    sAcc_1 = compose(sBody_2, compose(sPat, sAcc_1));
+                }
+            }
+            finally {
+                disposeSafe(enumerator_3);
+            }
+            const tRes_3 = defaultArg(resultTypeOpt, Types_freshVar());
+            return [sAcc_1, tRes_3, asTyped(expr, tRes_3)];
+        }
+        case 13: {
+            const tv_5 = Types_freshVar();
+            let sAcc_2 = emptySubst;
+            const enumerator_4 = getEnumerator(expr.fields[0]);
+            try {
+                while (enumerator_4["System.Collections.IEnumerator.MoveNext"]()) {
+                    const item = enumerator_4["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const patternInput_24 = inferExpr(typeDefs, constructors, applyEnv(sAcc_2, env), item);
+                    const s1_11 = patternInput_24[0];
+                    const s2_8 = unify(typeDefs, applyType(s1_11, tv_5), patternInput_24[1], expr.fields[1]);
+                    sAcc_2 = compose(s2_8, compose(s1_11, sAcc_2));
+                }
+            }
+            finally {
+                disposeSafe(enumerator_4);
+            }
+            const tRes_4 = new Type(5, [applyType(sAcc_2, tv_5)]);
+            return [sAcc_2, tRes_4, asTyped(expr, tRes_4)];
+        }
+        case 14: {
+            const span_13 = expr.fields[2];
+            const patternInput_25 = inferExpr(typeDefs, constructors, env, expr.fields[0]);
+            const s1_12 = patternInput_25[0];
+            const patternInput_26 = inferExpr(typeDefs, constructors, applyEnv(s1_12, env), expr.fields[1]);
+            const s2_9 = patternInput_26[0];
+            const s3_3 = unify(typeDefs, applyType(s2_9, patternInput_25[1]), new Type(1, []), span_13);
+            const tRes_5 = new Type(5, [new Type(1, [])]);
+            return [compose(unify(typeDefs, applyType(s3_3, applyType(s2_9, patternInput_26[1])), new Type(1, []), span_13), compose(s3_3, compose(s2_9, s1_12))), tRes_5, asTyped(expr, tRes_5)];
+        }
+        case 15: {
+            let sAcc_3 = emptySubst;
+            let inferred_1 = empty_2();
+            const enumerator_5 = getEnumerator(expr.fields[0]);
+            try {
+                while (enumerator_5["System.Collections.IEnumerator.MoveNext"]()) {
+                    const item_1 = enumerator_5["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const patternInput_27 = inferExpr(typeDefs, constructors, applyEnv(sAcc_3, env), item_1);
+                    sAcc_3 = compose(patternInput_27[0], sAcc_3);
+                    inferred_1 = append(inferred_1, singleton(applyType(sAcc_3, patternInput_27[1])));
+                }
+            }
+            finally {
+                disposeSafe(enumerator_5);
+            }
+            const tRes_6 = new Type(7, [inferred_1]);
+            return [sAcc_3, tRes_6, asTyped(expr, tRes_6)];
+        }
+        case 16: {
+            const span_14 = expr.fields[1];
+            let sAcc_4 = emptySubst;
+            let inferred_2 = empty({
+                Compare: (x_1, y_1) => (comparePrimitives(x_1, y_1) | 0),
+            });
+            const enumerator_6 = getEnumerator(expr.fields[0]);
+            try {
+                while (enumerator_6["System.Collections.IEnumerator.MoveNext"]()) {
+                    const forLoopVar_3 = enumerator_6["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const patternInput_28 = inferExpr(typeDefs, constructors, applyEnv(sAcc_4, env), forLoopVar_3[1]);
+                    sAcc_4 = compose(patternInput_28[0], sAcc_4);
+                    inferred_2 = FSharpMap__Add(inferred_2, forLoopVar_3[0], applyType(sAcc_4, patternInput_28[1]));
+                }
+            }
+            finally {
+                disposeSafe(enumerator_6);
+            }
+            const expected_1 = new Type(12, [resolveNamedRecordByFieldSet(typeDefs, ofSeq(keys(inferred_2), {
+                Compare: (x_2, y_2) => (comparePrimitives(x_2, y_2) | 0),
+            }), span_14)]);
+            const s_10 = compose(unify(typeDefs, applyType(sAcc_4, new Type(8, [inferred_2])), expected_1, span_14), sAcc_4);
+            const tRes_7 = applyType(s_10, expected_1);
+            return [s_10, tRes_7, asTyped(expr, tRes_7)];
+        }
+        case 17: {
+            let sAcc_5 = emptySubst;
+            let inferred_3 = empty({
+                Compare: (x_3, y_3) => (comparePrimitives(x_3, y_3) | 0),
+            });
+            const enumerator_7 = getEnumerator(expr.fields[0]);
+            try {
+                while (enumerator_7["System.Collections.IEnumerator.MoveNext"]()) {
+                    const forLoopVar_4 = enumerator_7["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const patternInput_29 = inferExpr(typeDefs, constructors, applyEnv(sAcc_5, env), forLoopVar_4[1]);
+                    sAcc_5 = compose(patternInput_29[0], sAcc_5);
+                    inferred_3 = FSharpMap__Add(inferred_3, forLoopVar_4[0], applyType(sAcc_5, patternInput_29[1]));
+                }
+            }
+            finally {
+                disposeSafe(enumerator_7);
+            }
+            const tRes_8 = new Type(8, [inferred_3]);
+            return [sAcc_5, tRes_8, asTyped(expr, tRes_8)];
+        }
+        case 18: {
+            const ensureSupportedMapKeyType = (t_3) => {
+                switch (t_3.tag) {
+                    case 4:
+                    case 15: {
+                        break;
+                    }
+                    default:
+                        throw new TypeException(new TypeError$(concat("Map key type must be string, got ", Types_typeToString(t_3)), expr.fields[1]));
+                }
+            };
+            const keyType = Types_freshVar();
+            const valueType = Types_freshVar();
+            let sAcc_6 = emptySubst;
+            const enumerator_8 = getEnumerator(expr.fields[0]);
+            try {
+                while (enumerator_8["System.Collections.IEnumerator.MoveNext"]()) {
+                    const entry = enumerator_8["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    if (entry.tag === 1) {
+                        const spreadExpr = entry.fields[0];
+                        const patternInput_32 = inferExpr(typeDefs, constructors, applyEnv(sAcc_6, env), spreadExpr);
+                        const sSpread = patternInput_32[0];
+                        const expectedSpreadType = new Type(9, [applyType(sSpread, applyType(sAcc_6, keyType)), applyType(sSpread, applyType(sAcc_6, valueType))]);
+                        const sSpreadMap = unify(typeDefs, applyType(sSpread, patternInput_32[1]), expectedSpreadType, Ast_spanOfExpr(spreadExpr));
+                        sAcc_6 = compose(sSpreadMap, compose(sSpread, sAcc_6));
+                    }
+                    else {
+                        const valueExpr_3 = entry.fields[1];
+                        const keyExpr = entry.fields[0];
+                        const patternInput_30 = inferExpr(typeDefs, constructors, applyEnv(sAcc_6, env), keyExpr);
+                        const sKey = patternInput_30[0];
+                        const sAfterKey = compose(unify(typeDefs, applyType(sKey, patternInput_30[1]), applyType(sKey, applyType(sAcc_6, keyType)), Ast_spanOfExpr(keyExpr)), compose(sKey, sAcc_6));
+                        ensureSupportedMapKeyType(applyType(sAfterKey, keyType));
+                        const patternInput_31 = inferExpr(typeDefs, constructors, applyEnv(sAfterKey, env), valueExpr_3);
+                        const sValue_3 = patternInput_31[0];
+                        const sValueType = unify(typeDefs, applyType(sValue_3, applyType(sAfterKey, valueType)), patternInput_31[1], Ast_spanOfExpr(valueExpr_3));
+                        sAcc_6 = compose(sValueType, compose(sValue_3, sAfterKey));
+                    }
+                }
+            }
+            finally {
+                disposeSafe(enumerator_8);
+            }
+            ensureSupportedMapKeyType(applyType(sAcc_6, keyType));
+            const tRes_9 = new Type(9, [applyType(sAcc_6, keyType), applyType(sAcc_6, valueType)]);
+            return [sAcc_6, tRes_9, asTyped(expr, tRes_9)];
+        }
+        case 19: {
+            const span_16 = expr.fields[2];
+            const patternInput_33 = inferExpr(typeDefs, constructors, env, expr.fields[0]);
+            const sBase = patternInput_33[0];
+            let baseFields;
+            const matchValue_7 = applyType(sBase, patternInput_33[1]);
+            switch (matchValue_7.tag) {
+                case 8: {
+                    baseFields = matchValue_7.fields[0];
+                    break;
+                }
+                case 12: {
+                    const matchValue_8 = FSharpMap__TryFind(typeDefs, matchValue_7.fields[0]);
+                    let matchResult_2, fields_3;
+                    if (matchValue_8 != null) {
+                        if (matchValue_8.tag === 8) {
+                            matchResult_2 = 0;
+                            fields_3 = matchValue_8.fields[0];
+                        }
+                        else {
+                            matchResult_2 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_2 = 1;
+                    }
+                    switch (matchResult_2) {
+                        case 0: {
+                            baseFields = fields_3;
+                            break;
+                        }
+                        default:
+                            throw new TypeException(new TypeError$("Record update requires a record value", span_16));
+                    }
+                    break;
+                }
+                default:
+                    throw new TypeException(new TypeError$("Record update requires a record value", span_16));
+            }
+            let sAcc_7 = sBase;
+            const enumerator_9 = getEnumerator(expr.fields[1]);
+            try {
+                while (enumerator_9["System.Collections.IEnumerator.MoveNext"]()) {
+                    const forLoopVar_5 = enumerator_9["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const valueExpr_4 = forLoopVar_5[1];
+                    const name_16 = forLoopVar_5[0];
+                    let expectedFieldType;
+                    const matchValue_9 = FSharpMap__TryFind(baseFields, name_16);
+                    if (matchValue_9 == null) {
+                        throw new TypeException(new TypeError$(toText(printf("Record field \'%s\' not found"))(name_16), Ast_spanOfExpr(valueExpr_4)));
+                    }
+                    else {
+                        expectedFieldType = matchValue_9;
+                    }
+                    const patternInput_34 = inferExpr(typeDefs, constructors, applyEnv(sAcc_7, env), valueExpr_4);
+                    const sField_2 = patternInput_34[0];
+                    const sEq_1 = unify(typeDefs, applyType(sField_2, applyType(sAcc_7, expectedFieldType)), patternInput_34[1], Ast_spanOfExpr(valueExpr_4));
+                    sAcc_7 = compose(sEq_1, compose(sField_2, sAcc_7));
+                }
+            }
+            finally {
+                disposeSafe(enumerator_9);
+            }
+            const tRes_10 = new Type(8, [map_1((_arg_7, t_5) => applyType(sAcc_7, t_5), baseFields)]);
+            return [sAcc_7, tRes_10, asTyped(expr, tRes_10)];
+        }
+        case 20: {
+            const span_17 = expr.fields[2];
+            const patternInput_35 = inferExpr(typeDefs, constructors, env, expr.fields[0]);
+            const sBase_1 = patternInput_35[0];
+            let sAcc_8 = sBase_1;
+            let resultFields_1;
+            const matchValue_10 = applyType(sBase_1, patternInput_35[1]);
+            switch (matchValue_10.tag) {
+                case 8: {
+                    resultFields_1 = matchValue_10.fields[0];
+                    break;
+                }
+                case 12: {
+                    const matchValue_11 = FSharpMap__TryFind(typeDefs, matchValue_10.fields[0]);
+                    let matchResult_3, fields_5;
+                    if (matchValue_11 != null) {
+                        if (matchValue_11.tag === 8) {
+                            matchResult_3 = 0;
+                            fields_5 = matchValue_11.fields[0];
+                        }
+                        else {
+                            matchResult_3 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_3 = 1;
+                    }
+                    switch (matchResult_3) {
+                        case 0: {
+                            resultFields_1 = fields_5;
+                            break;
+                        }
+                        default:
+                            throw new TypeException(new TypeError$("Structural record update requires a record value", span_17));
+                    }
+                    break;
+                }
+                default:
+                    throw new TypeException(new TypeError$("Structural record update requires a record value", span_17));
+            }
+            const enumerator_10 = getEnumerator(expr.fields[1]);
+            try {
+                while (enumerator_10["System.Collections.IEnumerator.MoveNext"]()) {
+                    let matchValue_12, existingFieldType, table_17;
+                    const forLoopVar_6 = enumerator_10["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const valueExpr_5 = forLoopVar_6[1];
+                    const name_18 = forLoopVar_6[0];
+                    const patternInput_36 = inferExpr(typeDefs, constructors, applyEnv(sAcc_8, env), valueExpr_5);
+                    const sField_3 = patternInput_36[0];
+                    const tFieldApplied = applyType(sField_3, patternInput_36[1]);
+                    const sEq_2 = unify(typeDefs, (matchValue_12 = FSharpMap__TryFind(resultFields_1, name_18), (matchValue_12 == null) ? tFieldApplied : ((existingFieldType = matchValue_12, applyType(sField_3, applyType(sAcc_8, existingFieldType))))), tFieldApplied, Ast_spanOfExpr(valueExpr_5));
+                    sAcc_8 = compose(sEq_2, compose(sField_3, sAcc_8));
+                    resultFields_1 = ((table_17 = resultFields_1, add(name_18, applyType(sAcc_8, tFieldApplied), table_17)));
+                }
+            }
+            finally {
+                disposeSafe(enumerator_10);
+            }
+            const tRes_11 = new Type(8, [map_1((_arg_8, t_6) => applyType(sAcc_8, t_6), resultFields_1)]);
+            return [sAcc_8, tRes_11, asTyped(expr, tRes_11)];
+        }
+        case 21: {
+            const target = expr.fields[0];
+            const span_18 = expr.fields[2];
+            const fieldName = expr.fields[1];
+            const inferRecordField = (s1_16, tTarget) => {
+                const matchValue_13 = applyType(s1_16, tTarget);
+                switch (matchValue_13.tag) {
+                    case 8: {
+                        const matchValue_14 = FSharpMap__TryFind(matchValue_13.fields[0], fieldName);
+                        if (matchValue_14 == null) {
+                            throw new TypeException(new TypeError$(toText(printf("Record field \'%s\' not found"))(fieldName), span_18));
+                        }
+                        else {
+                            return [s1_16, matchValue_14];
+                        }
+                    }
+                    case 12: {
+                        const matchValue_15 = FSharpMap__TryFind(typeDefs, matchValue_13.fields[0]);
+                        let matchResult_4, fields_7;
+                        if (matchValue_15 != null) {
+                            if (matchValue_15.tag === 8) {
+                                matchResult_4 = 0;
+                                fields_7 = matchValue_15.fields[0];
+                            }
+                            else {
+                                matchResult_4 = 1;
+                            }
+                        }
+                        else {
+                            matchResult_4 = 1;
+                        }
+                        switch (matchResult_4) {
+                            case 0: {
+                                const matchValue_16 = FSharpMap__TryFind(fields_7, fieldName);
+                                if (matchValue_16 == null) {
+                                    throw new TypeException(new TypeError$(toText(printf("Record field \'%s\' not found"))(fieldName), span_18));
+                                }
+                                else {
+                                    return [s1_16, matchValue_16];
+                                }
+                            }
+                            default:
+                                throw new TypeException(new TypeError$("Field access requires a record value", span_18));
+                        }
+                    }
+                    case 15: {
+                        const tField_4 = Types_freshVar();
+                        const s_11 = compose(unify(typeDefs, matchValue_13, new Type(8, [ofList(singleton([fieldName, tField_4]), {
+                            Compare: (x_4, y_4) => (comparePrimitives(x_4, y_4) | 0),
+                        })]), span_18), s1_16);
+                        return [s_11, applyType(s_11, tField_4)];
+                    }
+                    default:
+                        throw new TypeException(new TypeError$("Field access requires a record value", span_18));
+                }
+            };
+            let matchResult_5, moduleName_1;
+            if (target.tag === 2) {
+                if (!FSharpMap__ContainsKey(env, target.fields[0])) {
+                    matchResult_5 = 0;
+                    moduleName_1 = target.fields[0];
+                }
+                else {
+                    matchResult_5 = 1;
+                }
+            }
+            else {
+                matchResult_5 = 1;
+            }
+            switch (matchResult_5) {
+                case 0: {
+                    const matchValue_17 = FSharpMap__TryFind(env, concat(moduleName_1, ".", fieldName));
+                    if (matchValue_17 == null) {
+                        const patternInput_37 = inferExpr(typeDefs, constructors, env, target);
+                        const patternInput_38 = inferRecordField(patternInput_37[0], patternInput_37[1]);
+                        const tField_5 = patternInput_38[1];
+                        return [patternInput_38[0], tField_5, asTyped(expr, tField_5)];
+                    }
+                    else {
+                        const t_7 = instantiate(matchValue_17);
+                        return [emptySubst, t_7, asTyped(expr, t_7)];
+                    }
+                }
+                default: {
+                    const patternInput_39 = inferExpr(typeDefs, constructors, env, target);
+                    const patternInput_40 = inferRecordField(patternInput_39[0], patternInput_39[1]);
+                    const tField_6 = patternInput_40[1];
+                    return [patternInput_40[0], tField_6, asTyped(expr, tField_6)];
+                }
+            }
+        }
+        case 22: {
+            const span_19 = expr.fields[2];
+            const patternInput_41 = inferExpr(typeDefs, constructors, env, expr.fields[0]);
+            const s1_19 = patternInput_41[0];
+            const patternInput_42 = inferExpr(typeDefs, constructors, applyEnv(s1_19, env), expr.fields[1]);
+            const s2_10 = patternInput_42[0];
+            const targetType = applyType(s2_10, patternInput_41[1]);
+            const keyType_1 = applyType(s2_10, patternInput_42[1]);
+            let matchResult_6, itemType_1, mapKeyType, valueType_1;
+            switch (targetType.tag) {
+                case 5: {
+                    matchResult_6 = 0;
+                    itemType_1 = targetType.fields[0];
+                    break;
+                }
+                case 9: {
+                    matchResult_6 = 1;
+                    mapKeyType = targetType.fields[0];
+                    valueType_1 = targetType.fields[1];
+                    break;
+                }
+                case 15: {
+                    switch (keyType_1.tag) {
+                        case 1: {
+                            matchResult_6 = 2;
+                            break;
+                        }
+                        case 4: {
+                            matchResult_6 = 3;
+                            break;
+                        }
+                        case 15: {
+                            matchResult_6 = 4;
+                            break;
+                        }
+                        default:
+                            matchResult_6 = 5;
+                    }
+                    break;
+                }
+                default:
+                    matchResult_6 = 5;
+            }
+            switch (matchResult_6) {
+                case 0: {
+                    const s_12 = compose(unify(typeDefs, keyType_1, new Type(1, []), span_19), compose(s2_10, s1_19));
+                    const tRes_12 = new Type(10, [applyType(s_12, itemType_1)]);
+                    return [s_12, tRes_12, asTyped(expr, tRes_12)];
+                }
+                case 1: {
+                    const s_13 = compose(unify(typeDefs, keyType_1, mapKeyType, span_19), compose(s2_10, s1_19));
+                    const matchValue_19 = applyType(s_13, mapKeyType);
+                    switch (matchValue_19.tag) {
+                        case 4:
+                        case 15: {
+                            break;
+                        }
+                        default:
+                            throw new TypeException(new TypeError$(concat("Map key type must be string, got ", Types_typeToString(matchValue_19)), span_19));
+                    }
+                    const tRes_13 = new Type(10, [applyType(s_13, valueType_1)]);
+                    return [s_13, tRes_13, asTyped(expr, tRes_13)];
+                }
+                case 2: {
+                    const itemType_2 = Types_freshVar();
+                    const s_14 = compose(unify(typeDefs, targetType, new Type(5, [itemType_2]), span_19), compose(s2_10, s1_19));
+                    const tRes_14 = new Type(10, [applyType(s_14, itemType_2)]);
+                    return [s_14, tRes_14, asTyped(expr, tRes_14)];
+                }
+                case 3: {
+                    const valueType_2 = Types_freshVar();
+                    const s_15 = compose(unify(typeDefs, targetType, new Type(9, [new Type(4, []), valueType_2]), span_19), compose(s2_10, s1_19));
+                    const tRes_15 = new Type(10, [applyType(s_15, valueType_2)]);
+                    return [s_15, tRes_15, asTyped(expr, tRes_15)];
+                }
+                case 4:
+                    throw new TypeException(new TypeError$("Ambiguous index access: use a list with int index or a map with string key", span_19));
+                default:
+                    throw new TypeException(new TypeError$(concat("Index access requires a ", (keyType_1.tag === 1) ? "list" : ((keyType_1.tag === 4) ? "map" : "list or map"), " target with a compatible index type"), span_19));
+            }
+        }
+        case 25: {
+            const span_20 = expr.fields[3];
+            const op = expr.fields[0];
+            const b = expr.fields[2];
+            const a = expr.fields[1];
+            switch (op) {
+                case "|>": {
+                    const patternInput_43 = inferExpr(typeDefs, constructors, env, a);
+                    const s1_20 = patternInput_43[0];
+                    const patternInput_44 = inferExpr(typeDefs, constructors, applyEnv(s1_20, env), b);
+                    const s2_11 = patternInput_44[0];
+                    const tv_7 = Types_freshVar();
+                    const s_16 = compose(unify(typeDefs, applyType(s2_11, patternInput_44[1]), new Type(11, [applyType(s2_11, patternInput_43[1]), tv_7]), span_20), compose(s2_11, s1_20));
+                    const tRes_16 = applyType(s_16, tv_7);
+                    return [s_16, tRes_16, asTyped(expr, tRes_16)];
+                }
+                case "::": {
+                    const patternInput_45 = inferExpr(typeDefs, constructors, env, a);
+                    const tHead = patternInput_45[1];
+                    const s1_21 = patternInput_45[0];
+                    const patternInput_46 = inferExpr(typeDefs, constructors, applyEnv(s1_21, env), b);
+                    const s2_12 = patternInput_46[0];
+                    const s_17 = compose(unify(typeDefs, applyType(s2_12, patternInput_46[1]), new Type(5, [tHead]), span_20), compose(s2_12, s1_21));
+                    const tRes_17 = applyType(s_17, new Type(5, [tHead]));
+                    return [s_17, tRes_17, asTyped(expr, tRes_17)];
+                }
+                case "@": {
+                    const patternInput_47 = inferExpr(typeDefs, constructors, env, a);
+                    const s1_22 = patternInput_47[0];
+                    const patternInput_48 = inferExpr(typeDefs, constructors, applyEnv(s1_22, env), b);
+                    const s2_13 = patternInput_48[0];
+                    const tv_8 = Types_freshVar();
+                    const s3_10 = unify(typeDefs, applyType(s2_13, patternInput_47[1]), new Type(5, [tv_8]), span_20);
+                    const s_18 = compose(unify(typeDefs, applyType(s3_10, applyType(s2_13, patternInput_48[1])), new Type(5, [applyType(s3_10, tv_8)]), span_20), compose(s3_10, compose(s2_13, s1_22)));
+                    const tRes_18 = new Type(5, [applyType(s_18, tv_8)]);
+                    return [s_18, tRes_18, asTyped(expr, tRes_18)];
+                }
+                default: {
+                    const patternInput_49 = inferExpr(typeDefs, constructors, env, a);
+                    const s1_23 = patternInput_49[0];
+                    const patternInput_50 = inferExpr(typeDefs, constructors, applyEnv(s1_23, env), b);
+                    const t2_3 = patternInput_50[1];
+                    const s2_14 = patternInput_50[0];
+                    const s3_11 = unify(typeDefs, applyType(s2_14, patternInput_49[1]), t2_3, span_20);
+                    const t_9 = applyType(s3_11, t2_3);
+                    let resultType;
+                    switch (op) {
+                        case "+":
+                        case "-":
+                        case "*":
+                        case "/":
+                        case "%": {
+                            resultType = numericResult(t_9, span_20);
+                            break;
+                        }
+                        case "=": {
+                            resultType = (new Type(3, []));
+                            break;
+                        }
+                        case "<":
+                        case ">":
+                        case "<=":
+                        case ">=": {
+                            numericResult(t_9, span_20);
+                            resultType = (new Type(3, []));
+                            break;
+                        }
+                        case "&&":
+                        case "||": {
+                            unify(typeDefs, t_9, new Type(3, []), span_20);
+                            resultType = (new Type(3, []));
+                            break;
+                        }
+                        default:
+                            throw new TypeException(new TypeError$(toText(printf("Unknown operator %s"))(op), span_20));
+                    }
+                    return [compose(s3_11, compose(s2_14, s1_23)), resultType, asTyped(expr, resultType)];
+                }
+            }
+        }
+        case 26: {
+            const patternInput_51 = inferExpr(typeDefs, constructors, env, expr.fields[0]);
+            const t1_11 = patternInput_51[1];
+            return [patternInput_51[0], new Type(10, [t1_11]), asTyped(expr, new Type(10, [t1_11]))];
+        }
+        case 27: {
+            const tv_9 = Types_freshVar();
+            return [emptySubst, new Type(10, [tv_9]), asTyped(expr, new Type(10, [tv_9]))];
+        }
+        case 23: {
+            const patternInput_52 = inferExpr(typeDefs, constructors, env, expr.fields[0]);
+            const t1_12 = patternInput_52[1];
+            const s1_25 = patternInput_52[0];
+            const patternInput_53 = inferExpr(typeDefs, constructors, applyEnv(s1_25, env), expr.fields[1]);
+            const s2_15 = patternInput_53[0];
+            const s_20 = compose(unify(typeDefs, applyType(s2_15, patternInput_53[1]), new Type(5, [t1_12]), expr.fields[2]), compose(s2_15, s1_25));
+            const tRes_19 = applyType(s_20, new Type(5, [t1_12]));
+            return [s_20, tRes_19, asTyped(expr, tRes_19)];
+        }
+        case 24: {
+            const span_22 = expr.fields[2];
+            const patternInput_54 = inferExpr(typeDefs, constructors, env, expr.fields[0]);
+            const s1_26 = patternInput_54[0];
+            const patternInput_55 = inferExpr(typeDefs, constructors, applyEnv(s1_26, env), expr.fields[1]);
+            const s2_16 = patternInput_55[0];
+            const tv_10 = Types_freshVar();
+            const s3_13 = unify(typeDefs, applyType(s2_16, patternInput_54[1]), new Type(5, [tv_10]), span_22);
+            const s_21 = compose(unify(typeDefs, applyType(s3_13, applyType(s2_16, patternInput_55[1])), new Type(5, [applyType(s3_13, tv_10)]), span_22), compose(s3_13, compose(s2_16, s1_26)));
+            const tRes_20 = new Type(5, [applyType(s_21, tv_10)]);
+            return [s_21, tRes_20, asTyped(expr, tRes_20)];
+        }
+        default:
+            return [emptySubst, new Type(0, []), asTyped(expr, new Type(0, []))];
+    }
+}
+
+function envFromExterns(externs) {
+    return fold((acc, ext) => FSharpMap__Add(acc, ext.Name, ext.Scheme), builtinSchemes, externs);
+}
+
+function patternBindingNames(pat) {
+    const loop = (acc_mut, pattern_mut) => {
+        loop:
+        while (true) {
+            const acc = acc_mut, pattern = pattern_mut;
+            switch (pattern.tag) {
+                case 1:
+                    return cons(pattern.fields[0], acc);
+                case 4: {
+                    acc_mut = loop(acc, pattern.fields[0]);
+                    pattern_mut = pattern.fields[1];
+                    continue loop;
+                }
+                case 5:
+                    return fold(loop, acc, pattern.fields[0]);
+                case 6:
+                    return fold((state, tupledArg) => loop(state, tupledArg[1]), acc, pattern.fields[0]);
+                case 7: {
+                    const tailPattern = pattern.fields[1];
+                    const withClauses = fold((state_1, tupledArg_1) => loop(loop(state_1, tupledArg_1[0]), tupledArg_1[1]), acc, pattern.fields[0]);
+                    if (tailPattern == null) {
+                        return withClauses;
+                    }
+                    else {
+                        acc_mut = withClauses;
+                        pattern_mut = tailPattern;
+                        continue loop;
+                    }
+                }
+                case 8: {
+                    acc_mut = acc;
+                    pattern_mut = pattern.fields[0];
+                    continue loop;
+                }
+                case 10: {
+                    const payload = pattern.fields[2];
+                    if (payload == null) {
+                        return acc;
+                    }
+                    else {
+                        acc_mut = acc;
+                        pattern_mut = payload;
+                        continue loop;
+                    }
+                }
+                default:
+                    return acc;
+            }
+            break;
+        }
+    };
+    return loop(empty_2(), pat);
+}
+
+function topLevelBindingNames(program) {
+    return collect((_arg) => {
+        switch (_arg.tag) {
+            case 2:
+                return singleton(_arg.fields[0]);
+            case 3:
+                return patternBindingNames(_arg.fields[0]);
+            case 4:
+                return map((tupledArg) => tupledArg[0], _arg.fields[0]);
+            default:
+                return empty_2();
+        }
+    }, program);
+}
+
+function inferProgramWithExternsRawAndLocals(externs, program) {
+    const decls = ofList(append(map((d) => [d.Name, d], typeDefs_1), choose((_arg) => {
+        if (_arg.tag === 0) {
+            const d_1 = _arg.fields[0];
+            return [d_1.Name, d_1];
+        }
+        else {
+            return undefined;
+        }
+    }, program)), {
+        Compare: (x, y) => (comparePrimitives(x, y) | 0),
+    });
+    const typeDefs = map_1((name, d_2) => {
+        if (!isEmpty(d_2.Cases)) {
+            return new Type(13, [name, ofList(map((tupledArg) => [tupledArg[0], map_3((tref) => typeFromRef(decls, singleton(name), tref), tupledArg[1])], d_2.Cases), {
+                Compare: (x_1, y_1) => (comparePrimitives(x_1, y_1) | 0),
+            })]);
+        }
+        else {
+            return new Type(8, [ofList(map((tupledArg_1) => [tupledArg_1[0], typeFromRef(decls, singleton(d_2.Name), tupledArg_1[1])], d_2.Fields), {
+                Compare: (x_2, y_2) => (comparePrimitives(x_2, y_2) | 0),
+            })]);
+        }
+    }, decls);
+    const constructors = ofList(collect((tupledArg_2) => {
+        const typeName = tupledArg_2[0];
+        return collect((tupledArg_3) => {
+            const caseName_1 = tupledArg_3[0];
+            const sigInfo = new ConstructorSig(typeName, map_3((tref_1) => typeFromRef(decls, singleton(typeName), tref_1), tupledArg_3[1]));
+            return ofArray([[caseName_1, sigInfo], [concat(typeName, ".", caseName_1), sigInfo]]);
+        }, tupledArg_2[1].Cases);
+    }, toList(decls)), {
+        Compare: (x_3, y_3) => (comparePrimitives(x_3, y_3) | 0),
+    });
+    const constructorSchemes = map((tupledArg_4) => {
+        let matchValue;
+        const sigInfo_1 = tupledArg_4[1];
+        const unionType = new Type(12, [sigInfo_1.UnionName]);
+        return [tupledArg_4[0], new Scheme(empty_2(), (matchValue = sigInfo_1.Payload, (matchValue != null) ? (new Type(11, [matchValue, unionType])) : unionType))];
+    }, toList(constructors));
+    let env = fold((acc, tupledArg_5) => FSharpMap__Add(acc, tupledArg_5[0], tupledArg_5[1]), envFromExterns(externs), constructorSchemes);
+    beginTelemetry();
+    try {
+        const typed = [];
+        const enumerator = getEnumerator(indexed(program));
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                let expectedReturn, expectedReturn_1;
+                const forLoopVar = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                const stmt = forLoopVar[1];
+                switch (stmt.tag) {
+                    case 1: {
+                        throw new TypeException(new TypeError$("\'import\' must be resolved before type inference", stmt.fields[2]));
+                        break;
+                    }
+                    case 2: {
+                        const span_1 = stmt.fields[6];
+                        const returnAnnotation = stmt.fields[2];
+                        const name_2 = stmt.fields[0];
+                        const isExported = stmt.fields[5];
+                        const exprVal = foldBack((arg, acc_1) => (new Expr(4, [arg, acc_1, span_1])), stmt.fields[1], stmt.fields[3]);
+                        let startIndex;
+                        if (telemetry == null) {
+                            startIndex = 0;
+                        }
+                        else {
+                            const t_1 = telemetry;
+                            startIndex = t_1.LocalVariableTypes.length;
+                        }
+                        if (stmt.fields[4]) {
+                            const tv = Types_freshVar();
+                            const patternInput = inferExpr(typeDefs, constructors, add(name_2, new Scheme(empty_2(), tv), env), exprVal);
+                            const t1 = patternInput[1];
+                            const s1 = patternInput[0];
+                            const s2 = unify(typeDefs, applyType(s1, tv), t1, span_1);
+                            const s = compose((returnAnnotation == null) ? emptySubst : ((expectedReturn = annotationTypeFromRef(typeDefs, span_1, returnAnnotation), unify(typeDefs, functionReturnType(applyType(s2, t1)), expectedReturn, span_1))), compose(s2, s1));
+                            applySubstToCapturedLocals(startIndex, s);
+                            const env$0027 = applyEnv(s, env);
+                            const inferred = applyType(s, t1);
+                            validateMapKeyTypes(span_1, inferred);
+                            const scheme_1 = Types_generalize(env$0027, inferred);
+                            env = add(name_2, scheme_1, env$0027);
+                            void (typed.push(new TypedStmt(1, [name_2, exprVal, inferred, true, isExported, span_1])));
+                        }
+                        else {
+                            const patternInput_1 = inferExpr(typeDefs, constructors, env, exprVal);
+                            const t1_1 = patternInput_1[1];
+                            const s1_1 = patternInput_1[0];
+                            const s_1 = compose((returnAnnotation == null) ? emptySubst : ((expectedReturn_1 = annotationTypeFromRef(typeDefs, span_1, returnAnnotation), unify(typeDefs, functionReturnType(applyType(s1_1, t1_1)), expectedReturn_1, span_1))), s1_1);
+                            applySubstToCapturedLocals(startIndex, s_1);
+                            const env$0027_1 = applyEnv(s_1, env);
+                            const inferred_1 = applyType(s_1, t1_1);
+                            validateMapKeyTypes(span_1, inferred_1);
+                            const scheme_2 = Types_generalize(env$0027_1, inferred_1);
+                            env = add(name_2, scheme_2, env$0027_1);
+                            void (typed.push(new TypedStmt(1, [name_2, exprVal, inferred_1, false, isExported, span_1])));
+                        }
+                        break;
+                    }
+                    case 3: {
+                        const span_2 = stmt.fields[3];
+                        const pattern = stmt.fields[0];
+                        const expr_1 = stmt.fields[1];
+                        let startIndex_1;
+                        if (telemetry == null) {
+                            startIndex_1 = 0;
+                        }
+                        else {
+                            const t_2 = telemetry;
+                            startIndex_1 = t_2.LocalVariableTypes.length;
+                        }
+                        const patternInput_2 = inferExpr(typeDefs, constructors, env, expr_1);
+                        const s1_2 = patternInput_2[0];
+                        const patternInput_3 = inferPattern(typeDefs, constructors, pattern);
+                        const s_2 = compose(unify(typeDefs, applyType(s1_2, patternInput_2[1]), patternInput_3[1], span_2), s1_2);
+                        applySubstToCapturedLocals(startIndex_1, s_2);
+                        const envBase = applyEnv(s_2, env);
+                        const typedBindings = map_1((_arg_1, ty) => applyType(s_2, ty), patternInput_3[0]);
+                        iterate_2((_arg_2, ty_1) => {
+                            validateMapKeyTypes(span_2, ty_1);
+                        }, typedBindings);
+                        env = fold_1((state_1, name_3, bindingType) => add(name_3, Types_generalize(envBase, bindingType), state_1), envBase, typedBindings);
+                        void (typed.push(new TypedStmt(2, [pattern, expr_1, typedBindings, stmt.fields[2], span_2])));
+                        break;
+                    }
+                    case 4: {
+                        const span_3 = stmt.fields[2];
+                        let startIndex_2;
+                        if (telemetry == null) {
+                            startIndex_2 = 0;
+                        }
+                        else {
+                            const t_3 = telemetry;
+                            startIndex_2 = t_3.LocalVariableTypes.length;
+                        }
+                        const foldedBindings = map((tupledArg_6) => {
+                            const args_1 = tupledArg_6[1];
+                            const bindingSpan = tupledArg_6[4];
+                            if (isEmpty(args_1)) {
+                                throw new TypeException(new TypeError$("\'let rec ... and ...\' requires function arguments for each binding", bindingSpan));
+                            }
+                            return [tupledArg_6[0], tupledArg_6[2], foldBack((arg_1, acc_2) => (new Expr(4, [arg_1, acc_2, bindingSpan])), args_1, tupledArg_6[3]), bindingSpan];
+                        }, stmt.fields[0]);
+                        const freshByName = ofList(map((tupledArg_7) => [tupledArg_7[0], Types_freshVar()], foldedBindings), {
+                            Compare: (x_4, y_4) => (comparePrimitives(x_4, y_4) | 0),
+                        });
+                        const envRec_1 = fold_1((acc_3, name_6, tv_1) => add(name_6, new Scheme(empty_2(), tv_1), acc_3), env, freshByName);
+                        let sRec = emptySubst;
+                        const enumerator_1 = getEnumerator(foldedBindings);
+                        try {
+                            while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+                                const forLoopVar_1 = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                                const patternInput_4 = inferExpr(typeDefs, constructors, applyEnv(sRec, envRec_1), forLoopVar_1[2]);
+                                const s1_3 = patternInput_4[0];
+                                const s2_2 = unify(typeDefs, applyType(s1_3, applyType(sRec, FSharpMap__get_Item(freshByName, forLoopVar_1[0]))), patternInput_4[1], forLoopVar_1[3]);
+                                sRec = compose(s2_2, compose(s1_3, sRec));
+                            }
+                        }
+                        finally {
+                            disposeSafe(enumerator_1);
+                        }
+                        const enumerator_2 = getEnumerator(foldedBindings);
+                        try {
+                            while (enumerator_2["System.Collections.IEnumerator.MoveNext"]()) {
+                                const forLoopVar_2 = enumerator_2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                                const returnAnnotation_2 = forLoopVar_2[1];
+                                const bindingSpan_2 = forLoopVar_2[3];
+                                if (returnAnnotation_2 == null) {
+                                }
+                                else {
+                                    const expectedReturn_2 = annotationTypeFromRef(typeDefs, bindingSpan_2, returnAnnotation_2);
+                                    const sRet_2 = unify(typeDefs, functionReturnType(applyType(sRec, FSharpMap__get_Item(freshByName, forLoopVar_2[0]))), expectedReturn_2, bindingSpan_2);
+                                    sRec = compose(sRet_2, sRec);
+                                }
+                            }
+                        }
+                        finally {
+                            disposeSafe(enumerator_2);
+                        }
+                        applySubstToCapturedLocals(startIndex_2, sRec);
+                        const envGeneralize = applyEnv(sRec, env);
+                        const schemes = map((tupledArg_8) => {
+                            const name_9 = tupledArg_8[0];
+                            const inferred_2 = applyType(sRec, FSharpMap__get_Item(freshByName, name_9));
+                            validateMapKeyTypes(span_3, inferred_2);
+                            return [name_9, Types_generalize(envGeneralize, inferred_2)];
+                        }, foldedBindings);
+                        const typedBindings_1 = map((tupledArg_9) => {
+                            const name_10 = tupledArg_9[0];
+                            return [name_10, tupledArg_9[2], applyType(sRec, FSharpMap__get_Item(freshByName, name_10)), tupledArg_9[3]];
+                        }, foldedBindings);
+                        env = fold((acc_4, tupledArg_10) => add(tupledArg_10[0], tupledArg_10[1], acc_4), envGeneralize, schemes);
+                        void (typed.push(new TypedStmt(3, [typedBindings_1, stmt.fields[1], span_3])));
+                        break;
+                    }
+                    case 5: {
+                        const expr_2 = stmt.fields[0];
+                        let startIndex_3;
+                        if (telemetry == null) {
+                            startIndex_3 = 0;
+                        }
+                        else {
+                            const t_4 = telemetry;
+                            startIndex_3 = t_4.LocalVariableTypes.length;
+                        }
+                        const patternInput_5 = inferExpr(typeDefs, constructors, env, expr_2);
+                        const t1_3 = patternInput_5[1];
+                        const s1_4 = patternInput_5[0];
+                        const s_3 = compose((forLoopVar[0] < (length(program) - 1)) ? unify(typeDefs, applyType(s1_4, t1_3), new Type(0, []), Ast_spanOfExpr(expr_2)) : emptySubst, s1_4);
+                        applySubstToCapturedLocals(startIndex_3, s_3);
+                        validateMapKeyTypes(Ast_spanOfExpr(expr_2), applyType(s_3, t1_3));
+                        env = applyEnv(s_3, env);
+                        void (typed.push(new TypedStmt(4, [patternInput_5[2]])));
+                        break;
+                    }
+                    default:
+                        void (typed.push(new TypedStmt(0, [stmt.fields[0]])));
+                }
+            }
+        }
+        finally {
+            disposeSafe(enumerator);
+        }
+        return [toList_1(typed), endTelemetry()];
+    }
+    catch (matchValue_1) {
+        endTelemetry();
+        throw matchValue_1;
+    }
+}
+
+export function inferProgramWithExternsRaw(externs, program) {
+    return inferProgramWithExternsRawAndLocals(externs, program)[0];
+}
+
+export function inferProgramWithExterns(externs, program) {
+    iterate_1((ext_1) => {
+        throw new TypeException(new TypeError$(concat("Host extern \'", ext_1.Name, "\' collides with reserved stdlib symbol"), unknownSpan));
+    }, toArray(tryFind_1((ext) => contains(ext.Name, builtinReservedNames), externs)));
+    iterate_1((name_1) => {
+        throw new TypeException(new TypeError$(concat("Top-level binding \'", name_1, "\' collides with reserved stdlib symbol"), unknownSpan));
+    }, toArray(tryFind_1((name) => contains(name, builtinReservedNames), topLevelBindingNames(program))));
+    return inferProgramWithExternsRaw(externs, program);
+}
+
+export function inferProgramWithExternsAndLocalVariableTypes(externs, program) {
+    iterate_1((ext_1) => {
+        throw new TypeException(new TypeError$(concat("Host extern \'", ext_1.Name, "\' collides with reserved stdlib symbol"), unknownSpan));
+    }, toArray(tryFind_1((ext) => contains(ext.Name, builtinReservedNames), externs)));
+    iterate_1((name_1) => {
+        throw new TypeException(new TypeError$(concat("Top-level binding \'", name_1, "\' collides with reserved stdlib symbol"), unknownSpan));
+    }, toArray(tryFind_1((name) => contains(name, builtinReservedNames), topLevelBindingNames(program))));
+    return inferProgramWithExternsRawAndLocals(externs, program);
+}
+
+export function inferProgramWithLocalVariableTypes(program) {
+    return inferProgramWithExternsAndLocalVariableTypes(empty_2(), program);
+}
+
+export function inferProgram(program) {
+    return inferProgramWithExterns(empty_2(), program);
+}
+