yukigo-haskell-parser 0.1.0

package/dist/parser/preprocessor.js

@@ -0,0 +1,453 @@
+// Generated automatically by nearley, version 2.20.1
+// http://github.com/Hardmath123/nearley
+// Bypasses TS6133. Allow declared but unused functions.
+// @ts-ignore
+function id(d) { return d[0]; }
+import { HSLexer } from "./lexer.js";
+const filter = d => {
+    return d.filter((token) => token !== null);
+};
+;
+;
+;
+;
+const grammar = {
+    Lexer: HSLexer,
+    ParserRules: [
+        { "name": "program$ebnf$1", "symbols": [] },
+        { "name": "program$ebnf$1", "symbols": ["program$ebnf$1", "declaration"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "program", "symbols": ["program$ebnf$1"], "postprocess": (d) => d[0].filter(x => x !== null).join("\n") },
+        { "name": "program", "symbols": ["apply_operator"], "postprocess": id },
+        { "name": "declaration$subexpression$1", "symbols": ["function_declaration"] },
+        { "name": "declaration$subexpression$1", "symbols": ["function_signature"] },
+        { "name": "declaration$subexpression$1", "symbols": ["type_declaration"] },
+        { "name": "declaration$subexpression$1", "symbols": ["data_declaration"] },
+        { "name": "declaration$subexpression$1", "symbols": ["comment"] },
+        { "name": "declaration$subexpression$1", "symbols": ["empty_line"] },
+        { "name": "declaration", "symbols": ["declaration$subexpression$1"], "postprocess": (d) => d[0][0] },
+        { "name": "comment", "symbols": [(HSLexer.has("comment") ? { type: "comment" } : comment)], "postprocess": d => null },
+        { "name": "empty_line", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL)], "postprocess": d => null },
+        { "name": "expression$subexpression$1", "symbols": ["type_cast"] },
+        { "name": "expression$subexpression$1", "symbols": ["letin_expression"] },
+        { "name": "expression$subexpression$1", "symbols": ["if_expression"] },
+        { "name": "expression$subexpression$1", "symbols": ["case_expression"] },
+        { "name": "expression", "symbols": ["expression$subexpression$1"], "postprocess": (d) => `${d[0][0]}` },
+        { "name": "type_cast", "symbols": ["apply_operator", "_", { "literal": "::" }, "_", "type"], "postprocess": (d) => `${d[0]} ${d[2].value} ${d[4]}` },
+        { "name": "type_cast", "symbols": ["apply_operator"], "postprocess": (d) => d[0] },
+        { "name": "apply_operator", "symbols": ["logical_expression", "_", { "literal": "$" }, "_", "apply_operator"], "postprocess": (d) => `${d[0]} $ ${d[4]}` },
+        { "name": "apply_operator", "symbols": ["logical_expression"], "postprocess": (d) => d[0] },
+        { "name": "logical_expression", "symbols": ["comparison", "_", { "literal": "&&" }, "_", "logical_expression"], "postprocess": (d) => `${d[0]} ${d[2].value} ${d[4]}` },
+        { "name": "logical_expression", "symbols": ["comparison", "_", { "literal": "||" }, "_", "logical_expression"], "postprocess": (d) => `${d[0]} ${d[2].value} ${d[4]}` },
+        { "name": "logical_expression", "symbols": ["comparison"], "postprocess": (d) => d[0] },
+        { "name": "comparison", "symbols": ["cons_expression", "_", "comparison_operator", "_", "cons_expression"], "postprocess": (d) => `${d[0]} ${d[2]} ${d[4]}` },
+        { "name": "comparison", "symbols": ["cons_expression"], "postprocess": (d) => d[0] },
+        { "name": "cons_expression", "symbols": ["concatenation", "_", { "literal": ":" }, "_", "cons_expression"], "postprocess": (d) => `${d[0]} ${d[2].value} ${d[4]}` },
+        { "name": "cons_expression", "symbols": ["concatenation"], "postprocess": (d) => d[0] },
+        { "name": "concatenation", "symbols": ["addition", "_", { "literal": "++" }, "_", "concatenation"], "postprocess": (d) => `${d[0]} ${d[2].value} ${d[4]}` },
+        { "name": "concatenation", "symbols": ["addition"], "postprocess": (d) => d[0] },
+        { "name": "addition", "symbols": ["addition", "_", { "literal": "+" }, "_", "multiplication"], "postprocess": (d) => `${d[0]} ${d[2].value} ${d[4]}` },
+        { "name": "addition", "symbols": ["addition", "_", { "literal": "-" }, "_", "multiplication"], "postprocess": (d) => `${d[0]} ${d[2].value} ${d[4]}` },
+        { "name": "addition", "symbols": ["multiplication"], "postprocess": (d) => d[0] },
+        { "name": "multiplication", "symbols": ["multiplication", "_", { "literal": "*" }, "_", "power"], "postprocess": (d) => `${d[0]} ${d[2].value} ${d[4]}` },
+        { "name": "multiplication", "symbols": ["multiplication", "_", { "literal": "/" }, "_", "power"], "postprocess": (d) => `${d[0]} ${d[2].value} ${d[4]}` },
+        { "name": "multiplication", "symbols": ["power"], "postprocess": (d) => d[0] },
+        { "name": "power", "symbols": ["unary_negation", "_", { "literal": "**" }, "_", "power"], "postprocess": (d) => `${d[0]} ${d[2].value} ${d[4]}` },
+        { "name": "power", "symbols": ["unary_negation", "_", { "literal": "^" }, "_", "power"], "postprocess": (d) => `${d[0]} ${d[2].value} ${d[4]}` },
+        { "name": "power", "symbols": ["unary_negation", "_", { "literal": "^^" }, "_", "power"], "postprocess": (d) => `${d[0]} ${d[2].value} ${d[4]}` },
+        { "name": "power", "symbols": ["unary_negation"], "postprocess": (d) => d[0] },
+        { "name": "unary_negation", "symbols": [{ "literal": "-" }, "_", "unary_negation"], "postprocess": (d) => `-${d[2]}` },
+        { "name": "unary_negation", "symbols": ["index_access"], "postprocess": (d) => d[0] },
+        { "name": "index_access", "symbols": ["index_access", "_", { "literal": "!!" }, "_", "composition_expression"], "postprocess": (d) => `${d[0]} !! ${d[4]}` },
+        { "name": "index_access", "symbols": ["composition_expression"], "postprocess": d => d[0] },
+        { "name": "composition_expression", "symbols": ["composition_expression", "_", { "literal": "." }, "_", "infix_operator_expression"], "postprocess": (d) => `${d[0]} . ${d[4]}` },
+        { "name": "composition_expression", "symbols": ["infix_operator_expression"], "postprocess": d => d[0] },
+        { "name": "infix_operator_expression", "symbols": ["infix_operator_expression", "_", { "literal": "`" }, "_", "variable", "_", { "literal": "`" }, "_", "application"], "postprocess": (d) => `${d[0]} \`${d[4]}\` ${d[8]}` },
+        { "name": "infix_operator_expression", "symbols": ["application"], "postprocess": d => d[0] },
+        { "name": "application", "symbols": [{ "literal": "error" }, "__", "primary"], "postprocess": d => `error ${d[2]}` },
+        { "name": "application$ebnf$1", "symbols": [] },
+        { "name": "application$ebnf$1$subexpression$1$subexpression$1", "symbols": ["__"] },
+        { "name": "application$ebnf$1$subexpression$1$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "application$ebnf$1$subexpression$1", "symbols": ["application$ebnf$1$subexpression$1$subexpression$1", "primary"] },
+        { "name": "application$ebnf$1", "symbols": ["application$ebnf$1", "application$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "application", "symbols": ["primary", "application$ebnf$1"], "postprocess": (d) => {
+                if (d[1].length === 0)
+                    return d[0];
+                return [d[0], ...d[1].map(x => x[1])].join(" ");
+            } },
+        { "name": "operator$subexpression$1", "symbols": [{ "literal": "==" }] },
+        { "name": "operator$subexpression$1", "symbols": [{ "literal": "/=" }] },
+        { "name": "operator$subexpression$1", "symbols": [{ "literal": "<" }] },
+        { "name": "operator$subexpression$1", "symbols": [{ "literal": ">" }] },
+        { "name": "operator$subexpression$1", "symbols": [{ "literal": "<=" }] },
+        { "name": "operator$subexpression$1", "symbols": [{ "literal": ">=" }] },
+        { "name": "operator$subexpression$1", "symbols": [{ "literal": "++" }] },
+        { "name": "operator$subexpression$1", "symbols": [{ "literal": "+" }] },
+        { "name": "operator$subexpression$1", "symbols": [{ "literal": "," }] },
+        { "name": "operator$subexpression$1", "symbols": [{ "literal": "*" }] },
+        { "name": "operator$subexpression$1", "symbols": [{ "literal": "/" }] },
+        { "name": "operator$subexpression$1", "symbols": [{ "literal": ":" }] },
+        { "name": "operator", "symbols": ["operator$subexpression$1"], "postprocess": (d) => d[0][0].value },
+        { "name": "left_section", "symbols": [{ "literal": "(" }, "_", "expression", "_", "operator", "_", { "literal": ")" }], "postprocess": (d) => `(${d[2]} ${d[4]})` },
+        { "name": "right_section", "symbols": [{ "literal": "(" }, "_", "operator", "_", "expression", "_", { "literal": ")" }], "postprocess": (d) => `(${d[2]} ${d[4]})` },
+        { "name": "operator_section", "symbols": [{ "literal": "(" }, "_", "operator", "_", { "literal": ")" }], "postprocess": (d) => `(${d[2]})` },
+        { "name": "primary", "symbols": ["primitive"], "postprocess": (d) => d[0] },
+        { "name": "primary", "symbols": ["variable"], "postprocess": (d) => d[0] },
+        { "name": "primary", "symbols": ["constr"], "postprocess": (d) => d[0] },
+        { "name": "primary", "symbols": ["tuple_expression"], "postprocess": (d) => d[0] },
+        { "name": "primary", "symbols": ["left_section"], "postprocess": (d) => d[0] },
+        { "name": "primary", "symbols": ["right_section"], "postprocess": (d) => d[0] },
+        { "name": "primary", "symbols": ["operator_section"], "postprocess": (d) => d[0] },
+        { "name": "primary", "symbols": [{ "literal": "(" }, "_", "expression", "_", { "literal": ")" }], "postprocess": (d) => `(${d[2]})` },
+        { "name": "primary", "symbols": [{ "literal": "[" }, "_", "range_expression", "_", { "literal": "]" }], "postprocess": (d) => `[${d[2]}]` },
+        { "name": "primary", "symbols": ["list_literal"], "postprocess": (d) => d[0] },
+        { "name": "primary", "symbols": ["lambda_expression"], "postprocess": (d) => d[0] },
+        { "name": "primary", "symbols": ["data_expression"], "postprocess": d => d[0] },
+        { "name": "primary", "symbols": ["list_comprehension"], "postprocess": (d) => d[0] },
+        { "name": "list_comprehension", "symbols": [{ "literal": "[" }, "_", "expression", "_", { "literal": "|" }, "_", "comprehension_clause_list", "_", { "literal": "]" }], "postprocess": (d) => `[${d[2]} | ${d[6]}]` },
+        { "name": "comprehension_clause_list$ebnf$1", "symbols": [] },
+        { "name": "comprehension_clause_list$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "comprehension_clause"] },
+        { "name": "comprehension_clause_list$ebnf$1", "symbols": ["comprehension_clause_list$ebnf$1", "comprehension_clause_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "comprehension_clause_list", "symbols": ["comprehension_clause", "comprehension_clause_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map((x) => x[3])].join(`, `) },
+        { "name": "comprehension_clause", "symbols": ["variable", "_", { "literal": "<-" }, "_", "expression"], "postprocess": (d) => `${d[0]} <- ${d[4]}` },
+        { "name": "comprehension_clause", "symbols": ["expression"], "postprocess": (d) => d[0] },
+        { "name": "lambda_expression$subexpression$1", "symbols": ["_"] },
+        { "name": "lambda_expression$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "lambda_expression$subexpression$2", "symbols": ["_"] },
+        { "name": "lambda_expression$subexpression$2", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "lambda_expression", "symbols": [{ "literal": "(" }, "_", { "literal": "\\" }, "_", "parameter_list", "_", { "literal": "->" }, "lambda_expression$subexpression$1", "expression", "lambda_expression$subexpression$2", { "literal": ")" }], "postprocess": (d) => `(\\${d[4]} -> ${d[8]})` },
+        { "name": "tuple_expression$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "tuple_value"] },
+        { "name": "tuple_expression$ebnf$1", "symbols": ["tuple_expression$ebnf$1$subexpression$1"] },
+        { "name": "tuple_expression$ebnf$1$subexpression$2", "symbols": ["_", { "literal": "," }, "_", "tuple_value"] },
+        { "name": "tuple_expression$ebnf$1", "symbols": ["tuple_expression$ebnf$1", "tuple_expression$ebnf$1$subexpression$2"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "tuple_expression", "symbols": [{ "literal": "(" }, "_", "tuple_value", "tuple_expression$ebnf$1", "_", { "literal": ")" }], "postprocess": (d) => `(` + [d[2], ...d[3].map(x => `,${x[3]}`)].join(``) + `)` },
+        { "name": "tuple_value", "symbols": ["expression"], "postprocess": d => d[0] },
+        { "name": "data_expression", "symbols": ["constr", "_", (HSLexer.has("lbracket") ? { type: "lbracket" } : lbracket), "_", "fields_expressions", "_", (HSLexer.has("rbracket") ? { type: "rbracket" } : rbracket)], "postprocess": (d) => d[0] + ` { ` + d[4] + ` }`
+        },
+        { "name": "fields_expressions$ebnf$1", "symbols": [] },
+        { "name": "fields_expressions$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "field_exp"] },
+        { "name": "fields_expressions$ebnf$1", "symbols": ["fields_expressions$ebnf$1", "fields_expressions$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "fields_expressions", "symbols": ["field_exp", "fields_expressions$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[3])].join(", ") },
+        { "name": "field_exp", "symbols": ["variable", "_", { "literal": "=" }, "_", "expression"], "postprocess": (d) => d[0] + ` = ` + d[4] },
+        { "name": "if_expression$subexpression$1", "symbols": ["__"] },
+        { "name": "if_expression$subexpression$1$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "_"] },
+        { "name": "if_expression$subexpression$1", "symbols": ["if_expression$subexpression$1$subexpression$1"] },
+        { "name": "if_expression$subexpression$2", "symbols": ["__"] },
+        { "name": "if_expression$subexpression$2$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "_"] },
+        { "name": "if_expression$subexpression$2", "symbols": ["if_expression$subexpression$2$subexpression$1"] },
+        { "name": "if_expression$subexpression$3", "symbols": ["__"] },
+        { "name": "if_expression$subexpression$3$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "if_expression$subexpression$3", "symbols": ["if_expression$subexpression$3$subexpression$1"] },
+        { "name": "if_expression$subexpression$4", "symbols": ["__"] },
+        { "name": "if_expression$subexpression$4$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "_"] },
+        { "name": "if_expression$subexpression$4", "symbols": ["if_expression$subexpression$4$subexpression$1"] },
+        { "name": "if_expression$subexpression$5", "symbols": ["__"] },
+        { "name": "if_expression$subexpression$5$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "if_expression$subexpression$5", "symbols": ["if_expression$subexpression$5$subexpression$1"] },
+        { "name": "if_expression", "symbols": [{ "literal": "if" }, "if_expression$subexpression$1", "expression", "if_expression$subexpression$2", { "literal": "then" }, "if_expression$subexpression$3", "expression", "if_expression$subexpression$4", { "literal": "else" }, "if_expression$subexpression$5", "expression"], "postprocess": (d) => `if ` + d[2] + ` then ` + d[6] + ` else ` + d[10]
+        },
+        { "name": "letin_expression$subexpression$1", "symbols": ["_"] },
+        { "name": "letin_expression$subexpression$1$subexpression$1", "symbols": ["_", { "literal": "{" }, "_"] },
+        { "name": "letin_expression$subexpression$1", "symbols": ["letin_expression$subexpression$1$subexpression$1"] },
+        { "name": "letin_expression$subexpression$1$subexpression$2", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "letin_expression$subexpression$1", "symbols": ["letin_expression$subexpression$1$subexpression$2"] },
+        { "name": "letin_expression$ebnf$1", "symbols": ["bindings_list"], "postprocess": id },
+        { "name": "letin_expression$ebnf$1", "symbols": [], "postprocess": () => null },
+        { "name": "letin_expression$subexpression$2", "symbols": ["_"] },
+        { "name": "letin_expression$subexpression$2$subexpression$1", "symbols": ["_", { "literal": "}" }, "_"] },
+        { "name": "letin_expression$subexpression$2", "symbols": ["letin_expression$subexpression$2$subexpression$1"] },
+        { "name": "letin_expression$subexpression$2$subexpression$2", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "letin_expression$subexpression$2", "symbols": ["letin_expression$subexpression$2$subexpression$2"] },
+        { "name": "letin_expression$subexpression$3$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "letin_expression$subexpression$3", "symbols": ["letin_expression$subexpression$3$subexpression$1"] },
+        { "name": "letin_expression$subexpression$3", "symbols": ["_"] },
+        { "name": "letin_expression", "symbols": [{ "literal": "let" }, "letin_expression$subexpression$1", "letin_expression$ebnf$1", "letin_expression$subexpression$2", { "literal": "in" }, "letin_expression$subexpression$3", "expression"], "postprocess": (d) => `let { ${(d[2] ?? ``)} }` + ` in ` + d[6] },
+        { "name": "case_expression$subexpression$1$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "case_expression$subexpression$1", "symbols": ["case_expression$subexpression$1$subexpression$1"] },
+        { "name": "case_expression$subexpression$1", "symbols": ["_"] },
+        { "name": "case_expression$subexpression$2$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "case_expression$subexpression$2", "symbols": ["case_expression$subexpression$2$subexpression$1"] },
+        { "name": "case_expression$subexpression$2", "symbols": ["_"] },
+        { "name": "case_expression$subexpression$3", "symbols": ["_"] },
+        { "name": "case_expression$subexpression$3$subexpression$1", "symbols": ["_", { "literal": "{" }, "_"] },
+        { "name": "case_expression$subexpression$3", "symbols": ["case_expression$subexpression$3$subexpression$1"] },
+        { "name": "case_expression$subexpression$3$subexpression$2", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "case_expression$subexpression$3", "symbols": ["case_expression$subexpression$3$subexpression$2"] },
+        { "name": "case_expression$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "}" }, "_"] },
+        { "name": "case_expression$ebnf$1", "symbols": ["case_expression$ebnf$1$subexpression$1"], "postprocess": id },
+        { "name": "case_expression$ebnf$1", "symbols": [], "postprocess": () => null },
+        { "name": "case_expression", "symbols": [{ "literal": "case" }, "case_expression$subexpression$1", "expression", "case_expression$subexpression$2", { "literal": "of" }, "case_expression$subexpression$3", "case_arms", "case_expression$ebnf$1"], "postprocess": (d) => `case ${d[2]} of { ${d[6]} }` },
+        { "name": "case_arms$ebnf$1", "symbols": [] },
+        { "name": "case_arms$ebnf$1$subexpression$1$subexpression$1$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "case_arms$ebnf$1$subexpression$1$subexpression$1", "symbols": ["case_arms$ebnf$1$subexpression$1$subexpression$1$subexpression$1"] },
+        { "name": "case_arms$ebnf$1$subexpression$1$subexpression$1$subexpression$2", "symbols": ["_", { "literal": ";" }, "_"] },
+        { "name": "case_arms$ebnf$1$subexpression$1$subexpression$1", "symbols": ["case_arms$ebnf$1$subexpression$1$subexpression$1$subexpression$2"] },
+        { "name": "case_arms$ebnf$1$subexpression$1", "symbols": ["case_arms$ebnf$1$subexpression$1$subexpression$1", "case_arm"] },
+        { "name": "case_arms$ebnf$1", "symbols": ["case_arms$ebnf$1", "case_arms$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "case_arms", "symbols": ["case_arm", "case_arms$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[1])].join("; ") },
+        { "name": "case_arm$subexpression$1$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "case_arm$subexpression$1", "symbols": ["case_arm$subexpression$1$subexpression$1"] },
+        { "name": "case_arm$subexpression$1", "symbols": ["_"] },
+        { "name": "case_arm$subexpression$2$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "case_arm$subexpression$2", "symbols": ["case_arm$subexpression$2$subexpression$1"] },
+        { "name": "case_arm$subexpression$2", "symbols": ["_"] },
+        { "name": "case_arm", "symbols": ["pattern", "case_arm$subexpression$1", { "literal": "->" }, "case_arm$subexpression$2", "expression"], "postprocess": (d) => d[0] + ` -> ` + d[4] },
+        { "name": "data_declaration$ebnf$1", "symbols": [] },
+        { "name": "data_declaration$ebnf$1$subexpression$1", "symbols": ["__", "type_variable"] },
+        { "name": "data_declaration$ebnf$1", "symbols": ["data_declaration$ebnf$1", "data_declaration$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "data_declaration$ebnf$2", "symbols": [] },
+        { "name": "data_declaration$ebnf$2$subexpression$1", "symbols": ["_", { "literal": "|" }, "_", "constructor_def"] },
+        { "name": "data_declaration$ebnf$2", "symbols": ["data_declaration$ebnf$2", "data_declaration$ebnf$2$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "data_declaration$ebnf$3", "symbols": ["deriving_clause"], "postprocess": id },
+        { "name": "data_declaration$ebnf$3", "symbols": [], "postprocess": () => null },
+        { "name": "data_declaration", "symbols": [{ "literal": "data" }, "__", "constr", "data_declaration$ebnf$1", "_", { "literal": "=" }, "_", "constructor_def", "data_declaration$ebnf$2", "data_declaration$ebnf$3"], "postprocess": (d) => `data ` + d[2] + (d[3] ? ` ` + d[3].map(x => x[1]).join(" ") : ``) + ` = ` + [d[7], ...d[8].map(x => `| ${x[3]}`)].join(" ") + (d[9] ?? ``)
+        },
+        { "name": "deriving_clause", "symbols": ["__", { "literal": "deriving" }, "_", "deriving_spec"], "postprocess": (d) => ` deriving ` + d[3] },
+        { "name": "deriving_spec", "symbols": [{ "literal": "(" }, "_", "deriving_classes", "_", { "literal": ")" }], "postprocess": (d) => `(${d[2]})` },
+        { "name": "deriving_spec", "symbols": ["constr"], "postprocess": (d) => d[0] },
+        { "name": "deriving_classes$ebnf$1", "symbols": [] },
+        { "name": "deriving_classes$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", (HSLexer.has("typeClass") ? { type: "typeClass" } : typeClass)] },
+        { "name": "deriving_classes$ebnf$1", "symbols": ["deriving_classes$ebnf$1", "deriving_classes$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "deriving_classes", "symbols": [(HSLexer.has("typeClass") ? { type: "typeClass" } : typeClass), "deriving_classes$ebnf$1"], "postprocess": (d) => [d[0].value, ...d[1].map(x => x[3].value)].join(", ") },
+        { "name": "constructor_def$ebnf$1$subexpression$1", "symbols": [(HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "constructor_def$ebnf$1", "symbols": ["constructor_def$ebnf$1$subexpression$1"], "postprocess": id },
+        { "name": "constructor_def$ebnf$1", "symbols": [], "postprocess": () => null },
+        { "name": "constructor_def$ebnf$2$subexpression$1", "symbols": [(HSLexer.has("NL") ? { type: "NL" } : NL), "_"] },
+        { "name": "constructor_def$ebnf$2", "symbols": ["constructor_def$ebnf$2$subexpression$1"], "postprocess": id },
+        { "name": "constructor_def$ebnf$2", "symbols": [], "postprocess": () => null },
+        { "name": "constructor_def$ebnf$3$subexpression$1", "symbols": [(HSLexer.has("NL") ? { type: "NL" } : NL), "_"] },
+        { "name": "constructor_def$ebnf$3", "symbols": ["constructor_def$ebnf$3$subexpression$1"], "postprocess": id },
+        { "name": "constructor_def$ebnf$3", "symbols": [], "postprocess": () => null },
+        { "name": "constructor_def", "symbols": ["constr", "_", "constructor_def$ebnf$1", (HSLexer.has("lbracket") ? { type: "lbracket" } : lbracket), "_", "constructor_def$ebnf$2", "field_list", "_", "constructor_def$ebnf$3", (HSLexer.has("rbracket") ? { type: "rbracket" } : rbracket)], "postprocess": (d) => d[0] + ` { ` + d[6] + ` }` },
+        { "name": "constructor_def$ebnf$4", "symbols": [] },
+        { "name": "constructor_def$ebnf$4$subexpression$1", "symbols": ["__", "simple_type"] },
+        { "name": "constructor_def$ebnf$4", "symbols": ["constructor_def$ebnf$4", "constructor_def$ebnf$4$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "constructor_def", "symbols": ["constr", "constructor_def$ebnf$4"], "postprocess": (d) => [d[0], ...d[1].map(x => x[1])].join(" ") },
+        { "name": "field_list$ebnf$1", "symbols": [] },
+        { "name": "field_list$ebnf$1$subexpression$1$ebnf$1$subexpression$1", "symbols": [(HSLexer.has("NL") ? { type: "NL" } : NL), "_"] },
+        { "name": "field_list$ebnf$1$subexpression$1$ebnf$1", "symbols": ["field_list$ebnf$1$subexpression$1$ebnf$1$subexpression$1"], "postprocess": id },
+        { "name": "field_list$ebnf$1$subexpression$1$ebnf$1", "symbols": [], "postprocess": () => null },
+        { "name": "field_list$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "field_list$ebnf$1$subexpression$1$ebnf$1", "field"] },
+        { "name": "field_list$ebnf$1", "symbols": ["field_list$ebnf$1", "field_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "field_list", "symbols": ["field", "field_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[4])].join(", ") },
+        { "name": "field", "symbols": ["variable", "_", (HSLexer.has("typeEquals") ? { type: "typeEquals" } : typeEquals), "_", "type"], "postprocess": (d) => d[0] + ` :: ` + d[4] },
+        { "name": "binding_name", "symbols": [{ "literal": "(" }, "_", (HSLexer.has("op") ? { type: "op" } : op), "_", { "literal": ")" }], "postprocess": d => `(${d[2].value})` },
+        { "name": "binding_name", "symbols": ["variable"], "postprocess": d => d[0] },
+        { "name": "function_signature$ebnf$1", "symbols": [] },
+        { "name": "function_signature$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "binding_name"] },
+        { "name": "function_signature$ebnf$1", "symbols": ["function_signature$ebnf$1", "function_signature$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "function_signature$subexpression$1", "symbols": ["_"] },
+        { "name": "function_signature$subexpression$1$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "function_signature$subexpression$1", "symbols": ["function_signature$subexpression$1$subexpression$1"] },
+        { "name": "function_signature", "symbols": ["binding_name", "function_signature$ebnf$1", "_", (HSLexer.has("typeEquals") ? { type: "typeEquals" } : typeEquals), "function_signature$subexpression$1", "type"], "postprocess": (d) => [`${d[0]} :: ${d[5]}`, ...d[1].map(x => `${x[3]} :: ${d[5]}`)].join("\n") },
+        { "name": "function_declaration", "symbols": ["variable", "equation"], "postprocess": (d) => d[0] + d[1] },
+        { "name": "function_declaration", "symbols": [{ "literal": "(" }, "_", (HSLexer.has("op") ? { type: "op" } : op), "_", { "literal": ")" }, "equation"], "postprocess": (d) => `(${d[2]})` + d[5] },
+        { "name": "return_expression", "symbols": ["expression"], "postprocess": d => d[0] },
+        { "name": "where_clause$subexpression$1", "symbols": ["_"] },
+        { "name": "where_clause$subexpression$1$subexpression$1", "symbols": ["_", { "literal": "{" }, "_"] },
+        { "name": "where_clause$subexpression$1", "symbols": ["where_clause$subexpression$1$subexpression$1"] },
+        { "name": "where_clause$subexpression$1$subexpression$2", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "where_clause$subexpression$1", "symbols": ["where_clause$subexpression$1$subexpression$2"] },
+        { "name": "where_clause$subexpression$2", "symbols": ["_"] },
+        { "name": "where_clause$subexpression$2$subexpression$1", "symbols": ["_", { "literal": "}" }, "_"] },
+        { "name": "where_clause$subexpression$2", "symbols": ["where_clause$subexpression$2$subexpression$1"] },
+        { "name": "where_clause", "symbols": [{ "literal": "where" }, "where_clause$subexpression$1", "bindings_list", "where_clause$subexpression$2"], "postprocess": d => `where { ${d[2]} }` },
+        { "name": "bindings_list$ebnf$1", "symbols": [] },
+        { "name": "bindings_list$ebnf$1$subexpression$1$subexpression$1$subexpression$1", "symbols": ["_", { "literal": ";" }, "_"] },
+        { "name": "bindings_list$ebnf$1$subexpression$1$subexpression$1", "symbols": ["bindings_list$ebnf$1$subexpression$1$subexpression$1$subexpression$1"] },
+        { "name": "bindings_list$ebnf$1$subexpression$1$subexpression$1$subexpression$2", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "bindings_list$ebnf$1$subexpression$1$subexpression$1", "symbols": ["bindings_list$ebnf$1$subexpression$1$subexpression$1$subexpression$2"] },
+        { "name": "bindings_list$ebnf$1$subexpression$1", "symbols": ["bindings_list$ebnf$1$subexpression$1$subexpression$1", "function_declaration"] },
+        { "name": "bindings_list$ebnf$1", "symbols": ["bindings_list$ebnf$1", "bindings_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "bindings_list", "symbols": ["function_declaration", "bindings_list$ebnf$1"], "postprocess": d => [d[0], ...d[1].map(x => x[1])].join('; ') },
+        { "name": "equation$ebnf$1$subexpression$1", "symbols": [(HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "equation$ebnf$1", "symbols": ["equation$ebnf$1$subexpression$1"], "postprocess": id },
+        { "name": "equation$ebnf$1", "symbols": [], "postprocess": () => null },
+        { "name": "equation$ebnf$2$subexpression$1$subexpression$1$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "equation$ebnf$2$subexpression$1$subexpression$1", "symbols": ["equation$ebnf$2$subexpression$1$subexpression$1$subexpression$1"] },
+        { "name": "equation$ebnf$2$subexpression$1$subexpression$1", "symbols": ["_"] },
+        { "name": "equation$ebnf$2$subexpression$1", "symbols": ["equation$ebnf$2$subexpression$1$subexpression$1", "where_clause"] },
+        { "name": "equation$ebnf$2", "symbols": ["equation$ebnf$2$subexpression$1"], "postprocess": id },
+        { "name": "equation$ebnf$2", "symbols": [], "postprocess": () => null },
+        { "name": "equation", "symbols": ["params", "equation$ebnf$1", "guarded_rhs", "equation$ebnf$2"], "postprocess": (d) => {
+                const body = d[2];
+                const whereClause = d[3] ? ` ` + d[3][1] : ``;
+                return d[0] + ` ` + body + whereClause;
+            } },
+        { "name": "equation$subexpression$1$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "equation$subexpression$1", "symbols": ["equation$subexpression$1$subexpression$1"] },
+        { "name": "equation$subexpression$1", "symbols": ["_"] },
+        { "name": "equation$ebnf$3$subexpression$1$subexpression$1$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "equation$ebnf$3$subexpression$1$subexpression$1", "symbols": ["equation$ebnf$3$subexpression$1$subexpression$1$subexpression$1"] },
+        { "name": "equation$ebnf$3$subexpression$1$subexpression$1", "symbols": ["_"] },
+        { "name": "equation$ebnf$3$subexpression$1", "symbols": ["equation$ebnf$3$subexpression$1$subexpression$1", "where_clause"] },
+        { "name": "equation$ebnf$3", "symbols": ["equation$ebnf$3$subexpression$1"], "postprocess": id },
+        { "name": "equation$ebnf$3", "symbols": [], "postprocess": () => null },
+        { "name": "equation", "symbols": ["params", (HSLexer.has("assign") ? { type: "assign" } : assign), "equation$subexpression$1", "return_expression", "equation$ebnf$3"], "postprocess": d => d[0] + ` = ` + d[3] + (d[4] ? ` ` + d[4][1] : ``) },
+        { "name": "params", "symbols": ["__", "parameter_list", "_"], "postprocess": d => ` ${d[1]}` },
+        { "name": "params", "symbols": ["_"], "postprocess": d => `` },
+        { "name": "guarded_rhs$subexpression$1$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "guarded_rhs$subexpression$1", "symbols": ["guarded_rhs$subexpression$1$subexpression$1"] },
+        { "name": "guarded_rhs$subexpression$1", "symbols": ["_"] },
+        { "name": "guarded_rhs", "symbols": ["guarded_branch", "guarded_rhs$subexpression$1", "guarded_rhs"], "postprocess": (d) => `${d[0]} ${d[2]}` },
+        { "name": "guarded_rhs", "symbols": ["guarded_branch"], "postprocess": (d) => d[0] },
+        { "name": "guarded_branch$subexpression$1$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "guarded_branch$subexpression$1", "symbols": ["guarded_branch$subexpression$1$subexpression$1"] },
+        { "name": "guarded_branch$subexpression$1", "symbols": ["_"] },
+        { "name": "guarded_branch$subexpression$2$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "guarded_branch$subexpression$2", "symbols": ["guarded_branch$subexpression$2$subexpression$1"] },
+        { "name": "guarded_branch$subexpression$2", "symbols": ["_"] },
+        { "name": "guarded_branch$subexpression$3$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "guarded_branch$subexpression$3", "symbols": ["guarded_branch$subexpression$3$subexpression$1"] },
+        { "name": "guarded_branch$subexpression$3", "symbols": ["_"] },
+        { "name": "guarded_branch", "symbols": [{ "literal": "|" }, "guarded_branch$subexpression$1", "condition", "guarded_branch$subexpression$2", { "literal": "=" }, "guarded_branch$subexpression$3", "expression"], "postprocess": (d) => `| ${d[2]} = ${d[6]}` },
+        { "name": "condition", "symbols": [{ "literal": "otherwise" }], "postprocess": d => `otherwise` },
+        { "name": "condition", "symbols": ["expression"], "postprocess": d => d[0] },
+        { "name": "parameter_list$ebnf$1", "symbols": [] },
+        { "name": "parameter_list$ebnf$1$subexpression$1", "symbols": ["__", "pattern"] },
+        { "name": "parameter_list$ebnf$1", "symbols": ["parameter_list$ebnf$1", "parameter_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "parameter_list", "symbols": ["pattern", "parameter_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[1])].join(" ") },
+        { "name": "pattern$ebnf$1$subexpression$1", "symbols": [{ "literal": "~" }, "_"] },
+        { "name": "pattern$ebnf$1", "symbols": ["pattern$ebnf$1$subexpression$1"], "postprocess": id },
+        { "name": "pattern$ebnf$1", "symbols": [], "postprocess": () => null },
+        { "name": "pattern", "symbols": ["pattern$ebnf$1", "cons_pattern"], "postprocess": (d) => d[1] },
+        { "name": "cons_pattern$ebnf$1$subexpression$1", "symbols": ["_", { "literal": ":" }, "_", "cons_pattern"] },
+        { "name": "cons_pattern$ebnf$1", "symbols": ["cons_pattern$ebnf$1$subexpression$1"] },
+        { "name": "cons_pattern$ebnf$1$subexpression$2", "symbols": ["_", { "literal": ":" }, "_", "cons_pattern"] },
+        { "name": "cons_pattern$ebnf$1", "symbols": ["cons_pattern$ebnf$1", "cons_pattern$ebnf$1$subexpression$2"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "cons_pattern", "symbols": [{ "literal": "(" }, "_", "cons_pattern", "cons_pattern$ebnf$1", "_", { "literal": ")" }], "postprocess": (d) => `(${[d[2], ...d[3].map(x => x[3])].join(":")})` },
+        { "name": "cons_pattern", "symbols": ["simple_pattern"], "postprocess": (d) => d[0] },
+        { "name": "simple_pattern$subexpression$1", "symbols": ["as_pattern"] },
+        { "name": "simple_pattern$subexpression$1", "symbols": ["constructor_pattern"] },
+        { "name": "simple_pattern$subexpression$1", "symbols": ["list_pattern"] },
+        { "name": "simple_pattern$subexpression$1", "symbols": ["tuple_pattern"] },
+        { "name": "simple_pattern$subexpression$1", "symbols": ["literal_pattern"] },
+        { "name": "simple_pattern$subexpression$1", "symbols": ["variable_pattern"] },
+        { "name": "simple_pattern$subexpression$1", "symbols": ["wildcard_pattern"] },
+        { "name": "simple_pattern$subexpression$1", "symbols": ["paren_pattern"] },
+        { "name": "simple_pattern", "symbols": ["simple_pattern$subexpression$1"], "postprocess": (d) => d[0][0] },
+        { "name": "wildcard_pattern", "symbols": [(HSLexer.has("anonymousVariable") ? { type: "anonymousVariable" } : anonymousVariable)], "postprocess": (d) => `_` },
+        { "name": "paren_pattern", "symbols": [{ "literal": "(" }, "_", "pattern", "_", { "literal": ")" }], "postprocess": (d) => `(${d[2]})` },
+        { "name": "variable_pattern", "symbols": ["variable"], "postprocess": (d) => d[0] },
+        { "name": "literal_pattern", "symbols": ["primitive"], "postprocess": (d) => d[0] },
+        { "name": "as_pattern$subexpression$1", "symbols": ["variable_pattern"] },
+        { "name": "as_pattern$subexpression$1", "symbols": ["wildcard_pattern"] },
+        { "name": "as_pattern", "symbols": ["as_pattern$subexpression$1", { "literal": "@" }, "pattern"], "postprocess": (d) => d[0][0] + `@` + d[2] },
+        { "name": "constructor_pattern$ebnf$1$subexpression$1", "symbols": ["__", "pattern"] },
+        { "name": "constructor_pattern$ebnf$1", "symbols": ["constructor_pattern$ebnf$1$subexpression$1"] },
+        { "name": "constructor_pattern$ebnf$1$subexpression$2", "symbols": ["__", "pattern"] },
+        { "name": "constructor_pattern$ebnf$1", "symbols": ["constructor_pattern$ebnf$1", "constructor_pattern$ebnf$1$subexpression$2"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "constructor_pattern", "symbols": [{ "literal": "(" }, "_", "constr", "constructor_pattern$ebnf$1", "_", { "literal": ")" }], "postprocess": (d) => `(${[d[2], ...d[3].map(x => x[1])].join(" ")})` },
+        { "name": "constructor_pattern", "symbols": ["constr"], "postprocess": (d) => `${d[0]}` },
+        { "name": "field_pattern_list$ebnf$1", "symbols": [] },
+        { "name": "field_pattern_list$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "field_pattern"] },
+        { "name": "field_pattern_list$ebnf$1", "symbols": ["field_pattern_list$ebnf$1", "field_pattern_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "field_pattern_list", "symbols": ["field_pattern", "field_pattern_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[3])].join(`, `) },
+        { "name": "field_pattern", "symbols": ["variable", "_", { "literal": "=" }, "_", "pattern"], "postprocess": (d) => d[0] + ` = ` + d[4] },
+        { "name": "list_pattern$ebnf$1", "symbols": ["pattern_list"], "postprocess": id },
+        { "name": "list_pattern$ebnf$1", "symbols": [], "postprocess": () => null },
+        { "name": "list_pattern", "symbols": [{ "literal": "[" }, "_", "list_pattern$ebnf$1", "_", { "literal": "]" }], "postprocess": (d) => `[${d[2] ?? ``}]` },
+        { "name": "pattern_list$ebnf$1", "symbols": [] },
+        { "name": "pattern_list$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "pattern"] },
+        { "name": "pattern_list$ebnf$1", "symbols": ["pattern_list$ebnf$1", "pattern_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "pattern_list", "symbols": ["pattern", "pattern_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[3])].join(`, `) },
+        { "name": "tuple_pattern$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "pattern"] },
+        { "name": "tuple_pattern$ebnf$1", "symbols": ["tuple_pattern$ebnf$1$subexpression$1"] },
+        { "name": "tuple_pattern$ebnf$1$subexpression$2", "symbols": ["_", { "literal": "," }, "_", "pattern"] },
+        { "name": "tuple_pattern$ebnf$1", "symbols": ["tuple_pattern$ebnf$1", "tuple_pattern$ebnf$1$subexpression$2"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "tuple_pattern", "symbols": [{ "literal": "(" }, "_", "pattern", "tuple_pattern$ebnf$1", "_", { "literal": ")" }], "postprocess": (d) => `(${[d[2], ...d[3].map(x => x[3])].join(`, `)})` },
+        { "name": "type_declaration$ebnf$1$subexpression$1", "symbols": ["__", "variable_list"] },
+        { "name": "type_declaration$ebnf$1", "symbols": ["type_declaration$ebnf$1$subexpression$1"], "postprocess": id },
+        { "name": "type_declaration$ebnf$1", "symbols": [], "postprocess": () => null },
+        { "name": "type_declaration", "symbols": [{ "literal": "type" }, "__", "constr", "type_declaration$ebnf$1", "_", { "literal": "=" }, "_", "type"], "postprocess": (d) => {
+                const varList = d[3] ? ` ` + d[3][1] : ``;
+                return `type ${d[2]}` + varList + ` = ${d[7]}`;
+            } },
+        { "name": "variable_list$ebnf$1", "symbols": [] },
+        { "name": "variable_list$ebnf$1$subexpression$1", "symbols": ["__", "variable"] },
+        { "name": "variable_list$ebnf$1", "symbols": ["variable_list$ebnf$1", "variable_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "variable_list", "symbols": ["variable", "variable_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[1])].join(" ") },
+        { "name": "type", "symbols": ["function_type"], "postprocess": d => d[0] },
+        { "name": "constrained_type", "symbols": ["constraint_list", "_", (HSLexer.has("arrow") ? { type: "arrow" } : arrow), "_", "type"], "postprocess": (d) => d[0] + ` -> ` + d[4] },
+        { "name": "context", "symbols": ["constraint"], "postprocess": (d) => d[0] },
+        { "name": "context", "symbols": [{ "literal": "(" }, "_", "constraint_list", "_", { "literal": ")" }], "postprocess": (d) => `(${d[2]})` },
+        { "name": "constraint_list$ebnf$1", "symbols": [] },
+        { "name": "constraint_list$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "constraint"] },
+        { "name": "constraint_list$ebnf$1", "symbols": ["constraint_list$ebnf$1", "constraint_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "constraint_list", "symbols": ["constraint", "constraint_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[3])].join(", ")
+        },
+        { "name": "constraint$ebnf$1$subexpression$1", "symbols": ["_", "application_type"] },
+        { "name": "constraint$ebnf$1", "symbols": ["constraint$ebnf$1$subexpression$1"] },
+        { "name": "constraint$ebnf$1$subexpression$2", "symbols": ["_", "application_type"] },
+        { "name": "constraint$ebnf$1", "symbols": ["constraint$ebnf$1", "constraint$ebnf$1$subexpression$2"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "constraint", "symbols": [(HSLexer.has("typeClass") ? { type: "typeClass" } : typeClass), "constraint$ebnf$1"], "postprocess": (d) => [d[0].value, ...d[1].map(x => x[1])].join(" ") },
+        { "name": "function_type$ebnf$1$subexpression$1", "symbols": ["context", "_", (HSLexer.has("arrow") ? { type: "arrow" } : arrow), "_"] },
+        { "name": "function_type$ebnf$1", "symbols": ["function_type$ebnf$1$subexpression$1"], "postprocess": id },
+        { "name": "function_type$ebnf$1", "symbols": [], "postprocess": () => null },
+        { "name": "function_type$ebnf$2", "symbols": [] },
+        { "name": "function_type$ebnf$2$subexpression$1$subexpression$1", "symbols": ["_"] },
+        { "name": "function_type$ebnf$2$subexpression$1$subexpression$1$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "function_type$ebnf$2$subexpression$1$subexpression$1", "symbols": ["function_type$ebnf$2$subexpression$1$subexpression$1$subexpression$1"] },
+        { "name": "function_type$ebnf$2$subexpression$1$subexpression$2", "symbols": ["_"] },
+        { "name": "function_type$ebnf$2$subexpression$1$subexpression$2$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
+        { "name": "function_type$ebnf$2$subexpression$1$subexpression$2", "symbols": ["function_type$ebnf$2$subexpression$1$subexpression$2$subexpression$1"] },
+        { "name": "function_type$ebnf$2$subexpression$1", "symbols": ["application_type", "function_type$ebnf$2$subexpression$1$subexpression$1", (HSLexer.has("typeArrow") ? { type: "typeArrow" } : typeArrow), "function_type$ebnf$2$subexpression$1$subexpression$2"] },
+        { "name": "function_type$ebnf$2", "symbols": ["function_type$ebnf$2", "function_type$ebnf$2$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "function_type", "symbols": ["function_type$ebnf$1", "function_type$ebnf$2", "application_type"], "postprocess": (d) => {
+                const constraints = d[0] ? `${d[0][0]} => ` : ``;
+                const inputs = [...d[1].map(x => x[0]), d[2]].join(" -> ");
+                return constraints + inputs;
+            }
+        },
+        { "name": "application_type$ebnf$1$subexpression$1", "symbols": ["_", "simple_type"] },
+        { "name": "application_type$ebnf$1", "symbols": ["application_type$ebnf$1$subexpression$1"] },
+        { "name": "application_type$ebnf$1$subexpression$2", "symbols": ["_", "simple_type"] },
+        { "name": "application_type$ebnf$1", "symbols": ["application_type$ebnf$1", "application_type$ebnf$1$subexpression$2"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "application_type", "symbols": ["simple_type", "application_type$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[1])].join(" ") },
+        { "name": "application_type", "symbols": ["simple_type"], "postprocess": (d) => d[0] },
+        { "name": "simple_type$subexpression$1", "symbols": ["type_variable"] },
+        { "name": "simple_type$subexpression$1", "symbols": ["type_constructor"] },
+        { "name": "simple_type", "symbols": ["simple_type$subexpression$1"], "postprocess": (d) => d[0][0] },
+        { "name": "simple_type", "symbols": [{ "literal": "[" }, "_", "type", "_", { "literal": "]" }], "postprocess": (d) => `[${d[2]}]` },
+        { "name": "simple_type$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "type"] },
+        { "name": "simple_type$ebnf$1", "symbols": ["simple_type$ebnf$1$subexpression$1"] },
+        { "name": "simple_type$ebnf$1$subexpression$2", "symbols": ["_", { "literal": "," }, "_", "type"] },
+        { "name": "simple_type$ebnf$1", "symbols": ["simple_type$ebnf$1", "simple_type$ebnf$1$subexpression$2"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "simple_type", "symbols": [{ "literal": "(" }, "_", "type", "simple_type$ebnf$1", "_", { "literal": ")" }], "postprocess": (d) => `(${[d[2], ...d[3].map(x => x[3])].join(`, `)})` },
+        { "name": "simple_type", "symbols": [{ "literal": "(" }, "_", "type", "_", { "literal": ")" }], "postprocess": (d) => `(${d[2]})` },
+        { "name": "type_variable", "symbols": ["variable"], "postprocess": (d) => d[0] },
+        { "name": "type_constructor", "symbols": ["constr"], "postprocess": (d) => d[0] },
+        { "name": "constr", "symbols": [(HSLexer.has("constructor") ? { type: "constructor" } : constructor)], "postprocess": (d) => `${d[0].value}` },
+        { "name": "variable", "symbols": [(HSLexer.has("variable") ? { type: "variable" } : variable)], "postprocess": (d) => `${d[0].value}` },
+        { "name": "list_literal", "symbols": [{ "literal": "[" }, "_", { "literal": "]" }], "postprocess": (d) => `[]` },
+        { "name": "list_literal", "symbols": [{ "literal": "[" }, "_", "expression_list", "_", { "literal": "]" }], "postprocess": (d) => `[${d[2]}]` },
+        { "name": "range_expression", "symbols": ["expression", "_", { "literal": ".." }], "postprocess": (d) => d[0] + ".." },
+        { "name": "range_expression", "symbols": ["expression", "_", { "literal": ".." }, "_", "expression"], "postprocess": (d) => d[0] + ".." + d[4] },
+        { "name": "range_expression", "symbols": ["expression", "_", { "literal": "," }, "_", "expression", "_", { "literal": ".." }], "postprocess": (d) => d[0] + ", " + d[4] + ".." },
+        { "name": "range_expression", "symbols": ["expression", "_", { "literal": "," }, "_", "expression", "_", { "literal": ".." }, "_", "expression"], "postprocess": (d) => d[0] + ", " + d[4] + ".." + d[6] },
+        { "name": "expression_list$ebnf$1", "symbols": [] },
+        { "name": "expression_list$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "expression"] },
+        { "name": "expression_list$ebnf$1", "symbols": ["expression_list$ebnf$1", "expression_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "expression_list", "symbols": ["expression", "expression_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[3])].join(`, `) },
+        { "name": "comparison_operator$subexpression$1", "symbols": [{ "literal": "==" }] },
+        { "name": "comparison_operator$subexpression$1", "symbols": [{ "literal": "/=" }] },
+        { "name": "comparison_operator$subexpression$1", "symbols": [{ "literal": "<" }] },
+        { "name": "comparison_operator$subexpression$1", "symbols": [{ "literal": ">" }] },
+        { "name": "comparison_operator$subexpression$1", "symbols": [{ "literal": "<=" }] },
+        { "name": "comparison_operator$subexpression$1", "symbols": [{ "literal": ">=" }] },
+        { "name": "comparison_operator", "symbols": ["comparison_operator$subexpression$1"], "postprocess": (d) => d[0][0].value },
+        { "name": "primitive$subexpression$1", "symbols": [(HSLexer.has("number") ? { type: "number" } : number)] },
+        { "name": "primitive$subexpression$1", "symbols": [(HSLexer.has("char") ? { type: "char" } : char)] },
+        { "name": "primitive$subexpression$1", "symbols": [(HSLexer.has("string") ? { type: "string" } : string)] },
+        { "name": "primitive$subexpression$1", "symbols": [(HSLexer.has("bool") ? { type: "bool" } : bool)] },
+        { "name": "primitive", "symbols": ["primitive$subexpression$1"], "postprocess": (d) => `${d[0][0].value}` },
+        { "name": "_$ebnf$1", "symbols": [] },
+        { "name": "_$ebnf$1", "symbols": ["_$ebnf$1", (HSLexer.has("WS") ? { type: "WS" } : WS)], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "_", "symbols": ["_$ebnf$1"] },
+        { "name": "__$ebnf$1", "symbols": [(HSLexer.has("WS") ? { type: "WS" } : WS)] },
+        { "name": "__$ebnf$1", "symbols": ["__$ebnf$1", (HSLexer.has("WS") ? { type: "WS" } : WS)], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "__", "symbols": ["__$ebnf$1"] }
+    ],
+    ParserStart: "program",
+};
+export default grammar;
+//# sourceMappingURL=preprocessor.js.map