@magnusopera/fscript 0.80.1 → 0.81.0

package/dist/FScript.Language/Pretty.js

@@ -29,35 +29,135 @@ function escapeStringLiteral(value) {
 }
 
 export function valueToString(v) {
+    let matchResult, i, f, b, s, xs, xs_1, fields, fields_1, v_3, caseName_1, caseName_2, v_4, t, argName, body, caseName_3, args_1, ext;
     switch (v.tag) {
+        case 1: {
+            matchResult = 1;
+            i = v.fields[0];
+            break;
+        }
+        case 2: {
+            matchResult = 2;
+            f = v.fields[0];
+            break;
+        }
+        case 3: {
+            matchResult = 3;
+            b = v.fields[0];
+            break;
+        }
+        case 4: {
+            matchResult = 4;
+            s = v.fields[0];
+            break;
+        }
+        case 5: {
+            matchResult = 5;
+            xs = v.fields[0];
+            break;
+        }
+        case 6: {
+            matchResult = 6;
+            xs_1 = v.fields[0];
+            break;
+        }
+        case 7: {
+            matchResult = 7;
+            fields = v.fields[0];
+            break;
+        }
+        case 16: {
+            matchResult = 7;
+            fields = v.fields[0].Fields;
+            break;
+        }
+        case 8: {
+            matchResult = 8;
+            fields_1 = v.fields[0];
+            break;
+        }
+        case 9: {
+            if (v.fields[0] != null) {
+                matchResult = 10;
+                v_3 = v.fields[0];
+            }
+            else {
+                matchResult = 9;
+            }
+            break;
+        }
+        case 10: {
+            if (v.fields[2] != null) {
+                matchResult = 12;
+                caseName_2 = v.fields[1];
+                v_4 = v.fields[2];
+            }
+            else {
+                matchResult = 11;
+                caseName_1 = v.fields[1];
+            }
+            break;
+        }
+        case 12: {
+            matchResult = 13;
+            t = v.fields[0];
+            break;
+        }
+        case 13: {
+            matchResult = 14;
+            break;
+        }
+        case 14: {
+            matchResult = 15;
+            argName = v.fields[0];
+            body = v.fields[1];
+            break;
+        }
+        case 11: {
+            matchResult = 16;
+            caseName_3 = v.fields[1];
+            break;
+        }
+        case 15: {
+            matchResult = 17;
+            args_1 = v.fields[1];
+            ext = v.fields[0];
+            break;
+        }
+        default:
+            matchResult = 0;
+    }
+    switch (matchResult) {
+        case 0:
+            return "()";
         case 1:
-            return int64ToString(v.fields[0]);
+            return int64ToString(i);
         case 2:
-            return v.fields[0].toString();
+            return f.toString();
         case 3:
-            if (v.fields[0]) {
+            if (b) {
                 return "true";
             }
             else {
                 return "false";
             }
         case 4: {
-            const arg = escapeStringLiteral(v.fields[0]);
+            const arg = escapeStringLiteral(s);
             return toText(printf("\"%s\""))(arg);
         }
         case 5: {
-            const arg_1 = join(";", map(valueToString, v.fields[0]));
+            const arg_1 = join(";", map(valueToString, xs));
             return toText(printf("[%s]"))(arg_1);
         }
         case 6: {
-            const arg_2 = join(", ", map(valueToString, v.fields[0]));
+            const arg_2 = join(", ", map(valueToString, xs_1));
             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])));
+            }, toList(fields)));
             return toText(printf("{ %s }"))(arg_5);
         }
         case 8: {
@@ -67,49 +167,41 @@ export function valueToString(v) {
                 arg_6 = ((key.tag === 1) ? int64ToString(key.fields[0]) : ((key.tag === 2) ? (key.fields[0] ? "true" : "false") : ((key.tag === 3) ? concat(key.fields[0], ".", key.fields[1]) : 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])));
+            }, toList(fields_1)));
             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];
-            }
+            return "None";
+        case 10: {
+            const arg_9 = valueToString(v_3);
+            return toText(printf("Some %s"))(arg_9);
+        }
+        case 11:
+            return caseName_1;
         case 12: {
-            const arg_12 = Types_typeToString(v.fields[0]);
+            const arg_11 = valueToString(v_4);
+            return toText(printf("%s %s"))(caseName_2)(arg_11);
+        }
+        case 13: {
+            const arg_12 = Types_typeToString(t);
             return toText(printf("<type %s>"))(arg_12);
         }
-        case 13:
+        case 14:
             return "<task>";
-        case 14: {
-            const arg_13 = join(" ", closureParameters(v.fields[0], v.fields[1]));
+        case 15: {
+            const arg_13 = join(" ", closureParameters(argName, body));
             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);
+        case 16:
+            return toText(printf("<ctor %s>"))(caseName_3);
+        default:
+            if (isEmpty(args_1)) {
+                return toText(printf("<extern %s>"))(ext.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);
+                const arg_17 = length(args_1) | 0;
+                return toText(printf("<extern %s (%d/%d)>"))(ext.Name)(arg_17)(ext.Arity);
             }
-        default:
-            return "()";
     }
 }