@magnusopera/fscript 0.77.1 → 0.79.0

package/dist/FScript.Language/Eval.js

@@ -1,20 +1,20 @@
 
-import { toString, FSharpRef, Record } from "../fable_modules/fable-library-js.5.2.0/Types.js";
-import { option_type, array_type, obj_type, record_type, class_type, string_type } from "../fable_modules/fable-library-js.5.2.0/Reflection.js";
+import { toString, FSharpRef, Record } from "../fable_modules/fable-library-js.5.13.0/Types.js";
+import { option_type, array_type, obj_type, record_type, class_type, string_type } from "../fable_modules/fable-library-js.5.13.0/Reflection.js";
 import { Type, Types_typeToString, Type_$reflection } from "./Types.js";
 import { ExternalCallContext, MapKey, Value, TaskHandle_$reflection, Value_$reflection } from "./Value.js";
 import { EvalException, EvalError$, EvalError$_$reflection } from "./Error.js";
 import { Span, Position } from "./Span.js";
-import { printf, toText, join, concat } from "../fable_modules/fable-library-js.5.2.0/String.js";
-import { curry2, disposeSafe, getEnumerator, equals as equals_1, compare, comparePrimitives, int64ToString } from "../fable_modules/fable-library-js.5.2.0/Util.js";
-import { ofArray, collect, tryFindIndex, choose, tryPick as tryPick_1, tryFind as tryFind_1, append, reverse, zip, fold as fold_1, singleton, forAll as forAll_1, empty, cons, tail as tail_2, head as head_2, isEmpty, forAll2, length, map } from "../fable_modules/fable-library-js.5.2.0/List.js";
-import { map as map_2, containsKey, FSharpMap__Add, fold, empty as empty_1, FSharpMap__Remove, FSharpMap__get_IsEmpty, FSharpMap__ContainsKey, add, FSharpMap__TryFind, tryFind, toSeq, ofList, FSharpMap__get_Item, forAll, FSharpMap__get_Keys, FSharpMap__get_Count, toList } from "../fable_modules/fable-library-js.5.2.0/Map.js";
-import { op_Modulus, op_Division, op_Multiply, op_Subtraction, op_Addition, toInt64_unchecked, compare as compare_1, equals } from "../fable_modules/fable-library-js.5.2.0/BigInt.js";
-import { contains, ofSeq } from "../fable_modules/fable-library-js.5.2.0/Set.js";
-import { toArray, some, bind, map as map_1 } from "../fable_modules/fable-library-js.5.2.0/Option.js";
-import { filter, length as length_1, iterate, foldBack, head as head_3, tryPick } from "../fable_modules/fable-library-js.5.2.0/Seq.js";
+import { printf, toText, join, concat } from "../fable_modules/fable-library-js.5.13.0/String.js";
+import { curry2, disposeSafe, getEnumerator, equals as equals_1, compare, comparePrimitives, int64ToString } from "../fable_modules/fable-library-js.5.13.0/Util.js";
+import { ofArray, collect, tryFindIndex, choose, tryFind as tryFind_1, tryPick as tryPick_1, append, reverse, zip, fold as fold_1, singleton, forAll as forAll_1, empty, cons, tail as tail_2, head as head_2, isEmpty, forAll2, length, map } from "../fable_modules/fable-library-js.5.13.0/List.js";
+import { map as map_1, containsKey, FSharpMap__Add, fold, empty as empty_1, FSharpMap__Remove, FSharpMap__get_IsEmpty, FSharpMap__ContainsKey, add, FSharpMap__TryFind, tryFind, toSeq, ofList, FSharpMap__get_Item, forAll, FSharpMap__get_Keys, FSharpMap__get_Count, toList } from "../fable_modules/fable-library-js.5.13.0/Map.js";
+import { op_Modulus, op_Division, op_Multiply, op_Subtraction, op_Addition, toInt64_unchecked, compare as compare_1, equals } from "../fable_modules/fable-library-js.5.13.0/BigInt.js";
+import { contains, ofSeq } from "../fable_modules/fable-library-js.5.13.0/Set.js";
+import { filter, length as length_1, foldBack, head as head_3, tryPick } from "../fable_modules/fable-library-js.5.13.0/Seq.js";
 import { Ast_spanOfExpr, Expr, Ast_spanOfPattern, TypeRef } from "./Ast.js";
-import { StringBuilder__Append_Z721C83C5, StringBuilder_$ctor } from "../fable_modules/fable-library-js.5.2.0/System.Text.js";
+import { some } from "../fable_modules/fable-library-js.5.13.0/Option.js";
+import { StringBuilder__Append_Z721C83C5, StringBuilder_$ctor } from "../fable_modules/fable-library-js.5.13.0/System.Text.js";
 import { builtinReservedNames } from "./BuiltinSignatures.js";
 import { typeDefs as typeDefs_3 } from "./BuiltinTypes.js";
 import { builtinExterns } from "./BuiltinFunctions.js";
@@ -73,13 +73,13 @@ function raiseIfBackgroundFailed(runtime) {
 function literalToValue(lit) {
     switch (lit.tag) {
         case 1:
-            return new Value(2, [lit.fields[0]]);
+            return new Value(/* VFloat */ 2, [lit.fields[0]]);
         case 2:
-            return new Value(3, [lit.fields[0]]);
+            return new Value(/* VBool */ 3, [lit.fields[0]]);
         case 3:
-            return new Value(4, [lit.fields[0]]);
+            return new Value(/* VString */ 4, [lit.fields[0]]);
         default:
-            return new Value(1, [lit.fields[0]]);
+            return new Value(/* VInt */ 1, [lit.fields[0]]);
     }
 }
 
@@ -431,19 +431,19 @@ function valueEquals(a_mut, b_mut) {
 
 function mapKeyToValue(key) {
     if (key.tag === 1) {
-        return new Value(1, [key.fields[0]]);
+        return new Value(/* VInt */ 1, [key.fields[0]]);
     }
     else {
-        return new Value(4, [key.fields[0]]);
+        return new Value(/* VString */ 4, [key.fields[0]]);
     }
 }
 
 function valueToMapKey(span, value) {
     switch (value.tag) {
         case 4:
-            return new MapKey(0, [value.fields[0]]);
+            return new MapKey(/* MKString */ 0, [value.fields[0]]);
         case 1:
-            return new MapKey(1, [value.fields[0]]);
+            return new MapKey(/* MKInt */ 1, [value.fields[0]]);
         default:
             throw new EvalException(new EvalError$("Map key must be string or int", span));
     }
@@ -452,27 +452,64 @@ function valueToMapKey(span, value) {
 function valueMatchesTypeRef(typeDefs, tref, value) {
     const resolve = (tref_1) => {
         switch (tref_1.tag) {
-            case 1:
-                return map_1((Item) => (new Type(7, [Item])), resolveTypeList(tref_1.fields[0]));
+            case 1: {
+                const option_1 = resolveTypeList(tref_1.fields[0]);
+                if (option_1 != null) {
+                    return new Type(/* TTuple */ 7, [option_1]);
+                }
+                else {
+                    return undefined;
+                }
+            }
             case 2:
                 return undefined;
             case 3:
                 switch (tref_1.fields[1]) {
-                    case "list":
-                        return map_1((Item_1) => (new Type(5, [Item_1])), resolve(tref_1.fields[0]));
-                    case "task":
-                        return map_1((Item_2) => (new Type(6, [Item_2])), resolve(tref_1.fields[0]));
-                    case "option":
-                        return map_1((Item_3) => (new Type(10, [Item_3])), resolve(tref_1.fields[0]));
-                    case "map":
-                        return map_1((t) => (new Type(9, [new Type(4, []), t])), resolve(tref_1.fields[0]));
+                    case "list": {
+                        const option_3 = resolve(tref_1.fields[0]);
+                        if (option_3 != null) {
+                            return new Type(/* TList */ 5, [option_3]);
+                        }
+                        else {
+                            return undefined;
+                        }
+                    }
+                    case "task": {
+                        const option_5 = resolve(tref_1.fields[0]);
+                        if (option_5 != null) {
+                            return new Type(/* TTask */ 6, [option_5]);
+                        }
+                        else {
+                            return undefined;
+                        }
+                    }
+                    case "option": {
+                        const option_7 = resolve(tref_1.fields[0]);
+                        if (option_7 != null) {
+                            return new Type(/* TOption */ 10, [option_7]);
+                        }
+                        else {
+                            return undefined;
+                        }
+                    }
+                    case "map": {
+                        const option_9 = resolve(tref_1.fields[0]);
+                        if (option_9 != null) {
+                            return new Type(/* TMap */ 9, [Type.TString, option_9]);
+                        }
+                        else {
+                            return undefined;
+                        }
+                    }
                     default:
                         return undefined;
                 }
             case 4: {
-                const shape = map_1((elements) => ofList(elements, {
+                let shape;
+                const option_11 = resolveFieldList(tref_1.fields[0]);
+                shape = ((option_11 != null) ? ofList(option_11, {
                     Compare: (x, y) => (comparePrimitives(x, y) | 0),
-                }), resolveFieldList(tref_1.fields[0]));
+                }) : undefined);
                 if (shape != null) {
                     const s = shape;
                     return tryPick((tupledArg) => {
@@ -492,7 +529,7 @@ function valueMatchesTypeRef(typeDefs, tref, value) {
                         }
                         switch (matchResult) {
                             case 0:
-                                return new Type(12, [tupledArg[0]]);
+                                return new Type(/* TNamed */ 12, [tupledArg[0]]);
                             default:
                                 return undefined;
                         }
@@ -502,22 +539,29 @@ function valueMatchesTypeRef(typeDefs, tref, value) {
                     return undefined;
                 }
             }
-            case 5:
-                return map_1((arg) => (new Type(8, [ofList(arg, {
-                    Compare: (x_1, y_1) => (comparePrimitives(x_1, y_1) | 0),
-                })])), resolveFieldList(tref_1.fields[0]));
+            case 5: {
+                const option_13 = resolveFieldList(tref_1.fields[0]);
+                if (option_13 != null) {
+                    return new Type(/* TRecord */ 8, [ofList(option_13, {
+                        Compare: (x_1, y_1) => (comparePrimitives(x_1, y_1) | 0),
+                    })]);
+                }
+                else {
+                    return undefined;
+                }
+            }
             default:
                 switch (tref_1.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 "bool":
-                        return new Type(3, []);
+                        return Type.TBool;
                     case "string":
-                        return new Type(4, []);
+                        return Type.TString;
                     default:
                         return tryFind(tref_1.fields[0], typeDefs);
                 }
@@ -778,7 +822,7 @@ function valueMatchesTypeRef(typeDefs, tref, value) {
             }
         }
         case 5: {
-            const matchValue_10 = resolve(new TypeRef(5, [tref.fields[0]]));
+            const matchValue_10 = resolve(new TypeRef(/* TRStructuralRecord */ 5, [tref.fields[0]]));
             if (matchValue_10 == null) {
                 return false;
             }
@@ -897,11 +941,11 @@ function patternMatch(typeDefs_mut, pat_mut, value_mut) {
                                 let targetKey;
                                 switch (targetKeyValue.tag) {
                                     case 4: {
-                                        targetKey = (new MapKey(0, [targetKeyValue.fields[0]]));
+                                        targetKey = (new MapKey(/* MKString */ 0, [targetKeyValue.fields[0]]));
                                         break;
                                     }
                                     case 1: {
-                                        targetKey = (new MapKey(1, [targetKeyValue.fields[0]]));
+                                        targetKey = (new MapKey(/* MKInt */ 1, [targetKeyValue.fields[0]]));
                                         break;
                                     }
                                     default:
@@ -938,7 +982,7 @@ function patternMatch(typeDefs_mut, pat_mut, value_mut) {
                         }
                     }
                     else {
-                        return bind((tupledArg) => matchMapClauses(hasExplicitClauses, rest, tailPattern, FSharpMap__Remove(remaining, tupledArg[0]), tupledArg[1]), tryPick((kv) => {
+                        const option_1 = tryPick((kv) => {
                             const matchValue_10 = patternMatch(typeDefs, keyPattern, mapKeyToValue(kv[0]));
                             if (matchValue_10 == null) {
                                 return undefined;
@@ -965,7 +1009,19 @@ function patternMatch(typeDefs_mut, pat_mut, value_mut) {
                                     }
                                 }
                             }
-                        }, remaining));
+                        }, remaining);
+                        if (option_1 != null) {
+                            const tupledArg = option_1;
+                            hasExplicitClauses_mut = hasExplicitClauses;
+                            clauses_mut = rest;
+                            tailPattern_mut = tailPattern;
+                            remaining_mut = FSharpMap__Remove(remaining, tupledArg[0]);
+                            envAcc_mut = tupledArg[1];
+                            continue matchMapClauses;
+                        }
+                        else {
+                            return undefined;
+                        }
                     }
                 }
                 else if (tailPattern == null) {
@@ -977,7 +1033,7 @@ function patternMatch(typeDefs_mut, pat_mut, value_mut) {
                     }
                 }
                 else {
-                    const matchValue_1 = patternMatch(typeDefs, tailPattern, new Value(8, [remaining]));
+                    const matchValue_1 = patternMatch(typeDefs, tailPattern, new Value(/* VMap */ 8, [remaining]));
                     if (matchValue_1 == null) {
                         return undefined;
                     }
@@ -1151,7 +1207,7 @@ function patternMatch(typeDefs_mut, pat_mut, value_mut) {
                 });
             case 4: {
                 const matchValue_15 = patternMatch(typeDefs, p1, h);
-                const matchValue_16 = patternMatch(typeDefs, p2, new Value(5, [t]));
+                const matchValue_16 = patternMatch(typeDefs, p2, new Value(/* VList */ 5, [t]));
                 let matchResult_2, env1, env2;
                 if (matchValue_15 != null) {
                     if (matchValue_16 != null) {
@@ -1246,8 +1302,10 @@ function patternMatch(typeDefs_mut, pat_mut, value_mut) {
                 return empty_1({
                     Compare: (x_7, y_7) => (comparePrimitives(x_7, y_7) | 0),
                 });
-            case 10:
-                if ((caseName === valueCaseName) && ((qualifier == null) ? true : (qualifier === valueTypeName))) {
+            case 10: {
+                const caseMatches = caseName === valueCaseName;
+                const qualifierMatches = (qualifier == null) ? true : (qualifier === valueTypeName);
+                if (caseMatches && qualifierMatches) {
                     let matchResult_5, p_3, v_7;
                     if (payload != null) {
                         if (valuePayload != null) {
@@ -1283,6 +1341,7 @@ function patternMatch(typeDefs_mut, pat_mut, value_mut) {
                 else {
                     return undefined;
                 }
+            }
             case 11:
                 if (valueMatchesTypeRef(typeDefs, tref, v_8)) {
                     return empty_1({
@@ -1321,7 +1380,7 @@ function applyFunctionValue(runtime, eval$, typeDefs, span, fnValue, argValue) {
         case 14:
             return eval$(runtime, typeDefs, add(fnValue.fields[0], argValue, fnValue.fields[2].contents), fnValue.fields[1]);
         case 11:
-            return new Value(10, [fnValue.fields[0], fnValue.fields[1], argValue]);
+            return new Value(/* VUnionCase */ 10, [fnValue.fields[0], fnValue.fields[1], argValue]);
         case 15: {
             const ext = fnValue.fields[0];
             const args$0027 = cons(argValue, fnValue.fields[1]);
@@ -1329,7 +1388,7 @@ function applyFunctionValue(runtime, eval$, typeDefs, span, fnValue, argValue) {
                 return ext.Impl(createExternContext(runtime, typeDefs, span), reverse(args$0027));
             }
             else if (length(args$0027) < ext.Arity) {
-                return new Value(15, [ext, args$0027]);
+                return new Value(/* VExternal */ 15, [ext, args$0027]);
             }
             else {
                 throw new EvalException(new EvalError$(toText(printf("External function \'%s\' received too many arguments"))(ext.Name), span));
@@ -1366,7 +1425,7 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                 continue evalExpr;
             }
             case 4:
-                return new Value(14, [expr.fields[0].Name, expr.fields[1], new FSharpRef(env)]);
+                return new Value(/* VClosure */ 14, [expr.fields[0].Name, expr.fields[1], new FSharpRef(env)]);
             case 5:
                 return applyFunctionValue(runtime, evalExpr, typeDefs, expr.fields[2], evalExpr(runtime, typeDefs, env, expr.fields[0]), evalExpr(runtime, typeDefs, env, expr.fields[1]));
             case 6: {
@@ -1413,7 +1472,7 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                     finally {
                         disposeSafe(enumerator);
                     }
-                    return new Value(0, []);
+                    return Value.VUnit;
                 }
                 else {
                     throw new EvalException(new EvalError$("For loop source must be list", expr.fields[3]));
@@ -1426,7 +1485,7 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                 if (expr.fields[3]) {
                     if (value_1.tag === 4) {
                         const recEnv = new FSharpRef(env);
-                        recEnv.contents = add(name_2, new Value(14, [value_1.fields[0].Name, value_1.fields[1], recEnv]), env);
+                        recEnv.contents = add(name_2, new Value(/* VClosure */ 14, [value_1.fields[0].Name, value_1.fields[1], recEnv]), env);
                         runtime_mut = runtime;
                         typeDefs_mut = typeDefs;
                         env_mut = recEnv.contents;
@@ -1476,9 +1535,9 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                         if (isEmpty(args)) {
                             throw new EvalException(new EvalError$("\'let rec ... and ...\' requires function arguments for each binding", bindingSpan));
                         }
-                        const folded = foldBack((arg_2, accExpr) => (new Expr(4, [arg_2, accExpr, bindingSpan])), args, tupledArg[3]);
+                        const folded = foldBack((arg_2, accExpr) => (new Expr(/* ELambda */ 4, [arg_2, accExpr, bindingSpan])), args, tupledArg[3]);
                         if (folded.tag === 4) {
-                            return [tupledArg[0], new Value(14, [folded.fields[0].Name, folded.fields[1], recEnv_1])];
+                            return [tupledArg[0], new Value(/* VClosure */ 14, [folded.fields[0].Name, folded.fields[1], recEnv_1])];
                         }
                         else {
                             throw new EvalException(new EvalError$("let rec requires a function binding", expr.fields[2]));
@@ -1539,7 +1598,7 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                 return tryCases(expr.fields[1]);
             }
             case 13:
-                return new Value(5, [map((expr_2) => evalExpr(runtime, typeDefs, env, expr_2), expr.fields[0])]);
+                return new Value(/* VList */ 5, [map((expr_2) => evalExpr(runtime, typeDefs, env, expr_2), expr.fields[0])]);
             case 14: {
                 const startValue = evalExpr(runtime, typeDefs, env, expr.fields[0]);
                 const endValue = evalExpr(runtime, typeDefs, env, expr.fields[1]);
@@ -1568,31 +1627,31 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                                     return reverse(acc_3);
                                 }
                                 else {
-                                    acc_3_mut = cons(new Value(1, [current]), acc_3);
+                                    acc_3_mut = cons(new Value(/* VInt */ 1, [current]), acc_3);
                                     current_mut = toInt64_unchecked(op_Addition(current, step));
                                     continue build;
                                 }
                                 break;
                             }
                         };
-                        return new Value(5, [build(empty(), s)]);
+                        return new Value(/* VList */ 5, [build(empty(), s)]);
                     }
                     default:
                         throw new EvalException(new EvalError$("Range endpoints must be int", expr.fields[2]));
                 }
             }
             case 15:
-                return new Value(6, [map((expr_3) => evalExpr(runtime, typeDefs, env, expr_3), expr.fields[0])]);
+                return new Value(/* VTuple */ 6, [map((expr_3) => evalExpr(runtime, typeDefs, env, expr_3), expr.fields[0])]);
             case 16:
-                return new Value(7, [ofList(map((tupledArg_2) => [tupledArg_2[0], evalExpr(runtime, typeDefs, env, tupledArg_2[1])], expr.fields[0]), {
+                return new Value(/* VRecord */ 7, [ofList(map((tupledArg_2) => [tupledArg_2[0], evalExpr(runtime, typeDefs, env, tupledArg_2[1])], expr.fields[0]), {
                     Compare: (x, y) => (comparePrimitives(x, y) | 0),
                 })]);
             case 17:
-                return new Value(7, [ofList(map((tupledArg_3) => [tupledArg_3[0], evalExpr(runtime, typeDefs, env, tupledArg_3[1])], expr.fields[0]), {
+                return new Value(/* VRecord */ 7, [ofList(map((tupledArg_3) => [tupledArg_3[0], evalExpr(runtime, typeDefs, env, tupledArg_3[1])], expr.fields[0]), {
                     Compare: (x_1, y_1) => (comparePrimitives(x_1, y_1) | 0),
                 })]);
             case 18:
-                return new Value(8, [fold_1((acc_4, entry) => {
+                return new Value(/* VMap */ 8, [fold_1((acc_4, entry) => {
                     if (entry.tag === 1) {
                         const spreadExpr = entry.fields[0];
                         const matchValue_8 = evalExpr(runtime, typeDefs, env, spreadExpr);
@@ -1628,7 +1687,7 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                 const span_10 = expr.fields[2];
                 const matchValue_9 = evalExpr(runtime, typeDefs, env, expr.fields[0]);
                 if (matchValue_9.tag === 7) {
-                    return new Value(7, [fold_1((acc_5, tupledArg_4) => {
+                    return new Value(/* VRecord */ 7, [fold_1((acc_5, tupledArg_4) => {
                         const name_7 = tupledArg_4[0];
                         if (containsKey(name_7, acc_5)) {
                             return add(name_7, evalExpr(runtime, typeDefs, env, tupledArg_4[1]), acc_5);
@@ -1645,7 +1704,7 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
             case 20: {
                 const matchValue_10 = evalExpr(runtime, typeDefs, env, expr.fields[0]);
                 if (matchValue_10.tag === 7) {
-                    return new Value(7, [fold_1((acc_6, tupledArg_5) => add(tupledArg_5[0], evalExpr(runtime, typeDefs, env, tupledArg_5[1]), acc_6), matchValue_10.fields[0], expr.fields[1])]);
+                    return new Value(/* VRecord */ 7, [fold_1((acc_6, tupledArg_5) => add(tupledArg_5[0], evalExpr(runtime, typeDefs, env, tupledArg_5[1]), acc_6), matchValue_10.fields[0], expr.fields[1])]);
                 }
                 else {
                     throw new EvalException(new EvalError$("Structural record update requires a record value", expr.fields[2]));
@@ -1767,14 +1826,14 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                             }
                         };
                         if (compare_1(index, 0n) < 0) {
-                            return new Value(9, [undefined]);
+                            return new Value(/* VOption */ 9, [undefined]);
                         }
                         else {
-                            return new Value(9, [loop(values, 0n)]);
+                            return new Value(/* VOption */ 9, [loop(values, 0n)]);
                         }
                     }
                     case 1:
-                        return new Value(9, [FSharpMap__TryFind(mapValue, valueToMapKey(span_13, keyValue_1))]);
+                        return new Value(/* VOption */ 9, [FSharpMap__TryFind(mapValue, valueToMapKey(span_13, keyValue_1))]);
                     case 2:
                         throw new EvalException(new EvalError$("Map index key must be string or int", span_13));
                     case 3:
@@ -1787,7 +1846,7 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                 const h = evalExpr(runtime, typeDefs, env, expr.fields[0]);
                 const t = evalExpr(runtime, typeDefs, env, expr.fields[1]);
                 if (t.tag === 5) {
-                    return new Value(5, [cons(h, t.fields[0])]);
+                    return new Value(/* VList */ 5, [cons(h, t.fields[0])]);
                 }
                 else {
                     throw new EvalException(new EvalError$("Right side of \'::\' must be list", expr.fields[2]));
@@ -1812,7 +1871,7 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                 }
                 switch (matchResult_3) {
                     case 0:
-                        return new Value(5, [append(xs_1, ys)]);
+                        return new Value(/* VList */ 5, [append(xs_1, ys)]);
                     default:
                         throw new EvalException(new EvalError$("Both sides of \'@\' must be lists", expr.fields[2]));
                 }
@@ -1852,9 +1911,9 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                     }
                     switch (matchResult_4) {
                         case 0:
-                            return new Value(1, [fInt(x_3)(y_3)]);
+                            return new Value(/* VInt */ 1, [fInt(x_3)(y_3)]);
                         case 1:
-                            return new Value(2, [fFloat(x_4)(y_4)]);
+                            return new Value(/* VFloat */ 2, [fFloat(x_4)(y_4)]);
                         default:
                             throw new EvalException(new EvalError$("Numeric operands required", span_16));
                     }
@@ -1898,9 +1957,9 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                         }
                         switch (matchResult_5) {
                             case 0:
-                                return new Value(1, [toInt64_unchecked(op_Division(x_11, y_11))]);
+                                return new Value(/* VInt */ 1, [toInt64_unchecked(op_Division(x_11, y_11))]);
                             case 1:
-                                return new Value(2, [x_12 / y_12]);
+                                return new Value(/* VFloat */ 2, [x_12 / y_12]);
                             default:
                                 throw new EvalException(new EvalError$("Numeric operands required", span_16));
                         }
@@ -1922,13 +1981,13 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                         }
                         switch (matchResult_6) {
                             case 0:
-                                return new Value(1, [toInt64_unchecked(op_Modulus(x_13, y_13))]);
+                                return new Value(/* VInt */ 1, [toInt64_unchecked(op_Modulus(x_13, y_13))]);
                             default:
                                 throw new EvalException(new EvalError$("Integer operands required", span_16));
                         }
                     }
                     case "=":
-                        return new Value(3, [valueEquals(av_1, bv_1)]);
+                        return new Value(/* VBool */ 3, [valueEquals(av_1, bv_1)]);
                     case "<":
                     case ">":
                     case "<=":
@@ -1962,9 +2021,9 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                         }
                         switch (matchResult_7) {
                             case 0:
-                                return new Value(3, [(op === "<") ? (compare_1(x_14, y_14) < 0) : ((op === ">") ? (compare_1(x_14, y_14) > 0) : ((op === "<=") ? (compare_1(x_14, y_14) <= 0) : ((op === ">=") && (compare_1(x_14, y_14) >= 0))))]);
+                                return new Value(/* VBool */ 3, [(op === "<") ? (compare_1(x_14, y_14) < 0) : ((op === ">") ? (compare_1(x_14, y_14) > 0) : ((op === "<=") ? (compare_1(x_14, y_14) <= 0) : ((op === ">=") && (compare_1(x_14, y_14) >= 0))))]);
                             case 1:
-                                return new Value(3, [(op === "<") ? (x_15 < y_15) : ((op === ">") ? (x_15 > y_15) : ((op === "<=") ? (x_15 <= y_15) : ((op === ">=") && (x_15 >= y_15))))]);
+                                return new Value(/* VBool */ 3, [(op === "<") ? (x_15 < y_15) : ((op === ">") ? (x_15 > y_15) : ((op === "<=") ? (x_15 <= y_15) : ((op === ">=") && (x_15 >= y_15))))]);
                             default:
                                 throw new EvalException(new EvalError$("Numeric operands required", span_16));
                         }
@@ -1987,14 +2046,14 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                         }
                         switch (matchResult_8) {
                             case 0:
-                                return new Value(3, [(op === "&&") ? (x_16 && y_16) : (x_16 ? true : y_16)]);
+                                return new Value(/* VBool */ 3, [(op === "&&") ? (x_16 && y_16) : (x_16 ? true : y_16)]);
                             default:
                                 throw new EvalException(new EvalError$("Boolean operands required", span_16));
                         }
                     }
                     case "::":
                         if (bv_1.tag === 5) {
-                            return new Value(5, [cons(av_1, bv_1.fields[0])]);
+                            return new Value(/* VList */ 5, [cons(av_1, bv_1.fields[0])]);
                         }
                         else {
                             throw new EvalException(new EvalError$("Right side of \'::\' must be list", span_16));
@@ -2016,7 +2075,7 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                         }
                         switch (matchResult_9) {
                             case 0:
-                                return new Value(5, [append(xs_3, ys_1)]);
+                                return new Value(/* VList */ 5, [append(xs_3, ys_1)]);
                             default:
                                 throw new EvalException(new EvalError$("Both sides of \'@\' must be lists", span_16));
                         }
@@ -2026,9 +2085,9 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                 }
             }
             case 26:
-                return new Value(9, [evalExpr(runtime, typeDefs, env, expr.fields[0])]);
+                return new Value(/* VOption */ 9, [evalExpr(runtime, typeDefs, env, expr.fields[0])]);
             case 27:
-                return new Value(9, [undefined]);
+                return new Value(/* VOption */ 9, [undefined]);
             case 28: {
                 const name_9 = expr.fields[0];
                 const matchValue_24 = FSharpMap__TryFind(typeDefs, name_9);
@@ -2036,13 +2095,13 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                     throw new EvalException(new EvalError$(concat("Unknown type \'", name_9, "\'"), expr.fields[1]));
                 }
                 else {
-                    return new Value(12, [matchValue_24]);
+                    return new Value(/* VTypeToken */ 12, [matchValue_24]);
                 }
             }
             case 29: {
                 const name_10 = expr.fields[0];
                 if (FSharpMap__ContainsKey(env, name_10)) {
-                    return new Value(4, [name_10]);
+                    return new Value(/* VString */ 4, [name_10]);
                 }
                 else {
                     throw new EvalException(new EvalError$(concat("Unbound variable \'", name_10, "\'"), expr.fields[1]));
@@ -2065,10 +2124,10 @@ function evalExpr(runtime_mut, typeDefs_mut, env_mut, expr_mut) {
                 finally {
                     disposeSafe(enumerator_1);
                 }
-                return new Value(4, [toString(sb)]);
+                return new Value(/* VString */ 4, [toString(sb)]);
             }
             default:
-                return new Value(0, []);
+                return Value.VUnit;
         }
         break;
     }
@@ -2089,7 +2148,7 @@ export function invokeValue(typeDefs, fnValue, args) {
                             return ext.Impl(createExternContext(runtime, typeDefs, unknownSpan), allArgs);
                         }
                         else if (length(allArgs) < ext.Arity) {
-                            return new Value(15, [ext, reverse(allArgs)]);
+                            return new Value(/* VExternal */ 15, [ext, reverse(allArgs)]);
                         }
                         else {
                             throw new EvalException(new EvalError$(toText(printf("External function \'%s\' received too many arguments"))(ext.Name), unknownSpan));
@@ -2150,14 +2209,8 @@ export function invokeValue(typeDefs, fnValue, args) {
     return applyMany(fnValue, args);
 }
 
-export function evalProgramWithExternsState(externs, program) {
-    const runtime = new RuntimeState({}, [], undefined);
-    iterate((ext_1) => {
-        throw new EvalException(new EvalError$(concat("Host extern \'", ext_1.Name, "\' collides with reserved stdlib symbol"), unknownSpan));
-    }, toArray(tryFind_1((ext) => contains(ext.Name, builtinReservedNames), externs)));
-    iterate((name_5) => {
-        throw new EvalException(new EvalError$(concat("Top-level binding \'", name_5, "\' collides with reserved stdlib symbol"), unknownSpan));
-    }, toArray(tryPick_1((_arg) => {
+function validateTopLevelBindings(program) {
+    const option_5 = tryPick_1((_arg) => {
         let matchResult, name_1, bindings, bindings_1;
         switch (_arg.tag) {
             case 1: {
@@ -2186,17 +2239,127 @@ export function evalProgramWithExternsState(externs, program) {
         switch (matchResult) {
             case 0:
                 return name_1;
-            case 1:
-                return map_1((tuple) => tuple[0], tryFind_1((tupledArg) => contains(tupledArg[0], builtinReservedNames), toList(bindings)));
-            case 2:
-                return map_1((tupledArg_2) => tupledArg_2[0], tryFind_1((tupledArg_1) => contains(tupledArg_1[0], builtinReservedNames), bindings_1));
+            case 1: {
+                const option_1 = tryFind_1((tupledArg) => contains(tupledArg[0], builtinReservedNames), toList(bindings));
+                if (option_1 != null) {
+                    return option_1[0];
+                }
+                else {
+                    return undefined;
+                }
+            }
+            case 2: {
+                const option_3 = tryFind_1((tupledArg_1) => contains(tupledArg_1[0], builtinReservedNames), bindings_1);
+                if (option_3 != null) {
+                    return option_3[0];
+                }
+                else {
+                    return undefined;
+                }
+            }
             default:
                 return undefined;
         }
-    }, program)));
-    const decls = ofList(append(map((def) => [def.Name, def], typeDefs_3), choose((_arg_8) => {
-        if (_arg_8.tag === 0) {
-            const def_1 = _arg_8.fields[0];
+    }, program);
+    if (option_5 != null) {
+        throw new EvalException(new EvalError$(concat("Top-level binding \'", option_5, "\' collides with reserved stdlib symbol"), unknownSpan));
+    }
+}
+
+function evaluateStatements(runtime, typeDefs, initialEnv, program) {
+    validateTopLevelBindings(program);
+    let env = initialEnv;
+    let lastValue = Value.VUnit;
+    const enumerator = getEnumerator(program);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const stmt = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            raiseIfBackgroundFailed(runtime);
+            switch (stmt.tag) {
+                case 1: {
+                    const name = stmt.fields[0];
+                    const expr = stmt.fields[1];
+                    if (stmt.fields[3]) {
+                        if (expr.tag === 4) {
+                            const recEnv = new FSharpRef(env);
+                            const finalEnv = add(name, new Value(/* VClosure */ 14, [expr.fields[0].Name, expr.fields[1], recEnv]), env);
+                            recEnv.contents = finalEnv;
+                            env = finalEnv;
+                        }
+                        else {
+                            throw new EvalException(new EvalError$("let rec requires a function binding", stmt.fields[5]));
+                        }
+                    }
+                    else {
+                        const v = evalExpr(runtime, typeDefs, env, expr);
+                        env = add(name, v, env);
+                    }
+                    break;
+                }
+                case 2: {
+                    const matchValue = patternMatch(typeDefs, stmt.fields[0], evalExpr(runtime, typeDefs, env, stmt.fields[1]));
+                    if (matchValue == null) {
+                        throw new EvalException(new EvalError$("Let pattern did not match value", stmt.fields[4]));
+                    }
+                    else {
+                        const bindings = matchValue;
+                        env = fold((acc, k, value) => add(k, value, acc), env, bindings);
+                    }
+                    break;
+                }
+                case 3: {
+                    const bindings_1 = stmt.fields[0];
+                    if (!isEmpty(bindings_1)) {
+                        const recEnv_1 = new FSharpRef(env);
+                        let finalEnv_1;
+                        const list_1 = map((tupledArg) => {
+                            const expr_2 = tupledArg[1];
+                            if (expr_2.tag === 4) {
+                                return [tupledArg[0], new Value(/* VClosure */ 14, [expr_2.fields[0].Name, expr_2.fields[1], recEnv_1])];
+                            }
+                            else {
+                                throw new EvalException(new EvalError$("let rec requires a function binding", tupledArg[3]));
+                            }
+                        }, bindings_1);
+                        finalEnv_1 = fold_1((acc_1, tupledArg_1) => add(tupledArg_1[0], tupledArg_1[1], acc_1), env, list_1);
+                        recEnv_1.contents = finalEnv_1;
+                        env = finalEnv_1;
+                    }
+                    break;
+                }
+                case 4: {
+                    lastValue = evalExpr(runtime, typeDefs, env, stmt.fields[0].Expr);
+                    break;
+                }
+                default:
+                    undefined;
+            }
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    raiseIfBackgroundFailed(runtime);
+    const unawaitedCount = length_1(filter((handle) => !handle.Awaited, runtime.PendingTasks)) | 0;
+    if (unawaitedCount > 0) {
+        throw new EvalException(new EvalError$(`Program completed with ${unawaitedCount} unawaited ${(unawaitedCount === 1) ? "task" : "tasks"}`, unknownSpan));
+    }
+    return new ProgramState(typeDefs, env, lastValue);
+}
+
+export function evalProgramFromState(state, program) {
+    return evaluateStatements(new RuntimeState({}, [], undefined), state.TypeDefs, state.Env, program);
+}
+
+export function evalProgramWithExternsState(externs, program) {
+    const runtime = new RuntimeState({}, [], undefined);
+    const option_1 = tryFind_1((ext) => contains(ext.Name, builtinReservedNames), externs);
+    if (option_1 != null) {
+        throw new EvalException(new EvalError$(concat("Host extern \'", option_1.Name, "\' collides with reserved stdlib symbol"), unknownSpan));
+    }
+    const decls = ofList(append(map((def) => [def.Name, def], typeDefs_3), choose((_arg) => {
+        if (_arg.tag === 0) {
+            const def_1 = _arg.fields[0];
             return [def_1.Name, def_1];
         }
         else {
@@ -2208,65 +2371,68 @@ export function evalProgramWithExternsState(externs, program) {
     const fromRef = (stack, tref) => {
         switch (tref.tag) {
             case 1:
-                return new Type(7, [map(curry2(fromRef)(stack), tref.fields[0])]);
+                return new Type(/* TTuple */ 7, [map(curry2(fromRef)(stack), tref.fields[0])]);
             case 2:
-                return new Type(11, [fromRef(stack, tref.fields[0]), fromRef(stack, tref.fields[1])]);
+                return new Type(/* TFun */ 11, [fromRef(stack, tref.fields[0]), fromRef(stack, tref.fields[1])]);
             case 3:
                 switch (tref.fields[1]) {
                     case "list":
-                        return new Type(5, [fromRef(stack, tref.fields[0])]);
+                        return new Type(/* TList */ 5, [fromRef(stack, tref.fields[0])]);
                     case "task":
-                        return new Type(6, [fromRef(stack, tref.fields[0])]);
+                        return new Type(/* TTask */ 6, [fromRef(stack, tref.fields[0])]);
                     case "option":
-                        return new Type(10, [fromRef(stack, tref.fields[0])]);
+                        return new Type(/* TOption */ 10, [fromRef(stack, tref.fields[0])]);
                     case "map":
-                        return new Type(9, [new Type(4, []), fromRef(stack, tref.fields[0])]);
+                        return new Type(/* TMap */ 9, [Type.TString, fromRef(stack, tref.fields[0])]);
                     default:
                         throw new EvalException(new EvalError$(concat("Unsupported type suffix ", tref.fields[1]), unknownSpan));
                 }
             case 4:
-                return new Type(8, [ofList(map((tupledArg_5) => [tupledArg_5[0], fromRef(stack, tupledArg_5[1])], tref.fields[0]), {
+                return new Type(/* TRecord */ 8, [ofList(map((tupledArg_2) => [tupledArg_2[0], fromRef(stack, tupledArg_2[1])], tref.fields[0]), {
                     Compare: (x_3, y_4) => (comparePrimitives(x_3, y_4) | 0),
                 })]);
             case 5:
-                return new Type(8, [ofList(map((tupledArg_6) => [tupledArg_6[0], fromRef(stack, tupledArg_6[1])], tref.fields[0]), {
+                return new Type(/* TRecord */ 8, [ofList(map((tupledArg_3) => [tupledArg_3[0], fromRef(stack, tupledArg_3[1])], tref.fields[0]), {
                     Compare: (x_4, y_5) => (comparePrimitives(x_4, y_5) | 0),
                 })]);
             default:
                 switch (tref.fields[0]) {
                     case "unit":
-                        return new Type(0, []);
+                        return Type.TUnit;
                     case "int":
-                        return new Type(1, []);
+                        return Type.TInt;
                     case "float":
-                        return new Type(2, []);
+                        return Type.TFloat;
                     case "bool":
-                        return new Type(3, []);
+                        return Type.TBool;
                     case "string":
-                        return new Type(4, []);
+                        return Type.TString;
                     default: {
                         const matchValue = FSharpMap__TryFind(decls, tref.fields[0]);
                         if (matchValue == null) {
-                            return new Type(12, [tref.fields[0]]);
+                            return new Type(/* TNamed */ 12, [tref.fields[0]]);
                         }
                         else {
                             const d = matchValue;
                             const matchValue_1 = tryFindIndex((y_1) => (tref.fields[0] === y_1), stack);
                             if (matchValue_1 == null) {
                                 if (!isEmpty(d.Cases)) {
-                                    return new Type(13, [tref.fields[0], ofList(map((tupledArg_3) => [tupledArg_3[0], map_1(curry2(fromRef)(cons(tref.fields[0], stack)), tupledArg_3[1])], d.Cases), {
+                                    return new Type(/* TUnion */ 13, [tref.fields[0], ofList(map((tupledArg) => {
+                                        let mapping_1, option_3;
+                                        return [tupledArg[0], (mapping_1 = curry2(fromRef)(cons(tref.fields[0], stack)), (option_3 = tupledArg[1], (option_3 != null) ? mapping_1(option_3) : undefined))];
+                                    }, d.Cases), {
                                         Compare: (x_1, y_2) => (comparePrimitives(x_1, y_2) | 0),
                                     })]);
                                 }
                                 else {
-                                    return new Type(8, [ofList(map((tupledArg_4) => [tupledArg_4[0], fromRef(cons(tref.fields[0], stack), tupledArg_4[1])], d.Fields), {
+                                    return new Type(/* TRecord */ 8, [ofList(map((tupledArg_1) => [tupledArg_1[0], fromRef(cons(tref.fields[0], stack), tupledArg_1[1])], d.Fields), {
                                         Compare: (x_2, y_3) => (comparePrimitives(x_2, y_3) | 0),
                                     })]);
                                 }
                             }
                             else if (matchValue_1 === 0) {
                                 if (d.IsRecursive) {
-                                    return new Type(12, [tref.fields[0]]);
+                                    return new Type(/* TNamed */ 12, [tref.fields[0]]);
                                 }
                                 else {
                                     throw new EvalException(new EvalError$(concat("Recursive type \'", tref.fields[0], "\' requires \'type rec\'"), unknownSpan));
@@ -2280,118 +2446,44 @@ export function evalProgramWithExternsState(externs, program) {
                 }
         }
     };
-    const typeDefs = map_2((name_8, def_2) => {
+    const typeDefs = map_1((name_2, def_2) => {
         if (!isEmpty(def_2.Cases)) {
-            return new Type(13, [name_8, ofList(map((tupledArg_7) => [tupledArg_7[0], map_1(curry2(fromRef)(singleton(name_8)), tupledArg_7[1])], def_2.Cases), {
+            return new Type(/* TUnion */ 13, [name_2, ofList(map((tupledArg_4) => {
+                let mapping_8, option_5;
+                return [tupledArg_4[0], (mapping_8 = curry2(fromRef)(singleton(name_2)), (option_5 = tupledArg_4[1], (option_5 != null) ? mapping_8(option_5) : undefined))];
+            }, def_2.Cases), {
                 Compare: (x_5, y_6) => (comparePrimitives(x_5, y_6) | 0),
             })]);
         }
         else {
-            return new Type(8, [ofList(map((tupledArg_8) => [tupledArg_8[0], fromRef(singleton(name_8), tupledArg_8[1])], def_2.Fields), {
+            return new Type(/* TRecord */ 8, [ofList(map((tupledArg_5) => [tupledArg_5[0], fromRef(singleton(name_2), tupledArg_5[1])], def_2.Fields), {
                 Compare: (x_6, y_7) => (comparePrimitives(x_6, y_7) | 0),
             })]);
         }
     }, decls);
-    const constructorValues = collect((tupledArg_9) => {
-        const typeName = tupledArg_9[0];
-        return collect((tupledArg_10) => {
-            const caseName_2 = tupledArg_10[0];
-            const value = (tupledArg_10[1] != null) ? (new Value(11, [typeName, caseName_2])) : (new Value(10, [typeName, caseName_2, undefined]));
+    const constructorValues = collect((tupledArg_6) => {
+        const typeName = tupledArg_6[0];
+        return collect((tupledArg_7) => {
+            const caseName_2 = tupledArg_7[0];
+            const value = (tupledArg_7[1] != null) ? (new Value(/* VUnionCtor */ 11, [typeName, caseName_2])) : (new Value(/* VUnionCase */ 10, [typeName, caseName_2, undefined]));
             return ofArray([[caseName_2, value], [concat(typeName, ".", caseName_2), value]]);
-        }, tupledArg_9[1].Cases);
+        }, tupledArg_6[1].Cases);
     }, toList(decls));
     const externContext = createExternContext(runtime, typeDefs, unknownSpan);
     let env;
-    const list_16 = append(builtinExterns, externs);
+    const list_13 = append(builtinExterns, externs);
     env = fold_1((acc, ext_2) => {
         if (ext_2.Arity === 0) {
             return FSharpMap__Add(acc, ext_2.Name, ext_2.Impl(externContext, empty()));
         }
         else {
-            return FSharpMap__Add(acc, ext_2.Name, new Value(15, [ext_2, empty()]));
+            return FSharpMap__Add(acc, ext_2.Name, new Value(/* VExternal */ 15, [ext_2, empty()]));
         }
     }, empty_1({
         Compare: (x_7, y_8) => (comparePrimitives(x_7, y_8) | 0),
-    }), list_16);
-    env = fold_1((acc_1, tupledArg_11) => FSharpMap__Add(acc_1, tupledArg_11[0], tupledArg_11[1]), env, constructorValues);
-    let lastValue = new Value(0, []);
-    const enumerator = getEnumerator(program);
-    try {
-        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
-            const stmt = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
-            raiseIfBackgroundFailed(runtime);
-            switch (stmt.tag) {
-                case 1: {
-                    const name_10 = stmt.fields[0];
-                    const expr = stmt.fields[1];
-                    if (stmt.fields[3]) {
-                        if (expr.tag === 4) {
-                            const recEnv = new FSharpRef(env);
-                            const finalEnv = add(name_10, new Value(14, [expr.fields[0].Name, expr.fields[1], recEnv]), env);
-                            recEnv.contents = finalEnv;
-                            env = finalEnv;
-                        }
-                        else {
-                            throw new EvalException(new EvalError$("let rec requires a function binding", stmt.fields[5]));
-                        }
-                    }
-                    else {
-                        const v = evalExpr(runtime, typeDefs, env, expr);
-                        env = add(name_10, v, env);
-                    }
-                    break;
-                }
-                case 2: {
-                    const matchValue_2 = patternMatch(typeDefs, stmt.fields[0], evalExpr(runtime, typeDefs, env, stmt.fields[1]));
-                    if (matchValue_2 == null) {
-                        throw new EvalException(new EvalError$("Let pattern did not match value", stmt.fields[4]));
-                    }
-                    else {
-                        const bindings_2 = matchValue_2;
-                        env = fold((acc_2, k, value_3) => add(k, value_3, acc_2), env, bindings_2);
-                    }
-                    break;
-                }
-                case 3: {
-                    const bindings_3 = stmt.fields[0];
-                    if (isEmpty(bindings_3)) {
-                    }
-                    else {
-                        const recEnv_1 = new FSharpRef(env);
-                        let finalEnv_1;
-                        const list_19 = map((tupledArg_12) => {
-                            const expr_2 = tupledArg_12[1];
-                            if (expr_2.tag === 4) {
-                                return [tupledArg_12[0], new Value(14, [expr_2.fields[0].Name, expr_2.fields[1], recEnv_1])];
-                            }
-                            else {
-                                throw new EvalException(new EvalError$("let rec requires a function binding", tupledArg_12[3]));
-                            }
-                        }, bindings_3);
-                        finalEnv_1 = fold_1((acc_3, tupledArg_13) => add(tupledArg_13[0], tupledArg_13[1], acc_3), env, list_19);
-                        recEnv_1.contents = finalEnv_1;
-                        env = finalEnv_1;
-                    }
-                    break;
-                }
-                case 4: {
-                    lastValue = evalExpr(runtime, typeDefs, env, stmt.fields[0].Expr);
-                    break;
-                }
-                default:
-                    undefined;
-            }
-        }
-    }
-    finally {
-        disposeSafe(enumerator);
-    }
-    raiseIfBackgroundFailed(runtime);
-    const unawaitedCount = length_1(filter((handle) => !handle.Awaited, runtime.PendingTasks)) | 0;
-    if (unawaitedCount > 0) {
-        throw new EvalException(new EvalError$(`Program completed with ${unawaitedCount} unawaited ${(unawaitedCount === 1) ? "task" : "tasks"}`, unknownSpan));
-    }
-    return new ProgramState(typeDefs, env, lastValue);
+    }), list_13);
+    env = fold_1((acc_1, tupledArg_8) => FSharpMap__Add(acc_1, tupledArg_8[0], tupledArg_8[1]), env, constructorValues);
+    return evaluateStatements(runtime, typeDefs, env, program);
 }
 
 export function evalProgramWithExterns(externs, program) {