@magnusopera/fscript 0.75.0

package/dist/FScript.Language/Types.js

@@ -0,0 +1,205 @@
+
+import { Union } from "../fable_modules/fable-library-js.5.2.0/Types.js";
+import { union_type, int32_type, option_type, class_type, string_type, list_type } from "../fable_modules/fable-library-js.5.2.0/Reflection.js";
+import { fold, map } from "../fable_modules/fable-library-js.5.2.0/List.js";
+import { toList, ofList, difference, singleton, empty, union } from "../fable_modules/fable-library-js.5.2.0/Set.js";
+import { comparePrimitives } from "../fable_modules/fable-library-js.5.2.0/Util.js";
+import { fold as fold_1, map as map_1 } from "../fable_modules/fable-library-js.5.2.0/Seq.js";
+import { toList as toList_1, values } from "../fable_modules/fable-library-js.5.2.0/Map.js";
+import { join, printf, toText } from "../fable_modules/fable-library-js.5.2.0/String.js";
+
+export class Type extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["TUnit", "TInt", "TFloat", "TBool", "TString", "TList", "TTask", "TTuple", "TRecord", "TMap", "TOption", "TFun", "TNamed", "TUnion", "TTypeToken", "TVar"];
+    }
+}
+
+export function Type_$reflection() {
+    return union_type("FScript.Language.Type", [], Type, () => [[], [], [], [], [], [["Item", Type_$reflection()]], [["Item", Type_$reflection()]], [["Item", list_type(Type_$reflection())]], [["Item", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, Type_$reflection()])]], [["Item1", Type_$reflection()], ["Item2", Type_$reflection()]], [["Item", Type_$reflection()]], [["Item1", Type_$reflection()], ["Item2", Type_$reflection()]], [["Item", string_type]], [["Item1", string_type], ["Item2", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, option_type(Type_$reflection())])]], [], [["Item", int32_type]]]);
+}
+
+export class Scheme extends Union {
+    constructor(Item1, Item2) {
+        super();
+        this.tag = 0;
+        this.fields = [Item1, Item2];
+    }
+    cases() {
+        return ["Forall"];
+    }
+}
+
+export function Scheme_$reflection() {
+    return union_type("FScript.Language.Scheme", [], Scheme, () => [[["Item1", list_type(int32_type)], ["Item2", Type_$reflection()]]]);
+}
+
+let Types_nextId = 0;
+
+export function Types_freshVar() {
+    const id = Types_nextId | 0;
+    Types_nextId = ((Types_nextId + 1) | 0);
+    return new Type(15, [id]);
+}
+
+export function Types_ftvType(t_mut) {
+    Types_ftvType:
+    while (true) {
+        const t = t_mut;
+        switch (t.tag) {
+            case 5: {
+                t_mut = t.fields[0];
+                continue Types_ftvType;
+            }
+            case 6: {
+                t_mut = t.fields[0];
+                continue Types_ftvType;
+            }
+            case 7: {
+                const list_1 = map(Types_ftvType, t.fields[0]);
+                return fold(union, empty({
+                    Compare: (x_1, y_1) => (comparePrimitives(x_1, y_1) | 0),
+                }), list_1);
+            }
+            case 8: {
+                const source_1 = map_1(Types_ftvType, values(t.fields[0]));
+                return fold_1(union, empty({
+                    Compare: (x_2, y_2) => (comparePrimitives(x_2, y_2) | 0),
+                }), source_1);
+            }
+            case 9:
+                return union(Types_ftvType(t.fields[0]), Types_ftvType(t.fields[1]));
+            case 10: {
+                t_mut = t.fields[0];
+                continue Types_ftvType;
+            }
+            case 11:
+                return union(Types_ftvType(t.fields[0]), Types_ftvType(t.fields[1]));
+            case 12:
+            case 13:
+            case 14:
+                return empty({
+                    Compare: (x_3, y_3) => (comparePrimitives(x_3, y_3) | 0),
+                });
+            case 15:
+                return singleton(t.fields[0], {
+                    Compare: (x_4, y_4) => (comparePrimitives(x_4, y_4) | 0),
+                });
+            default:
+                return empty({
+                    Compare: (x, y) => (comparePrimitives(x, y) | 0),
+                });
+        }
+        break;
+    }
+}
+
+export function Types_ftvScheme(_arg) {
+    return difference(Types_ftvType(_arg.fields[1]), ofList(_arg.fields[0], {
+        Compare: (x, y) => (comparePrimitives(x, y) | 0),
+    }));
+}
+
+export function Types_ftvEnv(env) {
+    const source_1 = map_1(Types_ftvScheme, values(env));
+    return fold_1(union, empty({
+        Compare: (x, y) => (comparePrimitives(x, y) | 0),
+    }), source_1);
+}
+
+export function Types_generalize(env, t) {
+    return new Scheme(toList(difference(Types_ftvType(t), Types_ftvEnv(env))), t);
+}
+
+export function Types_typeToString(t) {
+    const go = (t_1) => {
+        switch (t_1.tag) {
+            case 1:
+                return "int";
+            case 2:
+                return "float";
+            case 3:
+                return "bool";
+            case 4:
+                return "string";
+            case 5: {
+                const arg = postfixArg(t_1.fields[0]);
+                return toText(printf("%s list"))(arg);
+            }
+            case 6: {
+                const arg_1 = postfixArg(t_1.fields[0]);
+                return toText(printf("%s task"))(arg_1);
+            }
+            case 7: {
+                const arg_2 = join(" * ", map(go, t_1.fields[0]));
+                return toText(printf("(%s)"))(arg_2);
+            }
+            case 8: {
+                const arg_5 = join("; ", map((tupledArg) => {
+                    const arg_4 = go(tupledArg[1]);
+                    return toText(printf("%s: %s"))(tupledArg[0])(arg_4);
+                }, toList_1(t_1.fields[0])));
+                return toText(printf("{ %s }"))(arg_5);
+            }
+            case 9: {
+                const tv = t_1.fields[1];
+                const tk = t_1.fields[0];
+                if (tk.tag === 4) {
+                    const arg_6 = postfixArg(tv);
+                    return toText(printf("%s map"))(arg_6);
+                }
+                else {
+                    const arg_7 = go(tk);
+                    const arg_8 = go(tv);
+                    return toText(printf("map<%s, %s>"))(arg_7)(arg_8);
+                }
+            }
+            case 10: {
+                const arg_9 = postfixArg(t_1.fields[0]);
+                return toText(printf("%s option"))(arg_9);
+            }
+            case 11: {
+                const arg_10 = go(t_1.fields[0]);
+                const arg_11 = go(t_1.fields[1]);
+                return toText(printf("(%s -> %s)"))(arg_10)(arg_11);
+            }
+            case 12:
+                return t_1.fields[0];
+            case 13:
+                return t_1.fields[0];
+            case 14:
+                return "type";
+            case 15: {
+                const v = t_1.fields[0] | 0;
+                const letter = String.fromCharCode((~~"a".charCodeAt(0) + (v % 26)) & 0xFFFF);
+                const suffix = ~~(v / 26) | 0;
+                if (suffix === 0) {
+                    return toText(printf("\'%c"))(letter);
+                }
+                else {
+                    return toText(printf("\'%c%d"))(letter)(suffix);
+                }
+            }
+            default:
+                return "unit";
+        }
+    };
+    const postfixArg = (t_3) => {
+        switch (t_3.tag) {
+            case 11:
+            case 7:
+            case 8: {
+                const arg_15 = go(t_3);
+                return toText(printf("(%s)"))(arg_15);
+            }
+            default:
+                return go(t_3);
+        }
+    };
+    return go(t);
+}
+

package/dist/FScript.Language/Value.js

@@ -0,0 +1,91 @@
+
+import { Record, FSharpRef, Union } from "../fable_modules/fable-library-js.5.2.0/Types.js";
+import { int32_type, unit_type, lambda_type, record_type, option_type, class_type, list_type, bool_type, float64_type, union_type, int64_type, string_type } from "../fable_modules/fable-library-js.5.2.0/Reflection.js";
+import { Scheme_$reflection, Type_$reflection } from "./Types.js";
+import { Expr_$reflection } from "./Ast.js";
+import { EvalError$_$reflection } from "./Error.js";
+
+export class MapKey extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["MKString", "MKInt"];
+    }
+}
+
+export function MapKey_$reflection() {
+    return union_type("FScript.Language.MapKey", [], MapKey, () => [[["Item", string_type]], [["Item", int64_type]]]);
+}
+
+export class Value extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["VUnit", "VInt", "VFloat", "VBool", "VString", "VList", "VTuple", "VRecord", "VMap", "VOption", "VUnionCase", "VUnionCtor", "VTypeToken", "VTask", "VClosure", "VExternal"];
+    }
+}
+
+export function Value_$reflection() {
+    return union_type("FScript.Language.Value", [], Value, () => [[], [["Item", int64_type]], [["Item", float64_type]], [["Item", bool_type]], [["Item", string_type]], [["Item", list_type(Value_$reflection())]], [["Item", list_type(Value_$reflection())]], [["Item", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, Value_$reflection()])]], [["Item", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [MapKey_$reflection(), Value_$reflection()])]], [["Item", option_type(Value_$reflection())]], [["Item1", string_type], ["Item2", string_type], ["Item3", option_type(Value_$reflection())]], [["Item1", string_type], ["Item2", string_type]], [["Item", Type_$reflection()]], [["Item", TaskHandle_$reflection()]], [["Item1", string_type], ["Item2", Expr_$reflection()], ["Item3", record_type("Microsoft.FSharp.Core.FSharpRef`1", [class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, Value_$reflection()])], FSharpRef, () => [["contents", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, Value_$reflection()])]])]], [["Item1", ExternalFunction_$reflection()], ["Item2", list_type(Value_$reflection())]]]);
+}
+
+export class TaskOutcome extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["TaskSucceeded", "TaskFailed"];
+    }
+}
+
+export function TaskOutcome_$reflection() {
+    return union_type("FScript.Language.TaskOutcome", [], TaskOutcome, () => [[["Item", Value_$reflection()]], [["Item", EvalError$_$reflection()]]]);
+}
+
+export class TaskHandle extends Record {
+    constructor(Awaited) {
+        super();
+        this.Awaited = Awaited;
+    }
+}
+
+export function TaskHandle_$reflection() {
+    return record_type("FScript.Language.TaskHandle", [], TaskHandle, () => [["Awaited", bool_type]]);
+}
+
+export class ExternalCallContext extends Record {
+    constructor(Apply, SpawnTask, AwaitTask, CheckRuntime) {
+        super();
+        this.Apply = Apply;
+        this.SpawnTask = SpawnTask;
+        this.AwaitTask = AwaitTask;
+        this.CheckRuntime = CheckRuntime;
+    }
+}
+
+export function ExternalCallContext_$reflection() {
+    return record_type("FScript.Language.ExternalCallContext", [], ExternalCallContext, () => [["Apply", lambda_type(Value_$reflection(), lambda_type(Value_$reflection(), Value_$reflection()))], ["SpawnTask", lambda_type(Value_$reflection(), Value_$reflection())], ["AwaitTask", lambda_type(Value_$reflection(), Value_$reflection())], ["CheckRuntime", lambda_type(unit_type, unit_type)]]);
+}
+
+export class ExternalFunction extends Record {
+    constructor(Name, Scheme, Impl, Arity) {
+        super();
+        this.Name = Name;
+        this.Scheme = Scheme;
+        this.Impl = Impl;
+        this.Arity = (Arity | 0);
+    }
+}
+
+export function ExternalFunction_$reflection() {
+    return record_type("FScript.Language.ExternalFunction", [], ExternalFunction, () => [["Name", string_type], ["Scheme", Scheme_$reflection()], ["Impl", lambda_type(ExternalCallContext_$reflection(), lambda_type(list_type(Value_$reflection()), Value_$reflection()))], ["Arity", int32_type]]);
+}
+