Name            Operator        Associativity
Call            a(), a., a?.    Left-to-right
postfix         a++, a--        Left-to-right
prefix          ++a, --a        Right-to-left
unary           !a, -a          Right-to-left
factor          /, *            Left-to-right
term            -, +            Left-to-right
comparison      >, >=, <, <=    Left-to-right
equality        !=, ==          Left-to-right
and             and             Left-to-right
or              or              Left-to-right
isNull          ??              Left-to-right
ternary         a?b:c           Right-to-left
assignment      =               Right-to-left
comma           ,               Left-to-right

program →  declaration* EOF | expression
declaration →  "class" classDeclaration 
            | "fun" function
            |  "var" variableDeclaration
            | statement
classDeclaration →  identifier  ("<" (identifier) ("," identifier)*)? "{" (("class")? function|getter)* "}"
function →  "fun" identifier "(" identifier (, identifier)* ")" block
getter → identifier block
block → "{" declaration* "}"
variableDeclaration → "var" identifier ("=" expression)? (("," term)?)*
statement → print
            | block
            | if | return
            | doWhile | while | for
            | break | continue
            | expressionStatement
print → "print" expression ";"
if → "if" "(" expression ")" statement ("else" statement)?
return →  "return" expression ";"
doWhile → "do" statement "while" "(" expression ")" ";"
while → "while" "(" expression ")" statement
for → "for" "(" (varDeclaration|expressionStatement)? ";" (expression)? ";" (expression)? ")" statement
break → "break" ";"
continue → "continue" ";"
expressionStatement → expression ";" | expression

expression → assignment
assignment → ternaryExpression ("=" assignment)
ternaryExpression → or ("?" equality ":" equality)?
or → and ("or" and)*
and → equality ("and" ternaryExpression)*
equality → comparison (("!="|"==") comparison)*
comparison → term (">"|">="|"<"|"<=" term)*
term → factor ("-"|"+" factor)*
factor → unary ("/"|"*" unary)*
unary → prefix | ("!"|"-" unary)
prefix → ("--"|"++" primary) 
		| postfix
postfix → call 
		| ("--"|"++" call)
call → primary (finishCall | ".")*
finishCall → "(" (expression ("," expression)*) ")"
primary → "false" | "true" | nil |  literal 
		| "(" expression ")" 
		| super "." identifier ";" 
		| "this" | identifier 
		| lambda 
        | "==" | "!=" | ">=" | "<" | "<=" | "/" | "*" | "-" | "+"   //Error productions
lambda → "fun" "(" (identifier ("," identifier)*)? ")" block