@magnusopera/fscript 0.80.0 → 0.81.0

package/dist/FScript.Language/HostInterop.js

@@ -0,0 +1,808 @@
+
+import { Span, Position } from "./Span.js";
+import { EvalException, EvalError$ } from "./Error.js";
+import { tail as tail_1, head, isEmpty as isEmpty_1, iterate2, iterate as iterate_1, tryFind as tryFind_1, forAll2, length, forAll as forAll_1, contains, map, ofArray, append, empty as empty_1 } from "../fable_modules/fable-library-js.5.13.0/List.js";
+import { Value, HostManagedValue, ExtensionRegistration } from "./Value.js";
+import { typeDefs } from "./BuiltinTypes.js";
+import { FSharpMap__get_Item, iterate, map as map_1, FSharpMap__get_Count, FSharpMap__TryFind, tryFind, forAll, FSharpMap__Add, containsKey, empty as empty_2 } from "../fable_modules/fable-library-js.5.13.0/Map.js";
+import { curry2, stringHash, disposeSafe, getEnumerator, comparePrimitives } from "../fable_modules/fable-library-js.5.13.0/Util.js";
+import { concat, isNullOrWhiteSpace } from "../fable_modules/fable-library-js.5.13.0/String.js";
+import { Types_ftvType, Types_typeToString, Type } from "./Types.js";
+import { exists } from "../fable_modules/fable-library-js.5.13.0/Seq.js";
+import { value as value_4, toArray } from "../fable_modules/fable-library-js.5.13.0/Option.js";
+import { minElement, isEmpty } from "../fable_modules/fable-library-js.5.13.0/Set.js";
+import { min } from "../fable_modules/fable-library-js.5.13.0/Double.js";
+
+const span = new Span(new Position(undefined, 0, 0), new Position(undefined, 0, 0));
+
+function fail(message) {
+    throw new EvalException(new EvalError$(message, span));
+}
+
+export const empty = new ExtensionRegistration(empty_1(), empty_1());
+
+export function ofExterns(functions) {
+    return new ExtensionRegistration(empty.Types, functions);
+}
+
+export function typeDefinitions(registration, scriptNames) {
+    const reserved = append(ofArray(["unit", "int", "float", "bool", "string", "numeric", "type"]), append(map((d) => d.Name, typeDefs), scriptNames));
+    let definitions = empty_2({
+        Compare: (x, y) => (comparePrimitives(x, y) | 0),
+    });
+    const enumerator = getEnumerator(registration.Types);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const descriptor = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            if (isNullOrWhiteSpace(descriptor.Name)) {
+                fail("Host type name must not be empty");
+            }
+            if (contains(descriptor.Name, reserved, {
+                Equals: (x_1, y_1) => (x_1 === y_1),
+                GetHashCode: (x_1) => (stringHash(x_1) | 0),
+            }) ? true : containsKey(descriptor.Name, definitions)) {
+                fail(concat("Host type name conflict: \'", descriptor.Name, "\'"));
+            }
+            definitions = FSharpMap__Add(definitions, descriptor.Name, descriptor.HostManaged ? (new Type(/* THostManaged */ 17, [descriptor.Name, descriptor.Fields])) : (new Type(/* TRecord */ 8, [descriptor.Fields])));
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    return definitions;
+}
+
+export function matches(definitions_mut, expected_mut, value_mut) {
+    matches:
+    while (true) {
+        const definitions = definitions_mut, expected = expected_mut, value = value_mut;
+        const fieldsMatch = (fields, values) => forAll((name, fieldType) => exists((value_1) => matches(definitions, fieldType, value_1), toArray(tryFind(name, values))), fields);
+        let matchResult, name_1, fields_1, host, name_2, fields_2, values_1, constructible, fields_3, host_1, fields_4, values_2, t_1, values_3, ts, values_4, t_2, v, t_3, values_5, actualName, caseName, cases, name_3, payload;
+        switch (expected.tag) {
+            case 17: {
+                if (value.tag === 16) {
+                    matchResult = 1;
+                    fields_1 = expected.fields[1];
+                    host = value.fields[0];
+                    name_2 = expected.fields[0];
+                }
+                else {
+                    matchResult = 16;
+                }
+                break;
+            }
+            case 8: {
+                if (value.tag === 7) {
+                    matchResult = 2;
+                    fields_2 = expected.fields[0];
+                    values_1 = value.fields[0];
+                }
+                else {
+                    matchResult = 16;
+                }
+                break;
+            }
+            case 18: {
+                switch (value.tag) {
+                    case 16: {
+                        matchResult = 3;
+                        constructible = expected.fields[2];
+                        fields_3 = expected.fields[1];
+                        host_1 = value.fields[0];
+                        break;
+                    }
+                    case 7: {
+                        matchResult = 4;
+                        fields_4 = expected.fields[1];
+                        values_2 = value.fields[0];
+                        break;
+                    }
+                    default:
+                        matchResult = 16;
+                }
+                break;
+            }
+            case 0: {
+                if (value.tag === 0) {
+                    matchResult = 5;
+                }
+                else {
+                    matchResult = 16;
+                }
+                break;
+            }
+            case 1: {
+                if (value.tag === 1) {
+                    matchResult = 5;
+                }
+                else {
+                    matchResult = 16;
+                }
+                break;
+            }
+            case 2: {
+                if (value.tag === 2) {
+                    matchResult = 5;
+                }
+                else {
+                    matchResult = 16;
+                }
+                break;
+            }
+            case 3: {
+                if (value.tag === 3) {
+                    matchResult = 5;
+                }
+                else {
+                    matchResult = 16;
+                }
+                break;
+            }
+            case 4: {
+                if (value.tag === 4) {
+                    matchResult = 5;
+                }
+                else {
+                    matchResult = 16;
+                }
+                break;
+            }
+            case 5: {
+                if (value.tag === 5) {
+                    matchResult = 6;
+                    t_1 = expected.fields[0];
+                    values_3 = value.fields[0];
+                }
+                else {
+                    matchResult = 16;
+                }
+                break;
+            }
+            case 7: {
+                if (value.tag === 6) {
+                    matchResult = 7;
+                    ts = expected.fields[0];
+                    values_4 = value.fields[0];
+                }
+                else {
+                    matchResult = 16;
+                }
+                break;
+            }
+            case 10: {
+                if (value.tag === 9) {
+                    if (value.fields[0] != null) {
+                        matchResult = 9;
+                        t_2 = expected.fields[0];
+                        v = value.fields[0];
+                    }
+                    else {
+                        matchResult = 8;
+                    }
+                }
+                else {
+                    matchResult = 16;
+                }
+                break;
+            }
+            case 9: {
+                if (value.tag === 8) {
+                    matchResult = 10;
+                    t_3 = expected.fields[1];
+                    values_5 = value.fields[0];
+                }
+                else {
+                    matchResult = 16;
+                }
+                break;
+            }
+            case 13: {
+                if (value.tag === 10) {
+                    matchResult = 11;
+                    actualName = value.fields[0];
+                    caseName = value.fields[1];
+                    cases = expected.fields[1];
+                    name_3 = expected.fields[0];
+                    payload = value.fields[2];
+                }
+                else {
+                    matchResult = 16;
+                }
+                break;
+            }
+            case 6: {
+                if (value.tag === 13) {
+                    matchResult = 12;
+                }
+                else {
+                    matchResult = 16;
+                }
+                break;
+            }
+            case 14: {
+                if (value.tag === 12) {
+                    matchResult = 12;
+                }
+                else {
+                    matchResult = 16;
+                }
+                break;
+            }
+            case 11: {
+                switch (value.tag) {
+                    case 14:
+                    case 15:
+                    case 11: {
+                        matchResult = 13;
+                        break;
+                    }
+                    default:
+                        matchResult = 16;
+                }
+                break;
+            }
+            case 15: {
+                matchResult = 14;
+                break;
+            }
+            case 16: {
+                switch (value.tag) {
+                    case 1:
+                    case 2: {
+                        matchResult = 15;
+                        break;
+                    }
+                    default:
+                        matchResult = 16;
+                }
+                break;
+            }
+            default: {
+                matchResult = 0;
+                name_1 = expected.fields[0];
+            }
+        }
+        switch (matchResult) {
+            case 0:
+                return exists((t) => matches(definitions, t, value), toArray(FSharpMap__TryFind(definitions, name_1)));
+            case 1:
+                if (((host.Descriptor.HostManaged && (host.Descriptor.Name === name_2)) && host.Descriptor.Fields.Equals(fields_1)) && (FSharpMap__get_Count(host.Fields) === FSharpMap__get_Count(fields_1))) {
+                    return fieldsMatch(fields_1, host.Fields);
+                }
+                else {
+                    return false;
+                }
+            case 2:
+                return fieldsMatch(fields_2, values_1);
+            case 3:
+                if (!constructible) {
+                    return fieldsMatch(fields_3, host_1.Fields);
+                }
+                else {
+                    return false;
+                }
+            case 4:
+                return fieldsMatch(fields_4, values_2);
+            case 5:
+                return true;
+            case 6:
+                return forAll_1((value_2) => matches(definitions, t_1, value_2), values_3);
+            case 7:
+                if (length(ts) === length(values_4)) {
+                    return forAll2((expected_1, value_3) => matches(definitions, expected_1, value_3), ts, values_4);
+                }
+                else {
+                    return false;
+                }
+            case 8:
+                return true;
+            case 9: {
+                definitions_mut = definitions;
+                expected_mut = t_2;
+                value_mut = v;
+                continue matches;
+            }
+            case 10:
+                return forAll((_arg, v_1) => matches(definitions, t_3, v_1), values_5);
+            case 11:
+                if (name_3 === actualName) {
+                    const matchValue_1 = FSharpMap__TryFind(cases, caseName);
+                    let matchResult_1, t_4, v_2;
+                    if (matchValue_1 != null) {
+                        if (value_4(matchValue_1) != null) {
+                            if (payload != null) {
+                                matchResult_1 = 1;
+                                t_4 = value_4(matchValue_1);
+                                v_2 = payload;
+                            }
+                            else {
+                                matchResult_1 = 2;
+                            }
+                        }
+                        else if (payload == null) {
+                            matchResult_1 = 0;
+                        }
+                        else {
+                            matchResult_1 = 2;
+                        }
+                    }
+                    else {
+                        matchResult_1 = 2;
+                    }
+                    switch (matchResult_1) {
+                        case 0:
+                            return true;
+                        case 1: {
+                            definitions_mut = definitions;
+                            expected_mut = t_4;
+                            value_mut = v_2;
+                            continue matches;
+                        }
+                        default:
+                            return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+            case 12:
+                return true;
+            case 13:
+                return true;
+            case 14:
+                return true;
+            case 15:
+                return true;
+            default:
+                return false;
+        }
+        break;
+    }
+}
+
+export function validate(definitions, expected, value) {
+    if (!matches(definitions, expected, value)) {
+        fail(concat("Host value does not match ", Types_typeToString(expected)));
+    }
+}
+
+export function create(registration, typeName, fields, payload) {
+    const definitions = typeDefinitions(registration, empty_1());
+    const matchValue = tryFind_1((d) => {
+        if (d.Name === typeName) {
+            return d.HostManaged;
+        }
+        else {
+            return false;
+        }
+    }, registration.Types);
+    if (matchValue == null) {
+        return fail(concat("Unknown host-managed type \'", typeName, "\'"));
+    }
+    else {
+        const value = new Value(/* VHostManaged */ 16, [new HostManagedValue(matchValue, fields, payload)]);
+        validate(definitions, new Type(/* TNamed */ 12, [typeName]), value);
+        return value;
+    }
+}
+
+export function unwrap(typeName, value) {
+    let host;
+    let matchResult, host_1;
+    if (value.tag === 16) {
+        if ((host = value.fields[0], (host.Descriptor.Name === typeName) && host.Descriptor.HostManaged)) {
+            matchResult = 0;
+            host_1 = value.fields[0];
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return host_1;
+        default:
+            return fail(concat("Expected host-managed type \'", typeName, "\'"));
+    }
+}
+
+/**
+ * Validate a call with one set of type-variable bindings, including polymorphic round trips.
+ */
+export function validateCall(definitions, signature, arguments$, action) {
+    let bindings = empty_2({
+        Compare: (x, y) => (comparePrimitives(x, y) | 0),
+    });
+    const variables = Types_ftvType(signature);
+    let nextVariable = isEmpty(variables) ? -1 : min(-1, minElement(variables) - 1);
+    const fresh = () => {
+        const id = nextVariable | 0;
+        nextVariable = ((nextVariable - 1) | 0);
+        return new Type(/* TVar */ 15, [id]);
+    };
+    const valueType = (value) => {
+        switch (value.tag) {
+            case 1:
+                return Type.TInt;
+            case 2:
+                return Type.TFloat;
+            case 3:
+                return Type.TBool;
+            case 4:
+                return Type.TString;
+            case 16: {
+                const host = value.fields[0];
+                return new Type(/* THostManaged */ 17, [host.Descriptor.Name, host.Descriptor.Fields]);
+            }
+            case 5:
+                return new Type(/* TList */ 5, [fresh()]);
+            case 6:
+                return new Type(/* TTuple */ 7, [map((_arg) => fresh(), value.fields[0])]);
+            case 7:
+                return new Type(/* TRecord */ 8, [map_1((_arg_1, _arg_2) => fresh(), value.fields[0])]);
+            case 8:
+                return new Type(/* TMap */ 9, [fresh(), fresh()]);
+            case 9:
+                return new Type(/* TOption */ 10, [fresh()]);
+            case 10:
+                return new Type(/* TNamed */ 12, [value.fields[0]]);
+            case 12:
+                return Type.TTypeToken;
+            case 13:
+                return new Type(/* TTask */ 6, [fresh()]);
+            case 14:
+            case 15:
+            case 11:
+                return new Type(/* TFun */ 11, [fresh(), fresh()]);
+            default:
+                return Type.TUnit;
+        }
+    };
+    const observe = (expected_mut, value_1_mut) => {
+        observe:
+        while (true) {
+            const expected = expected_mut, value_1 = value_1_mut;
+            let registered;
+            const observeFields = (required, actual) => {
+                iterate((name_2, t) => {
+                    observe(t, FSharpMap__get_Item(actual, name_2));
+                }, required);
+            };
+            let matchResult, id_1;
+            switch (expected.tag) {
+                case 15: {
+                    matchResult = 0;
+                    id_1 = expected.fields[0];
+                    break;
+                }
+                case 16: {
+                    matchResult = 0;
+                    id_1 = expected.fields[0];
+                    break;
+                }
+                case 12: {
+                    matchResult = 1;
+                    break;
+                }
+                case 18: {
+                    matchResult = 2;
+                    break;
+                }
+                default:
+                    matchResult = 3;
+            }
+            switch (matchResult) {
+                case 0: {
+                    const matchValue = FSharpMap__TryFind(bindings, id_1);
+                    if (matchValue == null) {
+                        validate(definitions, expected, value_1);
+                        const bound_1 = valueType(value_1);
+                        bindings = FSharpMap__Add(bindings, id_1, bound_1);
+                        expected_mut = bound_1;
+                        value_1_mut = value_1;
+                        continue observe;
+                    }
+                    else {
+                        expected_mut = matchValue;
+                        value_1_mut = value_1;
+                        continue observe;
+                    }
+                    break;
+                }
+                case 1: {
+                    const matchValue_1 = tryFind(expected.fields[0], definitions);
+                    if (matchValue_1 == null) {
+                        validate(definitions, expected, value_1);
+                    }
+                    else {
+                        expected_mut = matchValue_1;
+                        value_1_mut = value_1;
+                        continue observe;
+                    }
+                    break;
+                }
+                case 2: {
+                    const id_2 = expected.fields[0] | 0;
+                    const fields_1 = expected.fields[1];
+                    validate(definitions, expected, value_1);
+                    const matchValue_2 = FSharpMap__TryFind(bindings, id_2);
+                    if (matchValue_2 == null) {
+                        const bound_3 = valueType(value_1);
+                        bindings = FSharpMap__Add(bindings, id_2, bound_3);
+                        observe(bound_3, value_1);
+                    }
+                    else {
+                        observe(matchValue_2, value_1);
+                    }
+                    let matchResult_1, host_2, actual_1;
+                    switch (value_1.tag) {
+                        case 16: {
+                            if (!expected.fields[2]) {
+                                matchResult_1 = 0;
+                                host_2 = value_1.fields[0];
+                            }
+                            else {
+                                matchResult_1 = 2;
+                            }
+                            break;
+                        }
+                        case 7: {
+                            matchResult_1 = 1;
+                            actual_1 = value_1.fields[0];
+                            break;
+                        }
+                        default:
+                            matchResult_1 = 2;
+                    }
+                    switch (matchResult_1) {
+                        case 0: {
+                            observeFields(fields_1, host_2.Fields);
+                            break;
+                        }
+                        case 1: {
+                            observeFields(fields_1, actual_1);
+                            break;
+                        }
+                        case 2: {
+                            validate(definitions, expected, value_1);
+                            break;
+                        }
+                    }
+                    break;
+                }
+                case 3: {
+                    validate(definitions, expected, value_1);
+                    let matchResult_2, fields_2, host_3, name_4, actual_2, fields_3, t_1, values_1, ts, values_2, inner, t_2, keyType, t_3, values_3, cases, inner_1, name_5;
+                    switch (expected.tag) {
+                        case 17: {
+                            if (value_1.tag === 16) {
+                                matchResult_2 = 0;
+                                fields_2 = expected.fields[1];
+                                host_3 = value_1.fields[0];
+                                name_4 = expected.fields[0];
+                            }
+                            else {
+                                matchResult_2 = 7;
+                            }
+                            break;
+                        }
+                        case 8: {
+                            if (value_1.tag === 7) {
+                                matchResult_2 = 1;
+                                actual_2 = value_1.fields[0];
+                                fields_3 = expected.fields[0];
+                            }
+                            else {
+                                matchResult_2 = 7;
+                            }
+                            break;
+                        }
+                        case 5: {
+                            if (value_1.tag === 5) {
+                                matchResult_2 = 2;
+                                t_1 = expected.fields[0];
+                                values_1 = value_1.fields[0];
+                            }
+                            else {
+                                matchResult_2 = 7;
+                            }
+                            break;
+                        }
+                        case 7: {
+                            if (value_1.tag === 6) {
+                                matchResult_2 = 3;
+                                ts = expected.fields[0];
+                                values_2 = value_1.fields[0];
+                            }
+                            else {
+                                matchResult_2 = 7;
+                            }
+                            break;
+                        }
+                        case 10: {
+                            if (value_1.tag === 9) {
+                                if (value_1.fields[0] != null) {
+                                    matchResult_2 = 4;
+                                    inner = value_1.fields[0];
+                                    t_2 = expected.fields[0];
+                                }
+                                else {
+                                    matchResult_2 = 7;
+                                }
+                            }
+                            else {
+                                matchResult_2 = 7;
+                            }
+                            break;
+                        }
+                        case 9: {
+                            if (value_1.tag === 8) {
+                                matchResult_2 = 5;
+                                keyType = expected.fields[0];
+                                t_3 = expected.fields[1];
+                                values_3 = value_1.fields[0];
+                            }
+                            else {
+                                matchResult_2 = 7;
+                            }
+                            break;
+                        }
+                        case 13: {
+                            if (value_1.tag === 10) {
+                                if (value_1.fields[2] != null) {
+                                    matchResult_2 = 6;
+                                    cases = expected.fields[1];
+                                    inner_1 = value_1.fields[2];
+                                    name_5 = value_1.fields[1];
+                                }
+                                else {
+                                    matchResult_2 = 7;
+                                }
+                            }
+                            else {
+                                matchResult_2 = 7;
+                            }
+                            break;
+                        }
+                        default:
+                            matchResult_2 = 7;
+                    }
+                    switch (matchResult_2) {
+                        case 0: {
+                            const matchValue_4 = tryFind(name_4, definitions);
+                            let matchResult_3, registered_1;
+                            if (matchValue_4 != null) {
+                                if (matchValue_4.tag === 17) {
+                                    if ((registered = matchValue_4.fields[1], registered.Equals(fields_2))) {
+                                        matchResult_3 = 0;
+                                        registered_1 = matchValue_4.fields[1];
+                                    }
+                                    else {
+                                        matchResult_3 = 1;
+                                    }
+                                }
+                                else {
+                                    matchResult_3 = 1;
+                                }
+                            }
+                            else {
+                                matchResult_3 = 1;
+                            }
+                            switch (matchResult_3) {
+                                case 1: {
+                                    fail(concat("Unregistered host-managed type \'", name_4, "\'"));
+                                    break;
+                                }
+                            }
+                            observeFields(fields_2, host_3.Fields);
+                            break;
+                        }
+                        case 1: {
+                            observeFields(fields_3, actual_2);
+                            break;
+                        }
+                        case 2: {
+                            iterate_1(curry2(observe)(t_1), values_1);
+                            break;
+                        }
+                        case 3: {
+                            iterate2(observe, ts, values_2);
+                            break;
+                        }
+                        case 4: {
+                            expected_mut = t_2;
+                            value_1_mut = inner;
+                            continue observe;
+                            break;
+                        }
+                        case 5: {
+                            iterate((key_1, item) => {
+                                let key;
+                                observe(keyType, (key = key_1, (key.tag === 1) ? (new Value(/* VInt */ 1, [key.fields[0]])) : ((key.tag === 2) ? (new Value(/* VBool */ 3, [key.fields[0]])) : ((key.tag === 3) ? (new Value(/* VUnionCase */ 10, [key.fields[0], key.fields[1], undefined])) : (new Value(/* VString */ 4, [key.fields[0]]))))));
+                                observe(t_3, item);
+                            }, values_3);
+                            break;
+                        }
+                        case 6: {
+                            const option_1 = FSharpMap__get_Item(cases, name_5);
+                            if (option_1 != null) {
+                                expected_mut = option_1;
+                                value_1_mut = inner_1;
+                                continue observe;
+                            }
+                            break;
+                        }
+                        case 7: {
+                            break;
+                        }
+                    }
+                    break;
+                }
+            }
+            break;
+        }
+    };
+    const check = (remainingType_mut, remainingArguments_mut) => {
+        check:
+        while (true) {
+            const remainingType = remainingType_mut, remainingArguments = remainingArguments_mut;
+            let matchResult_4, argument, argumentType, resultType, tail, resultType_1;
+            if (remainingType.tag === 11) {
+                if (isEmpty_1(remainingArguments)) {
+                    matchResult_4 = 1;
+                    resultType_1 = remainingType;
+                }
+                else {
+                    matchResult_4 = 0;
+                    argument = head(remainingArguments);
+                    argumentType = remainingType.fields[0];
+                    resultType = remainingType.fields[1];
+                    tail = tail_1(remainingArguments);
+                }
+            }
+            else if (isEmpty_1(remainingArguments)) {
+                matchResult_4 = 1;
+                resultType_1 = remainingType;
+            }
+            else {
+                matchResult_4 = 2;
+            }
+            switch (matchResult_4) {
+                case 0: {
+                    observe(argumentType, argument);
+                    remainingType_mut = resultType;
+                    remainingArguments_mut = tail;
+                    continue check;
+                }
+                case 1:
+                    return resultType_1;
+                default:
+                    return fail("Invalid argument count for host call");
+            }
+            break;
+        }
+    };
+    const resultType_2 = check(signature, arguments$);
+    const result = action();
+    observe(resultType_2, result);
+    return result;
+}
+
+export function invoke(definitions, externalFunction, context, arguments$) {
+    return validateCall(definitions, externalFunction.Scheme.fields[1], arguments$, () => externalFunction.Impl(context, arguments$));
+}
+
+export function $007CRecordFields$007C_$007C(value) {
+    switch (value.tag) {
+        case 7:
+            return value.fields[0];
+        case 16:
+            return value.fields[0].Fields;
+        default:
+            return undefined;
+    }
+}
+