diff --git a/src/include/parser.h b/src/include/parser.h
index 082cb6d..b6dd1f3 100644
--- a/src/include/parser.h
+++ b/src/include/parser.h
@@ -55,19 +55,29 @@ ParseReturn parse_expr_statement(vector<Token> tokens);
 ParseReturn parse_expr(vector<Token> tokens);
 
 /**
- * Parse something derivated from T
+ * Parse something derivated from Comp
 */
-ParseReturn parse_t(vector<Token> tokens);
+ParseReturn parse_comp(vector<Token> tokens);
 
 /**
- * Parse something derivated from U
+ * Parse something derivated from Sum
 */
-ParseReturn parse_u(vector<Token> tokens);
+ParseReturn parse_sum(vector<Token> tokens);
 
 /**
- * Parse something derivated from F
+ * Parse something derivated from Term
 */
-ParseReturn parse_f(vector<Token> tokens);
+ParseReturn parse_term(vector<Token> tokens);
+
+/**
+ * Parse something derivated from Unary
+*/
+ParseReturn parse_unary(vector<Token> tokens);
+
+/**
+ * Parse something derivated from Val
+*/
+ParseReturn parse_val(vector<Token> tokens);
 
 /**
  * Parse something derivated from ParIdentifier
diff --git a/src/include/types.h b/src/include/types.h
index 7cb57fa..1822e22 100644
--- a/src/include/types.h
+++ b/src/include/types.h
@@ -99,13 +99,13 @@ enum class NodeType {
     Epsilon, //               -> ;
     AssignedDeclaration, //   -> Type Identifier = Expr
     Declaration, //           -> Type Identifier
-    Plus, //                  -> T + Expr
-    Minus, //                 -> T - Expr
-    Mult, //                  -> F * T
-    Div, //                   -> F / T
-    Mod, //                   -> F % T
-    UnaryMinus, //            -> -F
-    UnaryPlus, //             -> +F
+    Plus, //                  -> Term + Sum
+    Minus, //                 -> Term - Sum
+    Mult, //                  -> Unary * Term
+    Div, //                   -> Unary / Term
+    Mod, //                   -> Unary % Term
+    UnaryMinus, //            -> -Unary
+    UnaryPlus, //             -> +Unary
     Assignment, //            -> Identifier = Expr
     LIncr, //                 -> ++ParIdentifier 
     RIncr, //                 -> ParIdentifier++
diff --git a/src/parser.cpp b/src/parser.cpp
index 6e57e12..3ef8764 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -326,11 +326,19 @@ ParseReturn parse_expr_statement(vector<Token> tokens) {
 }
 
 ParseReturn parse_expr(vector<Token> tokens) {
+    return parse_comp(tokens);
+}
+
+ParseReturn parse_comp(vector<Token> tokens) {
+    return parse_sum(tokens);
+}
+
+ParseReturn parse_sum(vector<Token> tokens) {
     if (tokens.size() == 0)
         throw ParseException();
 
-    // At least 1 T
-    ParseReturn ret = parse_t(tokens);
+    // At least 1 Term
+    ParseReturn ret = parse_term(tokens);
     tokens = ret.tokens;
 
     Node node = ret.node;
@@ -358,7 +366,7 @@ ParseReturn parse_expr(vector<Token> tokens) {
             last_token = tokens.back();
             tokens.pop_back();
 
-            ParseReturn ret = parse_t(tokens);
+            ParseReturn ret = parse_term(tokens);
             tokens = ret.tokens;
 
             InnerNode new_node = {
@@ -382,13 +390,13 @@ ParseReturn parse_expr(vector<Token> tokens) {
     };
 }
 
-ParseReturn parse_t(vector<Token> tokens) {
+ParseReturn parse_term(vector<Token> tokens) {
     if (tokens.size() == 0)
         throw ParseException();
         
 
-    // At least 1 U
-    ParseReturn ret = parse_u(tokens);
+    // At least 1 Unary
+    ParseReturn ret = parse_unary(tokens);
     tokens = ret.tokens;
 
     Node node = ret.node;
@@ -419,7 +427,7 @@ ParseReturn parse_t(vector<Token> tokens) {
         try {
             last_token = tokens.back();
             tokens.pop_back();
-            ParseReturn ret = parse_u(tokens);
+            ParseReturn ret = parse_unary(tokens);
             tokens = ret.tokens;
 
             InnerNode new_node = {
@@ -443,11 +451,11 @@ ParseReturn parse_t(vector<Token> tokens) {
     };
 }
 
-ParseReturn parse_u(vector<Token> tokens) {
-    if (tokens.size() > 0 && tokens.back().type == TokenType::Minus) { //* U -> - U
+ParseReturn parse_unary(vector<Token> tokens) {
+    if (tokens.size() > 0 && tokens.back().type == TokenType::Minus) { //* Unary -> - Unary
         tokens.pop_back();
 
-        ParseReturn ret = parse_u(tokens);
+        ParseReturn ret = parse_unary(tokens);
 
         InnerNode node = {
             .type=NodeType::UnaryMinus,
@@ -460,10 +468,10 @@ ParseReturn parse_u(vector<Token> tokens) {
         };
     }
     
-    if (tokens.size() > 0 && tokens.back().type == TokenType::Plus) { //* U -> + U
+    if (tokens.size() > 0 && tokens.back().type == TokenType::Plus) { //* Unary -> + Unary
         tokens.pop_back();
 
-        ParseReturn ret = parse_u(tokens);
+        ParseReturn ret = parse_unary(tokens);
 
         InnerNode node = {
             .type=NodeType::UnaryPlus,
@@ -476,16 +484,16 @@ ParseReturn parse_u(vector<Token> tokens) {
         };
     }
 
-    //* U -> F
-    return parse_f(tokens);
+    //* Unary -> Val
+    return parse_val(tokens);
 }
 
-ParseReturn parse_f(vector<Token> tokens) {
+ParseReturn parse_val(vector<Token> tokens) {
     if (tokens.size() == 0)
         throw ParseException();
 
     switch (tokens.back().type) {
-        case TokenType::Int: { //* F -> Number
+        case TokenType::Int: { //* Val -> Number
             Token number = tokens.back();
             tokens.pop_back();
             return {
@@ -493,7 +501,7 @@ ParseReturn parse_f(vector<Token> tokens) {
                 .tokens=tokens
             };;
         }
-        case TokenType::DoublePlus: { //* F -> ++ParIdentifier
+        case TokenType::DoublePlus: { //* Val -> ++ParIdentifier
             tokens.pop_back();
             ParseReturn ret = parse_par_identifier(tokens);
 
@@ -507,7 +515,7 @@ ParseReturn parse_f(vector<Token> tokens) {
                 .tokens=ret.tokens
             };
         }
-        case TokenType::DoubleMinus: { //* F -> --ParIdentifier
+        case TokenType::DoubleMinus: { //* Val -> --ParIdentifier
             tokens.pop_back();
             ParseReturn ret = parse_par_identifier(tokens);
 
@@ -522,12 +530,12 @@ ParseReturn parse_f(vector<Token> tokens) {
             };
         }
         default: {
-            try { //* F -> ParIdentifier...
+            try { //* Val -> ParIdentifier...
                 ParseReturn ret = parse_par_identifier(tokens);
 
                 if (ret.tokens.size() >= 1) {
                     switch (ret.tokens.back().type){
-                        case TokenType::DoublePlus: { //* F -> ParIdentifier++
+                        case TokenType::DoublePlus: { //* Val -> ParIdentifier++
                             ret.tokens.pop_back();
                             InnerNode node = {
                                 .type = NodeType::RIncr,
@@ -539,7 +547,7 @@ ParseReturn parse_f(vector<Token> tokens) {
                                 .tokens=ret.tokens
                             };
                         }
-                        case TokenType::DoubleMinus: { //* F -> ParIdentifier--
+                        case TokenType::DoubleMinus: { //* Val -> ParIdentifier--
                             ret.tokens.pop_back();
                             InnerNode node = {
                                 .type = NodeType::RDecr,
@@ -551,7 +559,7 @@ ParseReturn parse_f(vector<Token> tokens) {
                                 .tokens=ret.tokens
                             };
                         }
-                        case TokenType::Equal: { //* F -> ParIdentifier = (Expr)
+                        case TokenType::Equal: { //* Val -> ParIdentifier = (Expr)
                             ret.tokens.pop_back();
                             ParseReturn ret_expr = parse_expr(ret.tokens);
 
@@ -569,10 +577,10 @@ ParseReturn parse_f(vector<Token> tokens) {
                             break;
                     }
                 }
-                //* F -> ParIdentifier
+                //* Val -> ParIdentifier
                 return ret;
 
-            } catch (const ParseException& pex) { //* F -> (Expr)
+            } catch (const ParseException& pex) { //* Val -> (Expr)
                 if (tokens.back().type != TokenType::LParenthese)
                     throw ParseException();