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

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

@@ -16,10 +16,24 @@ pub fn handle_indent_lexer(
             *current_indent += 1;
             chars.next();
             col += 1;
+            tokens.push(Token {
+                kind: TokenKind::Whitespace,
+                lexeme: " ".to_string(),
+                line: *line,
+                column: col,
+                indent: *current_indent,
+            });
         } else if c == '\t' {
             *current_indent += 4;
             chars.next();
             col += 4;
+            tokens.push(Token {
+                kind: TokenKind::Whitespace,
+                lexeme: "\t".to_string(),
+                line: *line,
+                column: col,
+                indent: *current_indent,
+            });
         } else {
             break;
         }
@@ -32,7 +46,7 @@ pub fn handle_indent_lexer(
         indent_stack.push(*current_indent);
         tokens.push(Token {
             kind: TokenKind::Indent,
-            lexeme: String::new(),
+            lexeme: String::from("<INDENT>"),
             line: *line,
             column: *column,
             indent: *current_indent,
@@ -42,7 +56,7 @@ pub fn handle_indent_lexer(
             indent_stack.pop();
             tokens.push(Token {
                 kind: TokenKind::Dedent,
-                lexeme: String::new(),
+                lexeme: String::from("<DEDENT>"),
                 line: *line,
                 column: *column,
                 indent: *current_indent,

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

@@ -2,7 +2,7 @@ use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_newline_lexer(
     ch: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,

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

@@ -1,15 +1,15 @@
 use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_number_lexer(
-    char: char,
+    ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
 ) {
-    let mut number = char.to_string();
+    let mut number = ch.to_string();
 
     while let Some(&c) = chars.peek() {
         if c.is_ascii_digit() {

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

@@ -4,7 +4,7 @@ pub fn handle_operator_lexer(
     ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
@@ -16,6 +16,8 @@ pub fn handle_operator_lexer(
         ('!', Some('=')) => (TokenKind::NotEquals, 2),
         ('>', Some('=')) => (TokenKind::GreaterEqual, 2),
         ('<', Some('=')) => (TokenKind::LessEqual, 2),
+        ('+', _) => (TokenKind::Plus, 1),
+        ('*', _) => (TokenKind::Asterisk, 1),
         ('=', _) => (TokenKind::Equals, 1),
         ('>', _) => (TokenKind::Greater, 1),
         ('<', _) => (TokenKind::Less, 1),

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

@@ -1,17 +1,17 @@
 use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_rparen_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<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(),
+        lexeme: ch.to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,
@@ -21,17 +21,17 @@ pub fn handle_rparen_lexer(
 }
 
 pub fn handle_lparen_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<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(),
+        lexeme: ch.to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,

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

@@ -1,21 +1,21 @@
 use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_slash_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
 ) {
-    let mut slash = char.to_string();
+    let slash = ch.to_string();
 
     tokens.push(Token {
         kind: TokenKind::Slash,
         lexeme: slash,
         line: *line,
         column: *column,
-        indent: *current_indent,
+    indent: *current_indent,
     });
 }

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

@@ -4,7 +4,7 @@ pub fn handle_string_lexer(
     ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize

package/rust/core/lexer/mod.rs

@@ -2,7 +2,7 @@ pub mod handler;
 pub mod token;
 
 use std::fs;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use crate::core::{
     lexer::{ handler::driver::handle_content_lexing, token::Token },
     utils::path::normalize_path,

package/rust/core/lexer/token.rs

@@ -51,6 +51,9 @@ pub enum TokenKind {
     Equals,
     Dot,
     Slash,
+    Plus,
+    Asterisk,
+    Minus,
 
     // ───── Operators ─────
     DoubleEquals,
@@ -84,6 +87,7 @@ pub enum TokenKind {
     ElseIf,
 
     // ───── Special / Internal ─────
+    Whitespace,
     Unknown,
     Error(String),
     EOF,

package/rust/core/mod.rs

@@ -7,4 +7,5 @@ pub mod debugger;
 pub mod utils;
 pub mod builder;
 pub mod error;
-pub mod audio;
+pub mod audio;
+pub mod plugin;

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::{function::parse_function_token, parse_identifier_token},
+            identifier::{ function::parse_function_token, parse_identifier_token },
             loop_::parse_loop_token,
             tempo::parse_tempo_token,
         },
@@ -107,7 +107,12 @@ impl Parser {
         tokens: Vec<Token>,
         global_store: &mut GlobalStore
     ) -> Vec<Statement> {
-        self.tokens = tokens;
+        // Filtrer uniquement les espaces, mais conserver les Newline car
+        // certaines constructions (ex: print ...) s'appuient sur la fin de ligne.
+        self.tokens = tokens
+            .into_iter()
+            .filter(|t| t.kind != TokenKind::Whitespace)
+            .collect();
         self.token_index = 0;
 
         let mut statements = Vec::new();
@@ -120,6 +125,11 @@ impl Parser {
                 }
             };
 
+            if token.kind == TokenKind::Newline {
+                self.advance();
+                continue;
+            }
+
             let statement = match &token.kind {
                 TokenKind::At => parse_at_token(self, global_store),
                 TokenKind::Identifier => {
@@ -149,7 +159,6 @@ impl Parser {
                 | TokenKind::LBrace
                 | TokenKind::RBrace
                 | TokenKind::Comma
-                | TokenKind::Newline
                 | TokenKind::Dedent
                 | TokenKind::Indent => {
                     self.advance();
@@ -189,17 +198,57 @@ impl Parser {
         let mut map = std::collections::HashMap::new();
 
         while !self.check_token(TokenKind::RBrace) && !self.is_eof() {
+            // Skip separators and formatting before the key
+            while
+                self.check_token(TokenKind::Newline) ||
+                self.check_token(TokenKind::Whitespace) ||
+                self.check_token(TokenKind::Indent) ||
+                self.check_token(TokenKind::Dedent) ||
+                self.check_token(TokenKind::Comma)
+            {
+                self.advance();
+            }
+
+            // Check if we are at the closing brace of the map
+            if self.check_token(TokenKind::RBrace) {
+                break;
+            }
+
             let key = if let Some(token) = self.advance() {
-                token.lexeme.clone()
+                match token.kind {
+                    | TokenKind::Whitespace
+                    | TokenKind::Indent
+                    | TokenKind::Dedent
+                    | TokenKind::Newline => {
+                        continue;
+                    }
+                    _ => token.lexeme.clone(),
+                }
             } else {
                 break;
             };
 
+            // Skip newlines and whitespace before colon
+            while self.check_token(TokenKind::Newline) || self.check_token(TokenKind::Whitespace) {
+                self.advance();
+            }
+
             if !self.match_token(TokenKind::Colon) {
                 println!("Expected ':' after map key '{}'", key);
                 break;
             }
 
+            // Skip separators and formatting before value
+            while
+                self.check_token(TokenKind::Newline) ||
+                self.check_token(TokenKind::Whitespace) ||
+                self.check_token(TokenKind::Indent) ||
+                self.check_token(TokenKind::Dedent) ||
+                self.check_token(TokenKind::Comma)
+            {
+                self.advance();
+            }
+
             let value = if let Some(token) = self.peek_clone() {
                 match token.kind {
                     TokenKind::String => {
@@ -250,6 +299,11 @@ impl Parser {
             };
 
             map.insert(key, value);
+
+            // Optionally skip a trailing comma after the value
+            while self.check_token(TokenKind::Comma) || self.check_token(TokenKind::Whitespace) || self.check_token(TokenKind::Newline) {
+                self.advance();
+            }
         }
 
         if !self.match_token(TokenKind::RBrace) {
@@ -259,6 +313,79 @@ impl Parser {
         Some(Value::Map(map))
     }
 
+    // Parse an array value like [1, 2, 3] or ["a", b]
+    pub fn parse_array_value(&mut self) -> Option<Value> {
+        if !self.match_token(TokenKind::LBracket) {
+            return None;
+        }
+
+        let mut arr: Vec<Value> = Vec::new();
+
+        while !self.check_token(TokenKind::RBracket) && !self.is_eof() {
+            // Skip formatting tokens
+            while
+                self.check_token(TokenKind::Newline) ||
+                self.check_token(TokenKind::Whitespace) ||
+                self.check_token(TokenKind::Indent) ||
+                self.check_token(TokenKind::Dedent) ||
+                self.check_token(TokenKind::Comma)
+            {
+                self.advance();
+            }
+
+            if self.check_token(TokenKind::RBracket) {
+                break;
+            }
+
+            if let Some(token) = self.peek_clone() {
+                let value = match token.kind {
+                    TokenKind::String => { self.advance(); Value::String(token.lexeme.clone()) }
+                    TokenKind::Number => {
+                        // Support simple decimals split as number '.' number
+                        let mut number_str = token.lexeme.clone();
+                        self.advance();
+                        if let Some(dot) = self.peek_clone() {
+                            if dot.kind == TokenKind::Dot {
+                                if let Some(next) = self.peek_nth(1).cloned() {
+                                    if next.kind == TokenKind::Number {
+                                        self.advance(); // consume dot
+                                        self.advance(); // consume next number
+                                        number_str.push('.');
+                                        number_str.push_str(&next.lexeme);
+                                    }
+                                }
+                            }
+                        }
+                        Value::Number(number_str.parse::<f32>().unwrap_or(0.0))
+                    }
+                    TokenKind::Identifier => { self.advance(); Value::Identifier(token.lexeme.clone()) }
+                    TokenKind::LBrace => {
+                        // Allow inline maps inside arrays
+                        if let Some(v) = self.parse_map_value() { v } else { Value::Null }
+                    }
+                    TokenKind::LBracket => {
+                        // Nested arrays
+                        if let Some(v) = self.parse_array_value() { v } else { Value::Null }
+                    }
+                    _ => { self.advance(); Value::Null }
+                };
+
+                // Only push non-null (retain alignment with permissive parsing)
+                if value != Value::Null { arr.push(value); }
+
+                // Optional trailing comma handled by the skipper at loop start
+            } else {
+                break;
+            }
+        }
+
+        if !self.match_token(TokenKind::RBracket) {
+            println!("Expected ']' at end of array");
+        }
+
+        Some(Value::Array(arr))
+    }
+
     pub fn peek(&self) -> Option<&Token> {
         self.tokens.get(self.token_index)
     }
@@ -292,19 +419,15 @@ impl Parser {
     pub fn collect_until<F>(&mut self, condition: F) -> Vec<Token> where F: Fn(&Token) -> bool {
         let mut collected = Vec::new();
         while let Some(token) = self.peek() {
-            if token.kind == TokenKind::Newline || token.kind == TokenKind::Indent {
-                self.advance(); // Skip newlines and indents
-                continue;
-            }
-            if token.kind == TokenKind::EOF {
+            if condition(token) {
                 break;
             }
-            if condition(token) {
+            if token.kind == TokenKind::EOF {
                 break;
             }
             collected.push(self.advance().unwrap().clone());
         }
-        
+
         collected
     }
 

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

@@ -5,7 +5,104 @@ use crate::core::{
     store::global::GlobalStore,
 };
 
-pub fn parse_arrow_call(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+fn parse_map_literal(parser: &mut Parser) -> Value {
+    // Assumes '{' has already been consumed by caller
+    let mut map = std::collections::HashMap::new();
+    loop {
+        let Some(inner_token) = parser.peek_clone() else { break; };
+
+        match inner_token.kind {
+            TokenKind::RBrace => {
+                parser.advance(); // consume '}'
+                break;
+            }
+            TokenKind::Newline | TokenKind::Comma => {
+                parser.advance();
+                continue;
+            }
+            _ => {}
+        }
+
+        // Key
+        parser.advance();
+        let key = inner_token.lexeme.clone();
+
+        // Expect ':'
+        if let Some(colon_token) = parser.peek_clone() {
+            if colon_token.kind == TokenKind::Colon {
+                parser.advance(); // consume ':'
+
+                // Value
+                if let Some(value_token) = parser.peek_clone() {
+                    match value_token.kind {
+                        TokenKind::LBrace => {
+                            parser.advance(); // consume '{'
+                            let nested = parse_map_literal(parser);
+                            map.insert(key, nested);
+                        }
+                        TokenKind::Identifier => {
+                            parser.advance();
+                            let v = if value_token.lexeme == "true" {
+                                Value::Boolean(true)
+                            } else if value_token.lexeme == "false" {
+                                Value::Boolean(false)
+                            } else {
+                                Value::Identifier(value_token.lexeme.clone())
+                            };
+                            map.insert(key, v);
+                        }
+                        TokenKind::String => {
+                            parser.advance();
+                            map.insert(key, Value::String(value_token.lexeme.clone()));
+                        }
+                        TokenKind::Number => {
+                            parser.advance();
+                            // Beat fraction support: NUMBER '/' NUMBER
+                            if let Some(TokenKind::Slash) = parser.peek_kind() {
+                                parser.advance(); // '/'
+                                if let Some(den) = parser.peek_clone() {
+                                    if den.kind == TokenKind::Number {
+                                        parser.advance();
+                                        let beat = format!("{}/{}", value_token.lexeme, den.lexeme);
+                                        map.insert(key, Value::Beat(beat));
+                                        continue;
+                                    }
+                                }
+                            }
+                            // Decimal support NUMBER '.' NUMBER
+                            if let Some(next) = parser.peek_clone() {
+                                if next.kind == TokenKind::Dot {
+                                    parser.advance(); // '.'
+                                    if let Some(after) = parser.peek_clone() {
+                                        if after.kind == TokenKind::Number {
+                                            parser.advance();
+                                            let combined = format!("{}.{}", value_token.lexeme, after.lexeme);
+                                            map.insert(key, Value::Number(combined.parse::<f32>().unwrap_or(0.0)));
+                                            continue;
+                                        }
+                                    }
+                                }
+                            }
+                            map.insert(key, Value::Number(value_token.lexeme.parse::<f32>().unwrap_or(0.0)));
+                        }
+                        TokenKind::Boolean => {
+                            parser.advance();
+                            map.insert(key, Value::Boolean(value_token.lexeme.parse::<bool>().unwrap_or(false)));
+                        }
+                        _ => {
+                            // Unknown value type, consume and store Unknown
+                            parser.advance();
+                            map.insert(key, Value::Unknown);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    Value::Map(map)
+}
+
+pub fn parse_arrow_call(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
     let Some(target_token) = parser.peek_clone() else {
         return Statement::unknown();
     };
@@ -54,87 +151,66 @@ pub fn parse_arrow_call(parser: &mut Parser, global_store: &mut GlobalStore) ->
     parser.advance(); // method
 
     let mut args = Vec::new();
+    let mut paren_depth = 0;
+    let mut map_depth = 0;
 
     while let Some(token) = parser.peek_clone() {
         if token.kind == TokenKind::Newline || token.kind == TokenKind::EOF {
             break;
         }
+        if token.kind == TokenKind::LParen {
+            paren_depth += 1;
+        }
+        if token.kind == TokenKind::RParen {
+            if paren_depth > 0 {
+                paren_depth -= 1;
+                parser.advance();
+                if paren_depth == 0 {
+                    break;
+                }
+                continue;
+            } else {
+                break;
+            }
+        }
+        if token.kind == TokenKind::LBrace {
+            map_depth += 1;
+        }
+        if token.kind == TokenKind::RBrace {
+            if map_depth > 0 {
+                map_depth -= 1;
+                parser.advance();
+                if map_depth == 0 {
+                    continue;
+                }
+                continue;
+            } else {
+                break;
+            }
+        }
 
         parser.advance();
 
-        let value = match token.kind {
+    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 => {
-                                        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 {
-                                                    parser.advance(); // consume denominator
-                                                    let denominator =
-                                                        denominator_token.lexeme.clone();
-                                                    Value::Beat(
-                                                        format!(
-                                                            "{}/{}",
-                                                            value_token.lexeme,
-                                                            denominator
-                                                        )
-                                                    )
-                                                } else {
-                                                    Value::Unknown
-                                                }
-                                            } else {
-                                                Value::Unknown
-                                            }
-                                        } else {
-                                            // Regular number without slash
-                                            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)
+        // Handle map literal (supports nested maps)
+        let map_val = parse_map_literal(parser);
+        // We consumed the matching '}', so outer map_depth should be decremented
+        // if the caller tracks it.
+        map_val
             }
             _ => Value::Unknown,
         };
 
         args.push(value);
+
+        // Stop if we reach the end of the statement
+    if paren_depth == 0 && (token.kind == TokenKind::RParen || token.kind == TokenKind::RBrace) {
+            break;
+        }
     }
 
     Statement {

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

@@ -4,7 +4,7 @@ use crate::core::{
     shared::value::Value,
     store::global::GlobalStore,
 };
-pub fn parse_at_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+pub fn parse_at_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
     parser.advance(); // consume '@'
 
     let Some(token) = parser.peek_clone() else {