yukigo-haskell-parser 0.1.3 → 0.2.2

package/src/parser/{grammar.ts → grammar.cjs}

@@ -1,133 +1,94 @@
 // Generated automatically by nearley, version 2.20.1
 // http://github.com/Hardmath123/nearley
-// Bypasses TS6133. Allow declared but unused functions.
-// @ts-ignore
-function id(d: any[]): any { return d[0]; }
-declare var lbracket: any;
-declare var rbracket: any;
-declare var assign: any;
-declare var anonymousVariable: any;
-declare var typeArrow: any;
-declare var constructor: any;
-declare var variable: any;
-declare var number: any;
-declare var char: any;
-declare var string: any;
-declare var bool: any;
-
-import { HaskellLayoutLexer } from "./lexer.js"
-import {
-  TypeCast,
-  Application,
-  ConsExpression,
-  StringOperation,
-  LogicalBinaryOperation,
-  ComparisonOperation,
-  ArithmeticBinaryOperation,
-  Print,
-  ListBinaryOperation,
-  ListUnaryOperation,
-  ArithmeticUnaryOperation,
-  LogicalUnaryOperation,
-  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();
-
-
-interface NearleyToken {
-  value: any;
-  [key: string]: any;
-};
-
-interface NearleyLexer {
-  reset: (chunk: string, info: any) => void;
-  next: () => NearleyToken | undefined;
-  save: () => any;
-  formatError: (token: never) => string;
-  has: (tokenType: string) => boolean;
-};
-
-interface NearleyRule {
-  name: string;
-  symbols: NearleySymbol[];
-  postprocess?: (d: any[], loc?: number, reject?: {}) => any;
-};
-
-type NearleySymbol = string | { literal: any } | { test: (token: any) => boolean };
-
-interface Grammar {
-  Lexer: NearleyLexer | undefined;
-  ParserRules: NearleyRule[];
-  ParserStart: string;
-};
-
-const grammar: Grammar = {
-  Lexer: HSLexer,
-  ParserRules: [
+(function () {
+function id(x) { return x[0]; }
+
+const { HaskellLayoutLexer } = require("./lexer.js")
+const {
+  TypeCast,
+  Application,
+  ConsExpression,
+  StringOperation,
+  LogicalBinaryOperation,
+  ComparisonOperation,
+  ArithmeticBinaryOperation,
+  Print,
+  ListBinaryOperation,
+  ListUnaryOperation,
+  ArithmeticUnaryOperation,
+  LogicalUnaryOperation,
+  Case,
+  SymbolPrimitive,
+  ListPrimitive,
+  Switch,
+  CompositionExpression,
+  Lambda,
+  TupleExpression,
+  DataExpression,
+  Function,
+  FieldExpression,
+  If,
+  Record,
+  Constructor,
+  Field,
+  ListComprehension, 
+  Generator,
+  RangeExpression,
+  TypeSignature,
+  Return,
+  GuardedExpression,
+  Guard,
+  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
+} = require("yukigo-ast");
+
+const filter = d => {
+    return d.filter((token) => token !== null);
+};
+
+const loc = (token) => new SourceLocation(token.line, token.col);
+const HSLexer = new HaskellLayoutLexer();
+
+var grammar = {
+    Lexer: HSLexer,
+    ParserRules: [
     {"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$1", "symbols": ["program$ebnf$1", "program$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"name": "program$ebnf$2", "symbols": [{"literal":";"}], "postprocess": id},
-    {"name": "program$ebnf$2", "symbols": [], "postprocess": () => null},
+    {"name": "program$ebnf$2", "symbols": [], "postprocess": function(d) {return 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"]},
@@ -137,8 +98,7 @@ const grammar: Grammar = {
     {"name": "declaration$subexpression$1", "symbols": ["instance_declaration"]},
     {"name": "declaration$subexpression$1", "symbols": ["apply_operator"]},
     {"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": "declaration", "symbols": ["declaration$subexpression$1"], "postprocess": (d) => d[0][0]},
     {"name": "expression$subexpression$1", "symbols": ["type_cast"]},
     {"name": "expression$subexpression$1", "symbols": ["letin_expression"]},
     {"name": "expression$subexpression$1", "symbols": ["if_expression"]},
@@ -149,11 +109,11 @@ const grammar: Grammar = {
     {"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": [{"literal":"let"}, (HSLexer.has("lbracket") ? {type: "lbracket"} : lbracket), "function_declaration", (HSLexer.has("rbracket") ? {type: "rbracket"} : rbracket)], "postprocess": (d) => d[2]},
     {"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$ebnf$1", "symbols": ["test_body$ebnf$1", "test_body$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return 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]))},
@@ -201,10 +161,10 @@ const grammar: Grammar = {
     {"name": "infix_operator_expression", "symbols": ["application"], "postprocess": id},
     {"name": "application", "symbols": [{"literal":"error"}, "primary"], "postprocess": d => new Raise(d[1])},
     {"name": "application$ebnf$1", "symbols": []},
-    {"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), d[0]);
+    {"name": "application$ebnf$1", "symbols": ["application$ebnf$1", "primary"], "postprocess": function arrpush(d) {return 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), d[0]);
         } },
     {"name": "operator", "symbols": ["operator_no_minus"], "postprocess": id},
     {"name": "operator", "symbols": [{"literal":"-"}], "postprocess": (d) => d[0].value},
@@ -231,13 +191,13 @@ const grammar: Grammar = {
     {"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[1]);
-          const expr = d[2];
-          const flipAppliedToOp = new Application(flipBody, op);
-          return new Application(flipAppliedToOp, expr);
-        }
+    {"name": "right_section", "symbols": [{"literal":"("}, "operator_no_minus", "expression", {"literal":")"}], "postprocess":  (d) => {
+          const flipBody = new SymbolPrimitive("flip");
+          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[1])},
     {"name": "primary", "symbols": ["primitive"], "postprocess": id},
@@ -253,14 +213,14 @@ const grammar: Grammar = {
     {"name": "primary", "symbols": ["list_comprehension"], "postprocess": id},
     {"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": "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", "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[1])];
+    {"name": "comprehension_clause_list$ebnf$1", "symbols": ["comprehension_clause_list$ebnf$1", "comprehension_clause_list$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return 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[1])];
         } },
     {"name": "comprehension_clause", "symbols": ["variable", {"literal":"<-"}, "expression"], "postprocess": (d) => new Generator(d[0], d[2])},
     {"name": "comprehension_clause", "symbols": ["expression"], "postprocess": id},
@@ -268,28 +228,28 @@ const grammar: Grammar = {
     {"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":","}, "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$ebnf$1", "symbols": ["tuple_expression$ebnf$1", "tuple_expression$ebnf$1$subexpression$2"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"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", "symbols": ["fields_expressions$ebnf$1", "fields_expressions$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "fields_expressions$ebnf$1", "symbols": ["fields_expressions$ebnf$1", "fields_expressions$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"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$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
     {"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", "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$ebnf$1", "symbols": ["case_arms$ebnf$1", "case_arms$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return 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) => 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$ebnf$1", "symbols": ["typeclass_body$ebnf$1", "typeclass_body$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return 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"]},
@@ -298,34 +258,34 @@ const grammar: Grammar = {
     {"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$1", "symbols": ["instance_body$ebnf$1", "instance_body$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return 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$ebnf$2", "symbols": [], "postprocess": function(d) {return 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", "symbols": ["data_declaration$ebnf$1", "type_variable"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "data_declaration$ebnf$1", "symbols": ["data_declaration$ebnf$1", "type_variable"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"name": "data_declaration$ebnf$2", "symbols": []},
     {"name": "data_declaration$ebnf$2$subexpression$1", "symbols": [{"literal":"|"}, "constructor_def"]},
-    {"name": "data_declaration$ebnf$2", "symbols": ["data_declaration$ebnf$2", "data_declaration$ebnf$2$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "data_declaration$ebnf$2", "symbols": ["data_declaration$ebnf$2", "data_declaration$ebnf$2$subexpression$1"], "postprocess": function arrpush(d) {return 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[1], [d[4], ...d[5].map(x => x[1])], d[6])
+    {"name": "data_declaration$ebnf$3", "symbols": [], "postprocess": function(d) {return 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[1], [d[4], ...d[5].map(x => x[1])], d[6])
         },
     {"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":","}, "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$ebnf$1", "symbols": ["deriving_classes$ebnf$1", "deriving_classes$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[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$ebnf$1", "symbols": ["constructor_def$ebnf$1", "simple_type"], "postprocess": function arrpush(d) {return 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", "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$ebnf$1", "symbols": ["field_list$ebnf$1", "field_list$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"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])},
@@ -338,42 +298,46 @@ const grammar: Grammar = {
     {"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", "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$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
+    {"name": "equation", "symbols": ["params", "guarded_rhs", "equation$ebnf$1"], "postprocess":  (d) => {
+            const guardsExpr = new GuardedExpression(d[1]);
+            const locals = d[2] || [];
+            const returnExpr = new Return(guardsExpr);
+            const sequence = new Sequence([...locals, returnExpr]);
+            
+            return new Equation(d[0], new UnguardedBody(sequence), returnExpr);
         } },
     {"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": "equation$ebnf$2", "symbols": [], "postprocess": function(d) {return null;}},
+    {"name": "equation", "symbols": ["params", (HSLexer.has("assign") ? {type: "assign"} : assign), "return_expression", "equation$ebnf$2"], "postprocess":  (d) => {
+            const locals = d[3] || [];
+            return new Equation(d[0], new UnguardedBody(new Sequence([...locals, d[2]])), d[2]);
+        } },
     {"name": "params$ebnf$1", "symbols": ["parameter_list"], "postprocess": id},
-    {"name": "params$ebnf$1", "symbols": [], "postprocess": () => null},
+    {"name": "params$ebnf$1", "symbols": [], "postprocess": function(d) {return 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$ebnf$1", "symbols": ["guarded_rhs$ebnf$1", "guarded_branch"], "postprocess": function arrpush(d) {return 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": "guarded_branch", "symbols": [{"literal":"|"}, "condition", {"literal":"="}, "expression"], "postprocess": (d) => new Guard(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": ["pattern"]},
-    {"name": "parameter_list$ebnf$1", "symbols": ["parameter_list$ebnf$1", "pattern"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "parameter_list$ebnf$1", "symbols": ["parameter_list$ebnf$1", "pattern"], "postprocess": function arrpush(d) {return 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", "symbols": ["cons_pattern$ebnf$1$subexpression$1"]},
     {"name": "cons_pattern$ebnf$1$subexpression$2", "symbols": [{"literal":":"}, "cons_pattern"]},
-    {"name": "cons_pattern$ebnf$1", "symbols": ["cons_pattern$ebnf$1", "cons_pattern$ebnf$1$subexpression$2"], "postprocess": (d) => d[0].concat([d[1]])},
-    {"name": "cons_pattern", "symbols": [{"literal":"("}, "cons_pattern", "cons_pattern$ebnf$1", {"literal":")"}], "postprocess":  
-        (d) => {
-          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);
-          });
-        }
+    {"name": "cons_pattern$ebnf$1", "symbols": ["cons_pattern$ebnf$1", "cons_pattern$ebnf$1$subexpression$2"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
+    {"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;
+            return new ConsPattern(head, tail);
+          });
+        }
           },
     {"name": "cons_pattern", "symbols": ["simple_pattern"], "postprocess": id},
     {"name": "simple_pattern$subexpression$1", "symbols": ["as_pattern"]},
@@ -393,31 +357,31 @@ const grammar: Grammar = {
     {"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", "symbols": ["pattern"]},
-    {"name": "constructor_pattern$ebnf$1", "symbols": ["constructor_pattern$ebnf$1", "pattern"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "constructor_pattern$ebnf$1", "symbols": ["constructor_pattern$ebnf$1", "pattern"], "postprocess": function arrpush(d) {return 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", "symbols": ["field_pattern_list$ebnf$1", "field_pattern_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "field_pattern_list$ebnf$1", "symbols": ["field_pattern_list$ebnf$1", "field_pattern_list$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return 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[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$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
     {"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", "symbols": ["pattern_list$ebnf$1", "pattern_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "pattern_list$ebnf$1", "symbols": ["pattern_list$ebnf$1", "pattern_list$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"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", "symbols": ["tuple_pattern$ebnf$1", "tuple_pattern$ebnf$1$subexpression$2"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "tuple_pattern$ebnf$1", "symbols": ["tuple_pattern$ebnf$1", "tuple_pattern$ebnf$1$subexpression$2"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"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$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
     {"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", "symbols": ["variable_list$ebnf$1", "variable"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "variable_list$ebnf$1", "symbols": ["variable_list$ebnf$1", "variable"], "postprocess": function arrpush(d) {return 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", {"literal":"=>"}, "type"], "postprocess": (d) => new ParameterizedType([], d[2], d[0])},
@@ -425,30 +389,30 @@ const grammar: Grammar = {
     {"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", "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[1])]
+    {"name": "constraint_list$ebnf$1", "symbols": ["constraint_list$ebnf$1", "constraint_list$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
+    {"name": "constraint_list", "symbols": ["constraint", "constraint_list$ebnf$1"], "postprocess":  (d) => 
+        [d[0], ...d[1].map(x => x[1])]
           },
     {"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$ebnf$1", "symbols": ["constraint$ebnf$1", "application_type"], "postprocess": function arrpush(d) {return 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$1", "symbols": [], "postprocess": function(d) {return null;}},
     {"name": "function_type$ebnf$2", "symbols": []},
     {"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] : [];
-            
-            if (d[1].length > 0) 
-                return new ParameterizedType(d[1].map(x => x[0]), d[2], constraints);
-            
-            if (constraints.length === 0) 
-                return d[2];
-        
-            return new ParameterizedType([], d[2], constraints);
-        } 
+    {"name": "function_type$ebnf$2", "symbols": ["function_type$ebnf$2", "function_type$ebnf$2$subexpression$1"], "postprocess": function arrpush(d) {return 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] : [];
+            
+            if (d[1].length > 0) 
+                return new ParameterizedType(d[1].map(x => x[0]), d[2], constraints);
+            
+            if (constraints.length === 0) 
+                return d[2];
+        
+            return new ParameterizedType([], d[2], constraints);
+        } 
         },
     {"name": "application_type", "symbols": ["simple_type", "application_type"], "postprocess": (d) => new TypeApplication(d[0], d[1])},
     {"name": "application_type", "symbols": ["simple_type"], "postprocess": id},
@@ -459,7 +423,7 @@ const grammar: Grammar = {
     {"name": "simple_type$ebnf$1$subexpression$1", "symbols": [{"literal":","}, "type"]},
     {"name": "simple_type$ebnf$1", "symbols": ["simple_type$ebnf$1$subexpression$1"]},
     {"name": "simple_type$ebnf$1$subexpression$2", "symbols": [{"literal":","}, "type"]},
-    {"name": "simple_type$ebnf$1", "symbols": ["simple_type$ebnf$1", "simple_type$ebnf$1$subexpression$2"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "simple_type$ebnf$1", "symbols": ["simple_type$ebnf$1", "simple_type$ebnf$1$subexpression$2"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"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 })},
@@ -474,7 +438,7 @@ const grammar: Grammar = {
     {"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", "symbols": ["expression_list$ebnf$1", "expression_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "expression_list$ebnf$1", "symbols": ["expression_list$ebnf$1", "expression_list$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"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"},
@@ -484,20 +448,24 @@ const grammar: Grammar = {
     {"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.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("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",
-};
-
-export default grammar;
+]
+  , ParserStart: "program"
+}
+if (typeof module !== 'undefined'&& typeof module.exports !== 'undefined') {
+   module.exports = grammar;
+} else {
+   window.grammar = grammar;
+}
+})();