diff --git a/src/evaluator/model/environment/mod.rs b/src/evaluator/environment/mod.rs
similarity index 76%
rename from src/evaluator/model/environment/mod.rs
rename to src/evaluator/environment/mod.rs
index 666b98b8..d14336c1 100644
--- a/src/evaluator/model/environment/mod.rs
+++ b/src/evaluator/environment/mod.rs
@@ -1,38 +1,38 @@
 use std::collections::BTreeMap;
 
-use crate::evaluator::model::object::Object;
+use crate::evaluator::Object;
 
 #[derive(Debug, Clone)]
-pub(crate) struct Environment {
+pub(super) struct Environment {
     variables: BTreeMap<String, Object>,
     sub_environment: Option<Box<Environment>>,
 }
 
 impl Environment {
-    pub(crate) fn new() -> Environment {
+    pub(super) fn new() -> Environment {
         Environment {
             variables: BTreeMap::new(),
             sub_environment: None,
         }
     }
 
-    pub(crate) fn push(&mut self) {
+    pub(super) fn push(&mut self) {
         self.sub_environment = Some(Box::new(self.clone()));
         self.variables = BTreeMap::new();
     }
 
-    pub(crate) fn pop(&mut self) {
+    pub(super) fn pop(&mut self) {
         if let Some(sub_environment) = self.sub_environment.clone() {
             self.variables = sub_environment.variables;
             self.sub_environment = sub_environment.sub_environment;
         }
     }
 
-    pub(crate) fn set(&mut self, identifier: String, value: Object) {
+    pub(super) fn set(&mut self, identifier: String, value: Object) {
         self.variables.insert(identifier, value);
     }
 
-    pub(crate) fn get<T: AsRef<str>>(&self, identifier: T) -> Object {
+    pub(super) fn get<T: AsRef<str>>(&self, identifier: T) -> Object {
         match self.variables.get(identifier.as_ref()) {
             Some(value) => value.clone(),
             None => {
diff --git a/src/evaluator/expression/boolean/mod.rs b/src/evaluator/expression/boolean/mod.rs
index cb050791..8ad31292 100644
--- a/src/evaluator/expression/boolean/mod.rs
+++ b/src/evaluator/expression/boolean/mod.rs
@@ -1,5 +1,5 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
+use crate::evaluator::Object;
 
 impl Evaluator {
     pub(super) fn evaluate_boolean(&self, literal: bool) -> anyhow::Result<Object> {
diff --git a/src/evaluator/expression/call/mod.rs b/src/evaluator/expression/call/mod.rs
index 8127fd8d..14369b85 100644
--- a/src/evaluator/expression/call/mod.rs
+++ b/src/evaluator/expression/call/mod.rs
@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
+use crate::evaluator::Object;
+use crate::syntax_analysis::Expression;
 
 impl Evaluator {
     pub(super) fn evaluate_call_expression(
diff --git a/src/evaluator/expression/function/mod.rs b/src/evaluator/expression/function/mod.rs
index 20336c07..6f0b7a53 100644
--- a/src/evaluator/expression/function/mod.rs
+++ b/src/evaluator/expression/function/mod.rs
@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::Block;
+use crate::evaluator::Object;
+use crate::syntax_analysis::Block;
 
 impl Evaluator {
     pub(super) fn evaluate_function_expression(
diff --git a/src/evaluator/expression/if_expression/mod.rs b/src/evaluator/expression/if_expression/mod.rs
index 0c038d25..928de124 100644
--- a/src/evaluator/expression/if_expression/mod.rs
+++ b/src/evaluator/expression/if_expression/mod.rs
@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::{Block, Expression};
+use crate::evaluator::Object;
+use crate::syntax_analysis::{Block, Expression};
 
 impl Evaluator {
     pub(super) fn evaluate_if_expression(
diff --git a/src/evaluator/expression/infix/mod.rs b/src/evaluator/expression/infix/mod.rs
index ab797d1e..4524dbfd 100644
--- a/src/evaluator/expression/infix/mod.rs
+++ b/src/evaluator/expression/infix/mod.rs
@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::{Expression, InfixOperator};
+use crate::evaluator::Object;
+use crate::syntax_analysis::{Expression, InfixOperator};
 
 impl Evaluator {
     pub(super) fn evaluate_infix_expression(
diff --git a/src/evaluator/expression/integer/mod.rs b/src/evaluator/expression/integer/mod.rs
index 0353edb6..abd548af 100644
--- a/src/evaluator/expression/integer/mod.rs
+++ b/src/evaluator/expression/integer/mod.rs
@@ -1,5 +1,5 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
+use crate::evaluator::Object;
 
 impl Evaluator {
     pub(super) fn evaluate_integer(&self, literal: i64) -> anyhow::Result<Object> {
diff --git a/src/evaluator/expression/mod.rs b/src/evaluator/expression/mod.rs
index d77cf080..d5e71e39 100644
--- a/src/evaluator/expression/mod.rs
+++ b/src/evaluator/expression/mod.rs
@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::*;
+use crate::evaluator::Object;
+use crate::syntax_analysis::*;
 
 mod boolean;
 mod call;
@@ -12,7 +12,7 @@ mod prefix;
 mod string;
 
 impl Evaluator {
-    pub(crate) fn evaluate_expression(&mut self, expression: Expression) -> anyhow::Result<Object> {
+    pub(super) fn evaluate_expression(&mut self, expression: Expression) -> anyhow::Result<Object> {
         match expression {
             Expression::Integer { literal } => self.evaluate_integer(literal),
             Expression::String { literal } => self.evaluate_string(literal),
diff --git a/src/evaluator/expression/prefix/mod.rs b/src/evaluator/expression/prefix/mod.rs
index e8b08019..fac8fc0a 100644
--- a/src/evaluator/expression/prefix/mod.rs
+++ b/src/evaluator/expression/prefix/mod.rs
@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
+use crate::evaluator::Object;
+use crate::syntax_analysis::Expression;
 
 impl Evaluator {
     pub(super) fn evaluate_not_prefix_expression(
diff --git a/src/evaluator/expression/string/mod.rs b/src/evaluator/expression/string/mod.rs
index 7b81e9e1..216c7013 100644
--- a/src/evaluator/expression/string/mod.rs
+++ b/src/evaluator/expression/string/mod.rs
@@ -1,5 +1,5 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
+use crate::evaluator::Object;
 
 impl Evaluator {
     pub(super) fn evaluate_string(&self, string: String) -> anyhow::Result<Object> {
diff --git a/src/evaluator/mod.rs b/src/evaluator/mod.rs
index 1733380b..fbe02164 100644
--- a/src/evaluator/mod.rs
+++ b/src/evaluator/mod.rs
@@ -1,12 +1,13 @@
-use crate::evaluator::model::environment::Environment;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::*;
-
-pub(crate) mod model;
+use crate::evaluator::environment::Environment;
+use crate::syntax_analysis::*;
 
+mod environment;
 mod expression;
+mod object;
 mod statement;
 
+pub use object::Object;
+
 #[derive(Debug)]
 pub(crate) struct Evaluator {
     environment: Environment,
diff --git a/src/evaluator/model/mod.rs b/src/evaluator/model/mod.rs
deleted file mode 100644
index 9de0932d..00000000
--- a/src/evaluator/model/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub(super) mod environment;
-pub(crate) mod object;
diff --git a/src/evaluator/model/object/mod.rs b/src/evaluator/object/mod.rs
similarity index 93%
rename from src/evaluator/model/object/mod.rs
rename to src/evaluator/object/mod.rs
index 1cf9923e..bfe8cdbf 100644
--- a/src/evaluator/model/object/mod.rs
+++ b/src/evaluator/object/mod.rs
@@ -1,9 +1,9 @@
 use std::fmt;
 
-use crate::syntax_analysis::model::syntax_tree_node::Block;
+use crate::syntax_analysis::Block;
 
 #[derive(Debug, Clone, PartialEq)]
-pub(crate) enum Object {
+pub enum Object {
     Return {
         value: Box<Object>,
     },
diff --git a/src/evaluator/statement/let_statement/mod.rs b/src/evaluator/statement/let_statement/mod.rs
index d9ed6028..3ce343ab 100644
--- a/src/evaluator/statement/let_statement/mod.rs
+++ b/src/evaluator/statement/let_statement/mod.rs
@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::*;
+use crate::evaluator::Object;
+use crate::syntax_analysis::*;
 
 impl Evaluator {
     pub(super) fn evaluate_let_statement(
diff --git a/src/evaluator/statement/mod.rs b/src/evaluator/statement/mod.rs
index a82f7fdc..b55f2b9e 100644
--- a/src/evaluator/statement/mod.rs
+++ b/src/evaluator/statement/mod.rs
@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::*;
+use crate::evaluator::Object;
+use crate::syntax_analysis::*;
 
 mod let_statement;
 mod return_statement;
diff --git a/src/evaluator/statement/return_statement/mod.rs b/src/evaluator/statement/return_statement/mod.rs
index b8be29d0..6c20b098 100644
--- a/src/evaluator/statement/return_statement/mod.rs
+++ b/src/evaluator/statement/return_statement/mod.rs
@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::*;
+use crate::evaluator::Object;
+use crate::syntax_analysis::*;
 
 impl Evaluator {
     pub(super) fn evaluate_return_statement(
diff --git a/src/lexical_analysis/mod.rs b/src/lexical_analysis/mod.rs
index a644f742..d954ad84 100644
--- a/src/lexical_analysis/mod.rs
+++ b/src/lexical_analysis/mod.rs
@@ -3,9 +3,9 @@ use std::str::Chars;
 
 use log::{debug, info, trace};
 
-use crate::lexical_analysis::model::token::Token;
+mod token;
 
-pub(crate) mod model;
+pub use token::Token;
 
 pub(crate) struct LexicalAnalysis<'a> {
     source_code: Peekable<Chars<'a>>,
diff --git a/src/lexical_analysis/model/mod.rs b/src/lexical_analysis/model/mod.rs
deleted file mode 100644
index 57b1f248..00000000
--- a/src/lexical_analysis/model/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub(crate) mod token;
diff --git a/src/lexical_analysis/model/token/mod.rs b/src/lexical_analysis/token/mod.rs
similarity index 95%
rename from src/lexical_analysis/model/token/mod.rs
rename to src/lexical_analysis/token/mod.rs
index 3776d580..3e7e6651 100644
--- a/src/lexical_analysis/model/token/mod.rs
+++ b/src/lexical_analysis/token/mod.rs
@@ -1,5 +1,5 @@
 #[derive(Debug, Clone, PartialEq)]
-pub(crate) enum Token {
+pub enum Token {
     // Identifiers
     Identifier { literal: String },
 
diff --git a/src/syntax_analysis/expression/function_expression/mod.rs b/src/syntax_analysis/expression/function_expression/mod.rs
index 6f658d87..57c0a30b 100644
--- a/src/syntax_analysis/expression/function_expression/mod.rs
+++ b/src/syntax_analysis/expression/function_expression/mod.rs
@@ -1,11 +1,11 @@
 use log::debug;
 
-use crate::lexical_analysis::model::token::Token;
+use crate::lexical_analysis::Token;
+use crate::syntax_analysis::Expression;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
 
 impl SyntaxAnalysis<'_> {
-    pub(crate) fn parse_function_expression(&mut self) -> anyhow::Result<Expression> {
+    pub(super) fn parse_function_expression(&mut self) -> anyhow::Result<Expression> {
         debug!("Parsing a function expression.");
 
         // parse function expression
diff --git a/src/syntax_analysis/expression/grouped_expression/mod.rs b/src/syntax_analysis/expression/grouped_expression/mod.rs
index 487564bf..338fec9c 100644
--- a/src/syntax_analysis/expression/grouped_expression/mod.rs
+++ b/src/syntax_analysis/expression/grouped_expression/mod.rs
@@ -1,12 +1,12 @@
 use log::debug;
 
-use crate::lexical_analysis::model::token::Token;
+use crate::lexical_analysis::Token;
+use crate::syntax_analysis::Expression;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
+use crate::syntax_analysis::expression_precedence::ExpressionPrecedence;
 
 impl SyntaxAnalysis<'_> {
-    pub(crate) fn parse_grouped_expression(&mut self) -> anyhow::Result<Expression> {
+    pub(super) fn parse_grouped_expression(&mut self) -> anyhow::Result<Expression> {
         debug!("Parsing a grouped expression.");
 
         assert_token!(
diff --git a/src/syntax_analysis/expression/if_expression/mod.rs b/src/syntax_analysis/expression/if_expression/mod.rs
index e88c3b5f..9fdcf2f3 100644
--- a/src/syntax_analysis/expression/if_expression/mod.rs
+++ b/src/syntax_analysis/expression/if_expression/mod.rs
@@ -1,12 +1,12 @@
 use log::debug;
 
-use crate::lexical_analysis::model::token::Token;
+use crate::lexical_analysis::Token;
+use crate::syntax_analysis::Expression;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
+use crate::syntax_analysis::expression_precedence::ExpressionPrecedence;
 
 impl SyntaxAnalysis<'_> {
-    pub(crate) fn parse_if_expression(&mut self) -> anyhow::Result<Expression> {
+    pub(super) fn parse_if_expression(&mut self) -> anyhow::Result<Expression> {
         debug!("Parsing a if expression.");
 
         // parse if expression
diff --git a/src/syntax_analysis/expression/mod.rs b/src/syntax_analysis/expression/mod.rs
index 1c3553d4..c3a2ed40 100644
--- a/src/syntax_analysis/expression/mod.rs
+++ b/src/syntax_analysis/expression/mod.rs
@@ -1,10 +1,10 @@
 use anyhow::Context;
 use log::{debug, trace};
 
-use crate::lexical_analysis::model::token::Token;
+use crate::lexical_analysis::Token;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
-use crate::syntax_analysis::model::syntax_tree_node::{Expression, SyntaxTreeNode};
+use crate::syntax_analysis::expression_precedence::ExpressionPrecedence;
+use crate::syntax_analysis::{Expression, SyntaxTreeNode};
 
 mod function_expression;
 mod grouped_expression;
@@ -13,13 +13,13 @@ mod pratt_parsing;
 mod utilities;
 
 impl SyntaxAnalysis<'_> {
-    pub(crate) fn get_expression_node(&mut self) -> anyhow::Result<SyntaxTreeNode> {
+    pub(super) fn get_expression_node(&mut self) -> anyhow::Result<SyntaxTreeNode> {
         let expression = self.get_expression(ExpressionPrecedence::Lowest)?;
         semicolon!(self);
         Ok(SyntaxTreeNode::Expression { expression })
     }
 
-    pub(crate) fn get_expression(
+    pub(super) fn get_expression(
         &mut self,
         expression_precedence: ExpressionPrecedence,
     ) -> anyhow::Result<Expression> {
diff --git a/src/syntax_analysis/expression/pratt_parsing/call_expression/mod.rs b/src/syntax_analysis/expression/pratt_parsing/call_expression/mod.rs
index cce28d2b..c54c8459 100644
--- a/src/syntax_analysis/expression/pratt_parsing/call_expression/mod.rs
+++ b/src/syntax_analysis/expression/pratt_parsing/call_expression/mod.rs
@@ -1,10 +1,10 @@
 use log::debug;
 
+use crate::syntax_analysis::Expression;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
 
 impl SyntaxAnalysis<'_> {
-    pub(crate) fn parse_call_expression(
+    pub(super) fn parse_call_expression(
         &mut self,
         function: Expression,
     ) -> anyhow::Result<Expression> {
diff --git a/src/syntax_analysis/expression/pratt_parsing/infix_expression/mod.rs b/src/syntax_analysis/expression/pratt_parsing/infix_expression/mod.rs
index c97c1477..dd0c7c9c 100644
--- a/src/syntax_analysis/expression/pratt_parsing/infix_expression/mod.rs
+++ b/src/syntax_analysis/expression/pratt_parsing/infix_expression/mod.rs
@@ -1,12 +1,12 @@
 use log::debug;
 
-use crate::lexical_analysis::model::token::Token;
+use crate::lexical_analysis::Token;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::expression_precedence::get_infix_operator_precedence;
-use crate::syntax_analysis::model::syntax_tree_node::{Expression, InfixOperator};
+use crate::syntax_analysis::expression_precedence::get_infix_operator_precedence;
+use crate::syntax_analysis::{Expression, InfixOperator};
 
 impl SyntaxAnalysis<'_> {
-    pub(crate) fn parse_infix_expression(
+    pub(super) fn parse_infix_expression(
         &mut self,
         left_hand: Expression,
     ) -> anyhow::Result<Expression> {
diff --git a/src/syntax_analysis/expression/pratt_parsing/mod.rs b/src/syntax_analysis/expression/pratt_parsing/mod.rs
index 47dcf2ce..8d951bf3 100644
--- a/src/syntax_analysis/expression/pratt_parsing/mod.rs
+++ b/src/syntax_analysis/expression/pratt_parsing/mod.rs
@@ -1,15 +1,15 @@
-use crate::lexical_analysis::model::token::Token;
+use crate::lexical_analysis::Token;
+use crate::syntax_analysis::Expression;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::expression_precedence::{
+use crate::syntax_analysis::expression_precedence::{
     ExpressionPrecedence, get_current_expression_precedence,
 };
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
 
 mod call_expression;
 mod infix_expression;
 
 impl SyntaxAnalysis<'_> {
-    pub(crate) fn pratt_parsing(
+    pub(super) fn pratt_parsing(
         &mut self,
         mut expression: Expression,
         minimum_expression_precedence: ExpressionPrecedence,
diff --git a/src/syntax_analysis/expression/utilities/mod.rs b/src/syntax_analysis/expression/utilities/mod.rs
index 3dac51af..b742608b 100644
--- a/src/syntax_analysis/expression/utilities/mod.rs
+++ b/src/syntax_analysis/expression/utilities/mod.rs
@@ -1,9 +1,9 @@
 use log::debug;
 
-use crate::lexical_analysis::model::token::Token;
+use crate::lexical_analysis::Token;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
-use crate::syntax_analysis::model::syntax_tree_node::{Block, Expression};
+use crate::syntax_analysis::expression_precedence::ExpressionPrecedence;
+use crate::syntax_analysis::{Block, Expression};
 
 impl SyntaxAnalysis<'_> {
     pub(super) fn parse_block(&mut self) -> anyhow::Result<Block> {
diff --git a/src/syntax_analysis/model/expression_precedence/mod.rs b/src/syntax_analysis/expression_precedence/mod.rs
similarity index 82%
rename from src/syntax_analysis/model/expression_precedence/mod.rs
rename to src/syntax_analysis/expression_precedence/mod.rs
index 6c2bafe3..156d2cfa 100644
--- a/src/syntax_analysis/model/expression_precedence/mod.rs
+++ b/src/syntax_analysis/expression_precedence/mod.rs
@@ -1,10 +1,10 @@
 use log::trace;
 
-use crate::lexical_analysis::model::token::Token;
-use crate::syntax_analysis::model::syntax_tree_node::InfixOperator;
+use crate::lexical_analysis::Token;
+use crate::syntax_analysis::InfixOperator;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub(crate) enum ExpressionPrecedence {
+pub(super) enum ExpressionPrecedence {
     Lowest,
     Equals,
     LesserOrGreater,
@@ -14,7 +14,7 @@ pub(crate) enum ExpressionPrecedence {
     Call,
 }
 
-pub(crate) fn get_current_expression_precedence(token: &Token) -> ExpressionPrecedence {
+pub(super) fn get_current_expression_precedence(token: &Token) -> ExpressionPrecedence {
     match token {
         Token::Equals => ExpressionPrecedence::Equals,
         Token::NotEquals => ExpressionPrecedence::Equals,
@@ -32,7 +32,7 @@ pub(crate) fn get_current_expression_precedence(token: &Token) -> ExpressionPrec
     }
 }
 
-pub(crate) fn get_infix_operator_precedence(operator: &InfixOperator) -> ExpressionPrecedence {
+pub(super) fn get_infix_operator_precedence(operator: &InfixOperator) -> ExpressionPrecedence {
     match operator {
         InfixOperator::Equals | InfixOperator::NotEquals => ExpressionPrecedence::Equals,
         InfixOperator::LesserThan | InfixOperator::GreaterThan => {
diff --git a/src/syntax_analysis/mod.rs b/src/syntax_analysis/mod.rs
index c6f71f53..6e24e274 100644
--- a/src/syntax_analysis/mod.rs
+++ b/src/syntax_analysis/mod.rs
@@ -1,19 +1,20 @@
 use log::debug;
 
-use crate::lexical_analysis::model::token::Token;
-use crate::syntax_analysis::model::syntax_tree_node::SyntaxTreeNode;
+use crate::lexical_analysis::Token;
 
 #[macro_use]
 mod macros;
 
-pub(crate) mod model;
-
 mod expression;
+mod expression_precedence;
 mod statement;
+mod syntax_tree_node;
 
 use std::iter::Peekable;
 use std::slice::Iter;
 
+pub use syntax_tree_node::{Block, Expression, InfixOperator, Statement, SyntaxTreeNode};
+
 pub(crate) struct SyntaxAnalysis<'a> {
     tokens: Peekable<Iter<'a, Token>>,
 }
@@ -27,7 +28,7 @@ impl SyntaxAnalysis<'_> {
         syntax_analysis.get_abstract_syntax_tree()
     }
 
-    pub(crate) fn get_abstract_syntax_tree(&mut self) -> anyhow::Result<Vec<SyntaxTreeNode>> {
+    pub(super) fn get_abstract_syntax_tree(&mut self) -> anyhow::Result<Vec<SyntaxTreeNode>> {
         let mut abstract_syntax_tree: Vec<SyntaxTreeNode> = vec![];
 
         while self.tokens.peek().is_some() {
diff --git a/src/syntax_analysis/model/mod.rs b/src/syntax_analysis/model/mod.rs
deleted file mode 100644
index b400e244..00000000
--- a/src/syntax_analysis/model/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub(crate) mod expression_precedence;
-pub(crate) mod syntax_tree_node;
diff --git a/src/syntax_analysis/statement/mod.rs b/src/syntax_analysis/statement/mod.rs
index 6e1e0e6d..0c6de668 100644
--- a/src/syntax_analysis/statement/mod.rs
+++ b/src/syntax_analysis/statement/mod.rs
@@ -1,12 +1,12 @@
 use log::{debug, trace};
 
-use crate::lexical_analysis::model::token::Token;
+use crate::lexical_analysis::Token;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
-use crate::syntax_analysis::model::syntax_tree_node::{Statement, SyntaxTreeNode};
+use crate::syntax_analysis::expression_precedence::ExpressionPrecedence;
+use crate::syntax_analysis::{Statement, SyntaxTreeNode};
 
 impl SyntaxAnalysis<'_> {
-    pub(crate) fn parse_return_statement(&mut self) -> anyhow::Result<SyntaxTreeNode> {
+    pub(super) fn parse_return_statement(&mut self) -> anyhow::Result<SyntaxTreeNode> {
         debug!("Parsing a return statement.");
 
         assert_token!(
@@ -24,7 +24,7 @@ impl SyntaxAnalysis<'_> {
         })
     }
 
-    pub(crate) fn parse_let_statement(&mut self) -> anyhow::Result<SyntaxTreeNode> {
+    pub(super) fn parse_let_statement(&mut self) -> anyhow::Result<SyntaxTreeNode> {
         debug!("Parsing a let statement.");
 
         assert_token!(
diff --git a/src/syntax_analysis/model/syntax_tree_node/mod.rs b/src/syntax_analysis/syntax_tree_node/mod.rs
similarity index 90%
rename from src/syntax_analysis/model/syntax_tree_node/mod.rs
rename to src/syntax_analysis/syntax_tree_node/mod.rs
index 8eef68cd..1acf4fc3 100644
--- a/src/syntax_analysis/model/syntax_tree_node/mod.rs
+++ b/src/syntax_analysis/syntax_tree_node/mod.rs
@@ -1,16 +1,16 @@
 #[derive(Debug, Clone, PartialEq)]
-pub(crate) struct Block {
-    pub(crate) nodes: Vec<SyntaxTreeNode>,
+pub struct Block {
+    pub nodes: Vec<SyntaxTreeNode>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub(crate) enum SyntaxTreeNode {
+pub enum SyntaxTreeNode {
     Statement { statement: Statement },
     Expression { expression: Expression },
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub(crate) enum Statement {
+pub enum Statement {
     Let {
         identifier: String,
         expression: Box<Expression>,
@@ -21,7 +21,7 @@ pub(crate) enum Statement {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub(crate) enum InfixOperator {
+pub enum InfixOperator {
     Plus,
     Minus,
     Multiply,
@@ -33,7 +33,7 @@ pub(crate) enum InfixOperator {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub(crate) enum Expression {
+pub enum Expression {
     Identifier {
         identifier: String,
     },