@devaloop/devalang 0.0.1-alpha.11 → 0.0.1-alpha.13

package/rust/core/debugger/store.rs

@@ -1,25 +1,39 @@
-use std::{ collections::HashMap, fs::create_dir_all };
-use crate::core::{ debugger::Debugger, preprocessor::module::Module };
+use std::{ fs::create_dir_all };
+use crate::core::{
+    debugger::Debugger,
+    store::{ function::FunctionTable, variable::VariableTable },
+};
 
-pub fn write_store_log_file(output_dir: &str, file_name: &str, modules: HashMap<String, Module>) {
+pub fn write_variables_log_file(output_dir: &str, file_name: &str, variables: VariableTable) {
     let debugger = Debugger::new();
     let mut content = String::new();
 
     let log_directory = format!("{}/logs", output_dir);
     create_dir_all(&log_directory).expect("Failed to create log directory");
 
-    for (path, module) in modules {
-        content.push_str(&format!("--- Module: {} ---\n", path));
+    for (var_name, var_data) in variables.variables {
+        content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
+    }
+
+    content.push_str("\n");
+
+    debugger.write_log_file(&log_directory, file_name, &content);
+}
 
-        for (index, var_value) in module.variable_table.variables.iter().enumerate() {
-            let var_name = var_value.0.clone();
-            let var_data = var_value.1;
+pub fn write_function_log_file(output_dir: &str, file_name: &str, functions: FunctionTable) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
 
-            content.push_str(&format!("{}: {:?} = {:?}\n", index + 1, var_name, var_data));
-        }
+    let log_directory = format!("{}/logs", output_dir);
+    create_dir_all(&log_directory).expect("Failed to create log directory");
 
-        content.push_str("\n");
+    for (index, function) in functions.functions {
+        content.push_str(
+            &format!("'{}' = [{:?}] => {:?}\n", function.name, function.parameters, function.body)
+        );
     }
 
+    content.push_str("\n");
+
     debugger.write_log_file(&log_directory, file_name, &content);
 }

package/rust/core/error/mod.rs

@@ -4,6 +4,12 @@ pub struct ErrorHandler {
     errors: Vec<Error>,
 }
 
+pub struct ErrorResult {
+    pub message: String,
+    pub line: usize,
+    pub column: usize,
+}
+
 pub struct Error {
     pub message: String,
     pub line: usize,

package/rust/core/lexer/handler/driver.rs

@@ -1,6 +1,6 @@
 use crate::core::lexer::{
     handler::{
-        arrow::handle_arrow_lexer, at::handle_at_lexer, brace::{ handle_lbrace_lexer, handle_rbrace_lexer }, colon::handle_colon_lexer, comment::handle_comment_lexer, dot::handle_dot_lexer, identifier::handle_identifier_lexer, indent::handle_indent_lexer, newline::handle_newline_lexer, number::handle_number_lexer, operator::handle_operator_lexer, slash::handle_slash_lexer, string::handle_string_lexer
+        arrow::handle_arrow_lexer, at::handle_at_lexer, brace::{ handle_lbrace_lexer, handle_rbrace_lexer }, colon::handle_colon_lexer, comment::handle_comment_lexer, dot::handle_dot_lexer, identifier::handle_identifier_lexer, indent::handle_indent_lexer, newline::handle_newline_lexer, number::handle_number_lexer, operator::handle_operator_lexer, parenthesis::{handle_lparen_lexer, handle_rparen_lexer}, slash::handle_slash_lexer, string::handle_string_lexer
     },
     token::{ Token, TokenKind },
 };
@@ -145,6 +145,28 @@ pub fn handle_content_lexing(content: String) -> Result<Vec<Token>, String> {
                     &mut column
                 );
             }
+            '(' => {
+                handle_lparen_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
+            ')' => {
+                handle_rparen_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
             '.' => {
                 handle_dot_lexer(
                     ch,

package/rust/core/lexer/handler/identifier.rs

@@ -28,6 +28,7 @@ pub fn handle_identifier_lexer(
         "bpm" => TokenKind::Tempo,
         "loop" => TokenKind::Loop,
         "synth" => TokenKind::Synth,
+        "fn" => TokenKind::Function,
         _ => TokenKind::Identifier,
     };
 

package/rust/core/lexer/handler/mod.rs

@@ -13,3 +13,4 @@ pub mod indent;
 pub mod string;
 pub mod arrow;
 pub mod slash;
+pub mod parenthesis;

package/rust/core/lexer/handler/parenthesis.rs

@@ -0,0 +1,41 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_rparen_lexer(
+    char: char,
+    chars: &mut std::iter::Peekable<std::str::Chars>,
+    current_indent: &mut usize,
+    indent_stack: &mut Vec<usize>,
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize
+) {
+    tokens.push(Token {
+        kind: TokenKind::RParen,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}
+
+pub fn handle_lparen_lexer(
+    char: char,
+    chars: &mut std::iter::Peekable<std::str::Chars>,
+    current_indent: &mut usize,
+    indent_stack: &mut Vec<usize>,
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize
+) {
+    tokens.push(Token {
+        kind: TokenKind::LParen,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}

package/rust/core/lexer/token.rs

@@ -29,6 +29,7 @@ pub enum TokenKind {
     Tempo,
     Bank,
     Loop,
+    Function,
 
     // ───── Instruments ─────
     Synth,
@@ -64,6 +65,8 @@ pub enum TokenKind {
     RBrace, // }
     LBracket, // [
     RBracket, // ]
+    LParen, // (
+    RParen, // )
 
     // ───── Quotes ─────
     Quote, // '

package/rust/core/parser/driver.rs

@@ -7,7 +7,7 @@ use crate::core::{
             bank::parse_bank_token,
             condition::parse_condition_token,
             dot::parse_dot_token,
-            identifier::parse_identifier_token,
+            identifier::{function::parse_function_token, parse_identifier_token},
             loop_::parse_loop_token,
             tempo::parse_tempo_token,
         },
@@ -138,6 +138,7 @@ impl Parser {
                 TokenKind::Bank => parse_bank_token(self, global_store),
                 TokenKind::Loop => parse_loop_token(self, global_store),
                 TokenKind::If => parse_condition_token(self, global_store),
+                TokenKind::Function => parse_function_token(self, global_store),
 
                 | TokenKind::Else // Ignore else, already handled in `parse_condition_token`
                 | TokenKind::Comment
@@ -206,9 +207,35 @@ impl Parser {
                         Value::String(token.lexeme.clone())
                     }
                     TokenKind::Number => {
-                        self.advance();
-                        Value::Number(token.lexeme.parse().unwrap_or(0.0))
+                        let mut number_str = token.lexeme.clone();
+                        self.advance(); // consume the first number
+
+                        if let Some(dot_token) = self.peek_clone() {
+                            if dot_token.kind == TokenKind::Dot {
+                                self.advance(); // consume the dot
+
+                                if let Some(decimal_token) = self.peek_clone() {
+                                    if decimal_token.kind == TokenKind::Number {
+                                        self.advance(); // consume the number after the dot
+                                        number_str.push('.');
+                                        number_str.push_str(&decimal_token.lexeme);
+                                    } else {
+                                        println!(
+                                            "Expected number after dot, got {:?}",
+                                            decimal_token
+                                        );
+                                        return Some(Value::Null);
+                                    }
+                                } else {
+                                    println!("Expected number after dot, but reached EOF");
+                                    return Some(Value::Null);
+                                }
+                            }
+                        }
+
+                        Value::Number(number_str.parse::<f32>().unwrap_or(0.0))
                     }
+
                     TokenKind::Identifier => {
                         self.advance();
                         Value::Identifier(token.lexeme.clone())
@@ -277,6 +304,7 @@ impl Parser {
             }
             collected.push(self.advance().unwrap().clone());
         }
+        
         collected
     }
 

package/rust/core/parser/handler/dot.rs

@@ -1,166 +1,102 @@
 use crate::core::{
     lexer::token::TokenKind,
-    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
-    shared::{ duration::Duration, value::Value },
-    store::global::GlobalStore,
+    parser::{driver::Parser, statement::{Statement, StatementKind}},
+    shared::{duration::Duration, value::Value},
 };
 
-pub fn parse_dot_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
-    parser.advance(); // consume the first dot
+pub fn parse_dot_token(
+    parser: &mut Parser,
+    _global_store: &mut crate::core::store::global::GlobalStore
+) -> Statement {
+    parser.advance(); // consume '.'
 
     let Some(dot_token) = parser.previous_clone() else {
         return Statement::unknown();
     };
 
-    // Parse namespaced identifier: .808.kick.snare
+    // Parse a single entity (namespace-friendly, stops at newline)
     let mut parts = Vec::new();
 
-    loop {
-        let Some(token) = parser.peek_clone() else {
-            break;
-        };
-
+    while let Some(token) = parser.peek_clone() {
         match token.kind {
-            // Stop if we encounter a likely duration keyword
-            TokenKind::Number => {
-                // If there's a slash after the number, it's probably a fraction (1/4)
-                if let Some(TokenKind::Slash) = parser.peek_nth_kind(1) {
-                    break;
-                }
-
+            TokenKind::Identifier | TokenKind::Number => {
                 parts.push(token.lexeme.clone());
                 parser.advance();
-            }
-
-            TokenKind::Identifier => {
-                // Stop if it's the duration keyword "auto"
-                if token.lexeme == "auto" {
+                if parser.peek_kind() != Some(TokenKind::Dot) {
                     break;
                 }
-
-                parts.push(token.lexeme.clone());
-                parser.advance();
             }
-
             TokenKind::Dot => {
-                parser.advance(); // consume dot
+                parser.advance();
+            }
+            TokenKind::Newline | TokenKind::EOF | TokenKind::Indent | TokenKind::Dedent => {
+                break; // Stop at newline or dedent
             }
-
             _ => {
                 break;
             }
         }
     }
 
-    let entity = parts.join(".");
-
-    if entity.is_empty() {
-        return Statement {
-            kind: StatementKind::Trigger {
-                entity: String::new(),
-                duration: Duration::Auto,
-            },
-            value: Value::Null,
-            indent: dot_token.indent,
-            line: dot_token.line,
-            column: dot_token.column,
-        };
-    }
-
-    // Check if there's a duration
-    let next = parser.peek_clone();
-
-    let (duration, value) = match next {
-        None => (Duration::Auto, Value::Null),
-
-        Some(token) =>
-            match token.kind {
-                TokenKind::Newline | TokenKind::EOF => (Duration::Auto, Value::Null),
-
-                TokenKind::Number => {
-                    let numerator = token.lexeme.clone();
-                    parser.advance(); // consume numerator
-
-                    if let Some(TokenKind::Slash) = parser.peek_kind() {
-                        parser.advance(); // consume slash
-
-                        if let Some(denominator_token) = parser.peek_clone() {
-                            if denominator_token.kind == TokenKind::Number {
-                                let denominator = denominator_token.lexeme.clone();
-                                parser.advance(); // consume denominator
-
-                                let beat_str = format!("{}/{}", numerator, denominator);
-                                let beat_duration = Duration::Beat(beat_str);
-
-                                let val = match parser.peek_clone() {
-                                    Some(param_token) if
-                                        param_token.kind == TokenKind::Identifier
-                                    => {
-                                        parser.advance();
-                                        Value::Identifier(param_token.lexeme.clone())
-                                    }
-                                    Some(param_token) if param_token.kind == TokenKind::LBrace => {
-                                        parser.parse_map_value().unwrap_or(Value::Null)
-                                    }
-                                    _ => Value::Null,
-                                };
-
-                                return Statement {
-                                    kind: StatementKind::Trigger {
-                                        entity,
-                                        duration: beat_duration,
-                                    },
-                                    value: val,
-                                    indent: dot_token.indent,
-                                    line: dot_token.line,
-                                    column: dot_token.column,
-                                };
-                            }
-                        }
-                    }
+    // Build entity name properly
+    let entity = if !parts.is_empty() {
+        parts.join(".") // only join within the same line
+    } else {
+        eprintln!("⚠️ Empty entity after '.' at line {}", dot_token.line);
+        String::new()
+    };
 
-                    // fallback: simple numeric duration
-                    let duration = parse_duration(numerator);
+    // Optional duration and effects map
+    let mut duration = Duration::Auto;
+    let mut value = Value::Null;
 
-                    let val = match parser.peek_clone() {
-                        Some(param_token) if param_token.kind == TokenKind::Identifier => {
+    if let Some(token) = parser.peek_clone() {
+        match token.kind {
+            TokenKind::Number => {
+                let numerator = token.lexeme.clone();
+                parser.advance();
+                if let Some(TokenKind::Slash) = parser.peek_kind() {
+                    parser.advance();
+                    if let Some(denominator_token) = parser.peek_clone() {
+                        if denominator_token.kind == TokenKind::Number {
+                            let denominator = denominator_token.lexeme.clone();
                             parser.advance();
-                            Value::Identifier(param_token.lexeme.clone())
-                        }
-                        Some(param_token) if param_token.kind == TokenKind::LBrace => {
-                            parser.parse_map_value().unwrap_or(Value::Null)
+                            duration = Duration::Beat(format!("{}/{}", numerator, denominator));
                         }
-                        _ => Value::Null,
-                    };
-
-                    (duration, val)
+                    }
+                } else {
+                    duration = parse_duration(numerator);
                 }
-
-                TokenKind::Identifier => {
-                    let duration_lexeme = token.lexeme.clone();
-                    parser.advance(); // consume duration
-
-                    let val = match parser.peek_clone() {
-                        Some(param_token) if param_token.kind == TokenKind::Identifier => {
-                            parser.advance();
-                            Value::Identifier(param_token.lexeme.clone())
-                        }
-                        Some(param_token) if param_token.kind == TokenKind::LBrace => {
-                            parser.parse_map_value().unwrap_or(Value::Null)
-                        }
-                        _ => Value::Null,
-                    };
-
-                    (parse_duration(duration_lexeme), val)
+                if let Some(next) = parser.peek_clone() {
+                    if next.kind == TokenKind::LBrace {
+                        value = parser.parse_map_value().unwrap_or(Value::Null);
+                    }
                 }
-
-                _ => (Duration::Auto, Value::Null),
             }
-    };
+            TokenKind::Identifier => {
+                let id = token.lexeme.clone();
+                parser.advance();
+                duration = parse_duration(id);
+                if let Some(next) = parser.peek_clone() {
+                    if next.kind == TokenKind::LBrace {
+                        value = parser.parse_map_value().unwrap_or(Value::Null);
+                    }
+                }
+            }
+            TokenKind::LBrace => {
+                value = parser.parse_map_value().unwrap_or(Value::Null);
+            }
+            _ => {}
+        }
+    }
 
     Statement {
-        kind: StatementKind::Trigger { entity, duration },
-        value,
+        kind: StatementKind::Trigger {
+            entity,
+            duration,
+            effects: Some(value.clone()),
+        },
+        value: Value::Null,
         indent: dot_token.indent,
         line: dot_token.line,
         column: dot_token.column,

package/rust/core/parser/handler/identifier/call.rs

@@ -1,6 +1,6 @@
 use crate::core::{
-    lexer::token::{ Token, TokenKind },
-    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
+    lexer::token::{Token, TokenKind},
+    parser::{statement::{Statement, StatementKind}, driver::Parser},
     shared::value::Value,
     store::global::GlobalStore,
 };
@@ -8,34 +8,81 @@ use crate::core::{
 pub fn parse_call_token(
     parser: &mut Parser,
     current_token: Token,
-    global_store: &mut GlobalStore
+    _global_store: &mut GlobalStore
 ) -> Statement {
     parser.advance(); // consume "call"
 
-    let value = if let Some(token) = parser.peek_clone() {
-        parser.advance();
-        match token.kind {
-            TokenKind::Identifier => Value::Identifier(token.lexeme.clone()),
-            TokenKind::String => Value::String(token.lexeme.clone()),
-            _ => {
-                return Statement::error(
-                    token,
-                    "Expected identifier or string after 'call'".to_string()
-                );
-            }
+    // Expect function name
+    let name_token = match parser.peek_clone() {
+        Some(t) => t,
+        None => {
+            return Statement::error(
+                current_token,
+                "Expected function name after 'call'".to_string()
+            );
         }
-    } else {
+    };
+
+    if name_token.kind != TokenKind::Identifier {
         return Statement::error(
-            current_token,
-            "Expected identifier or string after 'call'".to_string()
+            name_token,
+            "Expected function name to be an identifier".to_string()
         );
-    };
+    }
+
+    let func_name = name_token.lexeme.clone();
+    parser.advance(); // consume function name
+
+    // Expect '('
+    let mut args: Vec<Value> = Vec::new();
+    if let Some(open_paren) = parser.peek_clone() {
+        if open_paren.kind == TokenKind::LParen {
+            parser.advance(); // consume '('
 
-    return Statement {
-        kind: StatementKind::Call,
-        value,
+            // Collect args until ')'
+            while let Some(token) = parser.peek_clone() {
+                if token.kind == TokenKind::RParen {
+                    parser.advance(); // consume ')'
+                    break;
+                }
+
+                match token.kind {
+                    TokenKind::Number => {
+                        if let Ok(num) = token.lexeme.parse::<f32>() {
+                            args.push(Value::Number(num));
+                        }
+                        parser.advance();
+                    }
+                    TokenKind::String => {
+                        args.push(Value::String(token.lexeme.clone()));
+                        parser.advance();
+                    }
+                    TokenKind::Identifier => {
+                        args.push(Value::Identifier(token.lexeme.clone()));
+                        parser.advance();
+                    }
+                    TokenKind::Comma => {
+                        parser.advance(); // skip comma
+                    }
+                    _ => {
+                        return Statement::error(
+                            token,
+                            "Unexpected token in call arguments".to_string()
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    Statement {
+        kind: StatementKind::Call {
+            name: func_name,
+            args,
+        },
+        value: Value::Null,
         indent: current_token.indent,
         line: current_token.line,
         column: current_token.column,
-    };
+    }
 }

package/rust/core/parser/handler/identifier/function.rs

@@ -0,0 +1,92 @@
+use crate::core::{
+    lexer::{ token::TokenKind },
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_function_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+    parser.advance(); // consume 'fn'
+
+    let fn_token = match parser.previous_clone() {
+        Some(tok) => tok,
+        None => return Statement::unknown(),
+    };
+
+    let name_token = match parser.peek_clone() {
+        Some(tok) => tok,
+        None => return Statement::error(fn_token, "Expected function name after 'fn'".to_string()),
+    };
+
+    if name_token.kind != TokenKind::Identifier {
+        return Statement::error(
+            name_token.clone(),
+            "Expected function name to be an identifier".to_string()
+        );
+    }
+
+    let function_name = name_token.lexeme.clone();
+    parser.advance(); // consume function name
+
+    let mut parameters = Vec::new();
+    let mut body = Vec::new();
+
+    // Expect '('
+    if parser.peek_kind() != Some(TokenKind::LParen) {
+        return Statement::error(name_token.clone(), "Expected '(' after function name".to_string());
+    }
+    parser.advance(); // consume '('
+
+    // Parse parameters until ')'
+    let tokens = parser.collect_until(|t| t.kind == TokenKind::RParen || t.kind == TokenKind::EOF);
+    for token in tokens {
+        if token.kind == TokenKind::Identifier {
+            parameters.push(token.lexeme.clone());
+        }
+    }
+
+    if parser.peek_kind() == Some(TokenKind::RParen) {
+        parser.advance(); // consume ')'
+    } else {
+        return Statement::error(name_token.clone(), "Expected ')' after parameters".to_string());
+    }
+
+    // Expect colon
+    if parser.peek_kind() != Some(TokenKind::Colon) {
+        return Statement::error(name_token.clone(), "Expected ':' after ')'".to_string());
+    }
+    parser.advance(); // consume ':'
+
+    // Collect ALL tokens indented after this line until Dedent
+    let base_indent = fn_token.indent;
+    let mut body_tokens = Vec::new();
+
+    while let Some(tok) = parser.peek() {
+        if tok.kind == TokenKind::Dedent && tok.indent <= base_indent {
+            break;
+        }
+        body_tokens.push(parser.advance().unwrap().clone());
+    }
+
+    // arse those tokens into block statements
+    body = parser.parse_block(body_tokens.clone(), global_store);
+
+    // Skip Dedent if present
+    if let Some(tok) = parser.peek() {
+        if tok.kind == TokenKind::Dedent {
+            parser.advance();
+        }
+    }
+
+    Statement {
+        kind: StatementKind::Function {
+            name: function_name.clone(),
+            parameters: parameters.clone(),
+            body: body.clone(),
+        },
+        value: Value::Null,
+        indent: fn_token.indent,
+        line: fn_token.line,
+        column: fn_token.column,
+    }
+}