yukigo-haskell-parser 0.1.0 → 0.1.2

package/dist/parser/grammar.js

@@ -3,12 +3,13 @@
 // Bypasses TS6133. Allow declared but unused functions.
 // @ts-ignore
 function id(d) { return d[0]; }
-import { HSLexer } from "./lexer.js";
-import { TypeCast, Application, ConsExpression, StringOperation, LogicalBinaryOperation, ComparisonOperation, ArithmeticBinaryOperation, ListBinaryOperation, ArithmeticUnaryOperation, SymbolPrimitive, ListPrimitive, Switch, CompositionExpression, Lambda, TupleExpression, DataExpression, Function, FieldExpression, If, Record, Constructor, Field, ListComprehension, Generator, RangeExpression, TypeSignature, Return, GuardedBody, Equation, Raise, UnguardedBody, Sequence, Otherwise, WildcardPattern, ConsPattern, VariablePattern, LiteralPattern, AsPattern, ConstructorPattern, ListPattern, TuplePattern, TypeAlias, ParameterizedType, Constraint, TypeApplication, LetInExpression, SimpleType, ListType, TupleType, NumberPrimitive, CharPrimitive, StringPrimitive, BooleanPrimitive, SourceLocation } from "@yukigo/ast";
+import { HaskellLayoutLexer } from "./lexer.js";
+import { TypeCast, Application, ConsExpression, LogicalBinaryOperation, ComparisonOperation, ArithmeticBinaryOperation, ListBinaryOperation, ArithmeticUnaryOperation, Case, SymbolPrimitive, ListPrimitive, Switch, CompositionExpression, Lambda, TupleExpression, DataExpression, Function, FieldExpression, If, Record, Constructor, Field, ListComprehension, Generator, RangeExpression, TypeSignature, Return, GuardedBody, Equation, Raise, UnguardedBody, Sequence, Otherwise, WildcardPattern, ConsPattern, VariablePattern, LiteralPattern, AsPattern, ConstructorPattern, ListPattern, TuplePattern, TypeAlias, ParameterizedType, Constraint, TypeApplication, LetInExpression, SimpleType, ListType, TupleType, TypeClass, Instance, NumberPrimitive, CharPrimitive, StringPrimitive, BooleanPrimitive, SourceLocation, TestGroup, Test, Assert, Equality, Truth, Failure } from "yukigo-ast";
 const filter = d => {
     return d.filter((token) => token !== null);
 };
 const loc = (token) => new SourceLocation(token.line, token.col);
+const HSLexer = new HaskellLayoutLexer();
 ;
 ;
 ;
@@ -16,95 +17,124 @@ const loc = (token) => new SourceLocation(token.line, token.col);
 const grammar = {
     Lexer: HSLexer,
     ParserRules: [
-        { "name": "program$ebnf$1", "symbols": ["declaration"] },
-        { "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) },
+        { "name": "program$ebnf$1", "symbols": [] },
+        { "name": "program$ebnf$1$subexpression$1", "symbols": [{ "literal": ";" }, "declaration"] },
+        { "name": "program$ebnf$1", "symbols": ["program$ebnf$1", "program$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "program$ebnf$2", "symbols": [{ "literal": ";" }], "postprocess": id },
+        { "name": "program$ebnf$2", "symbols": [], "postprocess": () => null },
+        { "name": "program", "symbols": ["declaration", "program$ebnf$1", "program$ebnf$2"], "postprocess": (d) => [d[0], ...d[1].map(x => x[1])].flat(Infinity) },
         { "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$subexpression$1", "symbols": ["typeclass_declaration"] },
+        { "name": "declaration$subexpression$1", "symbols": ["instance_declaration"] },
         { "name": "declaration$subexpression$1", "symbols": ["apply_operator"] },
-        { "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": "declaration$subexpression$1", "symbols": ["test_declaration"] },
+        { "name": "declaration$subexpression$1", "symbols": [{ "literal": "let" }, "function_declaration"] },
+        { "name": "declaration", "symbols": ["declaration$subexpression$1"], "postprocess": (d) => d[0][0] === "let" ? d[0][1] : d[0][0] },
         { "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$subexpression$1", "symbols": ["test_declaration"] },
         { "name": "expression", "symbols": ["expression$subexpression$1"], "postprocess": (d) => d[0][0] },
-        { "name": "type_cast", "symbols": ["apply_operator", "_", { "literal": "::" }, "_", "type"], "postprocess": (d) => new TypeCast(d[0], d[4]) },
+        { "name": "test_declaration", "symbols": [{ "literal": "describe" }, "expression", { "literal": "do" }, (HSLexer.has("lbracket") ? { type: "lbracket" } : lbracket), "test_body", (HSLexer.has("rbracket") ? { type: "rbracket" } : rbracket)], "postprocess": (d) => new TestGroup(d[1], new Sequence(d[4])) },
+        { "name": "test_declaration", "symbols": [{ "literal": "describe" }, "expression", { "literal": "$" }, { "literal": "do" }, (HSLexer.has("lbracket") ? { type: "lbracket" } : lbracket), "test_body", (HSLexer.has("rbracket") ? { type: "rbracket" } : rbracket)], "postprocess": (d) => new TestGroup(d[1], new Sequence(d[5])) },
+        { "name": "test_declaration", "symbols": [{ "literal": "it" }, "expression", { "literal": "do" }, (HSLexer.has("lbracket") ? { type: "lbracket" } : lbracket), "test_body", (HSLexer.has("rbracket") ? { type: "rbracket" } : rbracket)], "postprocess": (d) => new Test(d[1], new Sequence(d[4])) },
+        { "name": "test_declaration", "symbols": [{ "literal": "it" }, "expression", { "literal": "$" }, { "literal": "do" }, (HSLexer.has("lbracket") ? { type: "lbracket" } : lbracket), "test_body", (HSLexer.has("rbracket") ? { type: "rbracket" } : rbracket)], "postprocess": (d) => new Test(d[1], new Sequence(d[5])) },
+        { "name": "test_declaration", "symbols": [{ "literal": "let" }, "function_declaration"], "postprocess": (d) => d[1] },
+        { "name": "test_declaration", "symbols": ["assertion"], "postprocess": id },
+        { "name": "test_body$ebnf$1", "symbols": [] },
+        { "name": "test_body$ebnf$1$subexpression$1", "symbols": [{ "literal": ";" }, "test_declaration"] },
+        { "name": "test_body$ebnf$1", "symbols": ["test_body$ebnf$1", "test_body$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "test_body", "symbols": ["test_declaration", "test_body$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[1])] },
+        { "name": "assertion", "symbols": ["expression", { "literal": "shouldBe" }, "expression"], "postprocess": (d) => new Assert(new BooleanPrimitive(false), new Equality(d[2], d[0])) },
+        { "name": "assertion", "symbols": ["expression", { "literal": "`" }, { "literal": "shouldBe" }, { "literal": "`" }, "expression"], "postprocess": (d) => new Assert(new BooleanPrimitive(false), new Equality(d[4], d[0])) },
+        { "name": "assertion", "symbols": ["expression", { "literal": "shouldNotBe" }, "expression"], "postprocess": (d) => new Assert(new BooleanPrimitive(true), new Equality(d[2], d[0])) },
+        { "name": "assertion", "symbols": ["expression", { "literal": "`" }, { "literal": "shouldNotBe" }, { "literal": "`" }, "expression"], "postprocess": (d) => new Assert(new BooleanPrimitive(true), new Equality(d[4], d[0])) },
+        { "name": "assertion", "symbols": ["expression", { "literal": "shouldSatisfy" }, "expression"], "postprocess": (d) => new Assert(new BooleanPrimitive(false), new Truth(new Application(d[2], d[0]))) },
+        { "name": "assertion", "symbols": ["expression", { "literal": "`" }, { "literal": "shouldSatisfy" }, { "literal": "`" }, "expression"], "postprocess": (d) => new Assert(new BooleanPrimitive(false), new Truth(new Application(d[4], d[0]))) },
+        { "name": "assertion", "symbols": ["expression", { "literal": "shouldThrow" }, "expression"], "postprocess": (d) => new Assert(new BooleanPrimitive(false), new Failure(d[0], d[2])) },
+        { "name": "assertion", "symbols": ["expression", { "literal": "`" }, { "literal": "shouldThrow" }, { "literal": "`" }, "expression"], "postprocess": (d) => new Assert(new BooleanPrimitive(false), new Failure(d[0], d[4])) },
+        { "name": "type_cast", "symbols": ["apply_operator", { "literal": "::" }, "type"], "postprocess": (d) => new TypeCast(d[0], d[2]) },
         { "name": "type_cast", "symbols": ["apply_operator"], "postprocess": id },
-        { "name": "apply_operator", "symbols": ["bind_expression", "_", { "literal": "$" }, "_", "apply_operator"], "postprocess": (d) => new Application(d[0], d[4]) },
+        { "name": "apply_operator$subexpression$1", "symbols": [{ "literal": "$" }] },
+        { "name": "apply_operator$subexpression$1", "symbols": [{ "literal": "$!" }] },
+        { "name": "apply_operator", "symbols": ["bind_expression", "apply_operator$subexpression$1", "apply_operator"], "postprocess": (d) => new Application(d[0], d[2]) },
         { "name": "apply_operator", "symbols": ["bind_expression"], "postprocess": id },
-        { "name": "bind_expression", "symbols": ["logical_expression", "_", { "literal": ">>=" }, "_", "bind_expression"], "postprocess": (d) => new Application(new Application(new SymbolPrimitive("(>>=)"), d[0]), d[4]) },
-        { "name": "bind_expression", "symbols": ["logical_expression", "_", { "literal": ">>" }, "_", "bind_expression"], "postprocess": (d) => new Application(new Application(new SymbolPrimitive("(>>)"), d[0]), d[4]) },
+        { "name": "bind_expression", "symbols": ["logical_expression", { "literal": ">>=" }, "bind_expression"], "postprocess": (d) => new Application(new Application(new SymbolPrimitive("(>>=)"), d[0]), d[2]) },
+        { "name": "bind_expression", "symbols": ["logical_expression", { "literal": ">>" }, "bind_expression"], "postprocess": (d) => new Application(new Application(new SymbolPrimitive("(>>)"), d[0]), d[2]) },
         { "name": "bind_expression", "symbols": ["logical_expression"], "postprocess": id },
-        { "name": "logical_expression", "symbols": ["comparison", "_", { "literal": "&&" }, "_", "logical_expression"], "postprocess": (d) => new LogicalBinaryOperation("And", d[0], d[4]) },
-        { "name": "logical_expression", "symbols": ["comparison", "_", { "literal": "||" }, "_", "logical_expression"], "postprocess": (d) => new LogicalBinaryOperation("Or", d[0], d[4]) },
+        { "name": "logical_expression", "symbols": ["comparison", { "literal": "&&" }, "logical_expression"], "postprocess": (d) => new LogicalBinaryOperation("And", d[0], d[2]) },
+        { "name": "logical_expression", "symbols": ["comparison", { "literal": "||" }, "logical_expression"], "postprocess": (d) => new LogicalBinaryOperation("Or", d[0], d[2]) },
         { "name": "logical_expression", "symbols": ["comparison"], "postprocess": id },
-        { "name": "comparison", "symbols": ["cons_expression", "_", "comparison_operator", "_", "cons_expression"], "postprocess": (d) => new ComparisonOperation(d[2], d[0], d[4]) },
+        { "name": "comparison", "symbols": ["cons_expression", "comparison_operator", "cons_expression"], "postprocess": (d) => new ComparisonOperation(d[1], d[0], d[2]) },
         { "name": "comparison", "symbols": ["cons_expression"], "postprocess": id },
-        { "name": "cons_expression", "symbols": ["concatenation", "_", { "literal": ":" }, "_", "cons_expression"], "postprocess": (d) => new ConsExpression(d[0], d[4]) },
+        { "name": "cons_expression", "symbols": ["concatenation", { "literal": ":" }, "cons_expression"], "postprocess": (d) => new ConsExpression(d[0], d[2]) },
         { "name": "cons_expression", "symbols": ["concatenation"], "postprocess": id },
-        { "name": "concatenation", "symbols": ["addition", "_", { "literal": "++" }, "_", "concatenation"], "postprocess": (d) => d[0] instanceof StringPrimitive || d[4] instanceof StringPrimitive ? new StringOperation("Concat", d[0], d[4]) : new ListBinaryOperation("Concat", d[0], d[4]) },
+        { "name": "concatenation", "symbols": ["addition", { "literal": "++" }, "concatenation"], "postprocess": (d) => new ListBinaryOperation("Concat", d[0], d[2]) },
         { "name": "concatenation", "symbols": ["addition"], "postprocess": id },
-        { "name": "addition", "symbols": ["addition", "_", { "literal": "+" }, "_", "multiplication"], "postprocess": (d) => new ArithmeticBinaryOperation("Plus", d[0], d[4]) },
-        { "name": "addition", "symbols": ["addition", "_", { "literal": "-" }, "_", "multiplication"], "postprocess": (d) => new ArithmeticBinaryOperation("Minus", d[0], d[4]) },
+        { "name": "addition", "symbols": ["addition", { "literal": "+" }, "multiplication"], "postprocess": (d) => new ArithmeticBinaryOperation("Plus", d[0], d[2]) },
+        { "name": "addition", "symbols": ["addition", { "literal": "-" }, "multiplication"], "postprocess": (d) => new ArithmeticBinaryOperation("Minus", d[0], d[2]) },
         { "name": "addition", "symbols": ["multiplication"], "postprocess": id },
-        { "name": "multiplication", "symbols": ["multiplication", "_", { "literal": "*" }, "_", "power"], "postprocess": (d) => new ArithmeticBinaryOperation("Multiply", d[0], d[4]) },
-        { "name": "multiplication", "symbols": ["multiplication", "_", { "literal": "/" }, "_", "power"], "postprocess": (d) => new ArithmeticBinaryOperation("Divide", d[0], d[4]) },
+        { "name": "multiplication", "symbols": ["multiplication", { "literal": "*" }, "power"], "postprocess": (d) => new ArithmeticBinaryOperation("Multiply", d[0], d[2]) },
+        { "name": "multiplication", "symbols": ["multiplication", { "literal": "/" }, "power"], "postprocess": (d) => new ArithmeticBinaryOperation("Divide", d[0], d[2]) },
         { "name": "multiplication", "symbols": ["power"], "postprocess": id },
-        { "name": "power", "symbols": ["unary_negation", "_", { "literal": "**" }, "_", "power"], "postprocess": (d) => new ArithmeticBinaryOperation("Power", d[0], d[4]) },
-        { "name": "power", "symbols": ["unary_negation", "_", { "literal": "^" }, "_", "power"], "postprocess": (d) => new ArithmeticBinaryOperation("Power", d[0], d[4]) },
-        { "name": "power", "symbols": ["unary_negation", "_", { "literal": "^^" }, "_", "power"], "postprocess": (d) => new ArithmeticBinaryOperation("Power", d[0], d[4]) },
+        { "name": "power", "symbols": ["unary_negation", { "literal": "**" }, "power"], "postprocess": (d) => new ArithmeticBinaryOperation("Power", d[0], d[2]) },
+        { "name": "power", "symbols": ["unary_negation", { "literal": "^" }, "power"], "postprocess": (d) => new ArithmeticBinaryOperation("Power", d[0], d[2]) },
+        { "name": "power", "symbols": ["unary_negation", { "literal": "^^" }, "power"], "postprocess": (d) => new ArithmeticBinaryOperation("Power", d[0], d[2]) },
         { "name": "power", "symbols": ["unary_negation"], "postprocess": id },
-        { "name": "unary_negation", "symbols": [{ "literal": "-" }, "_", "unary_negation"], "postprocess": (d) => new ArithmeticUnaryOperation("Negation", d[2]) },
+        { "name": "unary_negation", "symbols": [{ "literal": "-" }, "unary_negation"], "postprocess": (d) => new ArithmeticUnaryOperation("Negation", d[1]) },
         { "name": "unary_negation", "symbols": ["index_access"], "postprocess": id },
-        { "name": "index_access", "symbols": ["index_access", "_", { "literal": "!!" }, "_", "composition_expression"], "postprocess": (d) => new ListBinaryOperation("GetAt", d[0], d[4]) },
+        { "name": "index_access", "symbols": ["index_access", { "literal": "!!" }, "composition_expression"], "postprocess": (d) => new ListBinaryOperation("GetAt", d[0], d[2]) },
         { "name": "index_access", "symbols": ["composition_expression"], "postprocess": id },
-        { "name": "composition_expression", "symbols": ["composition_expression", "_", { "literal": "." }, "_", "infix_operator_expression"], "postprocess": (d) => new CompositionExpression(d[0], d[4]) },
+        { "name": "composition_expression", "symbols": ["composition_expression", { "literal": "." }, "infix_operator_expression"], "postprocess": (d) => new CompositionExpression(d[0], d[2]) },
         { "name": "composition_expression", "symbols": ["infix_operator_expression"], "postprocess": id },
-        { "name": "infix_operator_expression", "symbols": ["infix_operator_expression", "_", { "literal": "`" }, "_", "variable", "_", { "literal": "`" }, "_", "application"], "postprocess": (d) => new Application(new Application(d[4], d[0]), d[8]) },
+        { "name": "infix_operator_expression", "symbols": ["infix_operator_expression", { "literal": "`" }, "variable", { "literal": "`" }, "application"], "postprocess": (d) => new Application(new Application(d[2], d[0]), d[4]) },
         { "name": "infix_operator_expression", "symbols": ["application"], "postprocess": id },
-        { "name": "application", "symbols": [{ "literal": "error" }, "__", "primary"], "postprocess": d => new Raise(d[2]) },
+        { "name": "application", "symbols": [{ "literal": "error" }, "primary"], "postprocess": d => new Raise(d[1]) },
         { "name": "application$ebnf$1", "symbols": [] },
-        { "name": "application$ebnf$1$subexpression$1$subexpression$1", "symbols": ["_"] },
-        { "name": "application$ebnf$1$subexpression$1$subexpression$1$subexpression$1", "symbols": ["_", (HSLexer.has("NL") ? { type: "NL" } : NL), "__"] },
-        { "name": "application$ebnf$1$subexpression$1$subexpression$1", "symbols": ["application$ebnf$1$subexpression$1$subexpression$1$subexpression$1"] },
-        { "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$ebnf$1", "symbols": ["application$ebnf$1", "primary"], "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[1].reduce((left, right) => new Application(left, right[1]), d[0]);
+                return d[1].reduce((left, right) => new Application(left, right), d[0]);
             } },
-        { "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$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) => new Application(new SymbolPrimitive(d[4]), d[2]) },
-        { "name": "right_section", "symbols": [{ "literal": "(" }, "_", "operator", "_", "expression", "_", { "literal": ")" }], "postprocess": (d) => {
+        { "name": "operator", "symbols": ["operator_no_minus"], "postprocess": id },
+        { "name": "operator", "symbols": [{ "literal": "-" }], "postprocess": (d) => d[0].value },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "==" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "/=" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "<" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": ">" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "<=" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "&&" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "||" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": ">=" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "++" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "+" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "," }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "^^" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "^" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "**" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "*" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "!!" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "/" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "$" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "$!" }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": "." }] },
+        { "name": "operator_no_minus$subexpression$1", "symbols": [{ "literal": ":" }] },
+        { "name": "operator_no_minus", "symbols": ["operator_no_minus$subexpression$1"], "postprocess": (d) => d[0][0].value },
+        { "name": "left_section", "symbols": [{ "literal": "(" }, "expression", "operator", { "literal": ")" }], "postprocess": (d) => new Application(new SymbolPrimitive(d[2]), d[1]) },
+        { "name": "right_section", "symbols": [{ "literal": "(" }, "operator_no_minus", "expression", { "literal": ")" }], "postprocess": (d) => {
                 const flipBody = new SymbolPrimitive("flip");
-                const op = new SymbolPrimitive(d[2]);
-                const expr = d[4];
+                const op = new SymbolPrimitive(d[1]);
+                const expr = d[2];
                 const flipAppliedToOp = new Application(flipBody, op);
                 return new Application(flipAppliedToOp, expr);
             }
         },
-        { "name": "operator_section", "symbols": [{ "literal": "(" }, "_", "operator", "_", { "literal": ")" }], "postprocess": (d) => new SymbolPrimitive(d[2]) },
+        { "name": "operator_section", "symbols": [{ "literal": "(" }, "operator", { "literal": ")" }], "postprocess": (d) => new SymbolPrimitive(d[1]) },
         { "name": "primary", "symbols": ["primitive"], "postprocess": id },
         { "name": "primary", "symbols": ["variable"], "postprocess": id },
         { "name": "primary", "symbols": ["constr"], "postprocess": id },
@@ -116,151 +146,122 @@ const grammar = {
         { "name": "primary", "symbols": ["lambda_expression"], "postprocess": id },
         { "name": "primary", "symbols": ["data_expression"], "postprocess": id },
         { "name": "primary", "symbols": ["list_comprehension"], "postprocess": id },
-        { "name": "primary", "symbols": [{ "literal": "(" }, "_", "expression", "_", { "literal": ")" }], "postprocess": (d) => d[2] },
-        { "name": "primary", "symbols": [{ "literal": "[" }, "_", "range_expression", "_", { "literal": "]" }], "postprocess": (d) => d[2] },
-        { "name": "list_comprehension", "symbols": [{ "literal": "[" }, "_", "expression", "_", { "literal": "|" }, "_", "comprehension_clause_list", "_", { "literal": "]" }], "postprocess": (d) => {
-                return new ListComprehension(d[2], d[6]);
+        { "name": "primary", "symbols": [{ "literal": "(" }, "expression", { "literal": ")" }], "postprocess": (d) => d[1] },
+        { "name": "primary", "symbols": [{ "literal": "[" }, "range_expression", { "literal": "]" }], "postprocess": (d) => d[1] },
+        { "name": "list_comprehension", "symbols": [{ "literal": "[" }, "expression", { "literal": "|" }, "comprehension_clause_list", { "literal": "]" }], "postprocess": (d) => {
+                return new ListComprehension(d[1], d[3]);
             } },
         { "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$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) => {
-                return [d[0], ...d[1].map((x) => x[3])];
+                return [d[0], ...d[1].map((x) => x[1])];
             } },
-        { "name": "comprehension_clause", "symbols": ["variable", "_", { "literal": "<-" }, "_", "expression"], "postprocess": (d) => new Generator(d[0], d[4]) },
+        { "name": "comprehension_clause", "symbols": ["variable", { "literal": "<-" }, "expression"], "postprocess": (d) => new Generator(d[0], d[2]) },
         { "name": "comprehension_clause", "symbols": ["expression"], "postprocess": id },
-        { "name": "lambda_expression", "symbols": [{ "literal": "(" }, "_", { "literal": "\\" }, "_", "parameter_list", "_", { "literal": "->" }, "_", "expression", "_", { "literal": ")" }], "postprocess": (d) => new Lambda(d[4], d[8]) },
-        { "name": "tuple_expression$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "tuple_value"] },
+        { "name": "lambda_expression", "symbols": [{ "literal": "(" }, { "literal": "\\" }, "parameter_list", { "literal": "->" }, "expression", { "literal": ")" }], "postprocess": (d) => new Lambda(d[2], d[4]) },
+        { "name": "tuple_expression$ebnf$1$subexpression$1", "symbols": [{ "literal": "," }, "expression"] },
         { "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$subexpression$2", "symbols": [{ "literal": "," }, "expression"] },
         { "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) => new TupleExpression([d[2], ...d[3].map(x => x[3])]) },
-        { "name": "tuple_value", "symbols": ["expression"], "postprocess": id },
-        { "name": "data_expression", "symbols": ["constr", "_", (HSLexer.has("lbracket") ? { type: "lbracket" } : lbracket), "_", "fields_expressions", "_", (HSLexer.has("rbracket") ? { type: "rbracket" } : rbracket)], "postprocess": (d) => new DataExpression(d[0], d[4]) },
+        { "name": "tuple_expression", "symbols": [{ "literal": "(" }, "expression", "tuple_expression$ebnf$1", { "literal": ")" }], "postprocess": (d) => new TupleExpression([d[1], ...d[2].map(x => x[1])]) },
+        { "name": "data_expression", "symbols": ["constr", (HSLexer.has("lbracket") ? { type: "lbracket" } : lbracket), "fields_expressions", (HSLexer.has("rbracket") ? { type: "rbracket" } : rbracket)], "postprocess": (d) => new DataExpression(d[0], d[2]) },
         { "name": "fields_expressions$ebnf$1", "symbols": [] },
-        { "name": "fields_expressions$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "field_exp"] },
+        { "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])] },
-        { "name": "field_exp", "symbols": ["variable", "_", { "literal": "=" }, "_", "expression"], "postprocess": (d) => new FieldExpression(d[0], d[4]) },
-        { "name": "if_expression", "symbols": [{ "literal": "if" }, "__", "expression", "__", { "literal": "then" }, "__", "expression", "__", { "literal": "else" }, "__", "expression"], "postprocess": (d) => new If(d[2], d[6], d[10]) },
-        { "name": "letin_expression$subexpression$1", "symbols": ["_", { "literal": "{" }, "_"] },
+        { "name": "fields_expressions", "symbols": ["field_exp", "fields_expressions$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[1])] },
+        { "name": "field_exp", "symbols": ["variable", { "literal": "=" }, "expression"], "postprocess": (d) => new FieldExpression(d[0], d[2]) },
+        { "name": "if_expression", "symbols": [{ "literal": "if" }, "expression", { "literal": "then" }, "expression", { "literal": "else" }, "expression"], "postprocess": (d) => new If(d[1], d[3], d[5]) },
         { "name": "letin_expression$ebnf$1", "symbols": ["bindings_list"], "postprocess": id },
         { "name": "letin_expression$ebnf$1", "symbols": [], "postprocess": () => null },
-        { "name": "letin_expression$subexpression$2", "symbols": ["_", { "literal": "}" }, "_"] },
-        { "name": "letin_expression", "symbols": [{ "literal": "let" }, "letin_expression$subexpression$1", "letin_expression$ebnf$1", "letin_expression$subexpression$2", { "literal": "in" }, "_", "expression"], "postprocess": (d) => new LetInExpression(new Sequence(d[2] ?? []), d[6]) },
-        { "name": "case_expression$subexpression$1", "symbols": ["_", { "literal": "{" }, "_"] },
-        { "name": "case_expression$subexpression$2", "symbols": ["_", { "literal": "}" }, "_"] },
-        { "name": "case_expression", "symbols": [{ "literal": "case" }, "_", "expression", "_", { "literal": "of" }, "case_expression$subexpression$1", "case_arms", "case_expression$subexpression$2"], "postprocess": (d) => new Switch(d[2], d[6]) },
+        { "name": "letin_expression", "symbols": [{ "literal": "let" }, { "literal": "{" }, "letin_expression$ebnf$1", { "literal": "}" }, { "literal": "in" }, "expression"], "postprocess": (d) => new LetInExpression(new Sequence(d[2] ?? []), d[5]) },
+        { "name": "case_expression", "symbols": [{ "literal": "case" }, "expression", { "literal": "of" }, { "literal": "{" }, "case_arms", { "literal": "}" }], "postprocess": (d) => new Switch(d[1], d[4]) },
         { "name": "case_arms$ebnf$1", "symbols": [] },
-        { "name": "case_arms$ebnf$1$subexpression$1$subexpression$1", "symbols": ["_", { "literal": ";" }, "_"] },
-        { "name": "case_arms$ebnf$1$subexpression$1", "symbols": ["case_arms$ebnf$1$subexpression$1$subexpression$1", "case_arm"] },
+        { "name": "case_arms$ebnf$1$subexpression$1", "symbols": [{ "literal": ";" }, "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])] },
-        { "name": "case_arm", "symbols": ["pattern", "_", { "literal": "->" }, "_", "expression"], "postprocess": (d) => ({ condition: d[0], body: d[4] }) },
+        { "name": "case_arm", "symbols": ["pattern", { "literal": "->" }, "expression"], "postprocess": (d) => new Case(d[0], d[2]) },
+        { "name": "typeclass_declaration", "symbols": [{ "literal": "class" }, "constr", "variable", { "literal": "where" }, (HSLexer.has("lbracket") ? { type: "lbracket" } : lbracket), "typeclass_body", (HSLexer.has("rbracket") ? { type: "rbracket" } : rbracket)], "postprocess": (d) => new TypeClass(d[1], d[2], d[5]) },
+        { "name": "typeclass_body$ebnf$1", "symbols": [] },
+        { "name": "typeclass_body$ebnf$1$subexpression$1", "symbols": [{ "literal": ";" }, "function_signature"] },
+        { "name": "typeclass_body$ebnf$1", "symbols": ["typeclass_body$ebnf$1", "typeclass_body$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "typeclass_body", "symbols": ["function_signature", "typeclass_body$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[1])] },
+        { "name": "instance_declaration", "symbols": [{ "literal": "instance" }, "constr", "type", { "literal": "where" }, (HSLexer.has("lbracket") ? { type: "lbracket" } : lbracket), "instance_body", (HSLexer.has("rbracket") ? { type: "rbracket" } : rbracket)], "postprocess": (d) => new Instance(d[1], d[2], d[5]) },
+        { "name": "instance_body$subexpression$1", "symbols": ["function_declaration"] },
+        { "name": "instance_body$subexpression$1", "symbols": ["function_signature"] },
+        { "name": "instance_body$ebnf$1", "symbols": [] },
+        { "name": "instance_body$ebnf$1$subexpression$1$subexpression$1", "symbols": ["function_declaration"] },
+        { "name": "instance_body$ebnf$1$subexpression$1$subexpression$1", "symbols": ["function_signature"] },
+        { "name": "instance_body$ebnf$1$subexpression$1", "symbols": [{ "literal": ";" }, "instance_body$ebnf$1$subexpression$1$subexpression$1"] },
+        { "name": "instance_body$ebnf$1", "symbols": ["instance_body$ebnf$1", "instance_body$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "instance_body$ebnf$2", "symbols": [{ "literal": ";" }], "postprocess": id },
+        { "name": "instance_body$ebnf$2", "symbols": [], "postprocess": () => null },
+        { "name": "instance_body", "symbols": ["instance_body$subexpression$1", "instance_body$ebnf$1", "instance_body$ebnf$2"], "postprocess": (d) => [d[0][0], ...d[1].map(x => x[1][0])] },
         { "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$1", "symbols": ["data_declaration$ebnf$1", "type_variable"], "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$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) => new Record(d[2], [d[7], ...d[8].map(x => x[3])], d[9])
+        { "name": "data_declaration", "symbols": [{ "literal": "data" }, "constr", "data_declaration$ebnf$1", { "literal": "=" }, "constructor_def", "data_declaration$ebnf$2", "data_declaration$ebnf$3"], "postprocess": (d) => new Record(d[1], [d[4], ...d[5].map(x => x[1])], d[6])
         },
-        { "name": "deriving_clause", "symbols": ["_", { "literal": "deriving" }, "_", "deriving_spec"], "postprocess": (d) => d[3] },
-        { "name": "deriving_spec", "symbols": [{ "literal": "(" }, "_", "deriving_classes", "_", { "literal": ")" }], "postprocess": (d) => d[2] },
+        { "name": "deriving_clause", "symbols": [{ "literal": "deriving" }, "deriving_spec"], "postprocess": (d) => d[1] },
+        { "name": "deriving_spec", "symbols": [{ "literal": "(" }, "deriving_classes", { "literal": ")" }], "postprocess": (d) => d[1] },
         { "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$subexpression$1", "symbols": [{ "literal": "," }, "constr"] },
         { "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) => [new SymbolPrimitive(d[0].value), ...d[1].map(x => new SymbolPrimitive(x[3].value))] },
-        { "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) => new Constructor(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) => new Constructor(d[0], d[1].map(x => new Field(undefined, x[1]))) },
+        { "name": "deriving_classes", "symbols": ["constr", "deriving_classes$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[1])] },
+        { "name": "constructor_def", "symbols": ["constr", (HSLexer.has("lbracket") ? { type: "lbracket" } : lbracket), "field_list", (HSLexer.has("rbracket") ? { type: "rbracket" } : rbracket)], "postprocess": (d) => new Constructor(d[0], d[2]) },
+        { "name": "constructor_def$ebnf$1", "symbols": [] },
+        { "name": "constructor_def$ebnf$1", "symbols": ["constructor_def$ebnf$1", "simple_type"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "constructor_def", "symbols": ["constr", "constructor_def$ebnf$1"], "postprocess": (d) => new Constructor(d[0], d[1].map(x => new Field(undefined, x))) },
         { "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$subexpression$1", "symbols": [{ "literal": "," }, "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])] },
-        { "name": "field", "symbols": ["variable", "_", (HSLexer.has("typeEquals") ? { type: "typeEquals" } : typeEquals), "_", "type"], "postprocess": (d) => new Field(d[0], d[4]) },
-        { "name": "binding_name", "symbols": [{ "literal": "(" }, "_", (HSLexer.has("op") ? { type: "op" } : op), "_", { "literal": ")" }], "postprocess": d => new SymbolPrimitive(`${d[2].value}`) },
+        { "name": "field_list", "symbols": ["field", "field_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[1])] },
+        { "name": "field", "symbols": ["variable", { "literal": "::" }, "type"], "postprocess": (d) => new Field(d[0], d[2]) },
+        { "name": "op_name", "symbols": [{ "literal": "(" }, "operator", { "literal": ")" }], "postprocess": d => new SymbolPrimitive(d[1]) },
+        { "name": "binding_name", "symbols": ["op_name"], "postprocess": id },
         { "name": "binding_name", "symbols": ["variable"], "postprocess": id },
-        { "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", "symbols": ["binding_name", "function_signature$ebnf$1", "_", (HSLexer.has("typeEquals") ? { type: "typeEquals" } : typeEquals), "_", "type"], "postprocess": (d) => new TypeSignature(d[0], d[5]) },
-        { "name": "function_declaration", "symbols": ["variable", "equation"], "postprocess": (d) => new Function(d[0], [d[1]]) },
-        { "name": "function_declaration", "symbols": [{ "literal": "(" }, "_", (HSLexer.has("op") ? { type: "op" } : op), "_", { "literal": ")" }, "equation"], "postprocess": (d) => new Function(new SymbolPrimitive(`${d[2].value}`), [d[5]]) },
+        { "name": "function_signature", "symbols": ["binding_name", { "literal": "::" }, "type"], "postprocess": (d) => new TypeSignature(d[0], d[2]) },
+        { "name": "function_declaration", "symbols": ["binding_name", "equation"], "postprocess": (d) => new Function(d[0], [d[1]]) },
         { "name": "return_expression", "symbols": ["expression"], "postprocess": d => new Return(d[0]) },
-        { "name": "where_clause", "symbols": [{ "literal": "where" }, "_", { "literal": "{" }, "_", "bindings_list", "_", { "literal": "}" }], "postprocess": d => d[4] },
-        { "name": "bindings_list$ebnf$1", "symbols": [] },
-        { "name": "bindings_list$ebnf$1$subexpression$1$subexpression$1", "symbols": ["_", { "literal": ";" }, "_"] },
-        { "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])] },
-        { "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": "where_clause", "symbols": [{ "literal": "where" }, { "literal": "{" }, "bindings_list", { "literal": "}" }], "postprocess": d => d[2] },
+        { "name": "bindings_list", "symbols": ["function_declaration", { "literal": ";" }, "bindings_list"], "postprocess": d => [d[0], ...d[2]] },
+        { "name": "bindings_list", "symbols": ["function_declaration"], "postprocess": d => [d[0]] },
+        { "name": "equation$ebnf$1", "symbols": ["where_clause"], "postprocess": id },
         { "name": "equation$ebnf$1", "symbols": [], "postprocess": () => null },
-        { "name": "equation$ebnf$2$subexpression$1", "symbols": ["_", "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 finalBody = d[3]
-                    ? new LetInExpression(d[3], body)
+        { "name": "equation", "symbols": ["params", "guarded_rhs", "equation$ebnf$1"], "postprocess": (d) => {
+                const body = d[1];
+                const finalBody = d[2]
+                    ? body.map(guard => new GuardedBody(guard.condition, new Sequence([...d[2], new Return(guard.body)])))
                     : body;
                 return new Equation(d[0], finalBody);
             } },
-        { "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", "symbols": ["_", "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 => new Equation(d[0], new UnguardedBody(new Sequence(d[4] ? [...d[4][1], d[3]] : [d[3]])), d[3]) },
-        { "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) => new GuardedBody(d[2], d[6]) },
+        { "name": "equation$ebnf$2", "symbols": ["where_clause"], "postprocess": id },
+        { "name": "equation$ebnf$2", "symbols": [], "postprocess": () => null },
+        { "name": "equation", "symbols": ["params", (HSLexer.has("assign") ? { type: "assign" } : assign), "return_expression", "equation$ebnf$2"], "postprocess": d => new Equation(d[0], new UnguardedBody(new Sequence(d[3] ? [...d[3], d[2]] : [d[2]])), d[2]) },
+        { "name": "params$ebnf$1", "symbols": ["parameter_list"], "postprocess": id },
+        { "name": "params$ebnf$1", "symbols": [], "postprocess": () => null },
+        { "name": "params", "symbols": ["params$ebnf$1"], "postprocess": (d) => d[0] || [] },
+        { "name": "guarded_rhs$ebnf$1", "symbols": ["guarded_branch"] },
+        { "name": "guarded_rhs$ebnf$1", "symbols": ["guarded_rhs$ebnf$1", "guarded_branch"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "guarded_rhs", "symbols": ["guarded_rhs$ebnf$1"], "postprocess": (d) => d[0] },
+        { "name": "guarded_branch", "symbols": [{ "literal": "|" }, "condition", { "literal": "=" }, "expression"], "postprocess": (d) => new GuardedBody(d[1], d[3]) },
         { "name": "condition", "symbols": [{ "literal": "otherwise" }], "postprocess": d => new 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])] },
+        { "name": "parameter_list$ebnf$1", "symbols": ["pattern"] },
+        { "name": "parameter_list$ebnf$1", "symbols": ["parameter_list$ebnf$1", "pattern"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "parameter_list", "symbols": ["parameter_list$ebnf$1"], "postprocess": id },
         { "name": "pattern", "symbols": ["cons_pattern"], "postprocess": id },
-        { "name": "cons_pattern$ebnf$1$subexpression$1", "symbols": ["_", { "literal": ":" }, "_", "cons_pattern"] },
+        { "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$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) => {
-                const patterns = [d[2], ...d[3].map(item => item[3])];
+        { "name": "cons_pattern", "symbols": [{ "literal": "(" }, "cons_pattern", "cons_pattern$ebnf$1", { "literal": ")" }], "postprocess": (d) => {
+                const patterns = [d[1], ...d[2].map(item => item[1])];
                 return patterns.reduceRight((tail, head, index, arr) => {
                     if (index === arr.length - 1)
                         return tail;
@@ -279,68 +280,56 @@ const grammar = {
         { "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) => new WildcardPattern() },
-        { "name": "paren_pattern", "symbols": [{ "literal": "(" }, "_", "pattern", "_", { "literal": ")" }], "postprocess": (d) => d[2] },
+        { "name": "paren_pattern", "symbols": [{ "literal": "(" }, "pattern", { "literal": ")" }], "postprocess": (d) => d[1] },
         { "name": "variable_pattern", "symbols": ["variable"], "postprocess": (d) => new VariablePattern(d[0]) },
         { "name": "literal_pattern", "symbols": ["primitive"], "postprocess": (d) => new LiteralPattern(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) => new AsPattern(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) => new ConstructorPattern(d[2].value, d[3].map(x => x[1])) },
-        { "name": "constructor_pattern", "symbols": ["constr"], "postprocess": (d) => new ConstructorPattern(d[0].value, []) },
+        { "name": "constructor_pattern$ebnf$1", "symbols": ["pattern"] },
+        { "name": "constructor_pattern$ebnf$1", "symbols": ["constructor_pattern$ebnf$1", "pattern"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "constructor_pattern", "symbols": [{ "literal": "(" }, "constr", "constructor_pattern$ebnf$1", { "literal": ")" }], "postprocess": (d) => new ConstructorPattern(d[1], d[2]) },
+        { "name": "constructor_pattern", "symbols": ["constr"], "postprocess": (d) => new ConstructorPattern(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$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])] },
-        { "name": "field_pattern", "symbols": ["variable", "_", { "literal": "=" }, "_", "pattern"], "postprocess": (d) => ({ field: d[0].value, pattern: d[4] }) },
+        { "name": "field_pattern_list", "symbols": ["field_pattern", "field_pattern_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[1])] },
+        { "name": "field_pattern", "symbols": ["variable", { "literal": "=" }, "pattern"], "postprocess": (d) => ({ field: d[0].value, pattern: d[2] }) },
         { "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) => new ListPattern(d[2] || []) },
+        { "name": "list_pattern", "symbols": [{ "literal": "[" }, "list_pattern$ebnf$1", { "literal": "]" }], "postprocess": (d) => new ListPattern(d[1] || []) },
         { "name": "pattern_list$ebnf$1", "symbols": [] },
-        { "name": "pattern_list$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "pattern"] },
+        { "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])] },
-        { "name": "tuple_pattern$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "pattern"] },
+        { "name": "pattern_list", "symbols": ["pattern", "pattern_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[1])] },
+        { "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$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) => new TuplePattern([d[2], ...d[3].map(x => x[3])]) },
-        { "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": "tuple_pattern", "symbols": [{ "literal": "(" }, "pattern", "tuple_pattern$ebnf$1", { "literal": ")" }], "postprocess": (d) => new TuplePattern([d[1], ...d[2].map(x => x[1])]) },
+        { "name": "type_declaration$ebnf$1", "symbols": ["variable_list"], "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) => new TypeAlias(d[2], d[3] ? d[3][1] : [], d[7]) },
+        { "name": "type_declaration", "symbols": [{ "literal": "type" }, "constr", "type_declaration$ebnf$1", { "literal": "=" }, "type"], "postprocess": (d) => new TypeAlias(d[1], d[2] || [], d[4]) },
         { "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].value, ...d[1].map(x => x[1].value)] },
+        { "name": "variable_list$ebnf$1", "symbols": ["variable_list$ebnf$1", "variable"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "variable_list", "symbols": ["variable", "variable_list$ebnf$1"], "postprocess": (d) => [d[0].value, ...d[1]] },
         { "name": "type", "symbols": ["function_type"], "postprocess": id },
-        { "name": "constrained_type", "symbols": ["constraint_list", "_", (HSLexer.has("arrow") ? { type: "arrow" } : arrow), "_", "type"], "postprocess": (d) => new ParameterizedType([], d[4], d[0]) },
+        { "name": "constrained_type", "symbols": ["constraint_list", { "literal": "=>" }, "type"], "postprocess": (d) => new ParameterizedType([], d[2], d[0]) },
         { "name": "context", "symbols": ["constraint"], "postprocess": (d) => [d[0]] },
-        { "name": "context", "symbols": [{ "literal": "(" }, "_", "constraint_list", "_", { "literal": ")" }], "postprocess": (d) => d[2] },
+        { "name": "context", "symbols": [{ "literal": "(" }, "constraint_list", { "literal": ")" }], "postprocess": (d) => d[1] },
         { "name": "constraint_list$ebnf$1", "symbols": [] },
-        { "name": "constraint_list$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "constraint"] },
+        { "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])]
+        { "name": "constraint_list", "symbols": ["constraint", "constraint_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[1])]
         },
-        { "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) => new Constraint(d[0].value, d[1].map(x => x[1])) },
-        { "name": "function_type$ebnf$1$subexpression$1", "symbols": ["context", "_", (HSLexer.has("arrow") ? { type: "arrow" } : arrow), "_"] },
+        { "name": "constraint$ebnf$1", "symbols": ["application_type"] },
+        { "name": "constraint$ebnf$1", "symbols": ["constraint$ebnf$1", "application_type"], "postprocess": (d) => d[0].concat([d[1]]) },
+        { "name": "constraint", "symbols": ["constr", "constraint$ebnf$1"], "postprocess": (d) => new Constraint(d[0].value, d[1]) },
+        { "name": "function_type$ebnf$1$subexpression$1", "symbols": ["context", { "literal": "=>" }] },
         { "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$subexpression$1", "symbols": ["application_type", (HSLexer.has("typeArrow") ? { type: "typeArrow" } : typeArrow)] },
         { "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] : [];
@@ -351,36 +340,32 @@ const grammar = {
                 return new ParameterizedType([], d[2], constraints);
             }
         },
-        { "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[1].reduce((acc, arg) => new TypeApplication(acc, arg[1]), d[0]) },
+        { "name": "application_type", "symbols": ["simple_type", "application_type"], "postprocess": (d) => new TypeApplication(d[0], d[1]) },
         { "name": "application_type", "symbols": ["simple_type"], "postprocess": id },
         { "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) => new SimpleType(d[0][0].value, []) },
-        { "name": "simple_type", "symbols": [{ "literal": "[" }, "_", "type", "_", { "literal": "]" }], "postprocess": (d) => new ListType(d[2], []) },
-        { "name": "simple_type$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "type"] },
+        { "name": "simple_type", "symbols": [{ "literal": "[" }, "type", { "literal": "]" }], "postprocess": (d) => new ListType(d[1], []) },
+        { "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$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) => new TupleType([d[2], ...d[3].map(x => x[3])], []) },
-        { "name": "simple_type", "symbols": [{ "literal": "(" }, "_", "type", "_", { "literal": ")" }], "postprocess": (d) => d[2] },
+        { "name": "simple_type", "symbols": [{ "literal": "(" }, "type", "simple_type$ebnf$1", { "literal": ")" }], "postprocess": (d) => new TupleType([d[1], ...d[2].map(x => x[1])], []) },
+        { "name": "simple_type", "symbols": [{ "literal": "(" }, "type", { "literal": ")" }], "postprocess": (d) => d[1] },
         { "name": "type_variable", "symbols": ["variable"], "postprocess": ([v]) => ({ value: v.value }) },
         { "name": "type_constructor", "symbols": ["constr"], "postprocess": ([c]) => ({ value: c.value }) },
         { "name": "constr", "symbols": [(HSLexer.has("constructor") ? { type: "constructor" } : constructor)], "postprocess": ([c]) => new SymbolPrimitive(c.value, loc(c)) },
         { "name": "variable", "symbols": [(HSLexer.has("variable") ? { type: "variable" } : variable)], "postprocess": ([v]) => new SymbolPrimitive(v.value, loc(v)) },
-        { "name": "list_literal", "symbols": [{ "literal": "[" }, "_", { "literal": "]" }], "postprocess": (_) => new ListPrimitive([]) },
-        { "name": "list_literal", "symbols": [{ "literal": "[" }, "_", "expression_list", "_", { "literal": "]" }], "postprocess": ([_, __, list]) => new ListPrimitive(list) },
-        { "name": "range_expression", "symbols": ["expression", "_", { "literal": ".." }], "postprocess": (d) => new RangeExpression(d[0]) },
-        { "name": "range_expression", "symbols": ["expression", "_", { "literal": ".." }, "_", "expression"], "postprocess": (d) => new RangeExpression(d[0], d[4]) },
-        { "name": "range_expression", "symbols": ["expression", "_", { "literal": "," }, "_", "expression", "_", { "literal": ".." }], "postprocess": (d) => new RangeExpression(d[0], undefined, d[4]) },
-        { "name": "range_expression", "symbols": ["expression", "_", { "literal": "," }, "_", "expression", "_", { "literal": ".." }, "_", "expression"], "postprocess": (d) => new RangeExpression(d[0], d[6], d[4]) },
+        { "name": "list_literal", "symbols": [{ "literal": "[" }, { "literal": "]" }], "postprocess": (_) => new ListPrimitive([]) },
+        { "name": "list_literal", "symbols": [{ "literal": "[" }, "expression_list", { "literal": "]" }], "postprocess": (d) => new ListPrimitive(d[1]) },
+        { "name": "range_expression", "symbols": ["expression", { "literal": ".." }], "postprocess": (d) => new RangeExpression(d[0]) },
+        { "name": "range_expression", "symbols": ["expression", { "literal": ".." }, "expression"], "postprocess": (d) => new RangeExpression(d[0], d[2]) },
+        { "name": "range_expression", "symbols": ["expression", { "literal": "," }, "expression", { "literal": ".." }], "postprocess": (d) => new RangeExpression(d[0], undefined, d[2]) },
+        { "name": "range_expression", "symbols": ["expression", { "literal": "," }, "expression", { "literal": ".." }, "expression"], "postprocess": (d) => new RangeExpression(d[0], d[4], d[2]) },
         { "name": "expression_list$ebnf$1", "symbols": [] },
-        { "name": "expression_list$ebnf$1$subexpression$1", "symbols": ["_", { "literal": "," }, "_", "expression"] },
+        { "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])] },
+        { "name": "expression_list", "symbols": ["expression", "expression_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[1])] },
         { "name": "comparison_operator", "symbols": [{ "literal": "==" }], "postprocess": (d) => "Equal" },
         { "name": "comparison_operator", "symbols": [{ "literal": "/=" }], "postprocess": (d) => "NotEqual" },
         { "name": "comparison_operator", "symbols": [{ "literal": "<" }], "postprocess": (d) => "LessThan" },
@@ -388,15 +373,19 @@ const grammar = {
         { "name": "comparison_operator", "symbols": [{ "literal": "<=" }], "postprocess": (d) => "LessOrEqualThan" },
         { "name": "comparison_operator", "symbols": [{ "literal": ">=" }], "postprocess": (d) => "GreaterOrEqualThan" },
         { "name": "primitive", "symbols": [(HSLexer.has("number") ? { type: "number" } : number)], "postprocess": ([n]) => new NumberPrimitive(Number(n.value), loc(n)) },
-        { "name": "primitive", "symbols": [(HSLexer.has("char") ? { type: "char" } : char)], "postprocess": ([c]) => new CharPrimitive(c.value, loc(c)) },
-        { "name": "primitive", "symbols": [(HSLexer.has("string") ? { type: "string" } : string)], "postprocess": ([s]) => new StringPrimitive(s.value.slice(1, -1), loc(s)) },
-        { "name": "primitive", "symbols": [(HSLexer.has("bool") ? { type: "bool" } : bool)], "postprocess": ([b]) => new BooleanPrimitive(b.value === 'True' ? true : false, loc(b)) },
-        { "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"] }
+        { "name": "primitive", "symbols": [(HSLexer.has("char") ? { type: "char" } : char)], "postprocess": ([c]) => new CharPrimitive(c.value.slice(1, -1), loc(c)) },
+        { "name": "primitive", "symbols": [(HSLexer.has("string") ? { type: "string" } : string)], "postprocess": ([s]) => {
+                let val = s.value.slice(1, -1);
+                // Haskell multiline string continuation: \ whitespace \
+                val = val.replace(/\\\s+\\/g, "");
+                // Standard escapes
+                val = val.replace(/\\n/g, "\n")
+                    .replace(/\\t/g, "\t")
+                    .replace(/\\"/g, "\"")
+                    .replace(/\\\\/g, "\\");
+                return new StringPrimitive(val, loc(s));
+            } },
+        { "name": "primitive", "symbols": [(HSLexer.has("bool") ? { type: "bool" } : bool)], "postprocess": ([b]) => new BooleanPrimitive(b.value === 'True' ? true : false, loc(b)) }
     ],
     ParserStart: "program",
 };