@magnusopera/fscript 0.77.0 → 0.78.1

package/dist/FScript.Language/IncludeResolver.js

@@ -1,19 +1,18 @@
 
-import { printf, toText, isNullOrWhiteSpace, concat, endsWith, substring, split, join, trimEnd, startsWith, replace, isNullOrEmpty, compare } from "../fable_modules/fable-library-js.5.2.0/String.js";
-import { exists, choose, collect, append, map, ofArray, fold as fold_1, singleton, empty, tail as tail_2, cons, head as head_1, isEmpty, reverse } from "../fable_modules/fable-library-js.5.2.0/List.js";
-import { fold } from "../fable_modules/fable-library-js.5.2.0/Array.js";
+import { printf, toText, isNullOrWhiteSpace, concat, endsWith, substring, split, join, trimEnd, startsWith, replace, isNullOrEmpty, compare } from "../fable_modules/fable-library-js.5.13.0/String.js";
+import { exists, choose, collect, append, map, ofArray, fold as fold_1, singleton, empty, tail as tail_2, cons, head as head_1, isEmpty, reverse } from "../fable_modules/fable-library-js.5.13.0/List.js";
+import { fold } from "../fable_modules/fable-library-js.5.13.0/Array.js";
 import { ParseException, ParseError } from "./Error.js";
-import { isLetterOrDigit, isLetter } from "../fable_modules/fable-library-js.5.2.0/Char.js";
-import { toList as toList_1, fold as fold_2, forAll } from "../fable_modules/fable-library-js.5.2.0/Seq.js";
-import { union, toList, ofList, FSharpSet__Contains, empty as empty_1, add } from "../fable_modules/fable-library-js.5.2.0/Set.js";
-import { curry4, defaultOf, disposeSafe, getEnumerator, Exception, curry2, comparePrimitives } from "../fable_modules/fable-library-js.5.2.0/Util.js";
-import { empty as empty_2, add as add_1, FSharpMap__ContainsKey, FSharpMap__get_Item } from "../fable_modules/fable-library-js.5.2.0/Map.js";
+import { isLetterOrDigit, isLetter } from "../fable_modules/fable-library-js.5.13.0/Char.js";
+import { toList as toList_1, fold as fold_2, forAll } from "../fable_modules/fable-library-js.5.13.0/Seq.js";
+import { union, toList, ofList, FSharpSet__Contains, empty as empty_1, add } from "../fable_modules/fable-library-js.5.13.0/Set.js";
+import { curry4, defaultOf, disposeSafe, getEnumerator, Exception, curry2, comparePrimitives } from "../fable_modules/fable-library-js.5.13.0/Util.js";
+import { empty as empty_2, add as add_1, FSharpMap__ContainsKey, FSharpMap__get_Item } from "../fable_modules/fable-library-js.5.13.0/Map.js";
 import { TypeDef, Stmt, InterpolatedPart, MapEntry, Param, Expr, Pattern, TypeRef } from "./Ast.js";
-import { map as map_1 } from "../fable_modules/fable-library-js.5.2.0/Option.js";
 import { parseProgramWithSourceName } from "./Parser.js";
-import { FSharpRef } from "../fable_modules/fable-library-js.5.2.0/Types.js";
+import { FSharpRef } from "../fable_modules/fable-library-js.5.13.0/Types.js";
 import { Span, Position } from "./Span.js";
-import { addToSet, tryGetValue } from "../fable_modules/fable-library-js.5.2.0/MapUtil.js";
+import { addToSet, tryGetValue } from "../fable_modules/fable-library-js.5.13.0/MapUtil.js";
 
 const pathComparison = 4;
 
@@ -151,7 +150,9 @@ function ensureWithinRoot(rootDirectoryWithSeparator, path, span) {
     const fullPath = normalizePath(path);
     const fullRoot = trimTrailingDirectorySeparators(rootDirectoryWithSeparator);
     const rootWithSeparator = endsWith(fullRoot, "/", 4) ? fullRoot : (fullRoot + "/");
-    if (!((compare(fullPath, fullRoot, pathComparison) === 0) ? true : startsWith(fullPath, rootWithSeparator, pathComparison))) {
+    const isRootItself = compare(fullPath, fullRoot, pathComparison) === 0;
+    const isUnderRoot = startsWith(fullPath, rootWithSeparator, pathComparison);
+    if (!(isRootItself ? true : isUnderRoot)) {
         throw new ParseException(new ParseError(concat("Imported file \'", fullPath, "\' is outside of sandbox root"), span));
     }
     return fullPath;
@@ -304,10 +305,9 @@ function rewriteNameWithAliases(aliases, name) {
 }
 
 function rewriteNameWithSelfPrefix(selfPrefix, selfNames, boundNames, name) {
-    let prefix;
     let matchResult, prefix_1;
     if (selfPrefix != null) {
-        if ((prefix = selfPrefix, FSharpSet__Contains(selfNames, name) && !FSharpSet__Contains(boundNames, name))) {
+        if (FSharpSet__Contains(selfNames, name) && !FSharpSet__Contains(boundNames, name)) {
             matchResult = 0;
             prefix_1 = selfPrefix;
         }
@@ -327,7 +327,6 @@ function rewriteNameWithSelfPrefix(selfPrefix, selfNames, boundNames, name) {
 }
 
 function rewriteTypeName(aliases, selfPrefix, selfTypeNames, name) {
-    let prefix;
     const aliasRewritten = rewriteNameWithAliases(aliases, name);
     if (aliasRewritten !== name) {
         return aliasRewritten;
@@ -335,7 +334,7 @@ function rewriteTypeName(aliases, selfPrefix, selfTypeNames, name) {
     else {
         let matchResult, prefix_1;
         if (selfPrefix != null) {
-            if ((prefix = selfPrefix, FSharpSet__Contains(selfTypeNames, name))) {
+            if (FSharpSet__Contains(selfTypeNames, name)) {
                 matchResult = 0;
                 prefix_1 = selfPrefix;
             }
@@ -367,36 +366,37 @@ function rewriteTypeQualifier(aliases, selfPrefix, selfTypeNames, qualifier) {
 function rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tref) {
     switch (tref.tag) {
         case 1:
-            return new TypeRef(1, [map((tref_1) => rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tref_1), tref.fields[0])]);
+            return new TypeRef(/* TRTuple */ 1, [map((tref_1) => rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tref_1), tref.fields[0])]);
         case 2:
-            return new TypeRef(2, [rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tref.fields[0]), rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tref.fields[1])]);
+            return new TypeRef(/* TRFun */ 2, [rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tref.fields[0]), rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tref.fields[1])]);
         case 3:
-            return new TypeRef(3, [rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tref.fields[0]), tref.fields[1]]);
+            return new TypeRef(/* TRPostfix */ 3, [rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tref.fields[0]), tref.fields[1]]);
         case 4:
-            return new TypeRef(4, [map((tupledArg) => [tupledArg[0], rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tupledArg[1])], tref.fields[0])]);
+            return new TypeRef(/* TRRecord */ 4, [map((tupledArg) => [tupledArg[0], rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tupledArg[1])], tref.fields[0])]);
         case 5:
-            return new TypeRef(5, [map((tupledArg_1) => [tupledArg_1[0], rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tupledArg_1[1])], tref.fields[0])]);
+            return new TypeRef(/* TRStructuralRecord */ 5, [map((tupledArg_1) => [tupledArg_1[0], rewriteTypeRef(aliases, selfPrefix, selfTypeNames, tupledArg_1[1])], tref.fields[0])]);
         default:
-            return new TypeRef(0, [rewriteTypeName(aliases, selfPrefix, selfTypeNames, tref.fields[0])]);
+            return new TypeRef(/* TRName */ 0, [rewriteTypeName(aliases, selfPrefix, selfTypeNames, tref.fields[0])]);
     }
 }
 
 function rewritePattern(aliases, selfPrefix, selfTypeNames, pat) {
+    let option_1, option_3;
     switch (pat.tag) {
         case 4:
-            return new Pattern(4, [rewritePattern(aliases, selfPrefix, selfTypeNames, pat.fields[0]), rewritePattern(aliases, selfPrefix, selfTypeNames, pat.fields[1]), pat.fields[2]]);
+            return new Pattern(/* PCons */ 4, [rewritePattern(aliases, selfPrefix, selfTypeNames, pat.fields[0]), rewritePattern(aliases, selfPrefix, selfTypeNames, pat.fields[1]), pat.fields[2]]);
         case 5:
-            return new Pattern(5, [map((pat_1) => rewritePattern(aliases, selfPrefix, selfTypeNames, pat_1), pat.fields[0]), pat.fields[1]]);
+            return new Pattern(/* PTuple */ 5, [map((pat_1) => rewritePattern(aliases, selfPrefix, selfTypeNames, pat_1), pat.fields[0]), pat.fields[1]]);
         case 6:
-            return new Pattern(6, [map((tupledArg) => [tupledArg[0], rewritePattern(aliases, selfPrefix, selfTypeNames, tupledArg[1])], pat.fields[0]), pat.fields[1]]);
+            return new Pattern(/* PRecord */ 6, [map((tupledArg) => [tupledArg[0], rewritePattern(aliases, selfPrefix, selfTypeNames, tupledArg[1])], pat.fields[0]), pat.fields[1]]);
         case 7:
-            return new Pattern(7, [map((tupledArg_1) => [rewritePattern(aliases, selfPrefix, selfTypeNames, tupledArg_1[0]), rewritePattern(aliases, selfPrefix, selfTypeNames, tupledArg_1[1])], pat.fields[0]), map_1((pat_2) => rewritePattern(aliases, selfPrefix, selfTypeNames, pat_2), pat.fields[1]), pat.fields[2]]);
+            return new Pattern(/* PMap */ 7, [map((tupledArg_1) => [rewritePattern(aliases, selfPrefix, selfTypeNames, tupledArg_1[0]), rewritePattern(aliases, selfPrefix, selfTypeNames, tupledArg_1[1])], pat.fields[0]), (option_1 = pat.fields[1], (option_1 != null) ? rewritePattern(aliases, selfPrefix, selfTypeNames, option_1) : undefined), pat.fields[2]]);
         case 8:
-            return new Pattern(8, [rewritePattern(aliases, selfPrefix, selfTypeNames, pat.fields[0]), pat.fields[1]]);
+            return new Pattern(/* PSome */ 8, [rewritePattern(aliases, selfPrefix, selfTypeNames, pat.fields[0]), pat.fields[1]]);
         case 10:
-            return new Pattern(10, [rewriteTypeQualifier(aliases, selfPrefix, selfTypeNames, pat.fields[0]), pat.fields[1], map_1((pat_3) => rewritePattern(aliases, selfPrefix, selfTypeNames, pat_3), pat.fields[2]), pat.fields[3]]);
+            return new Pattern(/* PUnionCase */ 10, [rewriteTypeQualifier(aliases, selfPrefix, selfTypeNames, pat.fields[0]), pat.fields[1], (option_3 = pat.fields[2], (option_3 != null) ? rewritePattern(aliases, selfPrefix, selfTypeNames, option_3) : undefined), pat.fields[3]]);
         case 11:
-            return new Pattern(11, [rewriteTypeRef(aliases, selfPrefix, selfTypeNames, pat.fields[0]), pat.fields[1]]);
+            return new Pattern(/* PTypeRef */ 11, [rewriteTypeRef(aliases, selfPrefix, selfTypeNames, pat.fields[0]), pat.fields[1]]);
         default:
             return pat;
     }
@@ -459,90 +459,97 @@ function rewriteModuleScopedStatements(selfPrefix, aliases, statements) {
         }
     };
     const rewriteExpr = (boundNames_1, expr) => {
-        let rest;
+        let option_1;
         switch (expr.tag) {
             case 2:
-                return new Expr(2, [rewriteValueName(boundNames_1, expr.fields[0]), expr.fields[1]]);
+                return new Expr(/* EVar */ 2, [rewriteValueName(boundNames_1, expr.fields[0]), expr.fields[1]]);
             case 29:
-                return new Expr(29, [rewriteValueName(boundNames_1, expr.fields[0]), expr.fields[1]]);
+                return new Expr(/* ENameOf */ 29, [rewriteValueName(boundNames_1, expr.fields[0]), expr.fields[1]]);
             case 28:
-                return new Expr(28, [rewriteTypeName(aliases, selfPrefix, topLevelTypeNames, expr.fields[0]), expr.fields[1]]);
+                return new Expr(/* ETypeOf */ 28, [rewriteTypeName(aliases, selfPrefix, topLevelTypeNames, expr.fields[0]), expr.fields[1]]);
             case 3:
-                return new Expr(3, [rewriteExpr(boundNames_1, expr.fields[0]), expr.fields[1]]);
+                return new Expr(/* EParen */ 3, [rewriteExpr(boundNames_1, expr.fields[0]), expr.fields[1]]);
             case 4: {
                 const param = expr.fields[0];
-                return new Expr(4, [new Param(param.Name, map_1((tref) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref), param.Annotation), param.Span), rewriteExpr(add(param.Name, boundNames_1), expr.fields[1]), expr.fields[2]]);
+                return new Expr(/* ELambda */ 4, [new Param(param.Name, (option_1 = param.Annotation, (option_1 != null) ? rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, option_1) : undefined), param.Span), rewriteExpr(add(param.Name, boundNames_1), expr.fields[1]), expr.fields[2]]);
             }
             case 5:
-                return new Expr(5, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), expr.fields[2]]);
+                return new Expr(/* EApply */ 5, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), expr.fields[2]]);
             case 6:
-                return new Expr(6, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), rewriteExpr(boundNames_1, expr.fields[2]), expr.fields[3]]);
+                return new Expr(/* EIf */ 6, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), rewriteExpr(boundNames_1, expr.fields[2]), expr.fields[3]]);
             case 7:
-                return new Expr(7, [rewriteExpr(boundNames_1, expr.fields[0]), expr.fields[1]]);
+                return new Expr(/* ERaise */ 7, [rewriteExpr(boundNames_1, expr.fields[0]), expr.fields[1]]);
             case 8: {
                 const name_6 = expr.fields[0];
-                return new Expr(8, [name_6, rewriteExpr(boundNames_1, expr.fields[1]), rewriteExpr(add(name_6, boundNames_1), expr.fields[2]), expr.fields[3]]);
+                return new Expr(/* EFor */ 8, [name_6, rewriteExpr(boundNames_1, expr.fields[1]), rewriteExpr(add(name_6, boundNames_1), expr.fields[2]), expr.fields[3]]);
             }
             case 9: {
                 const rewrittenCases = map((tupledArg_1) => {
+                    let mapping_4, option_3;
                     const rewrittenPattern = rewritePattern(aliases, selfPrefix, topLevelTypeNames, tupledArg_1[0]);
                     const boundWithPattern = union(boundNames_1, collectPatternBindings(rewrittenPattern));
-                    return [rewrittenPattern, map_1(curry2(rewriteExpr)(boundWithPattern), tupledArg_1[1]), rewriteExpr(boundWithPattern, tupledArg_1[2]), tupledArg_1[3]];
+                    return [rewrittenPattern, (mapping_4 = curry2(rewriteExpr)(boundWithPattern), (option_3 = tupledArg_1[1], (option_3 != null) ? mapping_4(option_3) : undefined)), rewriteExpr(boundWithPattern, tupledArg_1[2]), tupledArg_1[3]];
                 }, expr.fields[1]);
-                return new Expr(9, [rewriteExpr(boundNames_1, expr.fields[0]), rewrittenCases, expr.fields[2]]);
+                return new Expr(/* EMatch */ 9, [rewriteExpr(boundNames_1, expr.fields[0]), rewrittenCases, expr.fields[2]]);
             }
             case 10: {
                 const valueExpr_1 = expr.fields[1];
                 const span_10 = expr.fields[5];
                 const name_7 = expr.fields[0];
                 const bodyExpr = expr.fields[2];
-                const rewrittenReturnAnnotation = map_1((tref_1) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref_1), expr.fields[4]);
+                let rewrittenReturnAnnotation;
+                const option_5 = expr.fields[4];
+                rewrittenReturnAnnotation = ((option_5 != null) ? rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, option_5) : undefined);
                 if (expr.fields[3]) {
                     const boundWithName = add(name_7, boundNames_1);
-                    return new Expr(10, [name_7, rewriteExpr(boundWithName, valueExpr_1), rewriteExpr(boundWithName, bodyExpr), true, rewrittenReturnAnnotation, span_10]);
+                    return new Expr(/* ELet */ 10, [name_7, rewriteExpr(boundWithName, valueExpr_1), rewriteExpr(boundWithName, bodyExpr), true, rewrittenReturnAnnotation, span_10]);
                 }
                 else {
-                    return new Expr(10, [name_7, rewriteExpr(boundNames_1, valueExpr_1), rewriteExpr(add(name_7, boundNames_1), bodyExpr), false, rewrittenReturnAnnotation, span_10]);
+                    return new Expr(/* ELet */ 10, [name_7, rewriteExpr(boundNames_1, valueExpr_1), rewriteExpr(add(name_7, boundNames_1), bodyExpr), false, rewrittenReturnAnnotation, span_10]);
                 }
             }
             case 11: {
                 const rewrittenPattern_1 = rewritePattern(aliases, selfPrefix, topLevelTypeNames, expr.fields[0]);
                 const boundWithPattern_1 = union(boundNames_1, collectPatternBindings(rewrittenPattern_1));
-                return new Expr(11, [rewrittenPattern_1, rewriteExpr(boundNames_1, expr.fields[1]), rewriteExpr(boundWithPattern_1, expr.fields[2]), expr.fields[3]]);
+                return new Expr(/* ELetPattern */ 11, [rewrittenPattern_1, rewriteExpr(boundNames_1, expr.fields[1]), rewriteExpr(boundWithPattern_1, expr.fields[2]), expr.fields[3]]);
             }
             case 12: {
                 const bindings_1 = expr.fields[0];
                 const recursiveBound = union(boundNames_1, ofList(map((tupledArg_2) => tupledArg_2[0], bindings_1), {
                     Compare: (x_2, y_2) => (comparePrimitives(x_2, y_2) | 0),
                 }));
-                return new Expr(12, [map((tupledArg_3) => {
-                    const rewrittenArgs = map((p) => (new Param(p.Name, map_1((tref_2) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref_2), p.Annotation), p.Span)), tupledArg_3[1]);
-                    return [tupledArg_3[0], rewrittenArgs, map_1((tref_3) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref_3), tupledArg_3[2]), rewriteExpr(fold_1((s, p_1) => add(p_1.Name, s), recursiveBound, rewrittenArgs), tupledArg_3[3]), tupledArg_3[4]];
+                return new Expr(/* ELetRecGroup */ 12, [map((tupledArg_3) => {
+                    let option_9;
+                    const rewrittenArgs = map((p) => {
+                        let option_7;
+                        return new Param(p.Name, (option_7 = p.Annotation, (option_7 != null) ? rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, option_7) : undefined), p.Span);
+                    }, tupledArg_3[1]);
+                    return [tupledArg_3[0], rewrittenArgs, (option_9 = tupledArg_3[2], (option_9 != null) ? rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, option_9) : undefined), rewriteExpr(fold_1((s, p_1) => add(p_1.Name, s), recursiveBound, rewrittenArgs), tupledArg_3[3]), tupledArg_3[4]];
                 }, bindings_1), rewriteExpr(recursiveBound, expr.fields[1]), expr.fields[2]]);
             }
             case 13:
-                return new Expr(13, [map(curry2(rewriteExpr)(boundNames_1), expr.fields[0]), expr.fields[1]]);
+                return new Expr(/* EList */ 13, [map(curry2(rewriteExpr)(boundNames_1), expr.fields[0]), expr.fields[1]]);
             case 14:
-                return new Expr(14, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), expr.fields[2]]);
+                return new Expr(/* ERange */ 14, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), expr.fields[2]]);
             case 15:
-                return new Expr(15, [map(curry2(rewriteExpr)(boundNames_1), expr.fields[0]), expr.fields[1]]);
+                return new Expr(/* ETuple */ 15, [map(curry2(rewriteExpr)(boundNames_1), expr.fields[0]), expr.fields[1]]);
             case 16:
-                return new Expr(16, [map((tupledArg_4) => [tupledArg_4[0], rewriteExpr(boundNames_1, tupledArg_4[1])], expr.fields[0]), expr.fields[1]]);
+                return new Expr(/* ERecord */ 16, [map((tupledArg_4) => [tupledArg_4[0], rewriteExpr(boundNames_1, tupledArg_4[1])], expr.fields[0]), expr.fields[1]]);
             case 17:
-                return new Expr(17, [map((tupledArg_5) => [tupledArg_5[0], rewriteExpr(boundNames_1, tupledArg_5[1])], expr.fields[0]), expr.fields[1]]);
+                return new Expr(/* EStructuralRecord */ 17, [map((tupledArg_5) => [tupledArg_5[0], rewriteExpr(boundNames_1, tupledArg_5[1])], expr.fields[0]), expr.fields[1]]);
             case 18:
-                return new Expr(18, [map((_arg_10) => {
+                return new Expr(/* EMap */ 18, [map((_arg_10) => {
                     if (_arg_10.tag === 1) {
-                        return new MapEntry(1, [rewriteExpr(boundNames_1, _arg_10.fields[0])]);
+                        return new MapEntry(/* MESpread */ 1, [rewriteExpr(boundNames_1, _arg_10.fields[0])]);
                     }
                     else {
-                        return new MapEntry(0, [rewriteExpr(boundNames_1, _arg_10.fields[0]), rewriteExpr(boundNames_1, _arg_10.fields[1])]);
+                        return new MapEntry(/* MEKeyValue */ 0, [rewriteExpr(boundNames_1, _arg_10.fields[0]), rewriteExpr(boundNames_1, _arg_10.fields[1])]);
                     }
                 }, expr.fields[0]), expr.fields[1]]);
             case 19:
-                return new Expr(19, [rewriteExpr(boundNames_1, expr.fields[0]), map((tupledArg_6) => [tupledArg_6[0], rewriteExpr(boundNames_1, tupledArg_6[1])], expr.fields[1]), expr.fields[2]]);
+                return new Expr(/* ERecordUpdate */ 19, [rewriteExpr(boundNames_1, expr.fields[0]), map((tupledArg_6) => [tupledArg_6[0], rewriteExpr(boundNames_1, tupledArg_6[1])], expr.fields[1]), expr.fields[2]]);
             case 20:
-                return new Expr(20, [rewriteExpr(boundNames_1, expr.fields[0]), map((tupledArg_7) => [tupledArg_7[0], rewriteExpr(boundNames_1, tupledArg_7[1])], expr.fields[1]), expr.fields[2]]);
+                return new Expr(/* EStructuralRecordUpdate */ 20, [rewriteExpr(boundNames_1, expr.fields[0]), map((tupledArg_7) => [tupledArg_7[0], rewriteExpr(boundNames_1, tupledArg_7[1])], expr.fields[1]), expr.fields[2]]);
             case 21: {
                 const target_2 = expr.fields[0];
                 const span_21 = expr.fields[2];
@@ -551,7 +558,7 @@ function rewriteModuleScopedStatements(selfPrefix, aliases, statements) {
                 let matchResult, rest_1, root_1;
                 if (matchValue != null) {
                     if (!isEmpty(matchValue)) {
-                        if ((rest = tail_2(matchValue), FSharpMap__ContainsKey(aliases, head_1(matchValue)))) {
+                        if ((tail_2(matchValue), FSharpMap__ContainsKey(aliases, head_1(matchValue)))) {
                             matchResult = 0;
                             rest_1 = tail_2(matchValue);
                             root_1 = head_1(matchValue);
@@ -569,28 +576,28 @@ function rewriteModuleScopedStatements(selfPrefix, aliases, statements) {
                 }
                 switch (matchResult) {
                     case 0:
-                        return new Expr(2, [(FSharpMap__get_Item(aliases, root_1) + ".") + joinDotted(append(rest_1, singleton(fieldName))), span_21]);
+                        return new Expr(/* EVar */ 2, [(FSharpMap__get_Item(aliases, root_1) + ".") + joinDotted(append(rest_1, singleton(fieldName))), span_21]);
                     default:
-                        return new Expr(21, [rewriteExpr(boundNames_1, target_2), fieldName, span_21]);
+                        return new Expr(/* EFieldGet */ 21, [rewriteExpr(boundNames_1, target_2), fieldName, span_21]);
                 }
             }
             case 22:
-                return new Expr(22, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), expr.fields[2]]);
+                return new Expr(/* EIndexGet */ 22, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), expr.fields[2]]);
             case 23:
-                return new Expr(23, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), expr.fields[2]]);
+                return new Expr(/* ECons */ 23, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), expr.fields[2]]);
             case 24:
-                return new Expr(24, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), expr.fields[2]]);
+                return new Expr(/* EAppend */ 24, [rewriteExpr(boundNames_1, expr.fields[0]), rewriteExpr(boundNames_1, expr.fields[1]), expr.fields[2]]);
             case 25:
-                return new Expr(25, [expr.fields[0], rewriteExpr(boundNames_1, expr.fields[1]), rewriteExpr(boundNames_1, expr.fields[2]), expr.fields[3]]);
+                return new Expr(/* EBinOp */ 25, [expr.fields[0], rewriteExpr(boundNames_1, expr.fields[1]), rewriteExpr(boundNames_1, expr.fields[2]), expr.fields[3]]);
             case 26:
-                return new Expr(26, [rewriteExpr(boundNames_1, expr.fields[0]), expr.fields[1]]);
+                return new Expr(/* ESome */ 26, [rewriteExpr(boundNames_1, expr.fields[0]), expr.fields[1]]);
             case 30:
-                return new Expr(30, [map((_arg_11) => {
+                return new Expr(/* EInterpolatedString */ 30, [map((_arg_11) => {
                     if (_arg_11.tag === 1) {
-                        return new InterpolatedPart(1, [rewriteExpr(boundNames_1, _arg_11.fields[0])]);
+                        return new InterpolatedPart(/* IPExpr */ 1, [rewriteExpr(boundNames_1, _arg_11.fields[0])]);
                     }
                     else {
-                        return new InterpolatedPart(0, [_arg_11.fields[0]]);
+                        return new InterpolatedPart(/* IPText */ 0, [_arg_11.fields[0]]);
                     }
                 }, expr.fields[0]), expr.fields[1]]);
             default:
@@ -605,7 +612,10 @@ function rewriteModuleScopedStatements(selfPrefix, aliases, statements) {
             return `${selfPrefix}.${name_14}`;
         }
     };
-    const rewriteParam = (param_1) => (new Param(param_1.Name, map_1((tref_4) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref_4), param_1.Annotation), param_1.Span));
+    const rewriteParam = (param_1) => {
+        let option_11;
+        return new Param(param_1.Name, (option_11 = param_1.Annotation, (option_11 != null) ? rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, option_11) : undefined), param_1.Span);
+    };
     return map((_arg_12) => {
         let def_1;
         switch (_arg_12.tag) {
@@ -613,14 +623,16 @@ function rewriteModuleScopedStatements(selfPrefix, aliases, statements) {
                 const isRec_1 = _arg_12.fields[4];
                 const rewrittenName = qualifySelfName(_arg_12.fields[0]);
                 const rewrittenArgs_1 = map(rewriteParam, _arg_12.fields[1]);
-                const rewrittenReturnAnnotation_2 = map_1((tref_6) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref_6), _arg_12.fields[2]);
+                let rewrittenReturnAnnotation_2;
+                const option_15 = _arg_12.fields[2];
+                rewrittenReturnAnnotation_2 = ((option_15 != null) ? rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, option_15) : undefined);
                 const bound = fold_1((s_1, p_2) => add(p_2.Name, s_1), empty_1({
                     Compare: (x_3, y_3) => (comparePrimitives(x_3, y_3) | 0),
                 }), rewrittenArgs_1);
-                return new Stmt(2, [rewrittenName, rewrittenArgs_1, rewrittenReturnAnnotation_2, rewriteExpr(isRec_1 ? add(rewrittenName, bound) : bound, _arg_12.fields[3]), isRec_1, _arg_12.fields[5], _arg_12.fields[6]]);
+                return new Stmt(/* SLet */ 2, [rewrittenName, rewrittenArgs_1, rewrittenReturnAnnotation_2, rewriteExpr(isRec_1 ? add(rewrittenName, bound) : bound, _arg_12.fields[3]), isRec_1, _arg_12.fields[5], _arg_12.fields[6]]);
             }
             case 3:
-                return new Stmt(3, [rewritePattern(aliases, selfPrefix, topLevelTypeNames, _arg_12.fields[0]), rewriteExpr(empty_1({
+                return new Stmt(/* SLetPattern */ 3, [rewritePattern(aliases, selfPrefix, topLevelTypeNames, _arg_12.fields[0]), rewriteExpr(empty_1({
                     Compare: (x_4, y_4) => (comparePrimitives(x_4, y_4) | 0),
                 }), _arg_12.fields[1]), _arg_12.fields[2], _arg_12.fields[3]]);
             case 4: {
@@ -628,20 +640,24 @@ function rewriteModuleScopedStatements(selfPrefix, aliases, statements) {
                 const names_1 = ofList(map((tupledArg_10) => qualifySelfName(tupledArg_10[0]), bindings_2), {
                     Compare: (x_5, y_5) => (comparePrimitives(x_5, y_5) | 0),
                 });
-                return new Stmt(4, [map((tupledArg_11) => {
+                return new Stmt(/* SLetRecGroup */ 4, [map((tupledArg_11) => {
+                    let option_17;
                     const rewrittenName_1 = qualifySelfName(tupledArg_11[0]);
                     const rewrittenArgs_2 = map(rewriteParam, tupledArg_11[1]);
-                    return [rewrittenName_1, rewrittenArgs_2, map_1((tref_7) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref_7), tupledArg_11[2]), rewriteExpr(fold_1((s_2, p_3) => add(p_3.Name, s_2), names_1, rewrittenArgs_2), tupledArg_11[3]), tupledArg_11[4]];
+                    return [rewrittenName_1, rewrittenArgs_2, (option_17 = tupledArg_11[2], (option_17 != null) ? rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, option_17) : undefined), rewriteExpr(fold_1((s_2, p_3) => add(p_3.Name, s_2), names_1, rewrittenArgs_2), tupledArg_11[3]), tupledArg_11[4]];
                 }, bindings_2), _arg_12.fields[1], _arg_12.fields[2]]);
             }
             case 5:
-                return new Stmt(5, [rewriteExpr(empty_1({
+                return new Stmt(/* SExpr */ 5, [rewriteExpr(empty_1({
                     Compare: (x_6, y_6) => (comparePrimitives(x_6, y_6) | 0),
                 }), _arg_12.fields[0])]);
             case 1:
                 throw new Exception("Unexpected unresolved import directive");
             default:
-                return new Stmt(0, [(def_1 = _arg_12.fields[0], new TypeDef(qualifySelfName(def_1.Name), def_1.IsRecursive, map((tupledArg_8) => [tupledArg_8[0], rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tupledArg_8[1])], def_1.Fields), map((tupledArg_9) => [tupledArg_9[0], map_1((tref_5) => rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tref_5), tupledArg_9[1])], def_1.Cases), def_1.Span))]);
+                return new Stmt(/* SType */ 0, [(def_1 = _arg_12.fields[0], new TypeDef(qualifySelfName(def_1.Name), def_1.IsRecursive, map((tupledArg_8) => [tupledArg_8[0], rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, tupledArg_8[1])], def_1.Fields), map((tupledArg_9) => {
+                    let option_13;
+                    return [tupledArg_9[0], (option_13 = tupledArg_9[1], (option_13 != null) ? rewriteTypeRef(aliases, selfPrefix, topLevelTypeNames, option_13) : undefined)];
+                }, def_1.Cases), def_1.Span))]);
         }
     }, statements);
 }
@@ -683,11 +699,13 @@ function expandProgram(rootDirectoryWithSeparator, fileSpan, getOrCreatePrefix,
     }, empty_2({
         Compare: (x, y) => (comparePrimitives(x, y) | 0),
     }), imports);
-    return append(collect((tupledArg_1) => {
+    const importedStatements = collect((tupledArg_1) => {
         const resolvedPath_1 = resolveImportPath(currentFile, tupledArg_1[1], rootDirectoryWithSeparator, tupledArg_1[2]);
         const childPrefix = FSharpMap__get_Item(aliasMappings, tupledArg_1[0]);
         return loadFileRef.contents(stack)(false)(resolvedPath_1)(childPrefix);
-    }, toList_1(imports)), rewriteModuleScopedStatements(isMainFile ? undefined : currentPrefix, aliasMappings, toList_1(localCode)));
+    }, toList_1(imports));
+    const localStatements = toList_1(localCode);
+    return append(importedStatements, rewriteModuleScopedStatements(isMainFile ? undefined : currentPrefix, aliasMappings, localStatements));
 }
 
 export function parseIncludedSource(sourceName, source) {

package/dist/FScript.Language/Interactive.js

@@ -0,0 +1,149 @@
+
+import { Record } from "../fable_modules/fable-library-js.5.13.0/Types.js";
+import { ExternalFunction, Value, ExternalFunction_$reflection } from "./Value.js";
+import { int32_type, record_type, option_type, class_type, string_type, list_type } from "../fable_modules/fable-library-js.5.13.0/Reflection.js";
+import { Stmt_$reflection } from "./Ast.js";
+import { evalProgramFromState, evalProgramWithExternsState, ProgramState_$reflection } from "./Eval.js";
+import { inferProgramWithExterns, TypedStmt_$reflection } from "./TypeInfer.js";
+import { skip, reverse, append, exists, length, empty, choose, cons, fold, filter } from "../fable_modules/fable-library-js.5.13.0/List.js";
+import { toList } from "../fable_modules/fable-library-js.5.13.0/Set.js";
+import { Scheme, Types_ftvType } from "./Types.js";
+import { values, empty as empty_1, add, fold as fold_1 } from "../fable_modules/fable-library-js.5.13.0/Map.js";
+import { comparePrimitives } from "../fable_modules/fable-library-js.5.13.0/Util.js";
+import { toList as toList_1 } from "../fable_modules/fable-library-js.5.13.0/Seq.js";
+
+export class Session extends Record {
+    constructor(Externs, RetainedProgramRev, TypeDeclarations, InferenceBindings, EvaluationState) {
+        super();
+        this.Externs = Externs;
+        this.RetainedProgramRev = RetainedProgramRev;
+        this.TypeDeclarations = TypeDeclarations;
+        this.InferenceBindings = InferenceBindings;
+        this.EvaluationState = EvaluationState;
+    }
+}
+
+export function Session_$reflection() {
+    return record_type("FScript.Language.Interactive.Session", [], Session, () => [["Externs", list_type(ExternalFunction_$reflection())], ["RetainedProgramRev", list_type(Stmt_$reflection())], ["TypeDeclarations", list_type(Stmt_$reflection())], ["InferenceBindings", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, ExternalFunction_$reflection()])], ["EvaluationState", option_type(ProgramState_$reflection())]]);
+}
+
+export class Submission extends Record {
+    constructor(Session, TypedProgram, State, RetainedCount) {
+        super();
+        this.Session = Session;
+        this.TypedProgram = TypedProgram;
+        this.State = State;
+        this.RetainedCount = (RetainedCount | 0);
+    }
+}
+
+export function Submission_$reflection() {
+    return record_type("FScript.Language.Interactive.Submission", [], Submission, () => [["Session", Session_$reflection()], ["TypedProgram", list_type(TypedStmt_$reflection())], ["State", ProgramState_$reflection()], ["RetainedCount", int32_type]]);
+}
+
+function retainedStatements(program) {
+    return filter((_arg) => {
+        if (_arg.tag === 5) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }, program);
+}
+
+function appendRetained(reversed, program) {
+    return fold((acc, statement) => {
+        if (statement.tag === 5) {
+            return acc;
+        }
+        else {
+            return cons(statement, acc);
+        }
+    }, reversed, program);
+}
+
+function typeDeclarations(program) {
+    return choose((_arg) => {
+        if (_arg.tag === 0) {
+            return _arg;
+        }
+        else {
+            return undefined;
+        }
+    }, program);
+}
+
+function inferenceBinding(name, bindingType) {
+    return new ExternalFunction(name, new Scheme(toList(Types_ftvType(bindingType)), bindingType), (_arg, _arg_1) => Value.VUnit, 0);
+}
+
+function updateInferenceBindings(bindings, typedProgram) {
+    return fold((current, statement) => {
+        switch (statement.tag) {
+            case 2:
+                return fold_1((state, name_1, bindingType_1) => add(name_1, inferenceBinding(name_1, bindingType_1), state), current, statement.fields[2]);
+            case 3:
+                return fold((state_1, tupledArg) => {
+                    const name_2 = tupledArg[0];
+                    return add(name_2, inferenceBinding(name_2, tupledArg[2]), state_1);
+                }, current, statement.fields[0]);
+            case 0:
+            case 4:
+                return current;
+            default: {
+                const name = statement.fields[0];
+                return add(name, inferenceBinding(name, statement.fields[2]), current);
+            }
+        }
+    }, bindings, typedProgram);
+}
+
+export function create(externs) {
+    return new Session(externs, empty(), empty(), empty_1({
+        Compare: (x, y) => (comparePrimitives(x, y) | 0),
+    }), undefined);
+}
+
+export function retainedCount(session) {
+    return length(session.RetainedProgramRev) | 0;
+}
+
+export function submit(session, program) {
+    const retainedRev = appendRetained(session.RetainedProgramRev, program);
+    const retainedCount_1 = length(retainedRev) | 0;
+    const containsTypeDeclaration = exists((_arg) => {
+        if (_arg.tag === 0) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }, program);
+    const matchValue = session.EvaluationState;
+    if (matchValue != null) {
+        if (containsTypeDeclaration) {
+            const typed_1 = inferProgramWithExterns(session.Externs, append(reverse(session.RetainedProgramRev), program));
+            const state_1 = evalProgramWithExternsState(session.Externs, typed_1);
+            const submittedTyped = skip(length(session.RetainedProgramRev), typed_1);
+            return new Submission(new Session(session.Externs, retainedRev, typeDeclarations(reverse(retainedRev)), updateInferenceBindings(empty_1({
+                Compare: (x_1, y_1) => (comparePrimitives(x_1, y_1) | 0),
+            }), typed_1), state_1), submittedTyped, state_1, retainedCount_1);
+        }
+        else {
+            const previousState = matchValue;
+            const typed_2 = inferProgramWithExterns(append(session.Externs, toList_1(values(session.InferenceBindings))), append(session.TypeDeclarations, program));
+            const submittedTyped_1 = skip(length(session.TypeDeclarations), typed_2);
+            const state_2 = evalProgramFromState(previousState, submittedTyped_1);
+            return new Submission(new Session(session.Externs, retainedRev, session.TypeDeclarations, updateInferenceBindings(session.InferenceBindings, submittedTyped_1), state_2), submittedTyped_1, state_2, retainedCount_1);
+        }
+    }
+    else {
+        const typed = inferProgramWithExterns(session.Externs, program);
+        const state = evalProgramWithExternsState(session.Externs, typed);
+        return new Submission(new Session(session.Externs, retainedRev, typeDeclarations(retainedStatements(program)), updateInferenceBindings(empty_1({
+            Compare: (x, y) => (comparePrimitives(x, y) | 0),
+        }), typed), state), typed, state, retainedCount_1);
+    }
+}
+