A42 Feature: Create complex functions

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");
 }

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;
 

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;
 

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()
     }
 }

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 {

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)]

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)]

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 {

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 {

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 {

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 {

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 {

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;

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 {

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 {

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 {

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 {

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 {

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};

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;
 

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)]

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)]

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;
 

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;
 

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)]

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();

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};
 

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(())
     }
 }

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> {