@magnusopera/fscript 0.77.1 → 0.79.0

package/dist/FScript.Language/TypeInfer.js

@@ -1,19 +1,19 @@
 
 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 { iterate as iterate_2, FSharpMap__Add, values, FSharpMap__get_Keys, keys, FSharpMap__TryFind, ofList, toList, FSharpMap__get_Item, FSharpMap__ContainsKey, FSharpMap__get_Count, exists as exists_1, add, fold as fold_1, remove, map as map_1, tryFind, isEmpty, empty } from "../fable_modules/fable-library-js.5.13.0/Map.js";
+import { disposeSafe, getEnumerator, stringHash, compareArrays, equals, comparePrimitives } from "../fable_modules/fable-library-js.5.13.0/Util.js";
+import { Types_generalize, Types_freshNumeric, Type_$reflection, Types_freshVar, Types_typeToString, 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 as isEmpty_1, empty as empty_2, singleton, zip, length, exists, fold, map } from "../fable_modules/fable-library-js.5.13.0/List.js";
+import { toList as toList_2, ofSeq, contains, add as add_1, empty as empty_1, FSharpSet__Add, FSharpSet__Contains } from "../fable_modules/fable-library-js.5.13.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 { endsWith, split, join, concat, isNullOrWhiteSpace, printf, toText } from "../fable_modules/fable-library-js.5.13.0/String.js";
+import { defaultArg } from "../fable_modules/fable-library-js.5.13.0/Option.js";
+import { Union, Record } from "../fable_modules/fable-library-js.5.13.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 { 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.13.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.13.0/Seq.js";
+import { last, item as item_2 } from "../fable_modules/fable-library-js.5.13.0/Array.js";
+import { distinct } from "../fable_modules/fable-library-js.5.13.0/Seq2.js";
 import { builtinReservedNames, builtinSchemes } from "./BuiltinSignatures.js";
 import { typeDefs as typeDefs_1 } from "./BuiltinTypes.js";
 
@@ -23,58 +23,218 @@ 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;
+function applyType(s, t) {
+    if (isEmpty(s)) {
+        return t;
+    }
+    else {
+        const apply = (current_mut) => {
+            apply:
+            while (true) {
+                const current = current_mut;
+                let matchResult, v;
+                switch (current.tag) {
+                    case 15: {
+                        matchResult = 0;
+                        v = current.fields[0];
+                        break;
+                    }
+                    case 16: {
+                        matchResult = 0;
+                        v = current.fields[0];
+                        break;
+                    }
+                    case 5: {
+                        matchResult = 1;
+                        break;
+                    }
+                    case 6: {
+                        matchResult = 2;
+                        break;
+                    }
+                    case 7: {
+                        matchResult = 3;
+                        break;
+                    }
+                    case 8: {
+                        matchResult = 4;
+                        break;
+                    }
+                    case 9: {
+                        matchResult = 5;
+                        break;
+                    }
+                    case 10: {
+                        matchResult = 6;
+                        break;
+                    }
+                    case 11: {
+                        matchResult = 7;
+                        break;
+                    }
+                    default:
+                        matchResult = 8;
                 }
-                else {
-                    s_mut = s;
-                    t_mut = matchValue;
-                    continue applyType;
+                switch (matchResult) {
+                    case 0: {
+                        const matchValue = tryFind(v, s);
+                        if (matchValue == null) {
+                            return current;
+                        }
+                        else if (!equals(matchValue, current)) {
+                            const mapped_1 = matchValue;
+                            current_mut = mapped_1;
+                            continue apply;
+                        }
+                        else {
+                            return current;
+                        }
+                    }
+                    case 1:
+                        return new Type(/* TList */ 5, [apply(current.fields[0])]);
+                    case 2:
+                        return new Type(/* TTask */ 6, [apply(current.fields[0])]);
+                    case 3:
+                        return new Type(/* TTuple */ 7, [map(apply, current.fields[0])]);
+                    case 4:
+                        return new Type(/* TRecord */ 8, [map_1((_arg, t1_2) => apply(t1_2), current.fields[0])]);
+                    case 5:
+                        return new Type(/* TMap */ 9, [apply(current.fields[0]), apply(current.fields[1])]);
+                    case 6:
+                        return new Type(/* TOption */ 10, [apply(current.fields[0])]);
+                    case 7:
+                        return new Type(/* TFun */ 11, [apply(current.fields[0]), apply(current.fields[1])]);
+                    default:
+                        return current;
                 }
+                break;
             }
-            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;
+        };
+        return apply(t);
     }
 }
 
-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 applyScheme(s, scheme) {
+    const scheme_1 = scheme;
+    const vars = scheme_1.fields[0];
+    if (isEmpty(s)) {
+        return scheme_1;
+    }
+    else {
+        return new Scheme(vars, applyType(fold((acc, v) => remove(v, acc), s, vars), scheme_1.fields[1]));
+    }
 }
 
 function applyEnv(s, env) {
-    return map_1((_arg, sc) => applyScheme(s, sc), env);
+    if (isEmpty(s)) {
+        return env;
+    }
+    else {
+        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));
+    if (isEmpty(s1)) {
+        return s2;
+    }
+    else if (isEmpty(s2)) {
+        return s1;
+    }
+    else {
+        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));
+    const loop = (current_mut) => {
+        loop:
+        while (true) {
+            const current = current_mut;
+            let matchResult, currentVar, item, keyType, valueType;
+            switch (current.tag) {
+                case 7: {
+                    matchResult = 2;
+                    break;
+                }
+                case 8: {
+                    matchResult = 3;
+                    break;
+                }
+                case 0:
+                case 1:
+                case 2:
+                case 3:
+                case 4:
+                case 12:
+                case 13:
+                case 14: {
+                    matchResult = 5;
+                    break;
+                }
+                case 16: {
+                    matchResult = 0;
+                    currentVar = current.fields[0];
+                    break;
+                }
+                case 5: {
+                    matchResult = 1;
+                    item = current.fields[0];
+                    break;
+                }
+                case 6: {
+                    matchResult = 1;
+                    item = current.fields[0];
+                    break;
+                }
+                case 10: {
+                    matchResult = 1;
+                    item = current.fields[0];
+                    break;
+                }
+                case 9: {
+                    matchResult = 4;
+                    keyType = current.fields[0];
+                    valueType = current.fields[1];
+                    break;
+                }
+                case 11: {
+                    matchResult = 4;
+                    keyType = current.fields[0];
+                    valueType = current.fields[1];
+                    break;
+                }
+                default: {
+                    matchResult = 0;
+                    currentVar = current.fields[0];
+                }
+            }
+            switch (matchResult) {
+                case 0:
+                    return currentVar === v;
+                case 1: {
+                    current_mut = item;
+                    continue loop;
+                }
+                case 2:
+                    return exists(loop, current.fields[0]);
+                case 3:
+                    return exists_1((_arg, fieldType) => loop(fieldType), current.fields[0]);
+                case 4:
+                    if (loop(keyType)) {
+                        return true;
+                    }
+                    else {
+                        current_mut = valueType;
+                        continue loop;
+                    }
+                default:
+                    return false;
+            }
+            break;
+        }
+    };
+    return loop(t);
 }
 
 function unify(typeDefs, t1, t2, span) {
@@ -82,13 +242,13 @@ function unify(typeDefs, t1, t2, span) {
         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;
+            let arg, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6;
             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;
+                let matchResult, x_1, y_1, x_2, y_2, x_3, y_3, xs, ys, xf, yf, kx, ky, vx, vy, x_5, y_5, a1, a2, b1, b2, t, v, name_2, t_1, name_3, t_2, v_1, w, concrete, v_2, other_4;
                 switch (a.tag) {
                     case 0: {
                         switch (b.tag) {
@@ -104,12 +264,17 @@ function unify(typeDefs, t1, t2, span) {
                             }
                             case 12: {
                                 matchResult = 11;
-                                name_2 = b.fields[0];
+                                name_3 = b.fields[0];
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -127,12 +292,18 @@ function unify(typeDefs, t1, t2, span) {
                             }
                             case 12: {
                                 matchResult = 11;
-                                name_2 = b.fields[0];
+                                name_3 = b.fields[0];
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 13;
+                                concrete = a;
+                                v_2 = b.fields[0];
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -150,12 +321,18 @@ function unify(typeDefs, t1, t2, span) {
                             }
                             case 12: {
                                 matchResult = 11;
-                                name_2 = b.fields[0];
+                                name_3 = b.fields[0];
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 13;
+                                concrete = a;
+                                v_2 = b.fields[0];
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -173,12 +350,17 @@ function unify(typeDefs, t1, t2, span) {
                             }
                             case 12: {
                                 matchResult = 11;
-                                name_2 = b.fields[0];
+                                name_3 = b.fields[0];
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -196,12 +378,17 @@ function unify(typeDefs, t1, t2, span) {
                             }
                             case 12: {
                                 matchResult = 11;
-                                name_2 = b.fields[0];
+                                name_3 = b.fields[0];
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -219,12 +406,17 @@ function unify(typeDefs, t1, t2, span) {
                             }
                             case 12: {
                                 matchResult = 11;
-                                name_2 = b.fields[0];
+                                name_3 = b.fields[0];
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -238,7 +430,7 @@ function unify(typeDefs, t1, t2, span) {
                                 }
                                 else {
                                     matchResult = 10;
-                                    name_1 = a.fields[0];
+                                    name_2 = a.fields[0];
                                     t_1 = b;
                                 }
                                 break;
@@ -249,9 +441,15 @@ function unify(typeDefs, t1, t2, span) {
                                 v = b.fields[0];
                                 break;
                             }
+                            case 16: {
+                                matchResult = 10;
+                                name_2 = a.fields[0];
+                                t_1 = b;
+                                break;
+                            }
                             default: {
                                 matchResult = 10;
-                                name_1 = a.fields[0];
+                                name_2 = a.fields[0];
                                 t_1 = b;
                             }
                         }
@@ -273,12 +471,17 @@ function unify(typeDefs, t1, t2, span) {
                             }
                             case 12: {
                                 matchResult = 11;
-                                name_2 = b.fields[0];
+                                name_3 = b.fields[0];
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -298,12 +501,17 @@ function unify(typeDefs, t1, t2, span) {
                             }
                             case 12: {
                                 matchResult = 11;
-                                name_2 = b.fields[0];
+                                name_3 = b.fields[0];
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -323,12 +531,17 @@ function unify(typeDefs, t1, t2, span) {
                             }
                             case 12: {
                                 matchResult = 11;
-                                name_2 = b.fields[0];
+                                name_3 = b.fields[0];
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -348,12 +561,17 @@ function unify(typeDefs, t1, t2, span) {
                             }
                             case 12: {
                                 matchResult = 11;
-                                name_2 = b.fields[0];
+                                name_3 = b.fields[0];
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -375,12 +593,17 @@ function unify(typeDefs, t1, t2, span) {
                             }
                             case 12: {
                                 matchResult = 11;
-                                name_2 = b.fields[0];
+                                name_3 = b.fields[0];
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -388,8 +611,8 @@ function unify(typeDefs, t1, t2, span) {
                         switch (b.tag) {
                             case 10: {
                                 matchResult = 7;
-                                x_7 = a.fields[0];
-                                y_7 = b.fields[0];
+                                x_5 = a.fields[0];
+                                y_5 = b.fields[0];
                                 break;
                             }
                             case 15: {
@@ -400,12 +623,17 @@ function unify(typeDefs, t1, t2, span) {
                             }
                             case 12: {
                                 matchResult = 11;
-                                name_2 = b.fields[0];
+                                name_3 = b.fields[0];
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -427,12 +655,17 @@ function unify(typeDefs, t1, t2, span) {
                             }
                             case 12: {
                                 matchResult = 11;
-                                name_2 = b.fields[0];
+                                name_3 = b.fields[0];
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -442,6 +675,45 @@ function unify(typeDefs, t1, t2, span) {
                         v = a.fields[0];
                         break;
                     }
+                    case 16: {
+                        switch (b.tag) {
+                            case 15: {
+                                matchResult = 9;
+                                t = a;
+                                v = b.fields[0];
+                                break;
+                            }
+                            case 12: {
+                                matchResult = 11;
+                                name_3 = b.fields[0];
+                                t_2 = a;
+                                break;
+                            }
+                            case 16: {
+                                matchResult = 12;
+                                v_1 = a.fields[0];
+                                w = b.fields[0];
+                                break;
+                            }
+                            case 1: {
+                                matchResult = 13;
+                                concrete = b;
+                                v_2 = a.fields[0];
+                                break;
+                            }
+                            case 2: {
+                                matchResult = 13;
+                                concrete = b;
+                                v_2 = a.fields[0];
+                                break;
+                            }
+                            default: {
+                                matchResult = 14;
+                                other_4 = b;
+                            }
+                        }
+                        break;
+                    }
                     default:
                         switch (b.tag) {
                             case 15: {
@@ -452,12 +724,17 @@ function unify(typeDefs, t1, t2, span) {
                             }
                             case 12: {
                                 matchResult = 11;
-                                name_2 = b.fields[0];
+                                name_3 = b.fields[0];
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                 }
                 switch (matchResult) {
@@ -484,26 +761,16 @@ function unify(typeDefs, t1, t2, 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 {
+                        const patternInput = (FSharpMap__get_Count(xf) <= FSharpMap__get_Count(yf)) ? [xf, yf] : [yf, xf];
+                        const otherFields = patternInput[1];
+                        const fieldsToCheck = patternInput[0];
+                        if (exists_1((name, _arg) => !FSharpMap__ContainsKey(otherFields, name), fieldsToCheck)) {
                             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]);
+                            const yt = FSharpMap__get_Item(otherFields, tupledArg_1[0]);
                             return compose(uni(seen$0027, applyType(sAcc_1, tupledArg_1[1]), applyType(sAcc_1, yt)), sAcc_1);
-                        }, emptySubst, toList(patternInput[0]));
+                        }, emptySubst, toList(fieldsToCheck));
                     }
                     case 6: {
                         const s1_2 = uni(seen$0027, kx, ky);
@@ -511,8 +778,8 @@ function unify(typeDefs, t1, t2, span) {
                     }
                     case 7: {
                         seen_mut = seen$0027;
-                        a_mut = x_7;
-                        b_mut = y_7;
+                        a_mut = x_5;
+                        b_mut = y_5;
                         continue uni;
                     }
                     case 8: {
@@ -520,22 +787,27 @@ function unify(typeDefs, t1, t2, span) {
                         return compose(uni(seen$0027, applyType(s1_3, b1), applyType(s1_3, b2)), s1_3);
                     }
                     case 9:
-                        if (equals(t, new Type(15, [v]))) {
+                        if (equals(t, new Type(/* TVar */ 15, [v]))) {
                             return emptySubst;
                         }
+                        else if (equals(t, new Type(/* TNumeric */ 16, [v]))) {
+                            return ofList(singleton([v, t]), {
+                                Compare: (x_6, y_6) => (comparePrimitives(x_6, y_6) | 0),
+                            });
+                        }
                         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),
+                                Compare: (x_7, y_7) => (comparePrimitives(x_7, y_7) | 0),
                             });
                         }
                     case 10: {
-                        const matchValue_1 = FSharpMap__TryFind(typeDefs, name_1);
+                        const matchValue_1 = FSharpMap__TryFind(typeDefs, name_2);
                         let matchResult_1, expanded_1;
                         if (matchValue_1 != null) {
-                            if (!equals(matchValue_1, new Type(12, [name_1]))) {
+                            if (!equals(matchValue_1, new Type(/* TNamed */ 12, [name_2]))) {
                                 matchResult_1 = 0;
                                 expanded_1 = matchValue_1;
                             }
@@ -556,7 +828,7 @@ function unify(typeDefs, t1, t2, span) {
                             default: {
                                 let matchResult_2, other_1;
                                 if (t_1.tag === 12) {
-                                    if (t_1.fields[0] === name_1) {
+                                    if (t_1.fields[0] === name_2) {
                                         matchResult_2 = 0;
                                         other_1 = t_1.fields[0];
                                     }
@@ -577,10 +849,10 @@ function unify(typeDefs, t1, t2, span) {
                         }
                     }
                     case 11: {
-                        const matchValue_2 = FSharpMap__TryFind(typeDefs, name_2);
+                        const matchValue_2 = FSharpMap__TryFind(typeDefs, name_3);
                         let matchResult_3, expanded_3;
                         if (matchValue_2 != null) {
-                            if (!equals(matchValue_2, new Type(12, [name_2]))) {
+                            if (!equals(matchValue_2, new Type(/* TNamed */ 12, [name_3]))) {
                                 matchResult_3 = 0;
                                 expanded_3 = matchValue_2;
                             }
@@ -601,7 +873,7 @@ function unify(typeDefs, t1, t2, span) {
                             default: {
                                 let matchResult_4, other_3;
                                 if (t_2.tag === 12) {
-                                    if (t_2.fields[0] === name_2) {
+                                    if (t_2.fields[0] === name_3) {
                                         matchResult_4 = 0;
                                         other_3 = t_2.fields[0];
                                     }
@@ -621,15 +893,30 @@ function unify(typeDefs, t1, t2, span) {
                             }
                         }
                     }
+                    case 12:
+                        if (v_1 === w) {
+                            return emptySubst;
+                        }
+                        else {
+                            return ofList(singleton([v_1, new Type(/* TNumeric */ 16, [w])]), {
+                                Compare: (x_8, y_8) => (comparePrimitives(x_8, y_8) | 0),
+                            });
+                        }
+                    case 13:
+                        return ofList(singleton([v_2, concrete]), {
+                            Compare: (x_9, y_9) => (comparePrimitives(x_9, y_9) | 0),
+                        });
+                    case 14:
+                        throw new TypeException(new TypeError$((arg_4 = Types_typeToString(other_4), toText(printf("Expected numeric type, got %s"))(arg_4)), 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));
+                        throw new TypeException(new TypeError$((arg_5 = Types_typeToString(a), (arg_6 = Types_typeToString(b), toText(printf("Type mismatch: %s vs %s"))(arg_5)(arg_6))), span));
                 }
             }
             break;
         }
     };
     return uni(empty_1({
-        Compare: (x_9, y_9) => (compareArrays(x_9, y_9) | 0),
+        Compare: (x_10, y_10) => (compareArrays(x_10, y_10) | 0),
     }), t1, t2);
 }
 
@@ -641,20 +928,42 @@ function instantiate(_arg) {
         switch (t_1.tag) {
             case 15:
                 return defaultArg(tryFind(t_1.fields[0], freshMap), t_1);
+            case 16: {
+                const matchValue = tryFind(t_1.fields[0], freshMap);
+                let matchResult, fresh;
+                if (matchValue != null) {
+                    if (matchValue.tag === 15) {
+                        matchResult = 0;
+                        fresh = matchValue.fields[0];
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+                switch (matchResult) {
+                    case 0:
+                        return new Type(/* TNumeric */ 16, [fresh]);
+                    default:
+                        return t_1;
+                }
+            }
             case 5:
-                return new Type(5, [subst(t_1.fields[0])]);
+                return new Type(/* TList */ 5, [subst(t_1.fields[0])]);
             case 6:
-                return new Type(6, [subst(t_1.fields[0])]);
+                return new Type(/* TTask */ 6, [subst(t_1.fields[0])]);
             case 7:
-                return new Type(7, [map(subst, t_1.fields[0])]);
+                return new Type(/* TTuple */ 7, [map(subst, t_1.fields[0])]);
             case 8:
-                return new Type(8, [map_1((_arg_1, t1) => subst(t1), t_1.fields[0])]);
+                return new Type(/* TRecord */ 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])]);
+                return new Type(/* TMap */ 9, [subst(t_1.fields[0]), subst(t_1.fields[1])]);
             case 10:
-                return new Type(10, [subst(t_1.fields[0])]);
+                return new Type(/* TOption */ 10, [subst(t_1.fields[0])]);
             case 11:
-                return new Type(11, [subst(t_1.fields[0]), subst(t_1.fields[1])]);
+                return new Type(/* TFun */ 11, [subst(t_1.fields[0]), subst(t_1.fields[1])]);
             default:
                 return t_1;
         }
@@ -728,21 +1037,22 @@ 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({
+function createTelemetry() {
+    return 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 capturedLocalVariableTypes(telemetry) {
+    if (telemetry == null) {
+        return empty_2();
+    }
+    else {
+        return toList_1(map_2((item) => (new LocalVariableTypeInfo(item.Name, item.Span, item.Type)), telemetry.LocalVariableTypes));
+    }
 }
 
-function withLocalBindings(names, work) {
+function withLocalBindings(telemetry, names, work) {
     let matchValue;
     if (telemetry != null) {
         const t = telemetry;
@@ -753,7 +1063,7 @@ function withLocalBindings(names, work) {
             else {
                 return add_1(name, acc);
             }
-        }, (matchValue = t.ScopeStack, isEmpty(matchValue) ? empty_1({
+        }, (matchValue = t.ScopeStack, isEmpty_1(matchValue) ? empty_1({
             Compare: (x, y) => (comparePrimitives(x, y) | 0),
         }) : head_1(matchValue)), names);
         t.ScopeStack = cons(pushed, t.ScopeStack);
@@ -762,7 +1072,7 @@ function withLocalBindings(names, work) {
         }
         finally {
             const matchValue_1 = t.ScopeStack;
-            if (isEmpty(matchValue_1)) {
+            if (isEmpty_1(matchValue_1)) {
             }
             else {
                 t.ScopeStack = tail_2(matchValue_1);
@@ -774,11 +1084,11 @@ function withLocalBindings(names, work) {
     }
 }
 
-function recordLocalVariableUse(name, span, varType) {
+function recordLocalVariableUse(telemetry, name, span, varType) {
     let matchValue;
     if (telemetry != null) {
         const t = telemetry;
-        if (contains(name, (matchValue = t.ScopeStack, isEmpty(matchValue) ? empty_1({
+        if (contains(name, (matchValue = t.ScopeStack, isEmpty_1(matchValue) ? empty_1({
             Compare: (x, y) => (comparePrimitives(x, y) | 0),
         }) : head_1(matchValue)))) {
             void (t.LocalVariableTypes.push(new LocalVariableTypeCapture(name, span, varType)));
@@ -786,7 +1096,7 @@ function recordLocalVariableUse(name, span, varType) {
     }
 }
 
-function recordLocalVariableDeclaration(name, span, varType) {
+function recordLocalVariableDeclaration(telemetry, name, span, varType) {
     if (isNullOrWhiteSpace(name) ? true : (name === "_")) {
     }
     else if (telemetry != null) {
@@ -795,7 +1105,7 @@ function recordLocalVariableDeclaration(name, span, varType) {
     }
 }
 
-function applySubstToCapturedLocals(startIndex, subst) {
+function applySubstToCapturedLocals(telemetry, startIndex, subst) {
     if (telemetry != null) {
         const t = telemetry;
         for (let i = startIndex; i <= (t.LocalVariableTypes.length - 1); i++) {
@@ -805,7 +1115,7 @@ function applySubstToCapturedLocals(startIndex, subst) {
     }
 }
 
-function currentTelemetryCaptureCount() {
+function currentTelemetryCaptureCount(telemetry) {
     if (telemetry == null) {
         return 0;
     }
@@ -834,15 +1144,17 @@ function asTyped(expr, t) {
 function builtinType(name) {
     switch (name) {
         case "unit":
-            return new Type(0, []);
+            return Type.TUnit;
         case "int":
-            return new Type(1, []);
+            return Type.TInt;
         case "float":
-            return new Type(2, []);
+            return Type.TFloat;
+        case "numeric":
+            return Types_freshNumeric();
         case "bool":
-            return new Type(3, []);
+            return Type.TBool;
         case "string":
-            return new Type(4, []);
+            return Type.TString;
         default:
             return undefined;
     }
@@ -871,14 +1183,14 @@ function resolveNamedRecordByShape(typeDefs, shape, span) {
                 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));
+    if (isEmpty_1(matches)) {
+        throw new TypeException(new TypeError$(concat("No declared record type matches shape ", Types_typeToString(new Type(/* TRecord */ 8, [shape]))), span));
     }
-    else if (isEmpty(tail_2(matches))) {
-        return new Type(12, [head_1(matches)]);
+    else if (isEmpty_1(tail_2(matches))) {
+        return new Type(/* TNamed */ 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));
+        throw new TypeException(new TypeError$(concat("Ambiguous declared record type for shape ", Types_typeToString(new Type(/* TRecord */ 8, [shape])), ": ", join(", ", matches)), span));
     }
 }
 
@@ -907,10 +1219,10 @@ function resolveNamedRecordByFieldSet(typeDefs, fields, span) {
                 return undefined;
         }
     }, toList(typeDefs));
-    if (isEmpty(matches)) {
+    if (isEmpty_1(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))) {
+    else if (isEmpty_1(tail_2(matches))) {
         return head_1(matches);
     }
     else {
@@ -937,10 +1249,10 @@ function resolveReferencedTypeName(knownNames, name, span) {
             Equals: (x_1, y_1) => (x_1 === y_1),
             GetHashCode: (x_1) => (stringHash(x_1) | 0),
         }));
-        if (isEmpty(matches)) {
+        if (isEmpty_1(matches)) {
             return name;
         }
-        else if (isEmpty(tail_2(matches))) {
+        else if (isEmpty_1(tail_2(matches))) {
             return head_1(matches);
         }
         else {
@@ -955,19 +1267,19 @@ function resolveReferencedTypeName(knownNames, name, span) {
 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])]);
+            return new Type(/* TTuple */ 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])]);
+            return new Type(/* TFun */ 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])]);
+                    return new Type(/* TList */ 5, [annotationTypeFromRef(typeDefs, span, tref.fields[0])]);
                 case "task":
-                    return new Type(6, [annotationTypeFromRef(typeDefs, span, tref.fields[0])]);
+                    return new Type(/* TTask */ 6, [annotationTypeFromRef(typeDefs, span, tref.fields[0])]);
                 case "option":
-                    return new Type(10, [annotationTypeFromRef(typeDefs, span, tref.fields[0])]);
+                    return new Type(/* TOption */ 10, [annotationTypeFromRef(typeDefs, span, tref.fields[0])]);
                 case "map":
-                    return new Type(9, [new Type(4, []), annotationTypeFromRef(typeDefs, span, tref.fields[0])]);
+                    return new Type(/* TMap */ 9, [Type.TString, annotationTypeFromRef(typeDefs, span, tref.fields[0])]);
                 default:
                     throw new TypeException(new TypeError$(concat("Unknown type suffix \'", tref.fields[1], "\'"), span));
             }
@@ -976,23 +1288,25 @@ function annotationTypeFromRef(typeDefs, span, tref) {
                 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]), {
+            return new Type(/* TRecord */ 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, []);
+                    return Type.TUnit;
                 case "int":
-                    return new Type(1, []);
+                    return Type.TInt;
                 case "float":
-                    return new Type(2, []);
+                    return Type.TFloat;
+                case "numeric":
+                    return Types_freshNumeric();
                 case "bool":
-                    return new Type(3, []);
+                    return Type.TBool;
                 case "string":
-                    return new Type(4, []);
+                    return Type.TString;
                 default:
-                    return new Type(12, [resolveReferencedTypeName(FSharpMap__get_Keys(typeDefs), tref.fields[0], span)]);
+                    return new Type(/* TNamed */ 12, [resolveReferencedTypeName(FSharpMap__get_Keys(typeDefs), tref.fields[0], span)]);
             }
     }
 }
@@ -1015,31 +1329,31 @@ function functionReturnType(t_mut) {
 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])]);
+            return new Type(/* TTuple */ 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])]);
+            return new Type(/* TFun */ 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]);
+                    return new Type(/* TList */ 5, [resolved]);
                 case "task":
-                    return new Type(6, [resolved]);
+                    return new Type(/* TTask */ 6, [resolved]);
                 case "option":
-                    return new Type(10, [resolved]);
+                    return new Type(/* TOption */ 10, [resolved]);
                 case "map":
-                    return new Type(9, [new Type(4, []), resolved]);
+                    return new Type(/* TMap */ 9, [Type.TString, 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]), {
+            return new Type(/* TRecord */ 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]), {
+            return new Type(/* TRecord */ 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: {
@@ -1049,24 +1363,24 @@ function typeFromRef(decls, stack, tref) {
                 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]);
+                    return new Type(/* TNamed */ 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]);
+                        if (!isEmpty_1(def.Cases)) {
+                            return new Type(/* TNamed */ 12, [resolvedName]);
                         }
                         else {
-                            return new Type(8, [ofList(map((tupledArg) => [tupledArg[0], typeFromRef(decls, cons(resolvedName, stack), tupledArg[1])], def.Fields), {
+                            return new Type(/* TRecord */ 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]);
+                            return new Type(/* TNamed */ 12, [resolvedName]);
                         }
                         else {
                             throw new TypeException(new TypeError$(concat("Recursive type \'", resolvedName, "\' requires \'type rec\'"), unknownSpan));
@@ -1084,20 +1398,20 @@ function typeFromRef(decls, stack, tref) {
     }
 }
 
-function inferPattern(typeDefs, constructors, pat) {
+function inferPattern(telemetry, 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);
+            recordLocalVariableDeclaration(telemetry, 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, []))));
+            const t = (lit.tag === 1) ? Type.TFloat : ((lit.tag === 2) ? Type.TBool : ((lit.tag === 3) ? Type.TString : Type.TInt));
             return [empty({
                 Compare: (x_2, y_2) => (comparePrimitives(x_2, y_2) | 0),
             }), t];
@@ -1106,43 +1420,43 @@ function inferPattern(typeDefs, constructors, pat) {
             const tv_1 = Types_freshVar();
             return [empty({
                 Compare: (x_3, y_3) => (comparePrimitives(x_3, y_3) | 0),
-            }), new Type(5, [tv_1])];
+            }), new Type(/* TList */ 5, [tv_1])];
         }
         case 4: {
-            const startIndex = currentTelemetryCaptureCount() | 0;
-            const patternInput = inferPattern(typeDefs, constructors, pat.fields[0]);
+            const startIndex = currentTelemetryCaptureCount(telemetry) | 0;
+            const patternInput = inferPattern(telemetry, typeDefs, constructors, pat.fields[0]);
             const t1 = patternInput[1];
-            const patternInput_1 = inferPattern(typeDefs, constructors, pat.fields[1]);
+            const patternInput_1 = inferPattern(telemetry, 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]))];
+            }), patternInput_1[1], new Type(/* TList */ 5, [t1]), pat.fields[2]);
+            applySubstToCapturedLocals(telemetry, 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(/* TList */ 5, [t1]))];
         }
         case 5: {
             const patternInput_3 = fold((tupledArg, p) => {
-                const patternInput_2 = inferPattern(typeDefs, constructors, p);
+                const patternInput_2 = inferPattern(telemetry, 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])])];
+            return [patternInput_3[0], new Type(/* TTuple */ 7, [reverse(patternInput_3[1])])];
         }
         case 6: {
             const patternInput_5 = fold((tupledArg_1, tupledArg_2) => {
-                const patternInput_4 = inferPattern(typeDefs, constructors, tupledArg_2[1]);
+                const patternInput_4 = inferPattern(telemetry, 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]])];
+            return [patternInput_5[0], new Type(/* TRecord */ 8, [patternInput_5[1]])];
         }
         case 7: {
             const tailPattern = pat.fields[1];
             const span_1 = pat.fields[2];
-            const startIndex_1 = currentTelemetryCaptureCount() | 0;
+            const startIndex_1 = currentTelemetryCaptureCount(telemetry) | 0;
             const ensureSupportedMapKeyType = (t_1) => {
                 switch (t_1.tag) {
                     case 4:
@@ -1163,8 +1477,8 @@ function inferPattern(typeDefs, constructors, pat) {
             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 patternInput_6 = inferPattern(telemetry, typeDefs, constructors, forLoopVar[0]);
+                    const patternInput_7 = inferPattern(telemetry, 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));
@@ -1180,25 +1494,25 @@ function inferPattern(typeDefs, constructors, pat) {
             if (tailPattern == null) {
             }
             else {
-                const patternInput_8 = inferPattern(typeDefs, constructors, tailPattern);
-                const expectedTailType = new Type(9, [applyType(sAcc, mapKeyType), applyType(sAcc, valueType)]);
+                const patternInput_8 = inferPattern(telemetry, typeDefs, constructors, tailPattern);
+                const expectedTailType = new Type(/* TMap */ 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)])];
+            applySubstToCapturedLocals(telemetry, startIndex_1, sAcc);
+            return [map_1((_arg_3, t_4) => applyType(sAcc, t_4), envAcc_2), new Type(/* TMap */ 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]])];
+            const patternInput_9 = inferPattern(telemetry, typeDefs, constructors, pat.fields[0]);
+            return [patternInput_9[0], new Type(/* TOption */ 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])];
+            }), new Type(/* TOption */ 10, [tv_2])];
         }
         case 10: {
             const span_2 = pat.fields[3];
@@ -1209,7 +1523,7 @@ function inferPattern(typeDefs, constructors, pat) {
             const matchValue = FSharpMap__TryFind(constructors, constructorName);
             if (matchValue != null) {
                 const sigInfo = matchValue;
-                const unionType = new Type(12, [sigInfo.UnionName]);
+                const unionType = new Type(/* TNamed */ 12, [sigInfo.UnionName]);
                 const matchValue_1 = sigInfo.Payload;
                 if (matchValue_1 != null) {
                     if (payload == null) {
@@ -1218,10 +1532,10 @@ function inferPattern(typeDefs, constructors, pat) {
                     else {
                         const expectedPayload = matchValue_1;
                         const payloadPattern = payload;
-                        const startIndex_2 = currentTelemetryCaptureCount() | 0;
-                        const patternInput_10 = inferPattern(typeDefs, constructors, payloadPattern);
+                        const startIndex_2 = currentTelemetryCaptureCount(telemetry) | 0;
+                        const patternInput_10 = inferPattern(telemetry, typeDefs, constructors, payloadPattern);
                         const s_1 = unify(typeDefs, patternInput_10[1], expectedPayload, span_2);
-                        applySubstToCapturedLocals(startIndex_2, s_1);
+                        applySubstToCapturedLocals(telemetry, startIndex_2, s_1);
                         return [map_1((_arg_4, t_6) => applyType(s_1, t_6), patternInput_10[0]), unionType];
                     }
                 }
@@ -1249,15 +1563,17 @@ function inferPattern(typeDefs, constructors, pat) {
     }
 }
 
-function numericResult(t, span) {
+function constrainNumeric(typeDefs, 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));
+        case 16:
+            return [emptySubst, t];
+        default: {
+            const numeric = Types_freshNumeric();
+            const subst = unify(typeDefs, t, numeric, span);
+            return [subst, applyType(subst, numeric)];
+        }
     }
 }
 
@@ -1319,12 +1635,12 @@ function validateMapKeyTypes(span, t) {
     loop(t);
 }
 
-function inferExpr(typeDefs, constructors, env, expr) {
+function inferExpr(telemetry, 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, []))));
+            const t = (lit.tag === 1) ? Type.TFloat : ((lit.tag === 2) ? Type.TBool : ((lit.tag === 3) ? Type.TString : Type.TInt));
             return [emptySubst, t, asTyped(expr, t)];
         }
         case 2: {
@@ -1336,19 +1652,19 @@ function inferExpr(typeDefs, constructors, env, expr) {
             }
             else {
                 const t_1 = instantiate(matchValue);
-                recordLocalVariableUse(name, span, t_1);
+                recordLocalVariableUse(telemetry, name, span, t_1);
                 return [emptySubst, t_1, asTyped(expr, t_1)];
             }
         }
         case 3: {
-            const patternInput = inferExpr(typeDefs, constructors, env, expr.fields[0]);
+            const patternInput = inferExpr(telemetry, 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, []))];
+                return [emptySubst, Type.TTypeToken, asTyped(expr, Type.TTypeToken)];
             }
             else {
                 throw new TypeException(new TypeError$(toText(printf("Unknown type \'%s\'"))(name_1), expr.fields[1]));
@@ -1357,7 +1673,7 @@ function inferExpr(typeDefs, constructors, env, expr) {
         case 29: {
             const name_2 = expr.fields[0];
             if (FSharpMap__ContainsKey(env, name_2)) {
-                return [emptySubst, new Type(4, []), asTyped(expr, new Type(4, []))];
+                return [emptySubst, Type.TString, asTyped(expr, Type.TString)];
             }
             else {
                 throw new TypeException(new TypeError$(toText(printf("Unbound variable \'%s\'"))(name_2), expr.fields[1]));
@@ -1370,7 +1686,7 @@ function inferExpr(typeDefs, constructors, env, expr) {
                 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]);
+                        const patternInput_1 = inferExpr(telemetry, typeDefs, constructors, applyEnv(sAcc, env), part.fields[0]);
                         sAcc = compose(patternInput_1[0], sAcc);
                     }
                 }
@@ -1378,38 +1694,38 @@ function inferExpr(typeDefs, constructors, env, expr) {
             finally {
                 disposeSafe(enumerator);
             }
-            return [sAcc, new Type(4, []), asTyped(expr, new Type(4, []))];
+            return [sAcc, Type.TString, asTyped(expr, Type.TString)];
         }
         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);
+            recordLocalVariableDeclaration(telemetry, 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 patternInput_2 = withLocalBindings(telemetry, singleton(param.Name), () => inferExpr(telemetry, 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]]);
+            const tFun = new Type(/* TFun */ 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 patternInput_3 = inferExpr(telemetry, 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 patternInput_4 = inferExpr(telemetry, 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 s_1 = compose(unify(typeDefs, applyType(s2, patternInput_3[1]), new Type(/* TFun */ 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 patternInput_5 = inferExpr(telemetry, 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 sBool = unify(typeDefs, patternInput_5[1], Type.TBool, span_5);
+            const patternInput_6 = inferExpr(telemetry, 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 patternInput_7 = inferExpr(telemetry, 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))));
@@ -1417,23 +1733,23 @@ function inferExpr(typeDefs, constructors, env, expr) {
             return [s_2, tRes_1, asTyped(expr, tRes_1)];
         }
         case 7: {
-            const patternInput_8 = inferExpr(typeDefs, constructors, env, expr.fields[0]);
+            const patternInput_8 = inferExpr(telemetry, 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 s_3 = compose(unify(typeDefs, applyType(s1_4, patternInput_8[1]), Type.TString, 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 patternInput_9 = inferExpr(telemetry, 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 sSource = compose(unify(typeDefs, applyType(s1_5, patternInput_9[1]), new Type(/* TList */ 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 patternInput_10 = withLocalBindings(telemetry, singleton(name_3), () => inferExpr(telemetry, 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, []))];
+            return [compose(unify(typeDefs, applyType(s2_3, patternInput_10[1]), Type.TUnit, Ast_spanOfExpr(body_1)), compose(s2_3, sSource)), Type.TUnit, asTyped(expr, Type.TUnit)];
         }
         case 10: {
             const value_3 = expr.fields[1];
@@ -1444,41 +1760,41 @@ function inferExpr(typeDefs, constructors, env, expr) {
             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 patternInput_11 = withLocalBindings(telemetry, singleton(name_4), () => inferExpr(telemetry, 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 patternInput_12 = withLocalBindings(telemetry, singleton(name_4), () => inferExpr(telemetry, 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 patternInput_13 = inferExpr(telemetry, 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 sDiscard = (name_4 === "_") ? unify(typeDefs, applyType(s1_7, t1_3), Type.TUnit, 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 patternInput_14 = withLocalBindings(telemetry, singleton(name_4), () => inferExpr(telemetry, 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 startIndex = currentTelemetryCaptureCount(telemetry) | 0;
+            const patternInput_15 = inferExpr(telemetry, typeDefs, constructors, env, expr.fields[1]);
             const s1_8 = patternInput_15[0];
-            const patternInput_16 = inferPattern(typeDefs, constructors, expr.fields[0]);
+            const patternInput_16 = inferPattern(telemetry, 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);
+            applySubstToCapturedLocals(telemetry, 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 patternInput_17 = withLocalBindings(telemetry, map((tuple) => tuple[0], toList(envPatTyped)), () => inferExpr(telemetry, 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)];
         }
@@ -1486,10 +1802,10 @@ function inferExpr(typeDefs, constructors, env, expr) {
             const foldedBindings = map((tupledArg) => {
                 const args = tupledArg[1];
                 const bindingSpan = tupledArg[4];
-                if (isEmpty(args)) {
+                if (isEmpty_1(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];
+                return [tupledArg[0], tupledArg[2], foldBack((arg_4, acc) => (new Expr(/* ELambda */ 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),
@@ -1497,12 +1813,12 @@ function inferExpr(typeDefs, constructors, env, expr) {
             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, () => {
+            withLocalBindings(telemetry, 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 patternInput_18 = inferExpr(telemetry, 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));
@@ -1535,12 +1851,12 @@ function inferExpr(typeDefs, constructors, env, expr) {
                 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 patternInput_19 = withLocalBindings(telemetry, recursiveNames, () => inferExpr(telemetry, 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 patternInput_20 = inferExpr(telemetry, typeDefs, constructors, env, expr.fields[0]);
             const tScrut = patternInput_20[1];
             let sAcc_1 = patternInput_20[0];
             let resultTypeOpt = undefined;
@@ -1552,7 +1868,7 @@ function inferExpr(typeDefs, constructors, env, expr) {
                     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 patternInput_21 = inferPattern(telemetry, typeDefs, constructors, pat_1);
                     const tPat_1 = patternInput_21[1];
                     const envPat_1 = patternInput_21[0];
                     let sPat;
@@ -1643,19 +1959,19 @@ function inferExpr(typeDefs, constructors, env, expr) {
                             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)), () => {
+                    const patternInput_23 = withLocalBindings(telemetry, 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 patternInput_22 = inferExpr(telemetry, typeDefs, constructors, envBodyCase, guardExpr);
                             const sGuard = patternInput_22[0];
-                            const sGuardBool = unify(typeDefs, applyType(sGuard, patternInput_22[1]), new Type(3, []), caseSpan);
+                            const sGuardBool = unify(typeDefs, applyType(sGuard, patternInput_22[1]), Type.TBool, caseSpan);
                             sAcc_1 = compose(sGuardBool, compose(sGuard, sAcc_1));
                             envBodyCase = applyEnv(compose(sGuardBool, sGuard), envBodyCase);
                         }
-                        return inferExpr(typeDefs, constructors, envBodyCase, forLoopVar_2[2]);
+                        return inferExpr(telemetry, typeDefs, constructors, envBodyCase, forLoopVar_2[2]);
                     });
                     const sBody_2 = patternInput_23[0];
                     const tBody$0027 = applyType(sBody_2, patternInput_23[1]);
@@ -1676,7 +1992,7 @@ function inferExpr(typeDefs, constructors, env, expr) {
             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 patternInput_24 = inferExpr(telemetry, 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));
@@ -1685,18 +2001,18 @@ function inferExpr(typeDefs, constructors, env, expr) {
             finally {
                 disposeSafe(enumerator_4);
             }
-            const tRes_4 = new Type(5, [applyType(sAcc_2, tv_5)]);
+            const tRes_4 = new Type(/* TList */ 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 patternInput_25 = inferExpr(telemetry, 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 patternInput_26 = inferExpr(telemetry, 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)];
+            const s3_3 = unify(typeDefs, applyType(s2_9, patternInput_25[1]), Type.TInt, span_13);
+            const tRes_5 = new Type(/* TList */ 5, [Type.TInt]);
+            return [compose(unify(typeDefs, applyType(s3_3, applyType(s2_9, patternInput_26[1])), Type.TInt, span_13), compose(s3_3, compose(s2_9, s1_12))), tRes_5, asTyped(expr, tRes_5)];
         }
         case 15: {
             let sAcc_3 = emptySubst;
@@ -1705,7 +2021,7 @@ function inferExpr(typeDefs, constructors, env, expr) {
             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);
+                    const patternInput_27 = inferExpr(telemetry, 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])));
                 }
@@ -1713,7 +2029,7 @@ function inferExpr(typeDefs, constructors, env, expr) {
             finally {
                 disposeSafe(enumerator_5);
             }
-            const tRes_6 = new Type(7, [inferred_1]);
+            const tRes_6 = new Type(/* TTuple */ 7, [inferred_1]);
             return [sAcc_3, tRes_6, asTyped(expr, tRes_6)];
         }
         case 16: {
@@ -1726,7 +2042,7 @@ function inferExpr(typeDefs, constructors, env, expr) {
             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]);
+                    const patternInput_28 = inferExpr(telemetry, 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]));
                 }
@@ -1734,10 +2050,10 @@ function inferExpr(typeDefs, constructors, env, expr) {
             finally {
                 disposeSafe(enumerator_6);
             }
-            const expected_1 = new Type(12, [resolveNamedRecordByFieldSet(typeDefs, ofSeq(keys(inferred_2), {
+            const expected_1 = new Type(/* TNamed */ 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 s_10 = compose(unify(typeDefs, applyType(sAcc_4, new Type(/* TRecord */ 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)];
         }
@@ -1750,7 +2066,7 @@ function inferExpr(typeDefs, constructors, env, expr) {
             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]);
+                    const patternInput_29 = inferExpr(telemetry, 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]));
                 }
@@ -1758,7 +2074,7 @@ function inferExpr(typeDefs, constructors, env, expr) {
             finally {
                 disposeSafe(enumerator_7);
             }
-            const tRes_8 = new Type(8, [inferred_3]);
+            const tRes_8 = new Type(/* TRecord */ 8, [inferred_3]);
             return [sAcc_5, tRes_8, asTyped(expr, tRes_8)];
         }
         case 18: {
@@ -1781,20 +2097,20 @@ function inferExpr(typeDefs, constructors, env, expr) {
                     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 patternInput_32 = inferExpr(telemetry, 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 expectedSpreadType = new Type(/* TMap */ 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 patternInput_30 = inferExpr(telemetry, 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 patternInput_31 = inferExpr(telemetry, 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));
@@ -1805,12 +2121,12 @@ function inferExpr(typeDefs, constructors, env, expr) {
                 disposeSafe(enumerator_8);
             }
             ensureSupportedMapKeyType(applyType(sAcc_6, keyType));
-            const tRes_9 = new Type(9, [applyType(sAcc_6, keyType), applyType(sAcc_6, valueType)]);
+            const tRes_9 = new Type(/* TMap */ 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 patternInput_33 = inferExpr(telemetry, typeDefs, constructors, env, expr.fields[0]);
             const sBase = patternInput_33[0];
             let baseFields;
             const matchValue_7 = applyType(sBase, patternInput_33[1]);
@@ -1862,7 +2178,7 @@ function inferExpr(typeDefs, constructors, env, expr) {
                     else {
                         expectedFieldType = matchValue_9;
                     }
-                    const patternInput_34 = inferExpr(typeDefs, constructors, applyEnv(sAcc_7, env), valueExpr_4);
+                    const patternInput_34 = inferExpr(telemetry, 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));
@@ -1871,12 +2187,12 @@ function inferExpr(typeDefs, constructors, env, expr) {
             finally {
                 disposeSafe(enumerator_9);
             }
-            const tRes_10 = new Type(8, [map_1((_arg_7, t_5) => applyType(sAcc_7, t_5), baseFields)]);
+            const tRes_10 = new Type(/* TRecord */ 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 patternInput_35 = inferExpr(telemetry, typeDefs, constructors, env, expr.fields[0]);
             const sBase_1 = patternInput_35[0];
             let sAcc_8 = sBase_1;
             let resultFields_1;
@@ -1921,7 +2237,7 @@ function inferExpr(typeDefs, constructors, env, expr) {
                     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 patternInput_36 = inferExpr(telemetry, 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));
@@ -1932,7 +2248,7 @@ function inferExpr(typeDefs, constructors, env, expr) {
             finally {
                 disposeSafe(enumerator_10);
             }
-            const tRes_11 = new Type(8, [map_1((_arg_8, t_6) => applyType(sAcc_8, t_6), resultFields_1)]);
+            const tRes_11 = new Type(/* TRecord */ 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: {
@@ -1982,7 +2298,7 @@ function inferExpr(typeDefs, constructors, env, expr) {
                     }
                     case 15: {
                         const tField_4 = Types_freshVar();
-                        const s_11 = compose(unify(typeDefs, matchValue_13, new Type(8, [ofList(singleton([fieldName, tField_4]), {
+                        const s_11 = compose(unify(typeDefs, matchValue_13, new Type(/* TRecord */ 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)];
@@ -2008,7 +2324,7 @@ function inferExpr(typeDefs, constructors, env, expr) {
                 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_37 = inferExpr(telemetry, 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)];
@@ -2019,7 +2335,7 @@ function inferExpr(typeDefs, constructors, env, expr) {
                     }
                 }
                 default: {
-                    const patternInput_39 = inferExpr(typeDefs, constructors, env, target);
+                    const patternInput_39 = inferExpr(telemetry, 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)];
@@ -2028,9 +2344,9 @@ function inferExpr(typeDefs, constructors, env, expr) {
         }
         case 22: {
             const span_19 = expr.fields[2];
-            const patternInput_41 = inferExpr(typeDefs, constructors, env, expr.fields[0]);
+            const patternInput_41 = inferExpr(telemetry, 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 patternInput_42 = inferExpr(telemetry, 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]);
@@ -2071,8 +2387,8 @@ function inferExpr(typeDefs, constructors, env, expr) {
             }
             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)]);
+                    const s_12 = compose(unify(typeDefs, keyType_1, Type.TInt, span_19), compose(s2_10, s1_19));
+                    const tRes_12 = new Type(/* TOption */ 10, [applyType(s_12, itemType_1)]);
                     return [s_12, tRes_12, asTyped(expr, tRes_12)];
                 }
                 case 1: {
@@ -2086,19 +2402,19 @@ function inferExpr(typeDefs, constructors, env, expr) {
                         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)]);
+                    const tRes_13 = new Type(/* TOption */ 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)]);
+                    const s_14 = compose(unify(typeDefs, targetType, new Type(/* TList */ 5, [itemType_2]), span_19), compose(s2_10, s1_19));
+                    const tRes_14 = new Type(/* TOption */ 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)]);
+                    const s_15 = compose(unify(typeDefs, targetType, new Type(/* TMap */ 9, [Type.TString, valueType_2]), span_19), compose(s2_10, s1_19));
+                    const tRes_15 = new Type(/* TOption */ 10, [applyType(s_15, valueType_2)]);
                     return [s_15, tRes_15, asTyped(expr, tRes_15)];
                 }
                 case 4:
@@ -2114,112 +2430,114 @@ function inferExpr(typeDefs, constructors, env, expr) {
             const a = expr.fields[1];
             switch (op) {
                 case "|>": {
-                    const patternInput_43 = inferExpr(typeDefs, constructors, env, a);
+                    const patternInput_43 = inferExpr(telemetry, typeDefs, constructors, env, a);
                     const s1_20 = patternInput_43[0];
-                    const patternInput_44 = inferExpr(typeDefs, constructors, applyEnv(s1_20, env), b);
+                    const patternInput_44 = inferExpr(telemetry, 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 s_16 = compose(unify(typeDefs, applyType(s2_11, patternInput_44[1]), new Type(/* TFun */ 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 patternInput_45 = inferExpr(telemetry, 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 patternInput_46 = inferExpr(telemetry, 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]));
+                    const s_17 = compose(unify(typeDefs, applyType(s2_12, patternInput_46[1]), new Type(/* TList */ 5, [tHead]), span_20), compose(s2_12, s1_21));
+                    const tRes_17 = applyType(s_17, new Type(/* TList */ 5, [tHead]));
                     return [s_17, tRes_17, asTyped(expr, tRes_17)];
                 }
                 case "@": {
-                    const patternInput_47 = inferExpr(typeDefs, constructors, env, a);
+                    const patternInput_47 = inferExpr(telemetry, typeDefs, constructors, env, a);
                     const s1_22 = patternInput_47[0];
-                    const patternInput_48 = inferExpr(typeDefs, constructors, applyEnv(s1_22, env), b);
+                    const patternInput_48 = inferExpr(telemetry, 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)]);
+                    const s3_10 = unify(typeDefs, applyType(s2_13, patternInput_47[1]), new Type(/* TList */ 5, [tv_8]), span_20);
+                    const s_18 = compose(unify(typeDefs, applyType(s3_10, applyType(s2_13, patternInput_48[1])), new Type(/* TList */ 5, [applyType(s3_10, tv_8)]), span_20), compose(s3_10, compose(s2_13, s1_22)));
+                    const tRes_18 = new Type(/* TList */ 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 patternInput_49 = inferExpr(telemetry, typeDefs, constructors, env, a);
                     const s1_23 = patternInput_49[0];
-                    const patternInput_50 = inferExpr(typeDefs, constructors, applyEnv(s1_23, env), b);
+                    const patternInput_50 = inferExpr(telemetry, 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;
+                    let patternInput_52;
                     switch (op) {
                         case "+":
                         case "-":
                         case "*":
-                        case "/":
+                        case "/": {
+                            patternInput_52 = constrainNumeric(typeDefs, t_9, span_20);
+                            break;
+                        }
                         case "%": {
-                            resultType = numericResult(t_9, span_20);
+                            patternInput_52 = [unify(typeDefs, t_9, Type.TInt, span_20), Type.TInt];
                             break;
                         }
                         case "=": {
-                            resultType = (new Type(3, []));
+                            patternInput_52 = [emptySubst, Type.TBool];
                             break;
                         }
                         case "<":
                         case ">":
                         case "<=":
                         case ">=": {
-                            numericResult(t_9, span_20);
-                            resultType = (new Type(3, []));
+                            patternInput_52 = [constrainNumeric(typeDefs, t_9, span_20)[0], Type.TBool];
                             break;
                         }
                         case "&&":
                         case "||": {
-                            unify(typeDefs, t_9, new Type(3, []), span_20);
-                            resultType = (new Type(3, []));
+                            patternInput_52 = [unify(typeDefs, t_9, Type.TBool, span_20), Type.TBool];
                             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)];
+                    const resultType = patternInput_52[1];
+                    return [compose(patternInput_52[0], 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]))];
+            const patternInput_53 = inferExpr(telemetry, typeDefs, constructors, env, expr.fields[0]);
+            const t1_11 = patternInput_53[1];
+            return [patternInput_53[0], new Type(/* TOption */ 10, [t1_11]), asTyped(expr, new Type(/* TOption */ 10, [t1_11]))];
         }
         case 27: {
             const tv_9 = Types_freshVar();
-            return [emptySubst, new Type(10, [tv_9]), asTyped(expr, new Type(10, [tv_9]))];
+            return [emptySubst, new Type(/* TOption */ 10, [tv_9]), asTyped(expr, new Type(/* TOption */ 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]));
+            const patternInput_54 = inferExpr(telemetry, typeDefs, constructors, env, expr.fields[0]);
+            const t1_12 = patternInput_54[1];
+            const s1_25 = patternInput_54[0];
+            const patternInput_55 = inferExpr(telemetry, typeDefs, constructors, applyEnv(s1_25, env), expr.fields[1]);
+            const s2_15 = patternInput_55[0];
+            const s_20 = compose(unify(typeDefs, applyType(s2_15, patternInput_55[1]), new Type(/* TList */ 5, [t1_12]), expr.fields[2]), compose(s2_15, s1_25));
+            const tRes_19 = applyType(s_20, new Type(/* TList */ 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 patternInput_56 = inferExpr(telemetry, typeDefs, constructors, env, expr.fields[0]);
+            const s1_26 = patternInput_56[0];
+            const patternInput_57 = inferExpr(telemetry, typeDefs, constructors, applyEnv(s1_26, env), expr.fields[1]);
+            const s2_16 = patternInput_57[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)]);
+            const s3_13 = unify(typeDefs, applyType(s2_16, patternInput_56[1]), new Type(/* TList */ 5, [tv_10]), span_22);
+            const s_21 = compose(unify(typeDefs, applyType(s3_13, applyType(s2_16, patternInput_57[1])), new Type(/* TList */ 5, [applyType(s3_13, tv_10)]), span_22), compose(s3_13, compose(s2_16, s1_26)));
+            const tRes_20 = new Type(/* TList */ 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, []))];
+            return [emptySubst, Type.TUnit, asTyped(expr, Type.TUnit)];
     }
 }
 
@@ -2296,7 +2614,7 @@ function topLevelBindingNames(program) {
     }, program);
 }
 
-function inferProgramWithExternsRawAndLocals(externs, program) {
+function inferProgramWithExternsRawAndLocals(captureLocalVariables, 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];
@@ -2309,13 +2627,16 @@ function inferProgramWithExternsRawAndLocals(externs, 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), {
+        if (!isEmpty_1(d_2.Cases)) {
+            return new Type(/* TUnion */ 13, [name, ofList(map((tupledArg) => {
+                let option_1;
+                return [tupledArg[0], (option_1 = tupledArg[1], (option_1 != null) ? typeFromRef(decls, singleton(name), option_1) : undefined)];
+            }, 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), {
+            return new Type(/* TRecord */ 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),
             })]);
         }
@@ -2323,8 +2644,9 @@ function inferProgramWithExternsRawAndLocals(externs, program) {
     const constructors = ofList(collect((tupledArg_2) => {
         const typeName = tupledArg_2[0];
         return collect((tupledArg_3) => {
+            let option_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]));
+            const sigInfo = new ConstructorSig(typeName, (option_3 = tupledArg_3[1], (option_3 != null) ? typeFromRef(decls, singleton(typeName), option_3) : undefined));
             return ofArray([[caseName_1, sigInfo], [concat(typeName, ".", caseName_1), sigInfo]]);
         }, tupledArg_2[1].Cases);
     }, toList(decls)), {
@@ -2333,13 +2655,13 @@ function inferProgramWithExternsRawAndLocals(externs, program) {
     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))];
+        const unionType = new Type(/* TNamed */ 12, [sigInfo_1.UnionName]);
+        return [tupledArg_4[0], new Scheme(empty_2(), (matchValue = sigInfo_1.Payload, (matchValue != null) ? (new Type(/* TFun */ 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();
+    const telemetry = captureLocalVariables ? createTelemetry() : undefined;
+    const typed = [];
     try {
-        const typed = [];
         const enumerator = getEnumerator(indexed(program));
         try {
             while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
@@ -2356,7 +2678,7 @@ function inferProgramWithExternsRawAndLocals(externs, program) {
                         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]);
+                        const exprVal = foldBack((arg, acc_1) => (new Expr(/* ELambda */ 4, [arg, acc_1, span_1])), stmt.fields[1], stmt.fields[3]);
                         let startIndex;
                         if (telemetry == null) {
                             startIndex = 0;
@@ -2367,31 +2689,31 @@ function inferProgramWithExternsRawAndLocals(externs, program) {
                         }
                         if (stmt.fields[4]) {
                             const tv = Types_freshVar();
-                            const patternInput = inferExpr(typeDefs, constructors, add(name_2, new Scheme(empty_2(), tv), env), exprVal);
+                            const patternInput = inferExpr(telemetry, 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);
+                            applySubstToCapturedLocals(telemetry, 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])));
+                            void (typed.push(new TypedStmt(/* TSLet */ 1, [name_2, exprVal, inferred, true, isExported, span_1])));
                         }
                         else {
-                            const patternInput_1 = inferExpr(typeDefs, constructors, env, exprVal);
+                            const patternInput_1 = inferExpr(telemetry, 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);
+                            applySubstToCapturedLocals(telemetry, 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])));
+                            void (typed.push(new TypedStmt(/* TSLet */ 1, [name_2, exprVal, inferred_1, false, isExported, span_1])));
                         }
                         break;
                     }
@@ -2407,18 +2729,18 @@ function inferProgramWithExternsRawAndLocals(externs, program) {
                             const t_2 = telemetry;
                             startIndex_1 = t_2.LocalVariableTypes.length;
                         }
-                        const patternInput_2 = inferExpr(typeDefs, constructors, env, expr_1);
+                        const patternInput_2 = inferExpr(telemetry, typeDefs, constructors, env, expr_1);
                         const s1_2 = patternInput_2[0];
-                        const patternInput_3 = inferPattern(typeDefs, constructors, pattern);
+                        const patternInput_3 = inferPattern(telemetry, 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);
+                        applySubstToCapturedLocals(telemetry, 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])));
+                        void (typed.push(new TypedStmt(/* TSLetPattern */ 2, [pattern, expr_1, typedBindings, stmt.fields[2], span_2])));
                         break;
                     }
                     case 4: {
@@ -2434,10 +2756,10 @@ function inferProgramWithExternsRawAndLocals(externs, program) {
                         const foldedBindings = map((tupledArg_6) => {
                             const args_1 = tupledArg_6[1];
                             const bindingSpan = tupledArg_6[4];
-                            if (isEmpty(args_1)) {
+                            if (isEmpty_1(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];
+                            return [tupledArg_6[0], tupledArg_6[2], foldBack((arg_1, acc_2) => (new Expr(/* ELambda */ 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),
@@ -2448,7 +2770,7 @@ function inferProgramWithExternsRawAndLocals(externs, program) {
                         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 patternInput_4 = inferExpr(telemetry, 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));
@@ -2475,7 +2797,7 @@ function inferProgramWithExternsRawAndLocals(externs, program) {
                         finally {
                             disposeSafe(enumerator_2);
                         }
-                        applySubstToCapturedLocals(startIndex_2, sRec);
+                        applySubstToCapturedLocals(telemetry, startIndex_2, sRec);
                         const envGeneralize = applyEnv(sRec, env);
                         const schemes = map((tupledArg_8) => {
                             const name_9 = tupledArg_8[0];
@@ -2488,7 +2810,7 @@ function inferProgramWithExternsRawAndLocals(externs, program) {
                             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])));
+                        void (typed.push(new TypedStmt(/* TSLetRecGroup */ 3, [typedBindings_1, stmt.fields[1], span_3])));
                         break;
                     }
                     case 5: {
@@ -2501,54 +2823,57 @@ function inferProgramWithExternsRawAndLocals(externs, program) {
                             const t_4 = telemetry;
                             startIndex_3 = t_4.LocalVariableTypes.length;
                         }
-                        const patternInput_5 = inferExpr(typeDefs, constructors, env, expr_2);
+                        const patternInput_5 = inferExpr(telemetry, 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);
+                        const s_3 = compose((forLoopVar[0] < (length(program) - 1)) ? unify(typeDefs, applyType(s1_4, t1_3), Type.TUnit, Ast_spanOfExpr(expr_2)) : emptySubst, s1_4);
+                        applySubstToCapturedLocals(telemetry, 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]])));
+                        void (typed.push(new TypedStmt(/* TSExpr */ 4, [patternInput_5[2]])));
                         break;
                     }
                     default:
-                        void (typed.push(new TypedStmt(0, [stmt.fields[0]])));
+                        void (typed.push(new TypedStmt(/* TSType */ 0, [stmt.fields[0]])));
                 }
             }
         }
         finally {
             disposeSafe(enumerator);
         }
-        return [toList_1(typed), endTelemetry()];
+        return [toList_1(typed), capturedLocalVariableTypes(telemetry)];
     }
     catch (matchValue_1) {
-        endTelemetry();
         throw matchValue_1;
     }
 }
 
 export function inferProgramWithExternsRaw(externs, program) {
-    return inferProgramWithExternsRawAndLocals(externs, program)[0];
+    return inferProgramWithExternsRawAndLocals(false, 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))));
+    const option_1 = tryFind_1((ext) => contains(ext.Name, builtinReservedNames), externs);
+    if (option_1 != null) {
+        throw new TypeException(new TypeError$(concat("Host extern \'", option_1.Name, "\' collides with reserved stdlib symbol"), unknownSpan));
+    }
+    const option_3 = tryFind_1((name) => contains(name, builtinReservedNames), topLevelBindingNames(program));
+    if (option_3 != null) {
+        throw new TypeException(new TypeError$(concat("Top-level binding \'", option_3, "\' collides with reserved stdlib symbol"), unknownSpan));
+    }
     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);
+    const option_1 = tryFind_1((ext) => contains(ext.Name, builtinReservedNames), externs);
+    if (option_1 != null) {
+        throw new TypeException(new TypeError$(concat("Host extern \'", option_1.Name, "\' collides with reserved stdlib symbol"), unknownSpan));
+    }
+    const option_3 = tryFind_1((name) => contains(name, builtinReservedNames), topLevelBindingNames(program));
+    if (option_3 != null) {
+        throw new TypeException(new TypeError$(concat("Top-level binding \'", option_3, "\' collides with reserved stdlib symbol"), unknownSpan));
+    }
+    return inferProgramWithExternsRawAndLocals(true, externs, program);
 }
 
 export function inferProgramWithLocalVariableTypes(program) {