@devaloop/devalang 0.0.1-alpha.8 → 0.0.1-alpha.9

package/rust/core/audio/interpreter/driver.rs

@@ -2,6 +2,7 @@ use crate::core::{
     audio::{
         engine::AudioEngine,
         interpreter::{
+            arrow_call::interprete_call_arrow_statement,
             call::interprete_call_statement,
             condition::interprete_condition_statement,
             let_::interprete_let_statement,
@@ -29,7 +30,7 @@ pub fn run_audio_program(
     let variable_table = audio_engine.variables.clone();
 
     let (updated_audio_engine, base_bpm, max_end_time) = execute_audio_block(
-        audio_engine.clone(),
+        audio_engine,
         variable_table.clone(),
         statements.clone(),
         base_bpm.clone(),
@@ -50,6 +51,8 @@ pub fn execute_audio_block(
     mut max_end_time: f32,
     mut cursor_time: f32
 ) -> (AudioEngine, f32, f32) {
+    let initial_cursor_time = cursor_time;
+
     for stmt in statements {
         match &stmt.kind {
             StatementKind::Load { .. } => {
@@ -108,26 +111,37 @@ pub fn execute_audio_block(
             }
 
             StatementKind::Spawn => {
+                let mut temp_engine = AudioEngine::new(audio_engine.module_name.clone());
+
                 if
-                    let Some((new_cursor_time, new_max_end_time, updated_engine)) =
-                        interprete_spawn_statement(
-                            &stmt,
-                            &mut audio_engine,
-                            &variable_table,
-                            base_bpm,
-                            base_duration,
-                            cursor_time,
-                            max_end_time
-                        )
+                    let Some((_cur, _max, updated_engine)) = interprete_spawn_statement(
+                        &stmt,
+                        temp_engine,
+                        &variable_table,
+                        base_bpm,
+                        base_duration,
+                        initial_cursor_time,
+                        max_end_time
+                    )
                 {
-                    cursor_time = new_cursor_time;
-                    max_end_time = new_max_end_time;
-                    audio_engine = updated_engine;
-                } else {
-                    eprintln!("❌ Failed to interpret spawn statement: {:?}", stmt);
+                    audio_engine.merge_with(updated_engine);
                 }
             }
 
+            StatementKind::Call => {
+                let (call_engine, new_max, new_cursor) = interprete_call_statement(
+                    &stmt,
+                    audio_engine.clone(),
+                    variable_table.clone(),
+                    base_bpm,
+                    base_duration,
+                    max_end_time,
+                    cursor_time
+                );
+
+                audio_engine.merge_with(call_engine);
+            }
+
             StatementKind::Sleep => {
                 let (new_cursor, new_max) = interprete_sleep_statement(
                     &stmt,
@@ -153,8 +167,8 @@ pub fn execute_audio_block(
                 max_end_time = new_max;
             }
 
-            StatementKind::Call => {
-                let (call_engine, new_max, new_cursor) = interprete_call_statement(
+            StatementKind::If | StatementKind::ElseIf | StatementKind::Else => {
+                let (condition_engine, new_max, new_cursor) = interprete_condition_statement(
                     &stmt,
                     audio_engine.clone(),
                     variable_table.clone(),
@@ -163,25 +177,23 @@ pub fn execute_audio_block(
                     max_end_time,
                     cursor_time
                 );
-                audio_engine = call_engine;
+
+                audio_engine = condition_engine;
                 cursor_time = new_cursor;
                 max_end_time = new_max;
             }
 
-            StatementKind::If | StatementKind::ElseIf | StatementKind::Else => {
-                let (condition_engine, new_max, new_cursor) = interprete_condition_statement(
+            StatementKind::ArrowCall { .. } => {
+                interprete_call_arrow_statement(
                     &stmt,
-                    audio_engine.clone(),
-                    variable_table.clone(),
+                    &mut audio_engine,
+                    &variable_table,
                     base_bpm,
                     base_duration,
-                    max_end_time,
-                    cursor_time
+                    &mut max_end_time,
+                    Some(&mut cursor_time),
+                    true
                 );
-
-                audio_engine = condition_engine;
-                cursor_time = new_cursor;
-                max_end_time = new_max;
             }
 
             | StatementKind::Bank

package/rust/core/audio/interpreter/loop_.rs

@@ -17,8 +17,16 @@ pub fn interprete_loop_statement(
     if let Value::Map(loop_value) = &stmt.value {
         let loop_count = match loop_value.get("iterator") {
             Some(Value::Number(n)) => *n as usize,
+            Some(Value::Identifier(ident)) => {
+                if let Some(Value::Number(n)) = variable_table.get(ident) {
+                    *n as usize
+                } else {
+                    eprintln!("❌ Loop iterator must be a number, found: {:?}", ident);
+                    return (audio_engine, max_end_time, cursor_time);
+                }
+            }
             _ => {
-                eprintln!("❌ Loop iterator must be a number");
+                eprintln!("❌ Loop iterator must be a number, found: {:?}", loop_value.get("iterator"));
                 return (audio_engine, max_end_time, cursor_time);
             }
         };
@@ -26,7 +34,7 @@ pub fn interprete_loop_statement(
         let loop_body = match loop_value.get("body") {
             Some(Value::Block(body)) => body.clone(),
             _ => {
-                eprintln!("❌ Loop body must be a block");
+                eprintln!("❌ Loop body must be a block, found: {:?}", loop_value.get("body"));
                 return (audio_engine, max_end_time, cursor_time);
             }
         };
@@ -37,7 +45,7 @@ pub fn interprete_loop_statement(
 
         for _ in 0..loop_count {
             let (eng, _, end_time) = execute_audio_block(
-                engine.clone(),
+                engine,
                 variable_table.clone(),
                 loop_body.clone(),
                 base_bpm,

package/rust/core/audio/interpreter/mod.rs

@@ -9,3 +9,4 @@ pub mod sleep;
 pub mod loop_;
 pub mod call;
 pub mod condition;
+pub mod arrow_call;

package/rust/core/audio/interpreter/spawn.rs

@@ -7,58 +7,59 @@ use crate::core::{
 
 pub fn interprete_spawn_statement(
     stmt: &Statement,
-    audio_engine: &mut AudioEngine,
+    audio_engine: AudioEngine,
     variable_table: &VariableTable,
     base_bpm: f32,
     base_duration: f32,
     cursor_time: f32,
     max_end_time: f32
 ) -> Option<(f32, f32, AudioEngine)> {
-    if let Value::String(identifier) = &stmt.value {
-        match variable_table.get(identifier) {
-            Some(Value::Map(map)) => {
-                if let Some(Value::Block(block)) = map.get("body") {
-                    let mut local_max = cursor_time;
-                    let mut updated_engine = audio_engine.clone();
-
-                    for inner_stmt in block {
-                        let (inner_engine, _, inner_end_time) = execute_audio_block(
-                            updated_engine.clone(),
-                            variable_table.clone(),
-                            vec![inner_stmt.clone()],
-                            base_bpm,
-                            base_duration,
-                            max_end_time,
-                            cursor_time
-                        );
-
-                        updated_engine = inner_engine;
-
-                        if inner_end_time > local_max {
-                            local_max = inner_end_time;
-                        }
-                    }
+    match &stmt.value {
+        Value::String(identifier) | Value::Identifier(identifier) => {
+            handle_spawn_identifier(
+                identifier,
+                audio_engine,
+                variable_table,
+                base_bpm,
+                base_duration,
+                cursor_time,
+                max_end_time
+            )
+        }
 
-                    let new_max_end_time = local_max.max(max_end_time);
+        _ => {
+            eprintln!("❌ Invalid spawn statement: expected identifier, found {:?}", stmt.value);
+            None
+        }
+    }
+}
 
-                    return Some((local_max, new_max_end_time, updated_engine));
-                } else {
-                    eprintln!("❌ Cannot spawn '{}': no valid body block", identifier);
-                }
-            }
-            Some(other) => {
-                eprintln!(
-                    "❌ Cannot spawn '{}': expected map with block, got {:?}",
-                    identifier,
-                    other
-                );
-            }
-            None => {
-                eprintln!("❌ Cannot spawn '{}': not found in variable table", identifier);
-            }
+fn handle_spawn_identifier(
+    identifier: &str,
+    audio_engine: AudioEngine,
+    variable_table: &VariableTable,
+    base_bpm: f32,
+    base_duration: f32,
+    cursor_time: f32,
+    max_end_time: f32
+) -> Option<(f32, f32, AudioEngine)> {
+    if let Some(Value::Map(map)) = variable_table.get(identifier) {
+        if let Some(Value::Block(block)) = map.get("body") {
+            let (eng, _, end_time) = execute_audio_block(
+                audio_engine.clone(),
+                variable_table.clone(),
+                block.clone(),
+                base_bpm,
+                base_duration,
+                max_end_time,
+                cursor_time
+            );
+            return Some((max_end_time.max(end_time), end_time, eng));
+        } else {
+            eprintln!("❌ Spawn group '{}' has no 'body' block", identifier);
         }
     } else {
-        eprintln!("❌ Invalid spawn statement: expected a string identifier, got {:?}", stmt.value);
+        eprintln!("❌ Spawn group '{}' not found or not a map", identifier);
     }
 
     None

package/rust/core/audio/interpreter/trigger.rs

@@ -54,7 +54,7 @@ pub fn interprete_trigger_statement(
             );
 
             let mut updated_engine = audio_engine.clone();
-            updated_engine.insert(&src, cursor_time, duration_final, None);
+            updated_engine.insert_sample(&src, cursor_time, duration_final, None);
 
             let new_cursor_time = cursor_time + duration_final;
             let new_max_end_time = new_cursor_time.max(max_end_time);

package/rust/core/audio/renderer.rs

@@ -17,40 +17,37 @@ pub fn render_audio_with_modules(
     let mut result = HashMap::new();
 
     for (module_name, statements) in modules {
-        let mut global_max_end_time = 0.0;
-        let mut audio_engine = AudioEngine::new();
+        let mut global_max_end_time: f32 = 0.0;
+        let mut initial_engine = AudioEngine::new(module_name.clone());
 
-        // Apply the module's variable table if it exists
+        // Apply global variables to the initial engine
         if let Some(module) = global_store.get_module(&module_name) {
-            audio_engine.set_variables(module.variable_table.clone());
+            initial_engine.set_variables(module.variable_table.clone());
         }
 
-        // Interpret the statements to fill the audio buffer
-        let (mut audio_engine, module_base_bpm, module_max_end_time) = run_audio_program(
+        // interprete statements to fill the audio buffer
+        let (mut updated_engine, _bpm, module_max_end_time) = run_audio_program(
             &statements,
-            audio_engine,
+            initial_engine,
             module_name.clone(),
             output_dir.to_string()
         );
 
-        // Calculate the module's maximum duration
-        global_max_end_time = module_max_end_time.max(global_max_end_time);
-        audio_engine.set_duration(global_max_end_time);
-
-        // Check if the buffer contains at least one non-zero sample
-        if audio_engine.buffer.iter().all(|&s| s == 0) {
+        // Verify if the buffer is silent (all samples are zero)
+        if updated_engine.buffer.iter().all(|&s| s == 0) {
             let logger = Logger::new();
-
             logger.log_message(
                 LogLevel::Warning,
-                format!("Module '{}' ignored: silent buffer (no non-zero samples)", module_name).as_str()
+                &format!("Module '{}' ignored: silent buffer (no non-zero samples)", module_name)
             );
-
             continue;
         }
 
-        // Insert only if the module produces sound
-        result.insert(module_name, audio_engine);
+        // Determines the maximum end time for the module
+        global_max_end_time = global_max_end_time.max(module_max_end_time);
+        updated_engine.set_duration(global_max_end_time);
+
+        result.insert(module_name, updated_engine);
     }
 
     result

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

@@ -0,0 +1,31 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_arrow_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
+) {
+    let mut arrow_call = char.to_string();
+
+    while let Some(&c) = chars.peek() {
+        if c == '>' {
+            chars.next();
+            arrow_call.push(c);
+            *column += 1;
+        } else {
+            break;
+        }
+    }
+
+    tokens.push(Token {
+        kind: TokenKind::Arrow,
+        lexeme: arrow_call,
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+}

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

@@ -1,6 +1,6 @@
 use crate::core::lexer::{
     handler::{
-        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, 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, string::handle_string_lexer
     },
     token::{ Token, TokenKind },
 };
@@ -97,6 +97,17 @@ pub fn handle_content_lexing(content: String) -> Result<Vec<Token>, String> {
                     &mut column
                 );
             }
+            '-' => {
+                handle_arrow_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
             '{' => {
                 handle_lbrace_lexer(
                     ch,

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

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

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

@@ -11,3 +11,4 @@ pub mod newline;
 pub mod number;
 pub mod indent;
 pub mod string;
+pub mod arrow;

package/rust/core/lexer/mod.rs

@@ -2,6 +2,7 @@ pub mod handler;
 pub mod token;
 
 use std::fs;
+use std::path::{Path, PathBuf};
 use crate::core::{
     lexer::{ handler::driver::handle_content_lexing, token::Token },
     utils::path::normalize_path,
@@ -20,11 +21,31 @@ impl Lexer {
 
     pub fn lex_tokens(&self, entrypoint: &str) -> Vec<Token> {
         let path = normalize_path(entrypoint);
+        let resolved_path = Self::resolve_entry_path(&path);
 
-        let file_content = fs::read_to_string(&path).expect("Failed to read the entrypoint file");
+        let file_content =
+            fs::read_to_string(&resolved_path).expect("Failed to read the entrypoint file");
 
-        let tokens = handle_content_lexing(file_content).expect("Failed to lex the content");
+        handle_content_lexing(file_content).expect("Failed to lex the content")
+    }
 
-        tokens
+    fn resolve_entry_path(path: &str) -> String {
+        let candidate = Path::new(path);
+
+        if candidate.is_dir() {
+            let index_path = candidate.join("index.deva");
+            if index_path.exists() {
+                return index_path.to_string_lossy().replace("\\", "/");
+            } else {
+                panic!(
+                    "Expected 'index.deva' in directory '{}', but it was not found",
+                    path
+                );
+            }
+        } else if candidate.is_file() {
+            return path.to_string();
+        } else {
+            panic!("Provided entrypoint '{}' is not a valid file or directory", path);
+        }
     }
 }

package/rust/core/lexer/token.rs

@@ -30,11 +30,15 @@ pub enum TokenKind {
     Bank,
     Loop,
 
+    // ───── Instruments ─────
+    Synth,
+
     // ───── Literals ─────
     Identifier,
     Number,
     String,
     Boolean,
+    Arrow,
 
     // ───── Structures ─────
     Map,

package/rust/core/parser/driver.rs

@@ -2,6 +2,7 @@ use crate::core::{
     lexer::token::{ Token, TokenKind },
     parser::{
         handler::{
+            arrow_call::parse_arrow_call,
             at::parse_at_token,
             bank::parse_bank_token,
             condition::parse_condition_token,
@@ -10,7 +11,7 @@ use crate::core::{
             loop_::parse_loop_token,
             tempo::parse_tempo_token,
         },
-        statement::{ Statement, StatementKind },
+        statement::Statement,
     },
     shared::value::Value,
     store::global::GlobalStore,
@@ -45,7 +46,7 @@ impl Parser {
             return None;
         }
 
-        self.previous = self.tokens.get(self.token_index).cloned(); // mémorise avant de bouger
+        self.previous = self.tokens.get(self.token_index).cloned();
         self.token_index += 1;
 
         self.tokens.get(self.token_index - 1)
@@ -55,6 +56,14 @@ impl Parser {
         self.peek().map_or(false, |t| t.lexeme == expected)
     }
 
+    pub fn peek_nth(&self, n: usize) -> Option<&Token> {
+        if self.token_index + n < self.tokens.len() {
+            self.tokens.get(self.token_index + n)
+        } else {
+            None
+        }
+    }
+
     pub fn advance_if(&mut self, kind: TokenKind) -> bool {
         if self.match_token(kind) { true } else { false }
     }
@@ -107,9 +116,19 @@ impl Parser {
                 }
             };
 
-            let mut statement = match &token.kind {
+            let statement = match &token.kind {
                 TokenKind::At => parse_at_token(self, global_store),
-                TokenKind::Identifier => parse_identifier_token(self, global_store),
+                TokenKind::Identifier => {
+                    if let Some(next) = self.peek_nth(1).cloned() {
+                        if next.kind == TokenKind::Arrow {
+                            parse_arrow_call(self, global_store)
+                        } else {
+                            parse_identifier_token(self, global_store)
+                        }
+                    } else {
+                        parse_identifier_token(self, global_store)
+                    }
+                }
                 TokenKind::Dot => parse_dot_token(self, global_store),
                 TokenKind::Tempo => parse_tempo_token(self, global_store),
                 TokenKind::Bank => parse_bank_token(self, global_store),

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

@@ -0,0 +1,126 @@
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{ driver::Parser, statement::{ Statement, StatementKind } },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_arrow_call(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+    let Some(target_token) = parser.peek_clone() else {
+        return Statement::unknown();
+    };
+
+    if target_token.kind != TokenKind::Identifier {
+        parser.advance(); // consume target token
+        return Statement::unknown();
+    }
+
+    let Some(arrow_token) = parser.peek_nth(1).cloned() else {
+        parser.advance(); // consume arrow token
+        return Statement {
+            kind: StatementKind::Unknown,
+            value: Value::String(target_token.lexeme.clone()),
+            indent: target_token.indent,
+            line: target_token.line,
+            column: target_token.column,
+        };
+    };
+
+    if arrow_token.kind != TokenKind::Arrow {
+        parser.advance(); // consume method token
+        return Statement {
+            kind: StatementKind::Unknown,
+            value: Value::String(target_token.lexeme.clone()),
+            indent: target_token.indent,
+            line: target_token.line,
+            column: target_token.column,
+        };
+    }
+
+    // We have a valid arrow call, so we consume the arrow token
+    let Some(method_token) = parser.peek_nth(2).cloned() else {
+        parser.advance();
+        return Statement::unknown();
+    };
+
+    if method_token.kind != TokenKind::Identifier {
+        parser.advance();
+        return Statement::unknown();
+    }
+
+    // Consume the tokens for target, arrow, and method
+    parser.advance(); // target
+    parser.advance(); // ->
+    parser.advance(); // method
+
+    let mut args = Vec::new();
+
+    while let Some(token) = parser.peek_clone() {
+        if token.kind == TokenKind::Newline || token.kind == TokenKind::EOF {
+            break;
+        }
+
+        parser.advance();
+
+        let value = match token.kind {
+            TokenKind::Identifier => Value::Identifier(token.lexeme.clone()),
+            TokenKind::String => Value::String(token.lexeme.clone()),
+            TokenKind::Number => Value::Number(token.lexeme.parse::<f32>().unwrap_or(0.0)),
+            TokenKind::LBrace => {
+                // Handle map literal
+                let mut map = std::collections::HashMap::new();
+                while let Some(inner_token) = parser.peek_clone() {
+                    if inner_token.kind == TokenKind::RBrace {
+                        parser.advance(); // consume RBrace
+                        break;
+                    }
+                    if inner_token.kind == TokenKind::Newline || inner_token.kind == TokenKind::EOF {
+                        break;
+                    }
+                    parser.advance(); // consume key token
+                    let key = inner_token.lexeme.clone();
+
+                    if let Some(colon_token) = parser.peek_clone() {
+                        if colon_token.kind == TokenKind::Colon {
+                            parser.advance(); // consume colon
+                            if let Some(value_token) = parser.peek_clone() {
+                                parser.advance(); // consume value token
+                                let value = match value_token.kind {
+                                    TokenKind::Identifier =>
+                                        Value::Identifier(value_token.lexeme.clone()),
+                                    TokenKind::String => Value::String(value_token.lexeme.clone()),
+                                    TokenKind::Number =>
+                                        Value::Number(
+                                            value_token.lexeme.parse::<f32>().unwrap_or(0.0)
+                                        ),
+                                    TokenKind::Boolean =>
+                                        Value::Boolean(
+                                            value_token.lexeme.parse::<bool>().unwrap_or(false)
+                                        ),
+                                    _ => Value::Unknown,
+                                };
+                                map.insert(key, value);
+                            }
+                        }
+                    }
+                }
+                Value::Map(map)
+            }
+            _ => Value::Unknown,
+        };
+
+        args.push(value);
+    }
+
+    Statement {
+        kind: StatementKind::ArrowCall {
+            target: target_token.lexeme.clone(),
+            method: method_token.lexeme.clone(),
+            args,
+        },
+        value: Value::Null,
+        indent: target_token.indent,
+        line: target_token.line,
+        column: target_token.column,
+    }
+}