diff --git a/src/cli/tests.rs b/src/cli/tests.rs
index f3046749..c77290c8 100644
--- a/src/cli/tests.rs
+++ b/src/cli/tests.rs
@@ -426,4 +426,40 @@ fn function_with_args_different_types() {
         test(11, 42)
     ";
     assert_eq!(cli.test_eval(code).trim(), "HelloWorld\n53");
+}
+
+#[test]
+fn function_with_typed_args() {
+    let cli = CLI::new();
+    let code = "
+        fun test(a: Num, b: Num) {
+            $echo {a + b}$
+        }
+        test(11, 42)
+    ";
+    assert_eq!(cli.test_eval(code).trim(), "53");
+}
+#[test]
+fn function_with_typed_different_args() {
+    let cli = CLI::new();
+    let code = "
+        fun test(a: Num, b: Text) {
+            $echo {a}$
+            $echo {b}$
+        }
+        test(11, 'Hello')
+    ";
+    assert_eq!(cli.test_eval(code).trim(), "11\nHello");
+}
+
+#[test]
+fn function_with_typed_args_text() {
+    let cli = CLI::new();
+    let code = "
+        fun test(a: Text, b: Text) {
+            $echo {a + b}$
+        }
+        test('Hello', 'World')
+    ";
+    assert_eq!(cli.test_eval(code).trim(), "HelloWorld");
 }
\ No newline at end of file
diff --git a/src/modules/command/expr.rs b/src/modules/command/expr.rs
index 03420a0e..935c3862 100644
--- a/src/modules/command/expr.rs
+++ b/src/modules/command/expr.rs
@@ -1,5 +1,5 @@
 use heraclitus_compiler::prelude::*;
-use crate::{utils::{ParserMetadata, TranslateMetadata}, modules::{Type, Typed}};
+use crate::{utils::{ParserMetadata, TranslateMetadata}, modules::types::{Type, Typed}};
 use crate::modules::expression::expr::Expr;
 use crate::translate::module::TranslateModule;
 
diff --git a/src/modules/command/statement.rs b/src/modules/command/statement.rs
index 440ab691..d634ec3d 100644
--- a/src/modules/command/statement.rs
+++ b/src/modules/command/statement.rs
@@ -1,5 +1,5 @@
 use heraclitus_compiler::prelude::*;
-use crate::{utils::{ParserMetadata, TranslateMetadata}, modules::{Type, Typed}};
+use crate::{utils::{ParserMetadata, TranslateMetadata}, modules::types::{Type, Typed}};
 use crate::modules::expression::expr::Expr;
 use crate::translate::module::TranslateModule;
 
diff --git a/src/modules/condition/ternary.rs b/src/modules/condition/ternary.rs
index 9c425ccf..ec154721 100644
--- a/src/modules/condition/ternary.rs
+++ b/src/modules/condition/ternary.rs
@@ -1,5 +1,5 @@
 use heraclitus_compiler::prelude::*;
-use crate::modules::Typed;
+use crate::modules::types::{Type, Typed};
 use crate::modules::expression::binop::{parse_left_expr, expression_arms_of_same_type};
 use crate::modules::expression::expr::Expr;
 use crate::translate::module::TranslateModule;
@@ -14,7 +14,7 @@ pub struct Ternary {
 }
 
 impl Typed for Ternary {
-    fn get_type(&self) -> crate::modules::Type {
+    fn get_type(&self) -> Type {
         self.true_expr.get_type()
     }
 }
diff --git a/src/modules/expression/binop/add.rs b/src/modules/expression/binop/add.rs
index d998e411..8244c91a 100644
--- a/src/modules/expression/binop/add.rs
+++ b/src/modules/expression/binop/add.rs
@@ -3,7 +3,7 @@ use crate::translate::compute::{translate_computation, ArithOp};
 use crate::utils::{ParserMetadata, TranslateMetadata};
 use crate::translate::module::TranslateModule;
 use super::{super::expr::Expr, parse_left_expr, expression_arms_of_type};
-use crate::modules::{Type, Typed};
+use crate::modules::types::{Typed, Type};
 
 #[derive(Debug, Clone)]
 pub struct Add {
diff --git a/src/modules/expression/binop/and.rs b/src/modules/expression/binop/and.rs
index c16b5c04..a136e98f 100644
--- a/src/modules/expression/binop/and.rs
+++ b/src/modules/expression/binop/and.rs
@@ -3,7 +3,7 @@ use crate::translate::compute::{translate_computation, ArithOp};
 use crate::utils::{ParserMetadata, TranslateMetadata};
 use crate::translate::module::TranslateModule;
 use super::{super::expr::Expr, parse_left_expr, expression_arms_of_same_type};
-use crate::modules::{Type, Typed};
+use crate::modules::types::{Typed, Type};
 
 
 #[derive(Debug, Clone)]
diff --git a/src/modules/expression/binop/div.rs b/src/modules/expression/binop/div.rs
index 368b4239..fe0ddbde 100644
--- a/src/modules/expression/binop/div.rs
+++ b/src/modules/expression/binop/div.rs
@@ -1,7 +1,7 @@
 use heraclitus_compiler::prelude::*;
 use crate::{utils::{metadata::ParserMetadata, TranslateMetadata}, translate::compute::{translate_computation, ArithOp}};
 use super::{super::expr::Expr, parse_left_expr, expression_arms_of_type};
-use crate::modules::{Type, Typed};
+use crate::modules::types::{Typed, Type};
 use crate::translate::module::TranslateModule;
 
 #[derive(Debug, Clone)]
diff --git a/src/modules/expression/binop/eq.rs b/src/modules/expression/binop/eq.rs
index 1a6387af..10e1ceda 100644
--- a/src/modules/expression/binop/eq.rs
+++ b/src/modules/expression/binop/eq.rs
@@ -4,7 +4,7 @@ use crate::utils::{ParserMetadata, TranslateMetadata};
 use crate::translate::module::TranslateModule;
 use super::strip_text_quotes;
 use super::{super::expr::Expr, parse_left_expr, expression_arms_of_same_type};
-use crate::modules::{Type, Typed};
+use crate::modules::types::{Typed, Type};
 
 #[derive(Debug, Clone)]
 pub struct Eq {
diff --git a/src/modules/expression/binop/ge.rs b/src/modules/expression/binop/ge.rs
index d62de498..d76bc9ff 100644
--- a/src/modules/expression/binop/ge.rs
+++ b/src/modules/expression/binop/ge.rs
@@ -3,7 +3,7 @@ use crate::translate::compute::{ArithOp, translate_computation};
 use crate::utils::{ParserMetadata, TranslateMetadata};
 use crate::translate::module::TranslateModule;
 use super::{super::expr::Expr, parse_left_expr, expression_arms_of_type};
-use crate::modules::{Type, Typed};
+use crate::modules::types::{Typed, Type};
 
 #[derive(Debug, Clone)]
 pub struct Ge {
diff --git a/src/modules/expression/binop/gt.rs b/src/modules/expression/binop/gt.rs
index a1c65ea2..19bc20a9 100644
--- a/src/modules/expression/binop/gt.rs
+++ b/src/modules/expression/binop/gt.rs
@@ -3,7 +3,7 @@ use crate::translate::compute::{ArithOp, translate_computation};
 use crate::utils::{ParserMetadata, TranslateMetadata};
 use crate::translate::module::TranslateModule;
 use super::{super::expr::Expr, parse_left_expr, expression_arms_of_type};
-use crate::modules::{Type, Typed};
+use crate::modules::types::{Typed, Type};
 
 #[derive(Debug, Clone)]
 pub struct Gt {
diff --git a/src/modules/expression/binop/le.rs b/src/modules/expression/binop/le.rs
index 3ccaeaf8..5f9bf03a 100644
--- a/src/modules/expression/binop/le.rs
+++ b/src/modules/expression/binop/le.rs
@@ -3,7 +3,7 @@ use crate::translate::compute::{ArithOp, translate_computation};
 use crate::utils::{ParserMetadata, TranslateMetadata};
 use crate::translate::module::TranslateModule;
 use super::{super::expr::Expr, parse_left_expr, expression_arms_of_type};
-use crate::modules::{Type, Typed};
+use crate::modules::types::{Typed, Type};
 
 #[derive(Debug, Clone)]
 pub struct Le {
diff --git a/src/modules/expression/binop/lt.rs b/src/modules/expression/binop/lt.rs
index f0c33326..da08d8d0 100644
--- a/src/modules/expression/binop/lt.rs
+++ b/src/modules/expression/binop/lt.rs
@@ -3,7 +3,7 @@ use crate::translate::compute::{translate_computation, ArithOp};
 use crate::utils::{ParserMetadata, TranslateMetadata};
 use crate::translate::module::TranslateModule;
 use super::{super::expr::Expr, parse_left_expr, expression_arms_of_type};
-use crate::modules::{Type, Typed};
+use crate::modules::types::{Typed, Type};
 
 #[derive(Debug, Clone)]
 pub struct Lt {
diff --git a/src/modules/expression/binop/mod.rs b/src/modules/expression/binop/mod.rs
index 9d7924d6..eecdd29b 100644
--- a/src/modules/expression/binop/mod.rs
+++ b/src/modules/expression/binop/mod.rs
@@ -1,5 +1,5 @@
 use heraclitus_compiler::prelude::*;
-use crate::{utils::{metadata::ParserMetadata, error::get_error_logger}, modules::{Type, Typed}};
+use crate::{utils::{metadata::ParserMetadata, error::get_error_logger}, modules::types::{Type, Typed}};
 use super::super::expression::expr::Expr;
 
 pub mod add;
diff --git a/src/modules/expression/binop/modulo.rs b/src/modules/expression/binop/modulo.rs
index f0f9e725..87464a58 100644
--- a/src/modules/expression/binop/modulo.rs
+++ b/src/modules/expression/binop/modulo.rs
@@ -3,7 +3,7 @@ use crate::translate::compute::{ArithOp, translate_computation};
 use crate::utils::{ParserMetadata, TranslateMetadata};
 use crate::translate::module::TranslateModule;
 use super::{super::expr::Expr, parse_left_expr, expression_arms_of_type};
-use crate::modules::{Type, Typed};
+use crate::modules::types::{Typed, Type};
 
 #[derive(Debug, Clone)]
 pub struct Modulo {
diff --git a/src/modules/expression/binop/mul.rs b/src/modules/expression/binop/mul.rs
index 43a68671..2fb9d7e3 100644
--- a/src/modules/expression/binop/mul.rs
+++ b/src/modules/expression/binop/mul.rs
@@ -3,7 +3,7 @@ use crate::translate::compute::{translate_computation, ArithOp};
 use crate::utils::{ParserMetadata, TranslateMetadata};
 use crate::translate::module::TranslateModule;
 use super::{super::expr::Expr, parse_left_expr, expression_arms_of_type};
-use crate::modules::{Type, Typed};
+use crate::modules::types::{Typed, Type};
 
 #[derive(Debug, Clone)]
 pub struct Mul {
diff --git a/src/modules/expression/binop/neq.rs b/src/modules/expression/binop/neq.rs
index 56c59139..36f543e2 100644
--- a/src/modules/expression/binop/neq.rs
+++ b/src/modules/expression/binop/neq.rs
@@ -4,7 +4,7 @@ use crate::utils::{ParserMetadata, TranslateMetadata};
 use crate::translate::module::TranslateModule;
 use super::strip_text_quotes;
 use super::{super::expr::Expr, parse_left_expr, expression_arms_of_same_type};
-use crate::modules::{Type, Typed};
+use crate::modules::types::{Typed, Type};
 
 #[derive(Debug, Clone)]
 pub struct Neq {
diff --git a/src/modules/expression/binop/or.rs b/src/modules/expression/binop/or.rs
index 618246dc..dcfd307e 100644
--- a/src/modules/expression/binop/or.rs
+++ b/src/modules/expression/binop/or.rs
@@ -3,7 +3,7 @@ use crate::translate::compute::{translate_computation, ArithOp};
 use crate::utils::{ParserMetadata, TranslateMetadata};
 use crate::translate::module::TranslateModule;
 use super::{super::expr::Expr, parse_left_expr, expression_arms_of_same_type};
-use crate::modules::{Type, Typed};
+use crate::modules::types::{Typed, Type};
 
 #[derive(Debug, Clone)]
 pub struct Or {
diff --git a/src/modules/expression/binop/sub.rs b/src/modules/expression/binop/sub.rs
index 62e5eea1..9a0a96ff 100644
--- a/src/modules/expression/binop/sub.rs
+++ b/src/modules/expression/binop/sub.rs
@@ -3,7 +3,7 @@ use crate::translate::compute::{ArithOp, translate_computation};
 use crate::utils::{ParserMetadata, TranslateMetadata};
 use crate::translate::module::TranslateModule;
 use super::{super::expr::Expr, parse_left_expr, expression_arms_of_type};
-use crate::modules::{Type, Typed};
+use crate::modules::types::{Typed, Type};
 
 #[derive(Debug, Clone)]
 pub struct Sub {
diff --git a/src/modules/expression/expr.rs b/src/modules/expression/expr.rs
index 1ead960a..a26d3047 100644
--- a/src/modules/expression/expr.rs
+++ b/src/modules/expression/expr.rs
@@ -1,5 +1,5 @@
 use heraclitus_compiler::prelude::*;
-use crate::modules::{Typed, Type};
+use crate::modules::types::{Typed, Type};
 use crate::translate::module::TranslateModule;
 use crate::utils::error::get_error_logger;
 use crate::utils::{ParserMetadata, TranslateMetadata};
diff --git a/src/modules/expression/literal/bool.rs b/src/modules/expression/literal/bool.rs
index 8a9ea333..df489362 100644
--- a/src/modules/expression/literal/bool.rs
+++ b/src/modules/expression/literal/bool.rs
@@ -1,5 +1,5 @@
 use heraclitus_compiler::prelude::*;
-use crate::{utils::metadata::ParserMetadata, modules::{Type, Typed}};
+use crate::{utils::metadata::ParserMetadata, modules::types::{Type, Typed}};
 use crate::translate::module::TranslateModule;
 use crate::utils::TranslateMetadata;
 
diff --git a/src/modules/expression/literal/null.rs b/src/modules/expression/literal/null.rs
index bcbe2619..cc144492 100644
--- a/src/modules/expression/literal/null.rs
+++ b/src/modules/expression/literal/null.rs
@@ -1,5 +1,5 @@
 use heraclitus_compiler::prelude::*;
-use crate::{utils::{ParserMetadata, TranslateMetadata}, modules::{Type, Typed}};
+use crate::{utils::{ParserMetadata, TranslateMetadata}, modules::types::{Type, Typed}};
 use crate::translate::module::TranslateModule;
 
 #[derive(Debug)]
diff --git a/src/modules/expression/literal/number.rs b/src/modules/expression/literal/number.rs
index 93ec3f3e..2604ad11 100644
--- a/src/modules/expression/literal/number.rs
+++ b/src/modules/expression/literal/number.rs
@@ -1,5 +1,5 @@
 use heraclitus_compiler::prelude::*;
-use crate::{utils::metadata::{ParserMetadata, TranslateMetadata}, modules::{Typed, Type}};
+use crate::{utils::metadata::{ParserMetadata, TranslateMetadata}, modules::types::{Type, Typed}};
 use crate::translate::module::TranslateModule;
 
 #[derive(Debug, Clone)]
diff --git a/src/modules/expression/literal/text.rs b/src/modules/expression/literal/text.rs
index f414a886..b562475c 100644
--- a/src/modules/expression/literal/text.rs
+++ b/src/modules/expression/literal/text.rs
@@ -1,5 +1,5 @@
 use heraclitus_compiler::prelude::*;
-use crate::{utils::{TranslateMetadata, ParserMetadata}, modules::{Type, Typed}};
+use crate::{utils::{TranslateMetadata, ParserMetadata}, modules::types::{Type, Typed}};
 use crate::translate::module::TranslateModule;
 use crate::modules::expression::expr::Expr;
 
diff --git a/src/modules/expression/parenthesis.rs b/src/modules/expression/parenthesis.rs
index 679c06d6..b6a8d00e 100644
--- a/src/modules/expression/parenthesis.rs
+++ b/src/modules/expression/parenthesis.rs
@@ -1,5 +1,5 @@
 use heraclitus_compiler::prelude::*;
-use crate::{utils::metadata::ParserMetadata, modules::{Type, Typed}};
+use crate::{utils::metadata::ParserMetadata, modules::types::{Type, Typed}};
 use crate::translate::module::TranslateModule;
 use super::expr::Expr;
 
diff --git a/src/modules/expression/unop/not.rs b/src/modules/expression/unop/not.rs
index 11b76c24..05853028 100644
--- a/src/modules/expression/unop/not.rs
+++ b/src/modules/expression/unop/not.rs
@@ -1,5 +1,5 @@
 use heraclitus_compiler::prelude::*;
-use crate::{utils::{metadata::ParserMetadata, TranslateMetadata}, modules::{Type, Typed}, translate::{module::TranslateModule, compute::{translate_computation, ArithOp}}};
+use crate::{utils::{metadata::ParserMetadata, TranslateMetadata}, modules::types::{Type, Typed}, translate::{module::TranslateModule, compute::{translate_computation, ArithOp}}};
 use super::super::expr::Expr;
 
 #[derive(Debug, Clone)]
diff --git a/src/modules/function/declaration.rs b/src/modules/function/declaration.rs
index b195e895..4e851944 100644
--- a/src/modules/function/declaration.rs
+++ b/src/modules/function/declaration.rs
@@ -1,10 +1,11 @@
 use heraclitus_compiler::prelude::*;
-use crate::modules::Type;
+use crate::modules::types::Type;
 use crate::modules::variable::variable_name_extensions;
 use crate::utils::error::get_error_logger;
 use crate::utils::metadata::{ParserMetadata, TranslateMetadata};
 use crate::translate::module::TranslateModule;
 use crate::modules::block::Block;
+use crate::modules::types::parse_type;
 use crate::context;
 
 use super::declaration_utils::*;
@@ -58,12 +59,21 @@ impl SyntaxModule<ParserMetadata> for FunctionDeclaration {
                     break
                 }
                 let name = variable(meta, variable_name_extensions())?;
-                self.args.push((name, Type::Generic));
+                // Optionally parse the argument type
+                match token(meta, ":") {
+                    Ok(_) => self.args.push((name.clone(), parse_type(meta)?)),
+                    Err(_) => self.args.push((name, Type::Generic))
+                }
                 match token(meta, ")") {
                     Ok(_) => break,
                     Err(_) => token(meta, ",")?
                 };
             }
+            // Optionally parse the return type
+            match token(meta, ":") {
+                Ok(_) => self.returns = parse_type(meta)?,
+                Err(_) => self.returns = Type::Text
+            }
             // Parse the body
             token(meta, "{")?;
             let index_begin = meta.get_index();
diff --git a/src/modules/function/declaration_utils.rs b/src/modules/function/declaration_utils.rs
index 5c56aa7f..2595fe7d 100644
--- a/src/modules/function/declaration_utils.rs
+++ b/src/modules/function/declaration_utils.rs
@@ -1,5 +1,5 @@
 use heraclitus_compiler::prelude::*;
-use crate::modules::Type;
+use crate::modules::types::Type;
 use crate::utils::{ParserMetadata, error::get_error_logger};
 use crate::modules::variable::{handle_identifier_name};
 
diff --git a/src/modules/function/invocation.rs b/src/modules/function/invocation.rs
index 2e6c3ce7..e6ae7b25 100644
--- a/src/modules/function/invocation.rs
+++ b/src/modules/function/invocation.rs
@@ -1,10 +1,9 @@
 use heraclitus_compiler::prelude::*;
-use crate::modules::Type;
+use crate::modules::types::{Type, Typed};
 use crate::modules::variable::variable_name_extensions;
 use crate::utils::metadata::{ParserMetadata, TranslateMetadata};
 use crate::translate::module::TranslateModule;
 use crate::modules::expression::expr::Expr;
-use crate::modules::Typed;
 
 use super::invocation_utils::*;
 
@@ -40,7 +39,7 @@ impl SyntaxModule<ParserMetadata> for FunctionInvocation {
         self.name = variable(meta, variable_name_extensions())?;
         // Get the arguments
         token(meta, "(")?;
-        handle_function_reference(meta, tok, &self.name);
+        handle_function_reference(meta, tok.clone(), &self.name);
         loop {
             if token(meta, ")").is_ok() {
                 break
@@ -54,7 +53,7 @@ impl SyntaxModule<ParserMetadata> for FunctionInvocation {
             };
         }
         let types = self.args.iter().map(|e| e.get_type()).collect::<Vec<Type>>();
-        (self.kind, self.id) = handle_function_parameters(meta, &self.name, &types);
+        (self.kind, self.id) = handle_function_parameters(meta, &self.name, &types, tok);
         Ok(())
     }
 }
diff --git a/src/modules/function/invocation_utils.rs b/src/modules/function/invocation_utils.rs
index 5009dd24..8ef5232c 100644
--- a/src/modules/function/invocation_utils.rs
+++ b/src/modules/function/invocation_utils.rs
@@ -1,10 +1,10 @@
 use heraclitus_compiler::prelude::*;
 use similar_string::find_best_similarity;
-use crate::modules::Type;
+use crate::modules::types::Type;
 use crate::utils::{ParserMetadata, error::get_error_logger};
 use crate::modules::block::Block;
 
-fn run_function_with_args(meta: &mut ParserMetadata, name: &str, args: &[Type]) -> usize {
+fn run_function_with_args(meta: &mut ParserMetadata, name: &str, args: &[Type], tok: Option<Token>) -> usize {
     let function = meta.mem.get_function(name).unwrap().clone();
     let mut block = Block::new();
     // Create a new parser metadata specific for the function parsing context
@@ -13,6 +13,28 @@ fn run_function_with_args(meta: &mut ParserMetadata, name: &str, args: &[Type])
     new_meta.expr = function.body.clone();
     new_meta.set_index(0);
     new_meta.function_ctx = true;
+    // Check if the function can exist
+    if function.typed {
+        if function.args.len() != args.len() {
+            let err_details = ErrorDetails::from_token_option(tok.clone());
+            let were_was = if args.len() == 1 { "was" } else { "were" };
+            let error = format!("Function '{}' expects {} arguments, but {} {were_was} given", name, function.args.len(), args.len());
+            get_error_logger(meta, err_details)
+                .attach_message(error)
+                .show()
+                .exit();
+        }
+        for (index, (arg, kind)) in function.args.iter().enumerate() {
+            if kind != &args[index] {
+                let err_details = ErrorDetails::from_token_option(tok.clone());
+                let error = format!("Function '{}' expects argument '{}' to be of type '{}', but '{}' was given", name, arg, kind, args[index]);
+                get_error_logger(meta, err_details)
+                    .attach_message(error)
+                    .show()
+                    .exit();
+            }
+        }
+    }
     // Create a sub context for new variables
     new_meta.mem.push_scope();
     for (kind, (name, _generic)) in args.iter().zip(function.args.iter()) {
@@ -24,7 +46,7 @@ fn run_function_with_args(meta: &mut ParserMetadata, name: &str, args: &[Type])
         new_meta.mem.pop_scope();
         new_meta.function_ctx = function_ctx;
         // Persist the new function instance
-        meta.mem.add_function_instance(function.id, args, Type::Text,  block)
+        meta.mem.add_function_instance(function.id, args, function.returns,  block)
     } else { 0 }
 }
 
@@ -41,10 +63,10 @@ pub fn handle_function_reference(meta: &mut ParserMetadata, tok: Option<Token>,
     }
 }
 
-pub fn handle_function_parameters(meta: &mut ParserMetadata, name: &str, args: &[Type]) -> (Type, usize) {
+pub fn handle_function_parameters(meta: &mut ParserMetadata, name: &str, args: &[Type], tok: Option<Token>) -> (Type, usize) {
     let function_unit = meta.mem.get_function(name).unwrap().clone();
     // TODO: Here is a good place to insert trace
-    (function_unit.returns, run_function_with_args(meta, name, args))
+    (function_unit.returns, run_function_with_args(meta, name, args, tok))
 }
 
 fn handle_similar_function(meta: &mut ParserMetadata, name: &str) -> Option<String> {
diff --git a/src/modules/mod.rs b/src/modules/mod.rs
index fb6168f9..b083771b 100644
--- a/src/modules/mod.rs
+++ b/src/modules/mod.rs
@@ -7,6 +7,7 @@ pub mod condition;
 pub mod shorthand;
 pub mod loops;
 pub mod function;
+pub mod types;
 
 #[macro_export]
 macro_rules! handle_types {
@@ -36,16 +37,3 @@ macro_rules! handle_types {
         }
     };
 }
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Type {
-    Text,
-    Bool,
-    Num,
-    Null,
-    Generic
-}
-
-pub trait Typed {
-    fn get_type(&self) -> Type;
-}
\ No newline at end of file
diff --git a/src/modules/shorthand/add.rs b/src/modules/shorthand/add.rs
index 077bb31a..10750dfc 100644
--- a/src/modules/shorthand/add.rs
+++ b/src/modules/shorthand/add.rs
@@ -1,6 +1,9 @@
 use heraclitus_compiler::prelude::*;
-use crate::{modules::{variable::{variable_name_extensions, handle_variable_reference}, expression::{expr::Expr, binop::expression_arms_of_type}, Type}, utils::ParserMetadata, translate::{module::TranslateModule, compute::{ArithOp, translate_computation}}};
-use crate::modules::Typed;
+use crate::modules::expression::{expr::Expr, binop::expression_arms_of_type};
+use crate::modules::variable::{variable_name_extensions, handle_variable_reference};
+use crate::utils::{ParserMetadata, TranslateMetadata};
+use crate::translate::{module::TranslateModule, compute::{ArithOp, translate_computation}};
+use crate::modules::types::{Type, Typed};
 
 #[derive(Debug, Clone)]
 pub struct ShorthandAdd {
@@ -34,7 +37,7 @@ impl SyntaxModule<ParserMetadata> for ShorthandAdd {
 }
 
 impl TranslateModule for ShorthandAdd {
-    fn translate(&self, meta: &mut crate::utils::TranslateMetadata) -> String {
+    fn translate(&self, meta: &mut TranslateMetadata) -> String {
         let expr = self.expr.translate(meta);
         let name = self.var.clone();
         let var = format!("${{{name}}}");
diff --git a/src/modules/shorthand/div.rs b/src/modules/shorthand/div.rs
index a11e3f38..b28c570f 100644
--- a/src/modules/shorthand/div.rs
+++ b/src/modules/shorthand/div.rs
@@ -1,6 +1,9 @@
 use heraclitus_compiler::prelude::*;
-use crate::{modules::{variable::{variable_name_extensions, handle_variable_reference}, expression::{expr::Expr, binop::expression_arms_of_type}, Type}, utils::ParserMetadata, translate::{module::TranslateModule, compute::{ArithOp, translate_computation}}};
-use crate::modules::Typed;
+use crate::modules::expression::{expr::Expr, binop::expression_arms_of_type};
+use crate::modules::variable::{variable_name_extensions, handle_variable_reference};
+use crate::utils::{ParserMetadata, TranslateMetadata};
+use crate::translate::{module::TranslateModule, compute::{ArithOp, translate_computation}};
+use crate::modules::types::{Type, Typed};
 
 #[derive(Debug, Clone)]
 pub struct ShorthandDiv {
@@ -34,7 +37,7 @@ impl SyntaxModule<ParserMetadata> for ShorthandDiv {
 }
 
 impl TranslateModule for ShorthandDiv {
-    fn translate(&self, meta: &mut crate::utils::TranslateMetadata) -> String {
+    fn translate(&self, meta: &mut TranslateMetadata) -> String {
         let expr = self.expr.translate(meta);
         let name = self.var.clone();
         let var = format!("${{{name}}}");
diff --git a/src/modules/shorthand/modulo.rs b/src/modules/shorthand/modulo.rs
index 6cc8b43a..086248cd 100644
--- a/src/modules/shorthand/modulo.rs
+++ b/src/modules/shorthand/modulo.rs
@@ -1,6 +1,9 @@
 use heraclitus_compiler::prelude::*;
-use crate::{modules::{variable::{variable_name_extensions, handle_variable_reference}, expression::{expr::Expr, binop::expression_arms_of_type}, Type}, utils::ParserMetadata, translate::{module::TranslateModule, compute::{ArithOp, translate_computation}}};
-use crate::modules::Typed;
+use crate::modules::expression::{expr::Expr, binop::expression_arms_of_type};
+use crate::modules::variable::{variable_name_extensions, handle_variable_reference};
+use crate::utils::{ParserMetadata, TranslateMetadata};
+use crate::translate::{module::TranslateModule, compute::{ArithOp, translate_computation}};
+use crate::modules::types::{Type, Typed};
 
 #[derive(Debug, Clone)]
 pub struct ShorthandModulo {
@@ -34,7 +37,7 @@ impl SyntaxModule<ParserMetadata> for ShorthandModulo {
 }
 
 impl TranslateModule for ShorthandModulo {
-    fn translate(&self, meta: &mut crate::utils::TranslateMetadata) -> String {
+    fn translate(&self, meta: &mut TranslateMetadata) -> String {
         let expr = self.expr.translate(meta);
         let name = self.var.clone();
         let var = format!("${{{name}}}");
diff --git a/src/modules/shorthand/mul.rs b/src/modules/shorthand/mul.rs
index 9ed691b2..2c662975 100644
--- a/src/modules/shorthand/mul.rs
+++ b/src/modules/shorthand/mul.rs
@@ -1,6 +1,9 @@
 use heraclitus_compiler::prelude::*;
-use crate::{modules::{variable::{variable_name_extensions, handle_variable_reference}, expression::{expr::Expr, binop::expression_arms_of_type}, Type}, utils::ParserMetadata, translate::{module::TranslateModule, compute::{ArithOp, translate_computation}}};
-use crate::modules::Typed;
+use crate::modules::expression::{expr::Expr, binop::expression_arms_of_type};
+use crate::modules::variable::{variable_name_extensions, handle_variable_reference};
+use crate::utils::{ParserMetadata, TranslateMetadata};
+use crate::translate::{module::TranslateModule, compute::{ArithOp, translate_computation}};
+use crate::modules::types::{Type, Typed};
 
 #[derive(Debug, Clone)]
 pub struct ShorthandMul {
@@ -34,7 +37,7 @@ impl SyntaxModule<ParserMetadata> for ShorthandMul {
 }
 
 impl TranslateModule for ShorthandMul {
-    fn translate(&self, meta: &mut crate::utils::TranslateMetadata) -> String {
+    fn translate(&self, meta: &mut TranslateMetadata) -> String {
         let expr = self.expr.translate(meta);
         let name = self.var.clone();
         let var = format!("${{{name}}}");
diff --git a/src/modules/shorthand/sub.rs b/src/modules/shorthand/sub.rs
index 5bb87640..510f3f9b 100644
--- a/src/modules/shorthand/sub.rs
+++ b/src/modules/shorthand/sub.rs
@@ -1,6 +1,9 @@
 use heraclitus_compiler::prelude::*;
-use crate::{modules::{variable::{variable_name_extensions, handle_variable_reference}, expression::{expr::Expr, binop::expression_arms_of_type}, Type}, utils::ParserMetadata, translate::{module::TranslateModule, compute::{ArithOp, translate_computation}}};
-use crate::modules::Typed;
+use crate::modules::expression::{expr::Expr, binop::expression_arms_of_type};
+use crate::modules::variable::{variable_name_extensions, handle_variable_reference};
+use crate::utils::{ParserMetadata, TranslateMetadata};
+use crate::translate::{module::TranslateModule, compute::{ArithOp, translate_computation}};
+use crate::modules::types::{Type, Typed};
 
 #[derive(Debug, Clone)]
 pub struct ShorthandSub {
@@ -34,7 +37,7 @@ impl SyntaxModule<ParserMetadata> for ShorthandSub {
 }
 
 impl TranslateModule for ShorthandSub {
-    fn translate(&self, meta: &mut crate::utils::TranslateMetadata) -> String {
+    fn translate(&self, meta: &mut TranslateMetadata) -> String {
         let expr = self.expr.translate(meta);
         let name = self.var.clone();
         let var = format!("${{{name}}}");
diff --git a/src/modules/types.rs b/src/modules/types.rs
new file mode 100644
index 00000000..fbd3909e
--- /dev/null
+++ b/src/modules/types.rs
@@ -0,0 +1,53 @@
+use std::fmt::Display;
+
+use heraclitus_compiler::prelude::*;
+use crate::utils::ParserMetadata;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Type {
+    Text,
+    Bool,
+    Num,
+    Null,
+    Generic
+}
+
+impl Display for Type {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Type::Text => write!(f, "Text"),
+            Type::Bool => write!(f, "Bool"),
+            Type::Num => write!(f, "Num"),
+            Type::Null => write!(f, "Null"),
+            Type::Generic => write!(f, "Generic")
+        }
+    }
+}
+
+pub trait Typed {
+    fn get_type(&self) -> Type;
+}
+
+pub fn parse_type(meta: &mut ParserMetadata) -> Result<Type,ErrorDetails> {
+    let tok = meta.get_current_token();
+    match tok {
+        Some(token) => {
+            match token.word.as_ref() {
+                "Text" => {
+                    meta.increment_index();
+                    Ok(Type::Text)
+                },
+                "Bool" => {
+                    meta.increment_index();
+                    Ok(Type::Bool)
+                },
+                "Num" => {
+                    meta.increment_index();
+                    Ok(Type::Num)
+                },
+                _ => Err(ErrorDetails::from_token_option(Some(token)))
+            }
+        },
+        None => Err(ErrorDetails::with_eof())
+    }
+}
\ No newline at end of file
diff --git a/src/modules/variable/get.rs b/src/modules/variable/get.rs
index 248b957e..3230b8ae 100644
--- a/src/modules/variable/get.rs
+++ b/src/modules/variable/get.rs
@@ -1,5 +1,5 @@
 use heraclitus_compiler::prelude::*;
-use crate::{utils::{ParserMetadata, TranslateMetadata}, modules::{Type, Typed}};
+use crate::{utils::{ParserMetadata, TranslateMetadata}, modules::types::{Type, Typed}};
 use crate::translate::module::TranslateModule;
 use super::{variable_name_extensions, handle_variable_reference};
 
diff --git a/src/modules/variable/init.rs b/src/modules/variable/init.rs
index 3b80192e..e3e7abbb 100644
--- a/src/modules/variable/init.rs
+++ b/src/modules/variable/init.rs
@@ -1,6 +1,6 @@
 use heraclitus_compiler::prelude::*;
 use crate::context;
-use crate::modules::{Typed, Type};
+use crate::modules::types::{Typed, Type};
 use crate::modules::expression::expr::Expr;
 use crate::translate::module::TranslateModule;
 use crate::utils::error::get_error_logger;
diff --git a/src/modules/variable/mod.rs b/src/modules/variable/mod.rs
index 8eb5ed26..68bd21ad 100644
--- a/src/modules/variable/mod.rs
+++ b/src/modules/variable/mod.rs
@@ -1,5 +1,5 @@
 use heraclitus_compiler::prelude::*;
-use crate::{utils::{metadata::ParserMetadata, error::get_error_logger}, modules::{Type}};
+use crate::{utils::{metadata::ParserMetadata, error::get_error_logger}, modules::{types::Type}};
 use similar_string::find_best_similarity;
 
 pub mod init;
diff --git a/src/rules.rs b/src/rules.rs
index b3c8c8f0..c88346fc 100644
--- a/src/rules.rs
+++ b/src/rules.rs
@@ -2,7 +2,7 @@ use heraclitus_compiler::prelude::*;
 
 pub fn get_rules() -> Rules {
     let symbols = vec![
-        '+', '-', '*', '/', '%', '\n', ';',
+        '+', '-', '*', '/', '%', '\n', ';', ':',
         '(', ')', '[', ']', '{', '}', ','
     ];
     let compounds = vec![
diff --git a/src/utils/function_map.rs b/src/utils/function_map.rs
index aa53ce15..3c44812a 100644
--- a/src/utils/function_map.rs
+++ b/src/utils/function_map.rs
@@ -1,5 +1,5 @@
 use std::collections::HashMap;
-use crate::modules::{Type, block::Block};
+use crate::modules::{types::Type, block::Block};
 
 #[derive(Clone, Debug)]
 pub struct FunctionInstance {
diff --git a/src/utils/memory.rs b/src/utils/memory.rs
index c25701a3..b8550af3 100644
--- a/src/utils/memory.rs
+++ b/src/utils/memory.rs
@@ -1,6 +1,6 @@
 use heraclitus_compiler::prelude::*;
 use std::collections::{HashMap, BTreeSet};
-use crate::modules::{Type, block::Block};
+use crate::modules::{types::Type, block::Block};
 
 use super::function_map::{FunctionMap, FunctionInstance};