yukigo-haskell-parser 0.1.0 → 0.1.2

package/src/parser/grammar.ts

@@ -3,16 +3,10 @@
 // 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;
@@ -20,9 +14,8 @@ 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"
+import { HaskellLayoutLexer } from "./lexer.js"
 import {
   TypeCast,
   Application,
@@ -36,6 +29,7 @@ import {
   ListUnaryOperation,
   ArithmeticUnaryOperation,
   LogicalUnaryOperation,
+  Case,
   SymbolPrimitive,
   ListPrimitive,
   Switch,
@@ -76,11 +70,19 @@ import {
   SimpleType,
   ListType,
   TupleType,
+  TypeClass,
+  Instance,
   NumberPrimitive,
   CharPrimitive,
   StringPrimitive,
   BooleanPrimitive,
-  SourceLocation
+  SourceLocation,
+  TestGroup,
+  Test,
+  Assert,
+  Equality,
+  Truth,
+  Failure
 } from "yukigo-ast";
 
 const filter = d => {
@@ -88,6 +90,7 @@ const filter = d => {
 };
 
 const loc = (token) => new SourceLocation(token.line, token.col);
+const HSLexer = new HaskellLayoutLexer();
 
 
 interface NearleyToken {
@@ -120,94 +123,123 @@ interface Grammar {
 const grammar: 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},
@@ -219,153 +251,124 @@ const grammar: 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":  
+    {"name": "cons_pattern", "symbols": [{"literal":"("}, "cons_pattern", "cons_pattern$ebnf$1", {"literal":")"}], "postprocess":  
         (d) => {
-          const patterns = [d[2], ...d[3].map(item => item[3])];
+          const patterns = [d[1], ...d[2].map(item => item[1])];
           return patterns.reduceRight((tail, head, index, arr) => {
             if (index === arr.length - 1) return tail;
             return new ConsPattern(head, tail);
@@ -383,69 +386,57 @@ const grammar: 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])]
+        [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] : [];
@@ -459,36 +450,32 @@ const grammar: 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"},
@@ -496,15 +483,19 @@ const grammar: 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",
 };