yukigo-haskell-parser 0.1.0 → 0.1.2

package/src/parser/preprocessor.ts

@@ -1,502 +0,0 @@
-// 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: any[]): any { return d[0]; }
-declare var comment: any;
-declare var NL: any;
-declare var lbracket: any;
-declare var rbracket: any;
-declare var typeClass: any;
-declare var typeEquals: any;
-declare var op: any;
-declare var assign: any;
-declare var anonymousVariable: any;
-declare var arrow: any;
-declare var typeArrow: any;
-declare var constructor: any;
-declare var variable: any;
-declare var number: any;
-declare var char: any;
-declare var string: any;
-declare var bool: any;
-declare var WS: any;
-
-import { HSLexer } from "./lexer.js"
-
-const filter = d => {
-    return d.filter((token) => token !== null);
-};
-
-
-interface NearleyToken {
-  value: any;
-  [key: string]: any;
-};
-
-interface NearleyLexer {
-  reset: (chunk: string, info: any) => void;
-  next: () => NearleyToken | undefined;
-  save: () => any;
-  formatError: (token: never) => string;
-  has: (tokenType: string) => boolean;
-};
-
-interface NearleyRule {
-  name: string;
-  symbols: NearleySymbol[];
-  postprocess?: (d: any[], loc?: number, reject?: {}) => any;
-};
-
-type NearleySymbol = string | { literal: any } | { test: (token: any) => boolean };
-
-interface Grammar {
-  Lexer: NearleyLexer | undefined;
-  ParserRules: NearleyRule[];
-  ParserStart: string;
-};
-
-const grammar: 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;