@magnusopera/fscript 0.75.0

package/dist/FScript.Language/Pretty.js

@@ -0,0 +1,115 @@
+
+import { length, isEmpty, map, singleton, append } from "../fable_modules/fable-library-js.5.2.0/List.js";
+import { concat, join, printf, toText, replace } from "../fable_modules/fable-library-js.5.2.0/String.js";
+import { int64ToString } from "../fable_modules/fable-library-js.5.2.0/Util.js";
+import { toList } from "../fable_modules/fable-library-js.5.2.0/Map.js";
+import { Types_typeToString } from "./Types.js";
+
+function closureParameters(firstArg, body) {
+    const loop = (acc_mut, expr_mut) => {
+        loop:
+        while (true) {
+            const acc = acc_mut, expr = expr_mut;
+            if (expr.tag === 4) {
+                acc_mut = append(acc, singleton(expr.fields[0].Name));
+                expr_mut = expr.fields[1];
+                continue loop;
+            }
+            else {
+                return acc;
+            }
+            break;
+        }
+    };
+    return loop(singleton(firstArg), body);
+}
+
+function escapeStringLiteral(value) {
+    return replace(replace(replace(replace(replace(value, "\\", "\\\\"), "\"", "\\\""), "\r", "\\r"), "\n", "\\n"), "\t", "\\t");
+}
+
+export function valueToString(v) {
+    switch (v.tag) {
+        case 1:
+            return int64ToString(v.fields[0]);
+        case 2:
+            return v.fields[0].toString();
+        case 3:
+            if (v.fields[0]) {
+                return "true";
+            }
+            else {
+                return "false";
+            }
+        case 4: {
+            const arg = escapeStringLiteral(v.fields[0]);
+            return toText(printf("\"%s\""))(arg);
+        }
+        case 5: {
+            const arg_1 = join(";", map(valueToString, v.fields[0]));
+            return toText(printf("[%s]"))(arg_1);
+        }
+        case 6: {
+            const arg_2 = join(", ", map(valueToString, v.fields[0]));
+            return toText(printf("(%s)"))(arg_2);
+        }
+        case 7: {
+            const arg_5 = join("; ", map((tupledArg) => {
+                const arg_4 = valueToString(tupledArg[1]);
+                return toText(printf("%s = %s"))(tupledArg[0])(arg_4);
+            }, toList(v.fields[0])));
+            return toText(printf("{ %s }"))(arg_5);
+        }
+        case 8: {
+            const arg_8 = join("; ", map((tupledArg_1) => {
+                let arg_6;
+                const key = tupledArg_1[0];
+                arg_6 = ((key.tag === 1) ? int64ToString(key.fields[0]) : concat("\"", escapeStringLiteral(key.fields[0]), "\""));
+                const arg_7 = valueToString(tupledArg_1[1]);
+                return toText(printf("%s => %s"))(arg_6)(arg_7);
+            }, toList(v.fields[0])));
+            return toText(printf("map { %s }"))(arg_8);
+        }
+        case 9:
+            if (v.fields[0] != null) {
+                const v_3 = v.fields[0];
+                const arg_9 = valueToString(v_3);
+                return toText(printf("Some %s"))(arg_9);
+            }
+            else {
+                return "None";
+            }
+        case 10:
+            if (v.fields[2] != null) {
+                const v_4 = v.fields[2];
+                const arg_11 = valueToString(v_4);
+                return toText(printf("%s %s"))(v.fields[1])(arg_11);
+            }
+            else {
+                return v.fields[1];
+            }
+        case 12: {
+            const arg_12 = Types_typeToString(v.fields[0]);
+            return toText(printf("<type %s>"))(arg_12);
+        }
+        case 13:
+            return "<task>";
+        case 14: {
+            const arg_13 = join(" ", closureParameters(v.fields[0], v.fields[1]));
+            return toText(printf("<fun %s>"))(arg_13);
+        }
+        case 11:
+            return toText(printf("<ctor %s>"))(v.fields[1]);
+        case 15:
+            if (isEmpty(v.fields[1])) {
+                return toText(printf("<extern %s>"))(v.fields[0].Name);
+            }
+            else {
+                const arg_17 = length(v.fields[1]) | 0;
+                return toText(printf("<extern %s (%d/%d)>"))(v.fields[0].Name)(arg_17)(v.fields[0].Arity);
+            }
+        default:
+            return "()";
+    }
+}
+

package/dist/FScript.Language/Span.js

@@ -0,0 +1,33 @@
+
+import { Record } from "../fable_modules/fable-library-js.5.2.0/Types.js";
+import { record_type, int32_type, option_type, string_type } from "../fable_modules/fable-library-js.5.2.0/Reflection.js";
+
+export class Position extends Record {
+    constructor(File, Line, Column) {
+        super();
+        this.File = File;
+        this.Line = (Line | 0);
+        this.Column = (Column | 0);
+    }
+}
+
+export function Position_$reflection() {
+    return record_type("FScript.Language.Position", [], Position, () => [["File", option_type(string_type)], ["Line", int32_type], ["Column", int32_type]]);
+}
+
+export class Span extends Record {
+    constructor(Start, End) {
+        super();
+        this.Start = Start;
+        this.End = End;
+    }
+}
+
+export function Span_$reflection() {
+    return record_type("FScript.Language.Span", [], Span, () => [["Start", Position_$reflection()], ["End", Position_$reflection()]]);
+}
+
+export function SpanModule_merge(a, b) {
+    return new Span(a.Start, b.End);
+}
+

package/dist/FScript.Language/Token.js

@@ -0,0 +1,32 @@
+
+import { Record, Union } from "../fable_modules/fable-library-js.5.2.0/Types.js";
+import { record_type, union_type, bool_type, float64_type, int64_type, string_type } from "../fable_modules/fable-library-js.5.2.0/Reflection.js";
+import { Span_$reflection } from "./Span.js";
+
+export class TokenKind extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["EOF", "Newline", "Indent", "Dedent", "Ident", "IntLit", "FloatLit", "StringLit", "InterpString", "BoolLit", "Let", "Rec", "And", "Fun", "Match", "With", "When", "If", "Then", "Else", "Elif", "Raise", "For", "In", "Arrow", "Equals", "Bar", "LParen", "RParen", "LBracket", "RBracket", "LBracketBar", "BarRBracket", "Semicolon", "Comma", "Colon", "Dot", "RangeDots", "Hash", "Import", "As", "Include", "Module", "LBrace", "RBrace", "Type", "Typeof", "Nameof", "Of", "Plus", "Minus", "Star", "Slash", "Percent", "Less", "Greater", "LessEqual", "GreaterEqual", "AndAnd", "OrOr", "PipeForward", "Cons", "Append"];
+    }
+}
+
+export function TokenKind_$reflection() {
+    return union_type("FScript.Language.TokenKind", [], TokenKind, () => [[], [], [], [], [["Item", string_type]], [["Item", int64_type]], [["Item", float64_type]], [["Item", string_type]], [["Item", string_type]], [["Item", bool_type]], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []]);
+}
+
+export class Token extends Record {
+    constructor(Kind, Span) {
+        super();
+        this.Kind = Kind;
+        this.Span = Span;
+    }
+}
+
+export function Token_$reflection() {
+    return record_type("FScript.Language.Token", [], Token, () => [["Kind", TokenKind_$reflection()], ["Span", Span_$reflection()]]);
+}
+