diff --git a/commons/src/err/mod.rs b/commons/src/err/mod.rs
index 0cef6bd..4777486 100644
--- a/commons/src/err/mod.rs
+++ b/commons/src/err/mod.rs
@@ -35,12 +35,14 @@ impl fmt::Display for PositionedError {
 		
 		let line = match self.start.get_line_content() {
 			Ok(v) => v,
-			Err(e) => format!("{}","Couldn't read file contents!".red().bold())
+			Err(e) => format!("{}: {}","Couldn't read file contents!".red().bold(), e)
 		};
 
+		println!("sz: {}, start: {}, end: {}", line.len(), self.start.col - 1, self.end.col - 1);
+
 		let before = &line[0..self.start.col - 1];
-		let target = &line[self.start.col - 1..self.end.col].cyan().underline();
-		let after = &line[self.end.col..];
+		let target = &line[self.start.col - 1..self.end.col - 1].cyan().underline();
+		let after = &line[self.end.col - 1..];
 
 		writeln!(f, "{}{}{}", before, target, after)?;
 		writeln!(f, "")?;
diff --git a/commons/src/lib.rs b/commons/src/lib.rs
index 3f7e032..1a81253 100644
--- a/commons/src/lib.rs
+++ b/commons/src/lib.rs
@@ -32,7 +32,7 @@ impl Position {
 
 impl fmt::Display for Position {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		write!(f, "{}:{} in {}", self.line, self.col, self.file_path);
+		let _ = write!(f, "{}:{} in {}", self.line, self.col, self.file_path);
 
 		Ok(())
 	}
diff --git a/examples/for.qf b/examples/for.qf
index ae71037..8aa5710 100644
--- a/examples/for.qf
+++ b/examples/for.qf
@@ -1,3 +1,5 @@
-for(si32 test = 0, test <= 10, test += 1) {
-	
+func test() {
+	for(si32 test = 0, test <= 10, test += 1) {
+		
+	}
 }
\ No newline at end of file
diff --git a/lexer/src/lexer.rs b/lexer/src/lexer.rs
index 2bc997c..72ce9ae 100644
--- a/lexer/src/lexer.rs
+++ b/lexer/src/lexer.rs
@@ -2,11 +2,11 @@
 //! Module containing the core lexer algorithm
 //! 
 
-use std::{fs, hash::{DefaultHasher, Hash, Hasher}, io::Error};
+use std::{fs, hash::{DefaultHasher, Hash, Hasher}};
 
 use commons::Position;
 
-use crate::{LexerParseResult, LexerParsingError, token::{LexerToken, LexerTokenType}, toks::math::MathOperator};
+use crate::{LexerParseResult, LexerParsingError, token::{LexerToken, LexerTokenType}, toks::{comp::ComparingOperator, math::MathOperator}};
 
 const FUNC_KEYWORD_HASH: u64 = 17439195341824537259;
 const RET_KEYWORD_HASH: u64 = 9222097151127739705;
@@ -46,75 +46,88 @@ pub fn lexer_parse_file(file_path: &String) -> LexerParseResult<Vec<LexerToken>>
         let c: char = contents.chars().nth(i).unwrap();
 		
 		if c == '\n' {
-			i += c.len_utf8();
+			i += 1;
 			last_line_break = i;
 			line += 1;
 			continue;
 		}
 
         if c.is_numeric() {
-			let col = i - last_line_break + 1;
+			let col = i - last_line_break;
             tokens.push(parse_number_token(&contents, &mut i, Position::new(file_path.to_string(), line, col))?);
             continue;
         }
 
         if c == '"' {
-			let col = i - last_line_break + 1;
+			let col = i - last_line_break;
 
             tokens.push(parse_string_token(&contents, &mut i, Position::new(file_path.to_string(), line, col)));
             continue;
         }
 
         if c.is_alphabetic() {
-			let col = i - last_line_break + 1;
+			let col = i - last_line_break;
 
             tokens.push(parse_keyword(&contents, &mut i, Position::new(file_path.to_string(), line, col)));
             continue;
         }
 
 		if c == '+' || c == '-' || c == '*' || c == '/' {
-			let col = i - last_line_break + 1;
+			let col = i - last_line_break;
 
 			tokens.push(parse_math_operator(&contents, &mut i, Position::new(file_path.to_string(), line, col))?);
 
 			continue;
 		}
 
-        i += c.len_utf8();
+		if c == '=' || c == '>' || c == '<' {
+			let col = i - last_line_break;
 
+			let parse = parse_comp_operator(&contents, &mut i, Position::new(file_path.to_string(), line, col));
 
-		let col = i - last_line_break + 1;
+			if parse.is_some() {
+				tokens.push(parse.unwrap());
+				continue;
+			}
+
+			i -= 2; // Try parsing operator as normal token.
+		}
+
+        i += 1;
+
+
+		let col = i - last_line_break;
 
 		let pos = Position::new(file_path.to_string(), line, col);
 
         match c {
-            '{' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::BRACKET_OPEN)),
-            '}' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::BRACKET_CLOSE)),
-            '(' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::PAREN_OPEN)),
-            ')' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::PAREN_CLOSE)),
-            '[' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::ARRAY_OPEN)),
-            ']' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::ARRAY_CLOSE)),
-            '=' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::EQUAL_SIGN)),
-            ',' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::COMMA)),
-            '.' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::DOT)),
-			'!' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::EXCLAMATION_MARK)),
-			'&' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::AMPERSAND)),
-            '<' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::ANGEL_BRACKET_OPEN)),
-            '>' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::ANGEL_BRACKET_CLOSE)),
+            '{' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::BracketOpen)),
+            '}' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::BracketClose)),
+            '(' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::ParenOpen)),
+            ')' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::ParenClose)),
+            '[' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::ArrayOpen)),
+            ']' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::ArrayClose)),
+            '=' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::EqualSign)),
+            ',' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::Comma)),
+            '.' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::Dot)),
+			'!' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::ExclamationMark)),
+			'&' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::Ampersand)),
+            '<' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::AngelBracketOpen)),
+            '>' => tokens.push(LexerToken::make_single_sized(pos, LexerTokenType::AngelBracketClose)),
 			_ => continue
         }
 
     }
 
-    tokens.push(LexerToken::make_single_sized(Position::new(file_path.to_string(), line, i - last_line_break + 1), LexerTokenType::END_OF_FILE));
+    tokens.push(LexerToken::make_single_sized(Position::new(file_path.to_string(), line, i - last_line_break + 1), LexerTokenType::EndOfFile));
 
     Ok(tokens)
 }
 
 fn parse_math_operator(contents: &String, ind: &mut usize, start_pos: Position) -> LexerParseResult<LexerToken> {
-	let operatorChar = contents.chars().nth(*ind).unwrap();
+	let operator_char = contents.chars().nth(*ind).unwrap();
 
-	let operator = match operatorChar {
+	let operator = match operator_char {
 		'+' => MathOperator::ADD,
 		'-' => MathOperator::SUBSTRACT,
 		'*' => MathOperator::MULTIPLY,
@@ -125,7 +138,7 @@ fn parse_math_operator(contents: &String, ind: &mut usize, start_pos: Position)
 	*ind += 1;
 
 	let assigns = match contents.chars().nth(*ind) {
-		Some(v) => v == '=',
+		Some(v) => v == '=', // TODO: make this enforce either '=' or ' '
 		None => false
 	};
 
@@ -133,15 +146,60 @@ fn parse_math_operator(contents: &String, ind: &mut usize, start_pos: Position)
 		*ind += 1;
 	}
 
-	let mut incrementCount = 1;
+	let mut increment_count = 1;
 
 	if assigns {
-		incrementCount += 1;
+		increment_count += 1;
 	}
 
-	let end = start_pos.increment_by(incrementCount);
+	let end = start_pos.increment_by(increment_count);
+
+	return Ok(LexerToken::new(start_pos, end, LexerTokenType::MathOperator(operator, assigns)));
+
+}
+
+fn parse_comp_operator(contents: &String, ind: &mut usize, start_pos: Position) -> Option<LexerToken> {
+	let first_char = contents.chars().nth(*ind).unwrap();
+	*ind += 1;
+	let second_char = contents.chars().nth(*ind).unwrap();
+
+	*ind += 1;
 
-	return Ok(LexerToken::new(start_pos, end, LexerTokenType::MATH_OPERATOR(operator, assigns)));
+	let end = start_pos.increment_by(2);
+
+	if second_char != '=' && second_char != ' ' {
+		return None;
+	}
+
+	match first_char {
+		'=' => {
+			if second_char != '=' {
+				return None;
+			}
+
+			return Some(LexerToken::new(start_pos, end, LexerTokenType::ComparingOperator(ComparingOperator::Equal)));
+		},
+
+		'>' => {
+			if second_char == '=' {
+				return Some(LexerToken::new(start_pos, end, LexerTokenType::ComparingOperator(ComparingOperator::HigherEqual)));
+			}
+
+			return Some(LexerToken::new(start_pos, end, LexerTokenType::ComparingOperator(ComparingOperator::Higher)));
+		},
+		
+		'<' => {
+			if second_char == '=' {
+				return Some(LexerToken::new(start_pos, end, LexerTokenType::ComparingOperator(ComparingOperator::LowerEqual)));
+			}
+
+			return Some(LexerToken::new(start_pos, end, LexerTokenType::ComparingOperator(ComparingOperator::Lower)));
+		},
+
+		_ => {
+			return None;
+		}
+	}
 
 }
 
@@ -166,7 +224,7 @@ fn parse_number_token(str: &String, ind: &mut usize, start_pos: Position) -> Lex
     *ind = end;
 
 	let endpos = start_pos.increment_by(end - start);
-    return Ok(LexerToken::new(start_pos, endpos, LexerTokenType::INT_LIT(num)));
+    return Ok(LexerToken::new(start_pos, endpos, LexerTokenType::IntLit(num)));
 }
 
 fn parse_string_token(str: &String, ind: &mut usize, start_pos: Position) -> LexerToken {
@@ -187,7 +245,7 @@ fn parse_string_token(str: &String, ind: &mut usize, start_pos: Position) -> Lex
     *ind = end;
     
 	let endpos: Position = start_pos.increment_by(end - start);
-    return LexerToken::new(start_pos, endpos, LexerTokenType::STRING_LIT(slice.to_string()));
+    return LexerToken::new(start_pos, endpos, LexerTokenType::StringLit(slice.to_string()));
 }
 
 fn parse_keyword(str: &String, ind: &mut usize, start_pos: Position) -> LexerToken {
@@ -212,18 +270,18 @@ fn parse_keyword(str: &String, ind: &mut usize, start_pos: Position) -> LexerTok
     *ind = end;
 
     let token_type = match hash {
-        FUNC_KEYWORD_HASH => LexerTokenType::FUNCTION,
-        RET_KEYWORD_HASH => LexerTokenType::RETURN,
-		STRUCT_KEYWORD_HASH => LexerTokenType::STRUCT,
-		LAYOUT_KEYWORD_HASH => LexerTokenType::LAYOUT,
-		LAY_KEYWORD_HASH => LexerTokenType::LAY,
-		TRUE_KEYWORD_HASH => LexerTokenType::TRUE,
-		FALSE_KEYWORD_HASH => LexerTokenType::FALSE,
-		VAR_KEYWORD_HASH => LexerTokenType::VAR,
-		IF_KEYWORD_HASH => LexerTokenType::IF,
-		ELSE_KEYWORD_HASH => LexerTokenType::ELSE,
-		WHILE_KEYWORD_HASH => LexerTokenType::WHILE,
-		FOR_KEYWORD_HASH => LexerTokenType::FOR,
+        FUNC_KEYWORD_HASH => LexerTokenType::Function,
+        RET_KEYWORD_HASH => LexerTokenType::Return,
+		STRUCT_KEYWORD_HASH => LexerTokenType::Struct,
+		LAYOUT_KEYWORD_HASH => LexerTokenType::Layout,
+		LAY_KEYWORD_HASH => LexerTokenType::Lay,
+		TRUE_KEYWORD_HASH => LexerTokenType::True,
+		FALSE_KEYWORD_HASH => LexerTokenType::False,
+		VAR_KEYWORD_HASH => LexerTokenType::Var,
+		IF_KEYWORD_HASH => LexerTokenType::If,
+		ELSE_KEYWORD_HASH => LexerTokenType::Else,
+		WHILE_KEYWORD_HASH => LexerTokenType::While,
+		FOR_KEYWORD_HASH => LexerTokenType::For,
         _ => LexerTokenType::KEYWORD(slice.to_string(), hash)
     };
 
diff --git a/lexer/src/token.rs b/lexer/src/token.rs
index 1d7e27d..b1a6387 100644
--- a/lexer/src/token.rs
+++ b/lexer/src/token.rs
@@ -2,65 +2,66 @@
 //! Module containing lexer token-based utilities and classes
 //! 
 
-use std::any::Any;
-
 use commons::{Position, err::{PositionedError, PositionedResult}};
 
-use crate::{LexerParseResult, LexerParsingError, toks::math::MathOperator};
+use crate::{LexerParseResult, LexerParsingError, toks::{comp::ComparingOperator, math::MathOperator}};
 
 /// The token type for the lexer
 #[derive(PartialEq, Debug)]
 pub enum LexerTokenType {
     /// Represent the func keyword
-    FUNCTION,
+    Function,
 
-	VAR,
-	STRUCT,
-	LAYOUT,
-	LAY,
+	Var,
+	Struct,
+	Layout,
+	Lay,
 		
 	/// 0: the operator
 	/// 1: does the operator affect the original variable!
-	MATH_OPERATOR(MathOperator, bool),
+	MathOperator(MathOperator, bool),
+
+	ComparingOperator(ComparingOperator),
 	
 
     /// Represent the ret keyword
-    RETURN,
+    Return,
 
-	TRUE,
-	FALSE,
+	True,
+	False,
 
-	FOR,
-	IF,
-	ELSE,
-	WHILE,
+	For,
+	If,
+	Else,
+	While,
 
-    EQUAL_SIGN,
-	EXCLAMATION_MARK,
+    EqualSign,
+	ExclamationMark,
 
-    COMMA,
-    DOT,
-	AMPERSAND,
+    Comma,
+    Dot,
+	Ampersand,
 
-    BRACKET_OPEN,
-    BRACKET_CLOSE,
+    BracketOpen,
+    BracketClose,
 
-    PAREN_OPEN,
-    PAREN_CLOSE,
+    ParenOpen,
+    ParenClose,
 
-    ARRAY_OPEN,
-    ARRAY_CLOSE,
+    ArrayOpen,
+    ArrayClose,
 
-    INT_LIT(i64),
-    STRING_LIT(String),
+    IntLit(i64),
+    StringLit(String),
 
-    ANGEL_BRACKET_OPEN,
-    ANGEL_BRACKET_CLOSE,
+    AngelBracketOpen,
+    AngelBracketClose,
 
     KEYWORD(String, u64),
-    END_OF_FILE
+    EndOfFile
 }
 
+#[derive(Debug)]
 pub struct LexerToken {
 	pub tok_type: LexerTokenType,
 	pub pos: Position, // Valid tokens require a position
@@ -91,21 +92,28 @@ impl LexerToken {
 
 	pub fn expects_int_lit(&self) -> PositionedResult<i64> {
 		match &self.tok_type {
-			LexerTokenType::INT_LIT(v) => return Ok(*v),
+			LexerTokenType::IntLit(v) => return Ok(*v),
 			_ => return Err(self.make_err("Expected int litteral here!"))
 		};
 	}
 
+	pub fn expects_comp_operator(&self) -> PositionedResult<ComparingOperator> {
+		match &self.tok_type {
+			LexerTokenType::ComparingOperator(op) => return Ok(op.clone()),
+			_ => return Err(self.make_err("Expected comparing operator here!"))
+		};
+	}
+
 	pub fn expects_math_operator(&self) -> PositionedResult<(MathOperator, bool)> {
 		match &self.tok_type {
-			LexerTokenType::MATH_OPERATOR(a, b) => return Ok((a.clone(), *b)),
+			LexerTokenType::MathOperator(a, b) => return Ok((a.clone(), *b)),
 			_ => return Err(self.make_err("Expected math operator here!"))
 		};
 	}
 
 	pub fn expects_string_lit(&self) -> PositionedResult<String> {
 		match &self.tok_type {
-			LexerTokenType::STRING_LIT(v) => return Ok(v.to_string()),
+			LexerTokenType::StringLit(v) => return Ok(v.to_string()),
 			_ => return Err(self.make_err("Expected string litteral here!"))
 		};
 	}
diff --git a/lexer/src/toks/comp.rs b/lexer/src/toks/comp.rs
new file mode 100644
index 0000000..d8df3d0
--- /dev/null
+++ b/lexer/src/toks/comp.rs
@@ -0,0 +1,12 @@
+//! Comparing token related utils
+
+/// The different comparing tokens
+#[derive(Debug, PartialEq, Clone)]
+pub enum ComparingOperator {
+	Equal, // A == B
+	NotEqual, // A != B
+	Higher, // A > B
+	HigherEqual, // A >= B
+	Lower, // A < B
+	LowerEqual // A <= B
+}
\ No newline at end of file
diff --git a/lexer/src/toks/mod.rs b/lexer/src/toks/mod.rs
index 354c7c9..1854b67 100644
--- a/lexer/src/toks/mod.rs
+++ b/lexer/src/toks/mod.rs
@@ -1 +1,2 @@
-pub mod math;
\ No newline at end of file
+pub mod math;
+pub mod comp;
\ No newline at end of file
diff --git a/parser/src/ast/cond/mod.rs b/parser/src/ast/cond/mod.rs
deleted file mode 100644
index 0d5d07c..0000000
--- a/parser/src/ast/cond/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-use lexer::token::LexerToken;
-
-use crate::{ParserError, ParserResult, ast::tree::ASTTreeNode};
-
-pub mod operators;
diff --git a/parser/src/ast/cond/operators.rs b/parser/src/ast/cond/operators.rs
deleted file mode 100644
index 8c9909d..0000000
--- a/parser/src/ast/cond/operators.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use commons::err::PositionedResult;
-use lexer::token::{LexerToken, LexerTokenType};
-
-use crate::{ParserError, ParserResult};
-
-#[derive(Debug, PartialEq, Clone)]
-pub enum ConditionOperator {
-	EQUAL,
-	NOT_EQUAL,
-
-	HIGHER, // A > B
-	LOWER, // A < B
-
-	HIGHEREQ, // A >= B
-	LOWEREQ // A <= B
-}
-
-pub fn parse_condition_operator(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedResult<ConditionOperator> {
-	match &tokens[*ind].tok_type {
-		LexerTokenType::EQUAL_SIGN => {
-			*ind += 1;
-
-			tokens[*ind].expects(LexerTokenType::EQUAL_SIGN);
-
-			return Ok(ConditionOperator::EQUAL)
-		},
-
-		LexerTokenType::EXCLAMATION_MARK => {
-			*ind += 1;
-
-			if tokens[*ind].tok_type == LexerTokenType::EQUAL_SIGN {
-				return Ok(ConditionOperator::NOT_EQUAL)
-			}
-		},
-
-		LexerTokenType::ANGEL_BRACKET_OPEN => {
-			*ind += 1;
-
-			if tokens[*ind].tok_type == LexerTokenType::EQUAL_SIGN {
-				return Ok(ConditionOperator::LOWEREQ);
-			}
-
-			return Ok(ConditionOperator::LOWER);
-		},
-
-		LexerTokenType::ANGEL_BRACKET_CLOSE => {
-			*ind += 1;
-
-			if tokens[*ind].tok_type == LexerTokenType::EQUAL_SIGN {
-				return Ok(ConditionOperator::HIGHEREQ);
-			}
-
-			return Ok(ConditionOperator::HIGHER);
-		},
-
-		_ => {}
-	}
-
-	Err(tokens[*ind].make_err("Token doesn't make a valid condition operator"))
-}
\ No newline at end of file
diff --git a/parser/src/ast/control/forloop.rs b/parser/src/ast/control/forloop.rs
index f65ed39..e4a59de 100644
--- a/parser/src/ast/control/forloop.rs
+++ b/parser/src/ast/control/forloop.rs
@@ -1,33 +1,31 @@
 use commons::err::PositionedResult;
 use lexer::token::{LexerToken, LexerTokenType};
 
-use crate::{ParserError, ParserResult, ast::{func::parse_node_body, parse_ast_node, parse_ast_value, tree::ASTTreeNode, var::decl::parse_variable_declaration}};
+use crate::ast::{func::parse_node_body, parse_ast_node, parse_ast_node_in_body, parse_ast_value, tree::ASTTreeNode, var::decl::parse_variable_declaration};
 
 pub fn parse_for_loop(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedResult<Box<ASTTreeNode>> {
 	*ind += 1;
 
-	tokens[*ind].expects(LexerTokenType::PAREN_OPEN)?;
+	tokens[*ind].expects(LexerTokenType::ParenOpen)?;
 
 	let initial = parse_variable_declaration(tokens, ind)?;
 
-	tokens[*ind].expects(LexerTokenType::COMMA)?;
+	tokens[*ind].expects(LexerTokenType::Comma)?;
 
 	*ind += 1;
 	let cond = parse_ast_value(tokens, ind)?;
 
-	tokens[*ind].expects(LexerTokenType::COMMA)?;
+	tokens[*ind].expects(LexerTokenType::Comma)?;
 	*ind += 1;
 
-	let increment = parse_ast_node(tokens, ind)?;
+	let increment = parse_ast_node_in_body(tokens, ind)?;
 
+	tokens[*ind].expects(LexerTokenType::ParenClose)?;
 	*ind += 1;
 
-	tokens[*ind].expects(LexerTokenType::PAREN_CLOSE)?;
-	*ind += 1;
-
-	tokens[*ind].expects(LexerTokenType::BRACKET_OPEN)?;
+	tokens[*ind].expects(LexerTokenType::BracketOpen)?;
 
 	let body = parse_node_body(tokens, ind)?;
 
-	return Ok(Box::new(ASTTreeNode::ForBlock { initialState: initial, cond, increment, body }));
+	return Ok(Box::new(ASTTreeNode::ForBlock { initial_state: initial, cond, increment, body }));
 }
\ No newline at end of file
diff --git a/parser/src/ast/control/ifelse.rs b/parser/src/ast/control/ifelse.rs
index e29033c..fc90cf1 100644
--- a/parser/src/ast/control/ifelse.rs
+++ b/parser/src/ast/control/ifelse.rs
@@ -5,15 +5,15 @@
 use commons::err::PositionedResult;
 use lexer::token::{LexerToken, LexerTokenType};
 
-use crate::{ParserError, ParserResult, ast::{func::parse_node_body, parse_ast_value, tree::ASTTreeNode}};
+use crate::{ast::{func::parse_node_body, parse_ast_value, tree::ASTTreeNode}};
 
 pub fn parse_condition_member(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedResult<Box<ASTTreeNode>> {
-	tokens[*ind].expects(LexerTokenType::PAREN_OPEN)?;
+	tokens[*ind].expects(LexerTokenType::ParenOpen)?;
 
 	*ind += 1;
 	let cond = parse_ast_value(tokens, ind)?;
 
-	tokens[*ind].expects(LexerTokenType::PAREN_CLOSE)?;
+	tokens[*ind].expects(LexerTokenType::ParenClose)?;
 
 	*ind += 1;
 
@@ -25,22 +25,22 @@ pub fn parse_if_statement(tokens: &Vec<LexerToken>, ind: &mut usize) -> Position
 
 	let cond = parse_condition_member(tokens, ind)?;
 
-	tokens[*ind].expects(LexerTokenType::BRACKET_OPEN)?;
+	tokens[*ind].expects(LexerTokenType::BracketOpen)?;
 
 	let body = match parse_node_body(tokens, ind) {
 		Ok(v) => v,
 		Err(e) => return Err(e)
 	};
 
-	let mut elseStatement = None;
+	let mut else_statement = None;
 
-	if tokens[*ind + 1].tok_type == LexerTokenType::ELSE {
+	if tokens[*ind + 1].tok_type == LexerTokenType::Else {
 		*ind += 1;
 
-		elseStatement = Some(parse_else_statement(tokens, ind)?);
+		else_statement = Some(parse_else_statement(tokens, ind)?);
 	}
 
-	return Ok(Box::new(ASTTreeNode::IfStatement { cond, body, elseStatement }));
+	return Ok(Box::new(ASTTreeNode::IfStatement { cond, body, else_statement }));
 }
 
 pub fn parse_else_statement(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedResult<Box<ASTTreeNode>> {
@@ -48,12 +48,12 @@ pub fn parse_else_statement(tokens: &Vec<LexerToken>, ind: &mut usize) -> Positi
 
 	let mut cond = None;
 
-	if tokens[*ind].tok_type == LexerTokenType::IF {
+	if tokens[*ind].tok_type == LexerTokenType::If {
 		*ind += 1;
 		cond = Some(parse_condition_member(tokens, ind)?);
 	}
 
-	tokens[*ind].expects(LexerTokenType::BRACKET_OPEN)?;
+	tokens[*ind].expects(LexerTokenType::BracketOpen)?;
 
 	let body = match parse_node_body(tokens, ind) {
 		Ok(v) => v,
@@ -61,15 +61,15 @@ pub fn parse_else_statement(tokens: &Vec<LexerToken>, ind: &mut usize) -> Positi
 	};
 
 	if cond.is_some() {
-		let mut elseStatement = None;
+		let mut else_statement = None;
 
-		if tokens[*ind + 1].tok_type == LexerTokenType::ELSE {
+		if tokens[*ind + 1].tok_type == LexerTokenType::Else {
 			*ind += 1;
 
-			elseStatement = Some(parse_else_statement(tokens, ind)?);
+			else_statement = Some(parse_else_statement(tokens, ind)?);
 		}
 
-		return Ok(Box::new(ASTTreeNode::IfElseStatement { cond, body, elseStatement }));
+		return Ok(Box::new(ASTTreeNode::IfElseStatement { cond, body, else_statement: else_statement }));
 	}
 
 	return Ok(Box::new(ASTTreeNode::ElseStatement { body }));
diff --git a/parser/src/ast/control/whileblock.rs b/parser/src/ast/control/whileblock.rs
index b4103d7..c9532b5 100644
--- a/parser/src/ast/control/whileblock.rs
+++ b/parser/src/ast/control/whileblock.rs
@@ -1,14 +1,14 @@
 use commons::err::PositionedResult;
 use lexer::token::LexerToken;
 
-use crate::{ParserError, ParserResult, ast::{control::ifelse::parse_condition_member, func::parse_node_body, tree::ASTTreeNode}};
+use crate::{ast::{control::ifelse::parse_condition_member, func::parse_node_body, tree::ASTTreeNode}};
 
 pub fn parse_while_block(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedResult<Box<ASTTreeNode>> {
 	*ind += 1;
 
 	let cond = parse_condition_member(tokens, ind)?;
 
-	tokens[*ind].expects(lexer::token::LexerTokenType::BRACKET_OPEN)?;
+	tokens[*ind].expects(lexer::token::LexerTokenType::BracketOpen)?;
 
 	let body = match parse_node_body(tokens, ind) {
 		Ok(v) => v,
diff --git a/parser/src/ast/func/call.rs b/parser/src/ast/func/call.rs
index c23da7e..c42cb2d 100644
--- a/parser/src/ast/func/call.rs
+++ b/parser/src/ast/func/call.rs
@@ -2,7 +2,7 @@ use commons::err::PositionedResult;
 use lexer::token::{LexerToken, LexerTokenType};
 use utils::hash::WithHash;
 
-use crate::{ParserError, ParserResult, ast::{parse_ast_value, tree::ASTTreeNode}};
+use crate::{ast::{parse_ast_value, tree::ASTTreeNode}};
 
 pub fn parse_function_call(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedResult<Box<ASTTreeNode>> {
 
@@ -10,16 +10,16 @@ pub fn parse_function_call(tokens: &Vec<LexerToken>, ind: &mut usize) -> Positio
 
 	*ind += 1;
 
-	tokens[*ind].expects(LexerTokenType::PAREN_OPEN)?;
+	tokens[*ind].expects(LexerTokenType::ParenOpen)?;
 
 	*ind += 1;
 
 	let mut vals: Vec<Box<ASTTreeNode>> = Vec::new();
 	
-	while tokens[*ind].tok_type != LexerTokenType::PAREN_CLOSE {
+	while tokens[*ind].tok_type != LexerTokenType::ParenClose {
 		vals.push(parse_ast_value(tokens, ind)?);
 		
-		tokens[*ind].expects(LexerTokenType::COMMA)?;
+		tokens[*ind].expects(LexerTokenType::Comma)?;
 
 		*ind += 1;
 	}
diff --git a/parser/src/ast/func/decl.rs b/parser/src/ast/func/decl.rs
index 8f89de9..5df13e1 100644
--- a/parser/src/ast/func/decl.rs
+++ b/parser/src/ast/func/decl.rs
@@ -2,22 +2,22 @@ use commons::err::PositionedResult;
 use lexer::token::{LexerToken, LexerTokenType};
 use utils::hash::WithHash;
 
-use crate::{ParserError, ParserResult, ast::{func::{parse_function_arguments, parse_node_body}, tree::ASTTreeNode}};
+use crate::{ast::{func::{parse_function_arguments, parse_node_body}, tree::ASTTreeNode}};
 
 pub fn parse_function_declaraction(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedResult<Box<ASTTreeNode>> {
 	*ind += 1;
-	let functionName = tokens[*ind].expects_keyword()?;
+	let function_name = tokens[*ind].expects_keyword()?;
 
 	*ind += 1;
-	tokens[*ind].expects(LexerTokenType::PAREN_OPEN)?;
+	tokens[*ind].expects(LexerTokenType::ParenOpen)?;
 
 	let args = parse_function_arguments(tokens, ind)?;
 
 	*ind += 1;
 
-	tokens[*ind].expects(LexerTokenType::BRACKET_OPEN)?;
+	tokens[*ind].expects(LexerTokenType::BracketOpen)?;
 
 	let body = parse_node_body(tokens, ind)?;
 
-	return Ok(Box::new(ASTTreeNode::FunctionDeclaration { funcName: WithHash::new(functionName.0), args, body }));
+	return Ok(Box::new(ASTTreeNode::FunctionDeclaration { func_name: WithHash::new(function_name.0), args, body }));
 }
\ No newline at end of file
diff --git a/parser/src/ast/func/mod.rs b/parser/src/ast/func/mod.rs
index 9444457..7926fb9 100644
--- a/parser/src/ast/func/mod.rs
+++ b/parser/src/ast/func/mod.rs
@@ -1,9 +1,9 @@
-use std::fmt::Debug;
+//! AST parsing for function related elements (function declarations, arguments, calls, ...)
 
 use commons::err::PositionedResult;
 use lexer::token::{LexerToken, LexerTokenType};
 
-use crate::{ParserError, ParserResult, ast::{parse_ast_node, tree::{ASTTreeNode, FunctionDeclarationArgument}}};
+use crate::{ast::{parse_ast_node_in_body, tree::{ASTTreeNode, FunctionDeclarationArgument}}};
 
 pub mod decl;
 pub mod call;
@@ -14,13 +14,11 @@ pub fn parse_node_body(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedR
     let mut tok: &LexerToken = &tokens[*ind];
     let mut body: Vec<Box<ASTTreeNode>> = Vec::new();
 
-    while tok.tok_type != LexerTokenType::END_OF_FILE && tok.tok_type != LexerTokenType::BRACKET_CLOSE {
-        let n = parse_ast_node(tokens, ind)?;
+    while tok.tok_type != LexerTokenType::EndOfFile && tok.tok_type != LexerTokenType::BracketClose {
+        let n = parse_ast_node_in_body(tokens, ind)?;
 
         body.push(n);
 
-        //println!("Func index: {}", *ind);
-
         tok = &tokens[*ind];
     }
 
@@ -35,25 +33,25 @@ pub fn parse_function_arguments(tokens: &Vec<LexerToken>, ind: &mut usize) -> Po
 	let mut args: Vec<FunctionDeclarationArgument> = Vec::new();
 	
 	while *ind < tokens.len() && tokens[*ind].is_keyword() {
-		let varType = tokens[*ind].expects_keyword()?;
+		let var_type = tokens[*ind].expects_keyword()?;
 
 		*ind += 1;
-		let varName = tokens[*ind].expects_keyword()?;
+		let var_name = tokens[*ind].expects_keyword()?;
 
-		args.push(FunctionDeclarationArgument::new(varName.0, varType.1));
+		args.push(FunctionDeclarationArgument::new(var_name.0, var_type.1));
 
 		*ind += 1;
 
-		if tokens[*ind].tok_type == LexerTokenType::PAREN_CLOSE {
+		if tokens[*ind].tok_type == LexerTokenType::ParenClose {
 			break;
 		}
 
-		tokens[*ind].expects(LexerTokenType::COMMA)?;
+		tokens[*ind].expects(LexerTokenType::Comma)?;
 
 		*ind += 1;
 	}
 
-	tokens[*ind].expects(LexerTokenType::PAREN_CLOSE)?;
+	tokens[*ind].expects(LexerTokenType::ParenClose)?;
 
 	Ok(args)
 }
\ No newline at end of file
diff --git a/parser/src/ast/literals.rs b/parser/src/ast/literals.rs
index 69f7e2d..b701102 100644
--- a/parser/src/ast/literals.rs
+++ b/parser/src/ast/literals.rs
@@ -1,7 +1,9 @@
-use commons::err::{PositionedError, PositionedResult};
-use lexer::token::{LexerToken, LexerTokenType};
+//! AST parsing for number & string literals
 
-use crate::{ParserError, ParserResult, ast::tree::ASTTreeNode};
+use commons::err::{PositionedResult};
+use lexer::token::{LexerToken};
+
+use crate::{ast::tree::ASTTreeNode};
 
 pub fn parse_integer_literal(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedResult<Box<ASTTreeNode>> {
 	let val = tokens[*ind].expects_int_lit()?;
diff --git a/parser/src/ast/math.rs b/parser/src/ast/math.rs
index 82aa244..49961ca 100644
--- a/parser/src/ast/math.rs
+++ b/parser/src/ast/math.rs
@@ -1,3 +1,5 @@
+//! AST parsing for math related elements (math operations, ...)
+
 use commons::err::PositionedResult;
 use lexer::token::LexerToken;
 
@@ -12,7 +14,7 @@ pub fn parse_math_operation(tokens: &Vec<LexerToken>, ind: &mut usize, original:
 
 	*ind += 1;
 
-	let rightMember = parse_ast_value(tokens, ind)?;
+	let right_member = parse_ast_value(tokens, ind)?;
 
-	return Ok(Box::new(ASTTreeNode::MathResult { lval: original, rval: rightMember, operator: oper.0, assigns: oper.1 }))
+	return Ok(Box::new(ASTTreeNode::MathResult { lval: original, rval: right_member, operator: oper.0, assigns: oper.1 }))
 }
\ No newline at end of file
diff --git a/parser/src/ast/mod.rs b/parser/src/ast/mod.rs
index d12aa8d..8542055 100644
--- a/parser/src/ast/mod.rs
+++ b/parser/src/ast/mod.rs
@@ -3,29 +3,56 @@
 //! The AST parsing is responsible for putting tokens into structures such as functions and other stuff.
 //! It is an extremely important step.
 //! 
-//! Indexes passed to parsing functions SHOULD be the "detected" token rather than the next one.
+//! # Parsing 
+//! Parsing the first AST node found in the lexer token buffer can be done using `parse_ast_node`.
+//! 
+//! Parsing inside of an AST node body (eg functions, if statements, ...) can be done using `parse_ast_node_in_body`
+//! 
+//! # Design notes
+//! The initial index represents the given value of the index value (usually `ind`) passed to any AST parsing function.
+//! 
+//! Whenever any AST parsing function requires a keyword (for example `var`) to be called, the initial index should be the index representing said keyword and not the next one.
+//! Furthermore, AST parsing functions requiring a keyword should increment index by one at the start to skip the detected keyword if needed.
+//! 
+//! AST parsing functions that aren't requiring a keyword will start at the actual start of the expression unless stated otherwise.
 //! 
-
-use std::fmt::Debug;
 
 use commons::err::PositionedResult;
 use lexer::token::{LexerToken, LexerTokenType};
 use utils::hash::WithHash;
 
-use crate::{ParserError, ParserResult, ast::{cond::operators::parse_condition_operator, control::{forloop::parse_for_loop, ifelse::parse_if_statement, whileblock::parse_while_block}, func::{call::parse_function_call, decl::parse_function_declaraction}, literals::{parse_integer_literal, parse_string_literal}, math::parse_math_operation, tree::ASTTreeNode, types::parse_type_declaration, var::decl::parse_variable_declaration}};
+use crate::{ast::{control::{forloop::parse_for_loop, ifelse::parse_if_statement, whileblock::parse_while_block}, func::{call::parse_function_call, decl::parse_function_declaraction}, literals::{parse_integer_literal, parse_string_literal}, math::parse_math_operation, tree::ASTTreeNode, types::parse_type_declaration, var::decl::parse_variable_declaration}};
 
 pub mod tree;
 pub mod func;
 pub mod var;
 pub mod literals;
-pub mod cond;
 pub mod control;
 pub mod math;
 pub mod types;
 
+/// Parses the post side of an AST node that can and WILL be intrepreted as a value.
+/// 
+/// This function should only be called by `parse_ast_value`
+/// 
+/// # Parsing Layout 
+/// The `parse_ast_value` function only parses the post side of the expression (noted L) if expression is:
+/// `R (pre) expression L (post) expression`
+/// 
+/// This layout allows us to seperate parsing from things like variable references, functions calls or even literals and
+/// treat them as the same while parsing other elements such as math operations or conditions!
+/// 
+/// # Possible node results
+/// `parse_ast_value_post_l` can possibly return the following node types:
+/// - original type
+/// - variable / function on type access
+/// - math operation
+/// - comparing
+/// - boolean negation
+/// 
 pub fn parse_ast_value_post_l(tokens: &Vec<LexerToken>, ind: &mut usize, original: PositionedResult<Box<ASTTreeNode>>, invoked_on_body: bool) -> PositionedResult<Box<ASTTreeNode>> {
 	match &tokens[*ind].tok_type {
-		LexerTokenType::DOT => {
+		LexerTokenType::Dot => {
 			let o = &original?;
 			let k = Box::new(ASTTreeNode::clone(o.as_ref()));
 
@@ -45,15 +72,15 @@ pub fn parse_ast_value_post_l(tokens: &Vec<LexerToken>, ind: &mut usize, origina
 			return Err(tokens[*ind].make_err("Invalid token type to use dot access!"));
 		},
 
-		LexerTokenType::MATH_OPERATOR(_, _) => {
+		LexerTokenType::MathOperator(_, _) => {
 			let o = &original?;
 			let k = Box::new(ASTTreeNode::clone(o.as_ref()));
 
 			return Ok(parse_math_operation(tokens, ind, k, invoked_on_body)?);
 		},
 
-		LexerTokenType::ANGEL_BRACKET_CLOSE | LexerTokenType::EQUAL_SIGN | LexerTokenType::ANGEL_BRACKET_OPEN => {
-			let operator = parse_condition_operator(tokens, ind)?;
+		LexerTokenType::ComparingOperator(op) => {
+			let operator = op.clone();
 
 			let o = &original?;
 			let k = Box::new(ASTTreeNode::clone(o.as_ref()));
@@ -68,10 +95,28 @@ pub fn parse_ast_value_post_l(tokens: &Vec<LexerToken>, ind: &mut usize, origina
 	}
 }
 
+/// Parses an AST node that can and WILL be intrepreted as a value
+/// 
+/// # Parsing Layout 
+/// The `parse_ast_value` function only parses the pre side of the expression (noted R) if expression is:
+/// `R (pre) expression L (post) expression`
+/// 
+/// This layout allows us to seperate parsing from things like variable references, functions calls or even literals and
+/// treat them as the same while parsing other elements such as math operations or conditions!
+/// 
+/// This function will call `parse_ast_value_post_l` to parse the L part of the expression.
+/// 
+/// # Recognized Nodes
+/// Possible nodes recognized as values include:
+/// - Function calls
+/// - Variable refs
+/// - Math operation results (both with or without value changing)
+/// - Boolean negation result
+/// - Boolean compare result
 pub fn parse_ast_value(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedResult<Box<ASTTreeNode>> {
 	match &tokens[*ind].tok_type {
 
-		LexerTokenType::EXCLAMATION_MARK => {
+		LexerTokenType::ExclamationMark => {
 			*ind += 1;
 			let ast = parse_ast_value(tokens, ind)?;
 
@@ -82,18 +127,18 @@ pub fn parse_ast_value(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedR
 			return Err(tokens[*ind].make_err("Boolean negative requires either func or var access!"));
 		},
 
-		LexerTokenType::INT_LIT(_) => {
+		LexerTokenType::IntLit(_) => {
 			let int = parse_integer_literal(tokens, ind);
 			return parse_ast_value_post_l(tokens, ind, int, false);
 		},
 
-		LexerTokenType::STRING_LIT(_) => {
+		LexerTokenType::StringLit(_) => {
 			let str = parse_string_literal(tokens, ind);
 			return parse_ast_value_post_l(tokens, ind, str, false);
 		},
 
 		LexerTokenType::KEYWORD(str, _) => {
-			if tokens[*ind + 1].tok_type == LexerTokenType::PAREN_OPEN {
+			if tokens[*ind + 1].tok_type == LexerTokenType::ParenOpen {
 				let call = parse_function_call(tokens, ind);
 				return parse_ast_value_post_l(tokens, ind, call, false);
 			}
@@ -109,40 +154,55 @@ pub fn parse_ast_value(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedR
 	}	
 }
 
+/// Parses an AST node outside of any other node.
+/// 
+/// # Examples
+/// `parse_ast_node` is used to parse:
+/// - Function declarations
+/// - Struct declarations
+/// - Layout declarations
 pub fn parse_ast_node(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedResult<Box<ASTTreeNode>> {
-	println!("Ind: {}, tok at: {:#?}", ind, tokens[*ind].tok_type);
-
 	match &tokens[*ind].tok_type {
-		LexerTokenType::FUNCTION => {
+		LexerTokenType::Function => {
 			return parse_function_declaraction(tokens, ind);
+		},
+
+		LexerTokenType::Struct => {
+			return parse_type_declaration(tokens, ind, false);
+		},
+
+		LexerTokenType::Layout => {
+			return parse_type_declaration(tokens, ind, true);
+		},
+
+		_ => {
+			return Err(tokens[*ind].make_err("Expected valid token type in this context!"));
 		}
+	}	
+}
 
-		LexerTokenType::VAR => {
+/// Parses an AST node inside of another compatible node (functions, control bodies)
+pub fn parse_ast_node_in_body(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedResult<Box<ASTTreeNode>> {
+	match &tokens[*ind].tok_type {
+
+		LexerTokenType::Var => {
 			return parse_variable_declaration(tokens, ind);
 		},
 
-		LexerTokenType::IF => {
+		LexerTokenType::If => {
 			return parse_if_statement(tokens, ind);
 		},
 		
-		LexerTokenType::WHILE => {
+		LexerTokenType::While => {
 			return parse_while_block(tokens, ind);
 		},
 
-		LexerTokenType::FOR => {
+		LexerTokenType::For => {
 			return parse_for_loop(tokens, ind);
-		},
-
-		LexerTokenType::STRUCT => {
-			return parse_type_declaration(tokens, ind, false);
-		},
-
-		LexerTokenType::LAYOUT => {
-			return parse_type_declaration(tokens, ind, true);
-		},
+		}
 
 		LexerTokenType::KEYWORD(str, _) => {
-			if tokens[*ind + 1].tok_type == LexerTokenType::PAREN_OPEN {
+			if tokens[*ind + 1].tok_type == LexerTokenType::ParenOpen {
 				let call = parse_function_call(tokens, ind);
 				return parse_ast_value_post_l(tokens, ind, call, true);
 			}
diff --git a/parser/src/ast/tree.rs b/parser/src/ast/tree.rs
index b3ca6ec..396d180 100644
--- a/parser/src/ast/tree.rs
+++ b/parser/src/ast/tree.rs
@@ -2,29 +2,28 @@
 //! AST tree related definitions.
 //! 
 
-use lexer::toks::math::MathOperator;
+use lexer::toks::{comp::ComparingOperator, math::MathOperator};
 use utils::hash::{TypeHash, WithHash};
 
-use crate::ast::{cond::operators::ConditionOperator};
-
 #[derive(Debug, PartialEq, Clone)]
 pub struct FunctionDeclarationArgument {
     pub name: WithHash<String>,
-    pub argumentType: TypeHash
+    pub argument_type: TypeHash
 }
 
 impl FunctionDeclarationArgument {
-    pub fn new(name: String, argType: TypeHash) -> Self {
-        FunctionDeclarationArgument { name: WithHash::new(name), argumentType: argType }
+    pub fn new(name: String, arg_type: TypeHash) -> Self {
+        FunctionDeclarationArgument { name: WithHash::new(name), argument_type: arg_type }
     }
 }
 
+/// The main AST node type in the AST parsing system.
 #[derive(Debug, PartialEq, Clone)]
 pub enum ASTTreeNode {
     IntegerLit(i64),
     StringLit(String),
 
-	OperatorBasedConditionMember { lval: Box<ASTTreeNode>, rval: Box<ASTTreeNode>, operator: ConditionOperator },
+	OperatorBasedConditionMember { lval: Box<ASTTreeNode>, rval: Box<ASTTreeNode>, operator: ComparingOperator },
 	BooleanBasedConditionMember { val: Box<ASTTreeNode>, negate: bool },
 
 	MathResult { lval: Box<ASTTreeNode>, rval: Box<ASTTreeNode>, operator: MathOperator, assigns: bool },
@@ -32,23 +31,23 @@ pub enum ASTTreeNode {
 	VariableReference(WithHash<String>),
 
 	StructLayoutDeclaration { name: WithHash<String>, layout: bool, members: Vec<Box<ASTTreeNode>> },
-	StructFieldMember { name: WithHash<String>, memberType: TypeHash },
+	StructFieldMember { name: WithHash<String>, member_type: TypeHash },
 
-    VarDeclaration { varName: WithHash<String>, varType: TypeHash, value: Option<Box<ASTTreeNode>> },
+    VarDeclaration { var_name: WithHash<String>, var_type: TypeHash, value: Option<Box<ASTTreeNode>> },
     VarValueChange { var: Box<ASTTreeNode>, value: Box<ASTTreeNode> },
-	VarIncrement { var: Box<ASTTreeNode>, incrementBy: Option<Box<ASTTreeNode>> }, // Default is by 1
+	VarIncrement { var: Box<ASTTreeNode>, increment_by: Option<Box<ASTTreeNode>> }, // Default is by 1
 
-	IfStatement { cond: Box<ASTTreeNode>, body: Vec<Box<ASTTreeNode>>, elseStatement: Option<Box<ASTTreeNode>> },
-	IfElseStatement { cond: Option<Box<ASTTreeNode>>, body: Vec<Box<ASTTreeNode>>, elseStatement: Option<Box<ASTTreeNode>> },
+	IfStatement { cond: Box<ASTTreeNode>, body: Vec<Box<ASTTreeNode>>, else_statement: Option<Box<ASTTreeNode>> },
+	IfElseStatement { cond: Option<Box<ASTTreeNode>>, body: Vec<Box<ASTTreeNode>>, else_statement: Option<Box<ASTTreeNode>> },
 	ElseStatement { body: Vec<Box<ASTTreeNode>> },
 
 	WhileBlock { cond: Box<ASTTreeNode>, body: Vec<Box<ASTTreeNode>> },
-	ForBlock { initialState: Box<ASTTreeNode>, cond: Box<ASTTreeNode>, increment: Box<ASTTreeNode>, body: Vec<Box<ASTTreeNode>> },
+	ForBlock { initial_state: Box<ASTTreeNode>, cond: Box<ASTTreeNode>, increment: Box<ASTTreeNode>, body: Vec<Box<ASTTreeNode>> },
 
     Return { value: Option<Box<ASTTreeNode>> },
 
     FunctionCall { func: WithHash<String>, args: Vec<Box<ASTTreeNode>>  },
-    FunctionDeclaration { funcName: WithHash<String>, args: Vec<FunctionDeclarationArgument>, body: Vec<Box<ASTTreeNode>> },
+    FunctionDeclaration { func_name: WithHash<String>, args: Vec<FunctionDeclarationArgument>, body: Vec<Box<ASTTreeNode>> },
 	
 	StructLRVariable { l: Box<ASTTreeNode>, r: Box<ASTTreeNode>,},
 	StructLRFunction { l: Box<ASTTreeNode>, r: Box<ASTTreeNode>, }
diff --git a/parser/src/ast/types/mod.rs b/parser/src/ast/types/mod.rs
index fb39816..90387dc 100644
--- a/parser/src/ast/types/mod.rs
+++ b/parser/src/ast/types/mod.rs
@@ -1,4 +1,4 @@
-use std::mem;
+//! AST parsing for struct & layout parsing
 
 use commons::err::PositionedResult;
 use lexer::token::{LexerToken, LexerTokenType};
@@ -8,32 +8,32 @@ use crate::ast::tree::ASTTreeNode;
 
 /// Parses a struct/layout member (field)
 pub fn parse_types_field_member(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedResult<Box<ASTTreeNode>> {
-	let typeName = tokens[*ind].expects_keyword()?;
+	let type_name = tokens[*ind].expects_keyword()?;
 
 	*ind += 1;
 
-	let fieldName = tokens[*ind].expects_keyword()?;
+	let field_name = tokens[*ind].expects_keyword()?;
 
 	*ind += 1;
 
-	return Ok(Box::new(ASTTreeNode::StructFieldMember { name: WithHash::new(fieldName.0), memberType: typeName.1 }))
+	return Ok(Box::new(ASTTreeNode::StructFieldMember { name: WithHash::new(field_name.0), member_type: type_name.1 }))
 }
 
 pub fn parse_type_declaration(tokens: &Vec<LexerToken>, ind: &mut usize, layout: bool) -> PositionedResult<Box<ASTTreeNode>> {
 	*ind += 1;
 
-	let typeName = tokens[*ind].expects_keyword()?;
+	let type_name = tokens[*ind].expects_keyword()?;
 
 	*ind += 1;
-	tokens[*ind].expects(LexerTokenType::BRACKET_OPEN)?;
+	tokens[*ind].expects(LexerTokenType::BracketOpen)?;
 
 	*ind += 1;
 
 	let mut members: Vec<Box<ASTTreeNode>> = Vec::new();	
 
-	while tokens[*ind].tok_type != LexerTokenType::BRACKET_CLOSE {
+	while tokens[*ind].tok_type != LexerTokenType::BracketClose {
 		members.push(parse_types_field_member(tokens, ind)?);
 	}
 
-	return Ok(Box::new(ASTTreeNode::StructLayoutDeclaration { name: WithHash::new(typeName.0), layout, members }));
+	return Ok(Box::new(ASTTreeNode::StructLayoutDeclaration { name: WithHash::new(type_name.0), layout, members }));
 }
\ No newline at end of file
diff --git a/parser/src/ast/var/decl.rs b/parser/src/ast/var/decl.rs
index 2821a2b..be949eb 100644
--- a/parser/src/ast/var/decl.rs
+++ b/parser/src/ast/var/decl.rs
@@ -2,26 +2,26 @@ use commons::err::PositionedResult;
 use lexer::token::{LexerToken, LexerTokenType};
 use utils::hash::WithHash;
 
-use crate::{ParserError, ParserResult, ast::{parse_ast_node, parse_ast_value, tree::ASTTreeNode}};
+use crate::{ast::{parse_ast_value, tree::ASTTreeNode}};
 
 pub fn parse_variable_declaration(tokens: &Vec<LexerToken>, ind: &mut usize) -> PositionedResult<Box<ASTTreeNode>> {
 	*ind += 1;
 
-	let typeName = tokens[*ind].expects_keyword()?;
+	let type_name = tokens[*ind].expects_keyword()?;
 
 	*ind += 1;
 
-	let varName = tokens[*ind].expects_keyword()?;
+	let var_name = tokens[*ind].expects_keyword()?;
 
 	*ind += 1;
 
 	let mut val: Option<Box<ASTTreeNode>> = None;
 
-	if tokens[*ind].tok_type == LexerTokenType::EQUAL_SIGN {
+	if tokens[*ind].tok_type == LexerTokenType::EqualSign {
 		*ind += 1;
 		
 		val = Some(parse_ast_value(tokens, ind)?);
 	}
 
-	return Ok(Box::new(ASTTreeNode::VarDeclaration { varName: WithHash::new(varName.0), varType: typeName.1, value: val }));
+	return Ok(Box::new(ASTTreeNode::VarDeclaration { var_name: WithHash::new(var_name.0), var_type: type_name.1, value: val }));
 }
\ No newline at end of file
diff --git a/parser/src/ast/var/mod.rs b/parser/src/ast/var/mod.rs
index ac63c09..96ed48d 100644
--- a/parser/src/ast/var/mod.rs
+++ b/parser/src/ast/var/mod.rs
@@ -1 +1,3 @@
+//! AST parsing for variable related elements (variable declarations, modifications, ...)
+
 pub mod decl;
\ No newline at end of file
diff --git a/parser/src/lib.rs b/parser/src/lib.rs
index 5cd3274..10b14b0 100644
--- a/parser/src/lib.rs
+++ b/parser/src/lib.rs
@@ -1,23 +1,8 @@
-use core::fmt;
+//!
+//! The parsing module of Quickfall. Contains all of the parsing code required for the Quickfall language.
+//! 
+//! # Introduction
+//! The `parser` module mostly contains the AST processor for Quickfall. Every element of the language is represented as an AST node which is then passed onto the AST tree. 
+//! The AST tree is then sent to the IR writer to actually compile.
 
 pub mod ast;
-
-type ParserResult<T> = std::result::Result<T, ParserError>;
-
-#[derive(Debug, Clone)]
-pub struct ParserError {
-	reason: String,
-	position: usize
-}
-
-impl ParserError {
-	pub fn new(reason: String, position: usize) -> Self {
-		ParserError { reason, position }
-	}
-}
-
-impl fmt::Display for ParserError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Parsing Error: {} at position {}", self.reason, self.position)
-    }
-}
\ No newline at end of file
diff --git a/test-main/src/main.rs b/test-main/src/main.rs
index 4eee812..dd20aeb 100644
--- a/test-main/src/main.rs
+++ b/test-main/src/main.rs
@@ -1,13 +1,13 @@
-use std::{env, hash::{DefaultHasher, Hash, Hasher}};
+use std::{env};
 
 use lexer::lexer::lexer_parse_file;
 use parser::ast::parse_ast_node;
 
 fn main() {
 	let args: Vec<String> = env::args().collect();
-    let filePath: &String = &args[1];
+    let file_path: &String = &args[1];
 
-	let lexer_res = lexer_parse_file(filePath).expect("Bad lexer!");
+	let lexer_res = lexer_parse_file(file_path).expect("Bad lexer!");
 
 	let mut ind = 0;
 
diff --git a/utils/src/hash.rs b/utils/src/hash.rs
index 8df23c3..bac5f7a 100644
--- a/utils/src/hash.rs
+++ b/utils/src/hash.rs
@@ -2,8 +2,7 @@
 //! Hash related utilities
 //! 
 
-use core::hash;
-use std::{any::TypeId, hash::{DefaultHasher, Hash, Hasher}};
+use std::{hash::{DefaultHasher, Hash, Hasher}};
 
 pub type TypeHash = u64;