@magnusopera/fscript 0.78.1 → 0.80.0

package/dist/FScript.Language/TypeInfer.js

@@ -1,9 +1,9 @@
 
 import { Span_$reflection, Span, Position } from "./Span.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 { iterate as iterate_2, FSharpMap__Add, values, forAll, 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, 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 { Types_generalize, Types_freshNumeric, Type_$reflection, Types_freshVar, Types_typeToString, Scheme, Type } from "./Types.js";
+import { tryFind as tryFind_1, indexed, ofArray, collect, append, reverse, iterate, 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.13.0/String.js";
@@ -32,30 +32,77 @@ function applyType(s, t) {
             apply:
             while (true) {
                 const current = current_mut;
+                let matchResult, v;
                 switch (current.tag) {
                     case 15: {
-                        const matchValue = tryFind(current.fields[0], s);
+                        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;
+                }
+                switch (matchResult) {
+                    case 0: {
+                        const matchValue = tryFind(v, s);
                         if (matchValue == null) {
                             return current;
                         }
-                        else {
-                            current_mut = matchValue;
+                        else if (!equals(matchValue, current)) {
+                            const mapped_1 = matchValue;
+                            current_mut = mapped_1;
                             continue apply;
                         }
+                        else {
+                            return current;
+                        }
                     }
-                    case 5:
+                    case 1:
                         return new Type(/* TList */ 5, [apply(current.fields[0])]);
-                    case 6:
+                    case 2:
                         return new Type(/* TTask */ 6, [apply(current.fields[0])]);
-                    case 7:
+                    case 3:
                         return new Type(/* TTuple */ 7, [map(apply, current.fields[0])]);
-                    case 8:
+                    case 4:
                         return new Type(/* TRecord */ 8, [map_1((_arg, t1_2) => apply(t1_2), current.fields[0])]);
-                    case 9:
+                    case 5:
                         return new Type(/* TMap */ 9, [apply(current.fields[0]), apply(current.fields[1])]);
-                    case 10:
+                    case 6:
                         return new Type(/* TOption */ 10, [apply(current.fields[0])]);
-                    case 11:
+                    case 7:
                         return new Type(/* TFun */ 11, [apply(current.fields[0]), apply(current.fields[1])]);
                     default:
                         return current;
@@ -104,7 +151,7 @@ function occurs(v, t) {
         loop:
         while (true) {
             const current = current_mut;
-            let matchResult, item, keyType, valueType;
+            let matchResult, currentVar, item, keyType, valueType;
             switch (current.tag) {
                 case 7: {
                     matchResult = 2;
@@ -125,6 +172,11 @@ function occurs(v, t) {
                     matchResult = 5;
                     break;
                 }
+                case 16: {
+                    matchResult = 0;
+                    currentVar = current.fields[0];
+                    break;
+                }
                 case 5: {
                     matchResult = 1;
                     item = current.fields[0];
@@ -152,12 +204,14 @@ function occurs(v, t) {
                     valueType = current.fields[1];
                     break;
                 }
-                default:
+                default: {
                     matchResult = 0;
+                    currentVar = current.fields[0];
+                }
             }
             switch (matchResult) {
                 case 0:
-                    return current.fields[0] === v;
+                    return currentVar === v;
                 case 1: {
                     current_mut = item;
                     continue loop;
@@ -188,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_5, y_5, a1, a2, b1, b2, t, v, name_2, t_1, name_3, 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) {
@@ -214,8 +268,13 @@ function unify(typeDefs, t1, t2, span) {
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -237,8 +296,14 @@ function unify(typeDefs, t1, t2, span) {
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 13;
+                                concrete = a;
+                                v_2 = b.fields[0];
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -260,8 +325,14 @@ function unify(typeDefs, t1, t2, span) {
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 13;
+                                concrete = a;
+                                v_2 = b.fields[0];
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -283,8 +354,13 @@ function unify(typeDefs, t1, t2, span) {
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -306,8 +382,13 @@ function unify(typeDefs, t1, t2, span) {
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -329,8 +410,13 @@ function unify(typeDefs, t1, t2, span) {
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -355,6 +441,12 @@ 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_2 = a.fields[0];
@@ -383,8 +475,13 @@ function unify(typeDefs, t1, t2, span) {
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -408,8 +505,13 @@ function unify(typeDefs, t1, t2, span) {
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -433,8 +535,13 @@ function unify(typeDefs, t1, t2, span) {
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -458,8 +565,13 @@ function unify(typeDefs, t1, t2, span) {
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -485,8 +597,13 @@ function unify(typeDefs, t1, t2, span) {
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -510,8 +627,13 @@ function unify(typeDefs, t1, t2, span) {
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -537,8 +659,13 @@ function unify(typeDefs, t1, t2, span) {
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                         break;
                     }
@@ -548,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: {
@@ -562,8 +728,13 @@ function unify(typeDefs, t1, t2, span) {
                                 t_2 = a;
                                 break;
                             }
+                            case 16: {
+                                matchResult = 14;
+                                other_4 = a;
+                                break;
+                            }
                             default:
-                                matchResult = 12;
+                                matchResult = 15;
                         }
                 }
                 switch (matchResult) {
@@ -619,12 +790,17 @@ function unify(typeDefs, t1, t2, span) {
                         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_6, y_6) => (comparePrimitives(x_6, y_6) | 0),
+                                Compare: (x_7, y_7) => (comparePrimitives(x_7, y_7) | 0),
                             });
                         }
                     case 10: {
@@ -717,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_7, y_7) => (compareArrays(x_7, y_7) | 0),
+        Compare: (x_10, y_10) => (compareArrays(x_10, y_10) | 0),
     }), t1, t2);
 }
 
@@ -737,6 +928,28 @@ 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(/* TList */ 5, [subst(t_1.fields[0])]);
             case 6:
@@ -936,6 +1149,8 @@ function builtinType(name) {
             return Type.TInt;
         case "float":
             return Type.TFloat;
+        case "numeric":
+            return Types_freshNumeric();
         case "bool":
             return Type.TBool;
         case "string":
@@ -1068,11 +1283,15 @@ function annotationTypeFromRef(typeDefs, span, tref) {
                 default:
                     throw new TypeException(new TypeError$(concat("Unknown type suffix \'", tref.fields[1], "\'"), span));
             }
-        case 4:
+        case 4: {
+            const key = annotationTypeFromRef(typeDefs, span, tref.fields[0]);
+            return new Type(/* TMap */ 9, [(key.tag === 16) ? Type.TInt : key, annotationTypeFromRef(typeDefs, span, tref.fields[1])]);
+        }
+        case 5:
             return resolveNamedRecordByShape(typeDefs, ofList(map((tupledArg) => [tupledArg[0], annotationTypeFromRef(typeDefs, span, tupledArg[1])], tref.fields[0]), {
                 Compare: (x, y) => (comparePrimitives(x, y) | 0),
             }), span);
-        case 5:
+        case 6:
             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),
             })]);
@@ -1084,6 +1303,8 @@ function annotationTypeFromRef(typeDefs, span, tref) {
                     return Type.TInt;
                 case "float":
                     return Type.TFloat;
+                case "numeric":
+                    return Types_freshNumeric();
                 case "bool":
                     return Type.TBool;
                 case "string":
@@ -1131,11 +1352,15 @@ function typeFromRef(decls, stack, tref) {
                     throw new TypeException(new TypeError$(concat("Unknown type suffix \'", suffix, "\'"), unknownSpan));
             }
         }
-        case 4:
+        case 4: {
+            const key = typeFromRef(decls, stack, tref.fields[0]);
+            return new Type(/* TMap */ 9, [(key.tag === 16) ? Type.TInt : key, typeFromRef(decls, stack, tref.fields[1])]);
+        }
+        case 5:
             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:
+        case 6:
             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),
             })]);
@@ -1181,6 +1406,137 @@ function typeFromRef(decls, stack, tref) {
     }
 }
 
+function ensureSupportedMapKeyType(typeDefs, span, t) {
+    switch (t.tag) {
+        case 4:
+        case 1:
+        case 3:
+        case 15:
+        case 16: {
+            break;
+        }
+        case 12: {
+            const matchValue = FSharpMap__TryFind(typeDefs, t.fields[0]);
+            let matchResult, cases_1;
+            if (matchValue != null) {
+                if (matchValue.tag === 13) {
+                    if (forAll((_arg, payload) => (payload == null), matchValue.fields[1])) {
+                        matchResult = 0;
+                        cases_1 = matchValue.fields[1];
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0: {
+                    break;
+                }
+                case 1: {
+                    throw new TypeException(new TypeError$(concat("Map key type must be string, int, bool, or a payload-free union, got ", Types_typeToString(t)), span));
+                    break;
+                }
+            }
+            break;
+        }
+        default:
+            throw new TypeException(new TypeError$(concat("Map key type must be string, int, bool, or a payload-free union, got ", Types_typeToString(t)), span));
+    }
+}
+
+function constrainMapKeyTypes(typeDefs, span, t) {
+    let subst = emptySubst;
+    const loop = (current_mut) => {
+        loop:
+        while (true) {
+            const current = current_mut;
+            const matchValue = applyType(subst, current);
+            let matchResult, inner;
+            switch (matchValue.tag) {
+                case 9: {
+                    matchResult = 0;
+                    break;
+                }
+                case 5: {
+                    matchResult = 1;
+                    inner = matchValue.fields[0];
+                    break;
+                }
+                case 6: {
+                    matchResult = 1;
+                    inner = matchValue.fields[0];
+                    break;
+                }
+                case 10: {
+                    matchResult = 1;
+                    inner = matchValue.fields[0];
+                    break;
+                }
+                case 7: {
+                    matchResult = 2;
+                    break;
+                }
+                case 8: {
+                    matchResult = 3;
+                    break;
+                }
+                case 11: {
+                    matchResult = 4;
+                    break;
+                }
+                default:
+                    matchResult = 5;
+            }
+            switch (matchResult) {
+                case 0: {
+                    const keyType = matchValue.fields[0];
+                    if (keyType.tag === 16) {
+                        subst = compose(unify(typeDefs, keyType, Type.TInt, span), subst);
+                    }
+                    else {
+                        ensureSupportedMapKeyType(typeDefs, span, keyType);
+                    }
+                    current_mut = matchValue.fields[1];
+                    continue loop;
+                    break;
+                }
+                case 1: {
+                    current_mut = inner;
+                    continue loop;
+                    break;
+                }
+                case 2: {
+                    iterate(loop, matchValue.fields[0]);
+                    break;
+                }
+                case 3: {
+                    iterate_1(loop, values(matchValue.fields[0]));
+                    break;
+                }
+                case 4: {
+                    loop(matchValue.fields[0]);
+                    current_mut = matchValue.fields[1];
+                    continue loop;
+                    break;
+                }
+                case 5: {
+                    break;
+                }
+            }
+            break;
+        }
+    };
+    loop(t);
+    return subst;
+}
+
 function inferPattern(telemetry, typeDefs, constructors, pat) {
     let table_5;
     switch (pat.tag) {
@@ -1240,15 +1596,8 @@ function inferPattern(telemetry, typeDefs, constructors, pat) {
             const tailPattern = pat.fields[1];
             const span_1 = pat.fields[2];
             const startIndex_1 = currentTelemetryCaptureCount(telemetry) | 0;
-            const ensureSupportedMapKeyType = (t_1) => {
-                switch (t_1.tag) {
-                    case 4:
-                    case 15: {
-                        break;
-                    }
-                    default:
-                        throw new TypeException(new TypeError$(concat("Map key type must be string, got ", Types_typeToString(t_1)), span_1));
-                }
+            const ensureSupportedMapKeyType_1 = (t_1) => {
+                ensureSupportedMapKeyType(typeDefs, span_1, t_1);
             };
             const mapKeyType = Types_freshVar();
             const valueType = Types_freshVar();
@@ -1264,7 +1613,7 @@ function inferPattern(telemetry, typeDefs, constructors, pat) {
                     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));
+                    ensureSupportedMapKeyType_1(applyType(sAcc, mapKeyType));
                     const sValue = unify(typeDefs, applyType(sAcc, patternInput_7[1]), applyType(sAcc, valueType), span_1);
                     sAcc = compose(sValue, sAcc);
                     const mergedClauseEnv = map_1((_arg_1, t_2) => applyType(sAcc, t_2), fold_1((acc_3, k_3, v_3) => add(k_3, v_3, acc_3), patternInput_7[0], patternInput_6[0]));
@@ -1283,7 +1632,7 @@ function inferPattern(telemetry, typeDefs, constructors, pat) {
                 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));
+            ensureSupportedMapKeyType_1(applyType(sAcc, mapKeyType));
             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)])];
         }
@@ -1346,19 +1695,21 @@ function inferPattern(telemetry, typeDefs, constructors, pat) {
     }
 }
 
-function numericResult(t, span) {
+function constrainNumeric(typeDefs, t, span) {
     switch (t.tag) {
         case 1:
         case 2:
-            return t;
-        case 15:
-            return Type.TInt;
-        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)];
+        }
     }
 }
 
-function validateMapKeyTypes(span, t) {
+function validateMapKeyTypes(typeDefs, span, t) {
     const loop = (t_1_mut) => {
         loop:
         while (true) {
@@ -1368,14 +1719,7 @@ function validateMapKeyTypes(span, t) {
                     const keyType = t_1.fields[0];
                     loop(keyType);
                     loop(t_1.fields[1]);
-                    switch (keyType.tag) {
-                        case 4:
-                        case 15: {
-                            break;
-                        }
-                        default:
-                            throw new TypeException(new TypeError$(concat("Map key type must be string, got ", Types_typeToString(keyType)), span));
-                    }
+                    ensureSupportedMapKeyType(typeDefs, span, keyType);
                     break;
                 }
                 case 5: {
@@ -1417,6 +1761,15 @@ function validateMapKeyTypes(span, t) {
 }
 
 function inferExpr(telemetry, typeDefs, constructors, env, expr) {
+    const patternInput = inferExprRaw(telemetry, typeDefs, constructors, env, expr);
+    const subst = patternInput[0];
+    const inferred = patternInput[1];
+    const combined = compose(constrainMapKeyTypes(typeDefs, Ast_spanOfExpr(expr), applyType(subst, inferred)), subst);
+    const resolved = applyType(combined, inferred);
+    return [combined, resolved, asTyped(expr, resolved)];
+}
+
+function inferExprRaw(telemetry, typeDefs, constructors, env, expr) {
     let expectedReturn, expectedReturn_1;
     switch (expr.tag) {
         case 1: {
@@ -1490,12 +1843,15 @@ function inferExpr(telemetry, typeDefs, constructors, env, expr) {
             return [s1_1, tFun, asTyped(expr, tFun)];
         }
         case 5: {
+            const span_4 = expr.fields[2];
             const patternInput_3 = inferExpr(telemetry, typeDefs, constructors, env, expr.fields[0]);
             const s1_2 = patternInput_3[0];
             const patternInput_4 = inferExpr(telemetry, typeDefs, constructors, applyEnv(s1_2, env), expr.fields[1]);
+            const t2 = patternInput_4[1];
             const s2 = patternInput_4[0];
             const tv_1 = Types_freshVar();
-            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 combined = compose(unify(typeDefs, applyType(s2, patternInput_3[1]), new Type(/* TFun */ 11, [t2, tv_1]), span_4), compose(s2, s1_2));
+            const s_1 = compose(constrainMapKeyTypes(typeDefs, span_4, applyType(combined, new Type(/* TFun */ 11, [t2, tv_1]))), combined);
             const tRes = applyType(s_1, tv_1);
             return [s_1, tRes, asTyped(expr, tRes)];
         }
@@ -1859,15 +2215,8 @@ function inferExpr(telemetry, typeDefs, constructors, env, expr) {
             return [sAcc_5, tRes_8, asTyped(expr, tRes_8)];
         }
         case 18: {
-            const ensureSupportedMapKeyType = (t_3) => {
-                switch (t_3.tag) {
-                    case 4:
-                    case 15: {
-                        break;
-                    }
-                    default:
-                        throw new TypeException(new TypeError$(concat("Map key type must be string, got ", Types_typeToString(t_3)), expr.fields[1]));
-                }
+            const ensureSupportedMapKeyType_1 = (t_3) => {
+                ensureSupportedMapKeyType(typeDefs, expr.fields[1], t_3);
             };
             const keyType = Types_freshVar();
             const valueType = Types_freshVar();
@@ -1890,7 +2239,7 @@ function inferExpr(telemetry, typeDefs, constructors, env, expr) {
                         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));
+                        ensureSupportedMapKeyType_1(applyType(sAfterKey, keyType));
                         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));
@@ -1901,7 +2250,7 @@ function inferExpr(telemetry, typeDefs, constructors, env, expr) {
             finally {
                 disposeSafe(enumerator_8);
             }
-            ensureSupportedMapKeyType(applyType(sAcc_6, keyType));
+            ensureSupportedMapKeyType_1(applyType(sAcc_6, keyType));
             const tRes_9 = new Type(/* TMap */ 9, [applyType(sAcc_6, keyType), applyType(sAcc_6, valueType)]);
             return [sAcc_6, tRes_9, asTyped(expr, tRes_9)];
         }
@@ -2150,7 +2499,9 @@ function inferExpr(telemetry, typeDefs, constructors, env, expr) {
                             matchResult_6 = 2;
                             break;
                         }
-                        case 4: {
+                        case 4:
+                        case 3:
+                        case 12: {
                             matchResult_6 = 3;
                             break;
                         }
@@ -2174,15 +2525,7 @@ function inferExpr(telemetry, typeDefs, constructors, env, expr) {
                 }
                 case 1: {
                     const s_13 = compose(unify(typeDefs, keyType_1, mapKeyType, span_19), compose(s2_10, s1_19));
-                    const matchValue_19 = applyType(s_13, mapKeyType);
-                    switch (matchValue_19.tag) {
-                        case 4:
-                        case 15: {
-                            break;
-                        }
-                        default:
-                            throw new TypeException(new TypeError$(concat("Map key type must be string, got ", Types_typeToString(matchValue_19)), span_19));
-                    }
+                    ensureSupportedMapKeyType(typeDefs, span_19, applyType(s_13, mapKeyType));
                     const tRes_13 = new Type(/* TOption */ 10, [applyType(s_13, valueType_1)]);
                     return [s_13, tRes_13, asTyped(expr, tRes_13)];
                 }
@@ -2194,12 +2537,13 @@ function inferExpr(telemetry, typeDefs, constructors, env, expr) {
                 }
                 case 3: {
                     const valueType_2 = Types_freshVar();
-                    const s_15 = compose(unify(typeDefs, targetType, new Type(/* TMap */ 9, [Type.TString, valueType_2]), span_19), compose(s2_10, s1_19));
+                    ensureSupportedMapKeyType(typeDefs, span_19, keyType_1);
+                    const s_15 = compose(unify(typeDefs, targetType, new Type(/* TMap */ 9, [keyType_1, 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:
-                    throw new TypeException(new TypeError$("Ambiguous index access: use a list with int index or a map with string key", span_19));
+                    throw new TypeException(new TypeError$("Ambiguous index access: annotate the list or map target", span_19));
                 default:
                     throw new TypeException(new TypeError$(concat("Index access requires a ", (keyType_1.tag === 1) ? "list" : ((keyType_1.tag === 4) ? "map" : "list or map"), " target with a compatible index type"), span_19));
             }
@@ -2212,11 +2556,13 @@ function inferExpr(telemetry, typeDefs, constructors, env, expr) {
             switch (op) {
                 case "|>": {
                     const patternInput_43 = inferExpr(telemetry, typeDefs, constructors, env, a);
+                    const tLeft = patternInput_43[1];
                     const s1_20 = patternInput_43[0];
                     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(/* TFun */ 11, [applyType(s2_11, patternInput_43[1]), tv_7]), span_20), compose(s2_11, s1_20));
+                    const combined_1 = compose(unify(typeDefs, applyType(s2_11, patternInput_44[1]), new Type(/* TFun */ 11, [applyType(s2_11, tLeft), tv_7]), span_20), compose(s2_11, s1_20));
+                    const s_16 = compose(constrainMapKeyTypes(typeDefs, span_20, applyType(combined_1, new Type(/* TFun */ 11, [tLeft, tv_7]))), combined_1);
                     const tRes_16 = applyType(s_16, tv_7);
                     return [s_16, tRes_16, asTyped(expr, tRes_16)];
                 }
@@ -2248,70 +2594,72 @@ function inferExpr(telemetry, typeDefs, constructors, env, expr) {
                     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;
+                    const t_8 = applyType(s3_11, t2_3);
+                    let patternInput_52;
                     switch (op) {
                         case "+":
                         case "-":
                         case "*":
-                        case "/":
+                        case "/": {
+                            patternInput_52 = constrainNumeric(typeDefs, t_8, span_20);
+                            break;
+                        }
                         case "%": {
-                            resultType = numericResult(t_9, span_20);
+                            patternInput_52 = [unify(typeDefs, t_8, Type.TInt, span_20), Type.TInt];
                             break;
                         }
                         case "=": {
-                            resultType = Type.TBool;
+                            patternInput_52 = [emptySubst, Type.TBool];
                             break;
                         }
                         case "<":
                         case ">":
                         case "<=":
                         case ">=": {
-                            numericResult(t_9, span_20);
-                            resultType = Type.TBool;
+                            patternInput_52 = [constrainNumeric(typeDefs, t_8, span_20)[0], Type.TBool];
                             break;
                         }
                         case "&&":
                         case "||": {
-                            unify(typeDefs, t_9, Type.TBool, span_20);
-                            resultType = Type.TBool;
+                            patternInput_52 = [unify(typeDefs, t_8, 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(telemetry, typeDefs, constructors, env, expr.fields[0]);
-            const t1_11 = patternInput_51[1];
-            return [patternInput_51[0], new Type(/* TOption */ 10, [t1_11]), asTyped(expr, new Type(/* TOption */ 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(/* TOption */ 10, [tv_9]), asTyped(expr, new Type(/* TOption */ 10, [tv_9]))];
         }
         case 23: {
-            const patternInput_52 = inferExpr(telemetry, typeDefs, constructors, env, expr.fields[0]);
-            const t1_12 = patternInput_52[1];
-            const s1_25 = patternInput_52[0];
-            const patternInput_53 = inferExpr(telemetry, 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(/* TList */ 5, [t1_12]), expr.fields[2]), compose(s2_15, s1_25));
+            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(telemetry, typeDefs, constructors, env, expr.fields[0]);
-            const s1_26 = patternInput_54[0];
-            const patternInput_55 = inferExpr(telemetry, 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(/* TList */ 5, [tv_10]), span_22);
-            const s_21 = compose(unify(typeDefs, applyType(s3_13, applyType(s2_16, patternInput_55[1])), new Type(/* TList */ 5, [applyType(s3_13, tv_10)]), span_22), compose(s3_13, compose(s2_16, s1_26)));
+            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)];
         }
@@ -2476,7 +2824,7 @@ function inferProgramWithExternsRawAndLocals(captureLocalVariables, externs, pro
                             applySubstToCapturedLocals(telemetry, startIndex, s);
                             const env$0027 = applyEnv(s, env);
                             const inferred = applyType(s, t1);
-                            validateMapKeyTypes(span_1, inferred);
+                            validateMapKeyTypes(typeDefs, span_1, inferred);
                             const scheme_1 = Types_generalize(env$0027, inferred);
                             env = add(name_2, scheme_1, env$0027);
                             void (typed.push(new TypedStmt(/* TSLet */ 1, [name_2, exprVal, inferred, true, isExported, span_1])));
@@ -2489,7 +2837,7 @@ function inferProgramWithExternsRawAndLocals(captureLocalVariables, externs, pro
                             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);
+                            validateMapKeyTypes(typeDefs, 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(/* TSLet */ 1, [name_2, exprVal, inferred_1, false, isExported, span_1])));
@@ -2516,7 +2864,7 @@ function inferProgramWithExternsRawAndLocals(captureLocalVariables, externs, pro
                         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);
+                            validateMapKeyTypes(typeDefs, 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(/* TSLetPattern */ 2, [pattern, expr_1, typedBindings, stmt.fields[2], span_2])));
@@ -2581,7 +2929,7 @@ function inferProgramWithExternsRawAndLocals(captureLocalVariables, externs, pro
                         const schemes = map((tupledArg_8) => {
                             const name_9 = tupledArg_8[0];
                             const inferred_2 = applyType(sRec, FSharpMap__get_Item(freshByName, name_9));
-                            validateMapKeyTypes(span_3, inferred_2);
+                            validateMapKeyTypes(typeDefs, span_3, inferred_2);
                             return [name_9, Types_generalize(envGeneralize, inferred_2)];
                         }, foldedBindings);
                         const typedBindings_1 = map((tupledArg_9) => {
@@ -2607,7 +2955,7 @@ function inferProgramWithExternsRawAndLocals(captureLocalVariables, externs, pro
                         const s1_4 = patternInput_5[0];
                         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));
+                        validateMapKeyTypes(typeDefs, Ast_spanOfExpr(expr_2), applyType(s_3, t1_3));
                         env = applyEnv(s_3, env);
                         void (typed.push(new TypedStmt(/* TSExpr */ 4, [patternInput_5[2]])));
                         break;