@scinorandex/sparse 0.0.1

package/example/LoLang/example.ts

@@ -0,0 +1,214 @@
+import fs from "fs/promises";
+import { buildProductions, LR1StackSymbol, Sparse } from "../../src/index";
+import { ColumnAndRow, Slex, Token } from "@scinorandex/slex";
+
+// prettier-ignore
+enum LoLangTokenType {
+  EOF,
+
+  IMPORT,
+  VARIABLE, CONSTANT,
+  FUNCTION, OBJECT,
+
+  RETURN,
+
+  TRY, CATCH, THROW,
+  IF, ELSE, ELIF,
+  SWITCH, DEFAULT, CASE, SWITCH_BREAK, SWITCH_GOTO,
+
+  FOR, OF, WHILE, LOOP_BREAK, LOOP_CONTINUE,
+  IDENTIFIER,
+  NUMBER_TYPE, BOOLEAN_TYPE, STRING_TYPE, VOID_TYPE,
+
+  L_PAREN, R_PAREN, L_CURLY_BRACE, R_CURLY_BRACE, L_BRACE, R_BRACE,
+  EQUALS, COMMA, MINUS_R_ANGLE_BAR, DOT, COLON, SEMICOLON,
+
+  // LOGICAL AND BITWISE OPERATORS
+  EXCLAMATION, DOUBLE_AMPERSAND, DOUBLE_PIPE, CARAT, AMPERSAND, PIPE,
+
+  // RELATIONAL AND EQUALITY OPERATORS
+  DOUBLE_EQUALS, EXCLAMATION_EQUALS, L_ANGLE_BAR, R_ANGLE_BAR, L_ANGLE_BAR_EQUALS, R_ANGLE_BAR_EQUALS,
+
+  // SHIFTING OPERATORS
+  DOUBLE_L_ANGLE_BAR, DOUBLE_R_ANGLE_BAR,
+
+  // ARITHMETIC OPERATORS
+  PLUS, MINUS, STAR, FORWARD_SLASH, PERCENT, DOUBLE_STAR,
+
+  // INCREMENTATION OPERATOR
+  DOUBLE_PLUS, DOUBLE_MINUS,
+
+  STRING_LITERAL, NUMBER_LITERAL, BOOLEAN_LITERAL, NULL_LITERAL
+}
+
+const lexerGenerator = new Slex<LoLangTokenType, {}>({
+  EOF_TYPE: LoLangTokenType.EOF,
+  isHigherPrecedence: ({ current, next }) => current === LoLangTokenType.IDENTIFIER,
+});
+{
+  lexerGenerator.addRule("plus", "$+", LoLangTokenType.PLUS);
+  lexerGenerator.addRule("minus", "$-", LoLangTokenType.MINUS);
+  lexerGenerator.addRule("star", "$*", LoLangTokenType.STAR);
+  lexerGenerator.addRule("forward_slash", "$/", LoLangTokenType.FORWARD_SLASH);
+  lexerGenerator.addRule("percent", "$%", LoLangTokenType.PERCENT);
+  lexerGenerator.addRule("double_star", "$*$*", LoLangTokenType.DOUBLE_STAR);
+  lexerGenerator.addRule("double_plus", "$+$+", LoLangTokenType.DOUBLE_PLUS);
+  lexerGenerator.addRule("double_minus", "$-$-", LoLangTokenType.DOUBLE_MINUS);
+
+  lexerGenerator.addRule("double_l_angle_bar", "$>$>", LoLangTokenType.DOUBLE_L_ANGLE_BAR);
+  lexerGenerator.addRule("double_r_angle_bar", "$<$<", LoLangTokenType.DOUBLE_R_ANGLE_BAR);
+  lexerGenerator.addRule("pipe", "$|", LoLangTokenType.PIPE);
+  lexerGenerator.addRule("ampersand", "$&", LoLangTokenType.AMPERSAND);
+  lexerGenerator.addRule("carat", "$^", LoLangTokenType.CARAT);
+
+  lexerGenerator.addRule("l_angle_bar", "$<", LoLangTokenType.L_ANGLE_BAR);
+  lexerGenerator.addRule("l_angle_bar_equals", "$<$=", LoLangTokenType.L_ANGLE_BAR_EQUALS);
+  lexerGenerator.addRule("r_angle_bar", "$>", LoLangTokenType.R_ANGLE_BAR);
+  lexerGenerator.addRule("r_angle_bar_equals", "$>$=", LoLangTokenType.R_ANGLE_BAR_EQUALS);
+  lexerGenerator.addRule("exclamation_equals", "$!$=", LoLangTokenType.EXCLAMATION_EQUALS);
+  lexerGenerator.addRule("double_equals", "$=$=", LoLangTokenType.DOUBLE_EQUALS);
+
+  lexerGenerator.addRule("double_ampersand", "$&$&", LoLangTokenType.DOUBLE_AMPERSAND);
+  lexerGenerator.addRule("double_pipe", "$|$|", LoLangTokenType.DOUBLE_PIPE);
+  lexerGenerator.addRule("exclamation", "$!", LoLangTokenType.EXCLAMATION);
+
+  lexerGenerator.addRule("minus_r_angle_bar", "$-$>", LoLangTokenType.MINUS_R_ANGLE_BAR);
+  lexerGenerator.addRule("equals", "$=", LoLangTokenType.EQUALS);
+  lexerGenerator.addRule("comma", "$,", LoLangTokenType.COMMA);
+  lexerGenerator.addRule("dot", "$.", LoLangTokenType.DOT);
+  lexerGenerator.addRule("colon", "$:", LoLangTokenType.COLON);
+  lexerGenerator.addRule("semicolon", "$;", LoLangTokenType.SEMICOLON);
+
+  lexerGenerator.addRule("l_paren", "$(", LoLangTokenType.L_PAREN);
+  lexerGenerator.addRule("r_paren", "$)", LoLangTokenType.R_PAREN);
+  lexerGenerator.addRule("l_brace", "$[", LoLangTokenType.L_BRACE);
+  lexerGenerator.addRule("r_brace", "$]", LoLangTokenType.R_BRACE);
+  lexerGenerator.addRule("l_curly_brace", "${", LoLangTokenType.L_CURLY_BRACE);
+  lexerGenerator.addRule("r_curly_brace", "$}", LoLangTokenType.R_CURLY_BRACE);
+
+  lexerGenerator.addRule("lowercase", "a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z");
+  lexerGenerator.addRule("uppercase", "A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z");
+  lexerGenerator.addRule("letter", "${lowercase}|${uppercase}");
+  lexerGenerator.addRule(
+    "symbols",
+    "$ | $! | $@ | $# | $$ | $% | $^ | $& | $* | $( | $) | ${ | $[ | $} | $] | $; | $: | $< | $, | $. | $> | $? | $/ | $` | $~ | $- | $_ | $+ | $= | $|"
+  );
+  lexerGenerator.addRule("escape_character", "$\\ | $\n | $\t | $\r | $\\$\" | $\\$'");
+  lexerGenerator.addRule("digit", "0|1|2|3|4|5|6|7|8|9");
+  lexerGenerator.addRule("character", "${letter}|${digit}|${symbols}|${escape_character}");
+
+  lexerGenerator.addRule("float_number", "(${digit})+$.(${digit})+");
+  lexerGenerator.addRule("decimal_number", "(${digit})+");
+  lexerGenerator.addRule("octal_number", "0e(0|1|2|3|4|5|6|7)+");
+  lexerGenerator.addRule("hexadecimal_number", "0x(${digit}|a|b|c|d|e|f|A|B|C|D|E|F)+");
+  lexerGenerator.addRule("binary_number", "0b(0|1)+");
+
+  // handle literal tokens
+  lexerGenerator.addRule(
+    "string_literal",
+    "$\"(${character} | $')*$\" | $'(${character} | $\")*$'",
+    LoLangTokenType.STRING_LITERAL,
+    (str) => str.substring(1, str.length - 1).replaceAll("\\n", "\n")
+  );
+  lexerGenerator.addRule(
+    "number_literal",
+    "${float_number}|${decimal_number}|${octal_number}|${binary_number}|${hexadecimal_number}",
+    LoLangTokenType.NUMBER_LITERAL
+  );
+  lexerGenerator.addRule("boolean_literal", "faker|shaker", LoLangTokenType.BOOLEAN_LITERAL);
+  lexerGenerator.addRule("null_literal", "cooldown", LoLangTokenType.NULL_LITERAL);
+
+  // handle identifier and reserved words
+  lexerGenerator.addRule("item", "item", LoLangTokenType.VARIABLE);
+  lexerGenerator.addRule("rune", "rune", LoLangTokenType.CONSTANT);
+  lexerGenerator.addRule("skill", "skill", LoLangTokenType.FUNCTION);
+  lexerGenerator.addRule("steal", "steal", LoLangTokenType.IMPORT);
+  lexerGenerator.addRule("build", "build", LoLangTokenType.OBJECT);
+  lexerGenerator.addRule("canwin", "canwin", LoLangTokenType.IF);
+  lexerGenerator.addRule("remake", "remake", LoLangTokenType.ELIF);
+  lexerGenerator.addRule("lose", "lose", LoLangTokenType.ELSE);
+  lexerGenerator.addRule("channel", "channel", LoLangTokenType.SWITCH);
+  lexerGenerator.addRule("teleport", "teleport", LoLangTokenType.CASE);
+  lexerGenerator.addRule("recall", "recall", LoLangTokenType.DEFAULT);
+  lexerGenerator.addRule("flash", "flash", LoLangTokenType.SWITCH_GOTO);
+  lexerGenerator.addRule("cancel", "cancel", LoLangTokenType.SWITCH_BREAK);
+  lexerGenerator.addRule("wave", "wave", LoLangTokenType.WHILE);
+  lexerGenerator.addRule("cannon", "cannon", LoLangTokenType.FOR);
+  lexerGenerator.addRule("clear", "clear", LoLangTokenType.LOOP_BREAK);
+  lexerGenerator.addRule("next", "next", LoLangTokenType.LOOP_CONTINUE);
+  lexerGenerator.addRule("of", "of", LoLangTokenType.OF);
+  lexerGenerator.addRule("support", "support", LoLangTokenType.TRY);
+  lexerGenerator.addRule("carry", "carry", LoLangTokenType.CATCH);
+  lexerGenerator.addRule("feed", "feed", LoLangTokenType.THROW);
+  lexerGenerator.addRule("recast", "recast", LoLangTokenType.RETURN);
+
+  // handle type tokens
+  lexerGenerator.addRule("number_type", "stats", LoLangTokenType.NUMBER_TYPE);
+  lexerGenerator.addRule("boolean_type", "goat", LoLangTokenType.BOOLEAN_TYPE);
+  lexerGenerator.addRule("string_type", "message", LoLangTokenType.STRING_TYPE);
+  lexerGenerator.addRule("void_type", "passive", LoLangTokenType.VOID_TYPE);
+  lexerGenerator.addRule("identifier", "(${letter}|$_)(${letter}|${digit}|$_)*", LoLangTokenType.IDENTIFIER);
+}
+
+type StringifiedNode = (StringifiedNode | string)[];
+class Node {
+  constructor(public readonly nodes: LR1StackSymbol<LoLangTokenType, {}, Node>[]) {}
+  toObject(): StringifiedNode {
+    return this.nodes.map((node) => (node.type === "token" ? node.token.lexeme : node.node.toObject()));
+  }
+}
+
+async function main() {
+  const exampleSourceCode = await fs.readFile("./example/LoLang/Features_Array_Methods.lol", "utf8");
+  const lexer = lexerGenerator.generate(exampleSourceCode, () => ({}));
+
+  const toStringifiedTokenType = (type: LoLangTokenType) => LoLangTokenType[type];
+  const productions = buildProductions(await fs.readFile("./example/LoLang/grammar.txt", "utf8"));
+  const parserGenerator = Sparse.fromProductions<LoLangTokenType, {}, Node>({ productions, toStringifiedTokenType });
+
+  const parser = parserGenerator.generate(lexer, {
+    reducer: (input, productionIndex) => new Node(input),
+    recover({ lexer, statesStack, symbolsStack, isSafe, addError, crash, finish, states }) {
+      let token = lexer.peekNextToken();
+      const currentState = statesStack.peek();
+
+      // check for extra semicolons
+      if (token.type === LoLangTokenType.SEMICOLON) {
+        while (lexer.peekNextToken().type === LoLangTokenType.SEMICOLON) token = lexer.getNextToken();
+        if (isSafe()) return finish();
+      }
+
+      token = lexer.peekNextToken();
+
+      // check for lacking semicolons
+      if (states[currentState].actions.has("[SEMICOLON]")) {
+        const action = states[currentState].getTerminalAction("SEMICOLON");
+        const newToken = new Token<LoLangTokenType, {}>(
+          LoLangTokenType.SEMICOLON,
+          ";",
+          new ColumnAndRow(token.column, token.line),
+          token.metadata
+        );
+
+        if (action) {
+          if (action.type === "reduce") return finish({ newToken });
+
+          statesStack.push(action.value);
+          symbolsStack.push({ type: "token", token: newToken });
+          addError(
+            `Expected SEMICOLON but received ${LoLangTokenType[token.type]}. SEMICOLON was automatically inserted.`
+          );
+        }
+
+        if (isSafe()) return finish();
+      }
+
+      console.log(lexer.peekNextToken());
+      return crash("Invalid syntax.");
+    },
+  });
+
+  console.log(parser.parse());
+}
+
+main();

package/example/LoLang/grammar.txt

@@ -0,0 +1,149 @@
+<S> : <PROGRAM>;
+<PROGRAM> : [EOF];
+<PROGRAM> : <STATEMENT_LIST> [EOF];
+<STATEMENT_LIST> : <STATEMENT_LIST> <STATEMENT>;
+<STATEMENT_LIST> : <STATEMENT>;
+<STATEMENT> : <IMPORT_STATEMENT>;
+<STATEMENT> : <IF_STATEMENT>;
+<STATEMENT> : <VARIABLE_DECLARATION_STATEMENT>;
+<STATEMENT> : <CONSTANT_DECLARATION>;
+<STATEMENT> : <BLOCK_STATEMENT>;
+<STATEMENT> : <RETURN_STATEMENT>;
+<STATEMENT> : <TRY_CATCH_STATEMENT>;
+<STATEMENT> : <THROW_STATEMENT>;
+<STATEMENT> : <SWITCH_STATEMENT>;
+<STATEMENT> : <LOOP_STATEMENT>;
+<STATEMENT> : <EXPRESSION_STATEMENT>;
+<STATEMENT> : <OBJECT_TYPE_DECLARATION>;
+<STATEMENT> : [SWITCH_BREAK] [SEMICOLON];
+<STATEMENT> : [SWITCH_GOTO] [STRING_LITERAL] [SEMICOLON];
+<STATEMENT> : [SWITCH_GOTO] [NUMBER_LITERAL] [SEMICOLON];
+<STATEMENT> : [LOOP_BREAK] [SEMICOLON];
+<STATEMENT> : [LOOP_CONTINUE] [SEMICOLON];
+<IMPORT_STATEMENT> : [IMPORT] [STRING_LITERAL] [SEMICOLON];
+<IF_STATEMENT> : [IF] [L_PAREN] <EXPRESSION> [R_PAREN] <STATEMENT> <ELSE_IF_STATEMENTS> [ELSE] <STATEMENT>;
+<IF_STATEMENT> : [IF] [L_PAREN] <EXPRESSION> [R_PAREN] <STATEMENT> <ELSE_IF_STATEMENTS>;
+<IF_STATEMENT> : [IF] [L_PAREN] <EXPRESSION> [R_PAREN] <STATEMENT> [ELSE] <STATEMENT>;
+<IF_STATEMENT> : [IF] [L_PAREN] <EXPRESSION> [R_PAREN] <STATEMENT>;
+<ELSE_IF_STATEMENTS> : <ELSE_IF_STATEMENTS> <ELSE_IF_STATEMENT>;
+<ELSE_IF_STATEMENTS> : <ELSE_IF_STATEMENT>;
+<ELSE_IF_STATEMENT> : [ELIF] [L_PAREN] <EXPRESSION> [R_PAREN] <STATEMENT>;
+<VARIABLE_DECLARATION_STATEMENT> : <VARIABLE_DECLARATION> [SEMICOLON];
+<VARIABLE_DECLARATION> : <VARIABLE_DECLARATION_HEADER>;
+<VARIABLE_DECLARATION> : <VARIABLE_DECLARATION_HEADER> [EQUALS] <EXPRESSION>;
+<VARIABLE_DECLARATION_HEADER> : [VARIABLE] [IDENTIFIER] [COLON] <TYPE>;
+<CONSTANT_DECLARATION> : [CONSTANT] [IDENTIFIER] [COLON] <TYPE> [EQUALS] <EXPRESSION> [SEMICOLON];
+<BLOCK_STATEMENT> : [L_CURLY_BRACE] [R_CURLY_BRACE];
+<BLOCK_STATEMENT> : [L_CURLY_BRACE] <STATEMENT_LIST> [R_CURLY_BRACE];
+<RETURN_STATEMENT> : [RETURN] <EXPRESSION> [SEMICOLON];
+<RETURN_STATEMENT> : [RETURN] [SEMICOLON];
+<TRY_CATCH_STATEMENT> : [TRY] <BLOCK_STATEMENT> [CATCH] [L_PAREN] [IDENTIFIER] [R_PAREN] <BLOCK_STATEMENT>;
+<THROW_STATEMENT> : [THROW] [STRING_LITERAL] [SEMICOLON];
+<SWITCH_STATEMENT> : [SWITCH] [L_PAREN] <EXPRESSION> [R_PAREN] [L_CURLY_BRACE] <SWITCH_CASE_LIST_WITH_DEFAULT> [R_CURLY_BRACE];
+<SWITCH_STATEMENT> : [SWITCH] [L_PAREN] <EXPRESSION> [R_PAREN] [L_CURLY_BRACE] [R_CURLY_BRACE];
+<SWITCH_CASE_LIST_WITH_DEFAULT> : <SWITCH_CASE_LIST> [DEFAULT] [COLON] <BLOCK_STATEMENT>;
+<SWITCH_CASE_LIST_WITH_DEFAULT> : [DEFAULT] [COLON] <BLOCK_STATEMENT>;
+<SWITCH_CASE_LIST_WITH_DEFAULT> : <SWITCH_CASE_LIST>;
+<SWITCH_CASE_LIST> : <SWITCH_CASE_LIST> <SWITCH_CASE>;
+<SWITCH_CASE_LIST> : <SWITCH_CASE>;
+<SWITCH_CASE> : [CASE] [L_PAREN] [STRING_LITERAL] [R_PAREN] [COLON] <BLOCK_STATEMENT>;
+<SWITCH_CASE> : [CASE] [L_PAREN] [NUMBER_LITERAL] [R_PAREN] [COLON] <BLOCK_STATEMENT>;
+<LOOP_STATEMENT> : <FOREACH_LOOP>;
+<LOOP_STATEMENT> : <COUNTER_CONTROLLED_LOOP>;
+<LOOP_STATEMENT> : <WHILE_LOOP>;
+<FOREACH_LOOP> : [FOR] [L_PAREN] [VARIABLE] [IDENTIFIER] [COLON] <TYPE> [OF] <EXPRESSION> [R_PAREN] <BLOCK_STATEMENT>;
+<COUNTER_CONTROLLED_LOOP> : [FOR] [L_PAREN] <COUNTER_LOOP_INIT> [SEMICOLON] <EXPRESSION> [SEMICOLON] <EXPRESSION_LIST> [R_PAREN] <BLOCK_STATEMENT>;
+<COUNTER_CONTROLLED_LOOP> : [FOR] [L_PAREN] [SEMICOLON] <EXPRESSION> [SEMICOLON] <EXPRESSION_LIST> [R_PAREN] <BLOCK_STATEMENT>;
+<COUNTER_CONTROLLED_LOOP> : [FOR] [L_PAREN] <COUNTER_LOOP_INIT> [SEMICOLON] [SEMICOLON] <EXPRESSION_LIST> [R_PAREN] <BLOCK_STATEMENT>;
+<COUNTER_CONTROLLED_LOOP> : [FOR] [L_PAREN] <COUNTER_LOOP_INIT> [SEMICOLON] <EXPRESSION> [SEMICOLON] [R_PAREN] <BLOCK_STATEMENT>;
+<COUNTER_CONTROLLED_LOOP> : [FOR] [L_PAREN] [SEMICOLON] [SEMICOLON] <EXPRESSION_LIST> [R_PAREN] <BLOCK_STATEMENT>;
+<COUNTER_CONTROLLED_LOOP> : [FOR] [L_PAREN] <COUNTER_LOOP_INIT> [SEMICOLON] [SEMICOLON] [R_PAREN] <BLOCK_STATEMENT>;
+<COUNTER_CONTROLLED_LOOP> : [FOR] [L_PAREN] [SEMICOLON] <EXPRESSION> [SEMICOLON] [R_PAREN] <BLOCK_STATEMENT>;
+<COUNTER_CONTROLLED_LOOP> : [FOR] [L_PAREN] [SEMICOLON] [SEMICOLON] [R_PAREN] <BLOCK_STATEMENT>;
+<COUNTER_LOOP_INIT> : <VARIABLE_DECLARATION> [COMMA] <COUNTER_LOOP_INIT>;
+<COUNTER_LOOP_INIT> : <VARIABLE_DECLARATION>;
+<EXPRESSION_LIST> : <EXPRESSION> [COMMA] <EXPRESSION_LIST>;
+<EXPRESSION_LIST> : <EXPRESSION>;
+<WHILE_LOOP> : [WHILE] [L_PAREN] <EXPRESSION> [R_PAREN] <BLOCK_STATEMENT>;
+<WHILE_LOOP> : [WHILE] [L_PAREN] [R_PAREN] <BLOCK_STATEMENT>;
+<EXPRESSION_STATEMENT> : <EXPRESSION> [SEMICOLON];
+<EXPRESSION> : <FUNCTION_EXPRESSION>;
+<EXPRESSION> : <ARRAY_LITERAL>;
+<EXPRESSION> : <OBJECT_LITERAL>;
+<EXPRESSION> : <LOGICAL_EXPRESSION>;
+<FUNCTION_EXPRESSION> : [FUNCTION] [L_PAREN] <PARAMETER_LIST> [R_PAREN] [COLON] <TYPE> [MINUS_R_ANGLE_BAR] <BLOCK_STATEMENT>;
+<FUNCTION_EXPRESSION> : [FUNCTION] [L_PAREN] [R_PAREN] [COLON] <TYPE> [MINUS_R_ANGLE_BAR] <BLOCK_STATEMENT>;
+<PARAMETER_LIST> : <VARIABLE_DECLARATION_HEADER> [COMMA] <PARAMETER_LIST>;
+<PARAMETER_LIST> : <VARIABLE_DECLARATION_HEADER>;
+<ARRAY_LITERAL> : [L_BRACE] <EXPRESSION_LIST> [R_BRACE];
+<ARRAY_LITERAL> : [L_BRACE] [R_BRACE];
+<OBJECT_LITERAL> : [L_CURLY_BRACE] <OBJECT_LITERAL_FIELD_LIST> [R_CURLY_BRACE];
+<OBJECT_LITERAL> : [L_CURLY_BRACE] [R_CURLY_BRACE];
+<OBJECT_LITERAL_FIELD_LIST> : <OBJECT_LITERAL_FIELD> [COMMA] <OBJECT_LITERAL_FIELD_LIST>;
+<OBJECT_LITERAL_FIELD_LIST> : <OBJECT_LITERAL_FIELD>;
+<OBJECT_LITERAL_FIELD> : [IDENTIFIER] [COLON] <EXPRESSION>;
+<LOGICAL_EXPRESSION> : <LOGICAL_EXPRESSION> [DOUBLE_AMPERSAND] <BITWISE_EXPRESSION>;
+<LOGICAL_EXPRESSION> : <LOGICAL_EXPRESSION> [DOUBLE_PIPE] <BITWISE_EXPRESSION>;
+<LOGICAL_EXPRESSION> : <BITWISE_EXPRESSION>;
+<BITWISE_EXPRESSION> : <BITWISE_EXPRESSION> [CARAT] <EQUALITY_EXPRESSION>;
+<BITWISE_EXPRESSION> : <BITWISE_EXPRESSION> [AMPERSAND] <EQUALITY_EXPRESSION>;
+<BITWISE_EXPRESSION> : <BITWISE_EXPRESSION> [PIPE] <EQUALITY_EXPRESSION>;
+<BITWISE_EXPRESSION> : <EQUALITY_EXPRESSION>;
+<EQUALITY_EXPRESSION> : <RELATIONAL_EXPRESSION> [DOUBLE_EQUALS] <RELATIONAL_EXPRESSION>;
+<EQUALITY_EXPRESSION> : <RELATIONAL_EXPRESSION> [EXCLAMATION_EQUALS] <RELATIONAL_EXPRESSION>;
+<EQUALITY_EXPRESSION> : <RELATIONAL_EXPRESSION>;
+<RELATIONAL_EXPRESSION> : <SHIFT_EXPRESSION> [L_ANGLE_BAR] <SHIFT_EXPRESSION>;
+<RELATIONAL_EXPRESSION> : <SHIFT_EXPRESSION> [L_ANGLE_BAR_EQUALS] <SHIFT_EXPRESSION>;
+<RELATIONAL_EXPRESSION> : <SHIFT_EXPRESSION> [R_ANGLE_BAR] <SHIFT_EXPRESSION>;
+<RELATIONAL_EXPRESSION> : <SHIFT_EXPRESSION> [R_ANGLE_BAR_EQUALS] <SHIFT_EXPRESSION>;
+<RELATIONAL_EXPRESSION> : <SHIFT_EXPRESSION>;
+<SHIFT_EXPRESSION> : <SHIFT_EXPRESSION> [DOUBLE_L_ANGLE_BAR] <TERM_EXPRESSION>;
+<SHIFT_EXPRESSION> : <SHIFT_EXPRESSION> [DOUBLE_R_ANGLE_BAR] <TERM_EXPRESSION>;
+<SHIFT_EXPRESSION> : <TERM_EXPRESSION>;
+<TERM_EXPRESSION> : <TERM_EXPRESSION> [PLUS] <FACTOR_EXPRESSION>;
+<TERM_EXPRESSION> : <TERM_EXPRESSION> [MINUS] <FACTOR_EXPRESSION>;
+<TERM_EXPRESSION> : <FACTOR_EXPRESSION>;
+<FACTOR_EXPRESSION> : <FACTOR_EXPRESSION> [STAR] <UNARY_EXPRESSION>;
+<FACTOR_EXPRESSION> : <FACTOR_EXPRESSION> [FORWARD_SLASH] <UNARY_EXPRESSION>;
+<FACTOR_EXPRESSION> : <FACTOR_EXPRESSION> [PERCENT] <UNARY_EXPRESSION>;
+<FACTOR_EXPRESSION> : <UNARY_EXPRESSION>;
+<UNARY_EXPRESSION> : [MINUS] <EXPONENTIATION_EXPRESSION>;
+<UNARY_EXPRESSION> : [EXCLAMATION] <EXPONENTIATION_EXPRESSION>;
+<UNARY_EXPRESSION> : <EXPONENTIATION_EXPRESSION>;
+<EXPONENTIATION_EXPRESSION> : <ENDPOINT> [DOUBLE_STAR] <EXPONENTIATION_EXPRESSION>;
+<EXPONENTIATION_EXPRESSION> : <ENDPOINT>;
+<ENDPOINT> : <ASSIGNMENT_EXPRESSION>;
+<ENDPOINT> : <LITERAL>;
+<ENDPOINT> : <GROUPING_EXPRESSION>;
+<ASSIGNMENT_EXPRESSION> : <IDENTIFIER_STACK_EXPRESSION> [DOUBLE_PLUS];
+<ASSIGNMENT_EXPRESSION> : <IDENTIFIER_STACK_EXPRESSION> [DOUBLE_MINUS];
+<ASSIGNMENT_EXPRESSION> : [DOUBLE_PLUS] <IDENTIFIER_STACK_EXPRESSION>;
+<ASSIGNMENT_EXPRESSION> : [DOUBLE_MINUS] <IDENTIFIER_STACK_EXPRESSION>;
+<ASSIGNMENT_EXPRESSION> : <IDENTIFIER_STACK_EXPRESSION> [EQUALS] <EXPRESSION>;
+<ASSIGNMENT_EXPRESSION> : <IDENTIFIER_STACK_EXPRESSION>;
+<IDENTIFIER_STACK_EXPRESSION> : [IDENTIFIER];
+<IDENTIFIER_STACK_EXPRESSION> : <IDENTIFIER_STACK_EXPRESSION> [DOT] [IDENTIFIER];
+<IDENTIFIER_STACK_EXPRESSION> : <IDENTIFIER_STACK_EXPRESSION> [L_BRACE] <EXPRESSION> [R_BRACE];
+<IDENTIFIER_STACK_EXPRESSION> : <IDENTIFIER_STACK_EXPRESSION> [L_PAREN] <EXPRESSION_LIST> [R_PAREN];
+<IDENTIFIER_STACK_EXPRESSION> : <IDENTIFIER_STACK_EXPRESSION> [L_PAREN] [R_PAREN];
+<LITERAL> : [STRING_LITERAL];
+<LITERAL> : [NUMBER_LITERAL];
+<LITERAL> : [BOOLEAN_LITERAL];
+<LITERAL> : [NULL_LITERAL];
+<GROUPING_EXPRESSION> : [L_PAREN] <EXPRESSION> [R_PAREN];
+<OBJECT_TYPE_DECLARATION> : [OBJECT] [IDENTIFIER] [L_CURLY_BRACE] <PROPERTY_LIST> [R_CURLY_BRACE];
+<OBJECT_TYPE_DECLARATION> : [OBJECT] [IDENTIFIER] [L_CURLY_BRACE] [R_CURLY_BRACE];
+<PROPERTY_LIST> : <PROPERTY_LIST> <PROPERTY_DEFINITION>;
+<PROPERTY_LIST> : <PROPERTY_DEFINITION>;
+<PROPERTY_DEFINITION> : [IDENTIFIER] [COLON] <TYPE> [SEMICOLON];
+<TYPE> : <TYPE> [L_BRACE] [R_BRACE];
+<TYPE> : [NUMBER_TYPE];
+<TYPE> : [BOOLEAN_TYPE];
+<TYPE> : [STRING_TYPE];
+<TYPE> : [VOID_TYPE];
+<TYPE> : [OBJECT] [IDENTIFIER];
+<TYPE> : <LAMBDA_TYPE>;
+<LAMBDA_TYPE> : [FUNCTION] [L_PAREN] <LAMBDA_PARAMETER_LIST> [R_PAREN] [MINUS_R_ANGLE_BAR] <TYPE>;
+<LAMBDA_TYPE> : [FUNCTION] [L_PAREN] [R_PAREN] [MINUS_R_ANGLE_BAR] <TYPE>;
+<LAMBDA_PARAMETER_LIST> : <TYPE> [COMMA] <LAMBDA_PARAMETER_LIST>;
+<LAMBDA_PARAMETER_LIST> : <TYPE>;