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

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

@@ -0,0 +1,133 @@
+use std::collections::HashMap;
+
+use crate::core::{
+    lexer::token::{ Token, TokenKind },
+    parser::{
+        driver::Parser,
+        handler::identifier::synth::parse_synth_token,
+        statement::{ Statement, StatementKind },
+    },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_let_token(
+    parser: &mut Parser,
+    current_token: Token,
+    global_store: &mut GlobalStore
+) -> Statement {
+    parser.advance(); // consume "let"
+
+    let identifier = if let Some(token) = parser.peek_clone() {
+        if token.kind == TokenKind::Identifier {
+            parser.advance();
+            token.lexeme.clone()
+        } else {
+            return Statement::error(token, "Expected identifier after 'let'".to_string());
+        }
+    } else {
+        return Statement::error(current_token, "Expected identifier after 'let'".to_string());
+    };
+
+    if !parser.match_token(TokenKind::Equals) {
+        return Statement::error(current_token, "Expected '=' after identifier".to_string());
+    }
+
+    if let Some(token) = parser.peek_clone() {
+        if token.kind == TokenKind::Synth {
+            let synth_stmt = parse_synth_token(parser, token.clone(), global_store);
+
+            return Statement {
+                kind: StatementKind::Let { name: identifier },
+                value: synth_stmt.value,
+                indent: current_token.indent,
+                line: current_token.line,
+                column: current_token.column,
+            };
+        }
+    }
+
+    let value = match parser.peek_clone() {
+        Some(token) if token.kind == TokenKind::Identifier => {
+            parser.advance();
+            Value::Identifier(token.lexeme.clone())
+        }
+        Some(token) if token.kind == TokenKind::String => {
+            parser.advance();
+            Value::String(token.lexeme.clone())
+        }
+        Some(token) if token.kind == TokenKind::Number => {
+            parser.advance();
+            Value::Number(token.lexeme.parse().unwrap_or(0.0))
+        }
+        Some(token) if token.kind == TokenKind::Boolean => {
+            parser.advance();
+            Value::Boolean(token.lexeme.parse().unwrap_or(false))
+        }
+        Some(token) if token.kind == TokenKind::LBrace => {
+            parser.advance(); // consume '{'
+            let mut map = HashMap::new();
+
+            while let Some(key_token) = parser.peek_clone() {
+                if key_token.kind == TokenKind::RBrace {
+                    parser.advance(); // consume '}'
+                    break;
+                }
+
+                if key_token.kind != TokenKind::Identifier {
+                    return Statement::error(token, "Expected key identifier in map".to_string());
+                }
+                parser.advance();
+                let key = key_token.lexeme.clone();
+
+                if !parser.match_token(TokenKind::Colon) {
+                    let message = format!("Expected ':' after key '{}'", key);
+                    return Statement::error(token, message);
+                }
+
+                let val = match parser.peek_clone() {
+                    Some(t) if t.kind == TokenKind::Number => {
+                        parser.advance();
+                        Value::Number(t.lexeme.parse().unwrap_or(0.0))
+                    }
+                    Some(t) if t.kind == TokenKind::String => {
+                        parser.advance();
+                        Value::String(t.lexeme.clone())
+                    }
+                    Some(t) if t.kind == TokenKind::Identifier => {
+                        parser.advance();
+                        Value::Identifier(t.lexeme.clone())
+                    }
+                    _ => Value::Null,
+                };
+
+                if val == Value::Null {
+                    let message = format!("Invalid value for key '{}'", key);
+                    return Statement::error(token, message);
+                }
+
+                map.insert(key, val);
+
+                if let Some(t) = parser.peek() {
+                    if t.kind == TokenKind::Comma {
+                        parser.advance(); // skip comma
+                    }
+                }
+            }
+
+            Value::Map(map)
+        }
+        other => {
+            let message = format!("Unexpected value token in let: {:?}", other);
+            return Statement::error(current_token, message);
+        }
+    };
+
+    Statement {
+        kind: StatementKind::Let { name: identifier },
+        value,
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    }
+}

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

@@ -0,0 +1,51 @@
+pub mod let_;
+pub mod group;
+pub mod call;
+pub mod spawn;
+pub mod sleep;
+pub mod synth;
+
+use crate::core::{
+    parser::{
+        driver::Parser,
+        handler::{
+            identifier::{
+                call::parse_call_token,
+                group::parse_group_token,
+                let_::parse_let_token,
+                sleep::parse_sleep_token,
+                spawn::parse_spawn_token,
+                synth::parse_synth_token
+            },
+        },
+        statement::Statement,
+    },
+    store::global::GlobalStore,
+};
+
+pub fn parse_identifier_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+    let Some(current_token) = parser.peek_clone() else {
+        return Statement::unknown();
+    };
+
+    let current_token_clone = current_token.clone();
+    let current_token_lexeme = current_token_clone.lexeme.clone();
+
+    let statement = match current_token_lexeme.as_str() {
+        "let" => parse_let_token(parser, current_token_clone, global_store),
+        "group" => parse_group_token(parser, current_token_clone, global_store),
+        "call" => parse_call_token(parser, current_token_clone, global_store),
+        "spawn" => parse_spawn_token(parser, current_token_clone, global_store),
+        "sleep" => parse_sleep_token(parser, current_token_clone, global_store),
+        "synth" => parse_synth_token(parser, current_token_clone, global_store),
+        _ => {
+            parser.advance(); // consume identifier
+
+            println!("Unrecognized identifier: {}", current_token_lexeme);
+
+            return Statement::error(current_token_clone, "Unexpected identifier".to_string());
+        }
+    };
+
+    return statement;
+}

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

@@ -0,0 +1,33 @@
+use crate::core::{
+    lexer::token::{ Token, TokenKind },
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_sleep_token(
+    parser: &mut Parser,
+    current_token: Token,
+    global_store: &mut GlobalStore
+) -> Statement {
+    parser.advance(); // consume "sleep"
+
+    let duration = if let Some(token) = parser.peek_clone() {
+        if token.kind == TokenKind::Number {
+            parser.advance();
+            token.lexeme.parse().unwrap_or(0.0)
+        } else {
+            return Statement::error(token, "Expected number after 'sleep'".to_string());
+        }
+    } else {
+        return Statement::error(current_token, "Expected number after 'sleep'".to_string());
+    };
+
+    return Statement {
+        kind: StatementKind::Sleep,
+        value: Value::Number(duration),
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    };
+}

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

@@ -0,0 +1,41 @@
+use crate::core::{
+    lexer::token::{ Token, TokenKind },
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_spawn_token(
+    parser: &mut Parser,
+    current_token: Token,
+    global_store: &mut GlobalStore
+) -> Statement {
+        parser.advance(); // consume "spawn"
+
+        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 'spawn'".to_string()
+                    );
+                }
+            }
+        } else {
+            return Statement::error(
+                current_token,
+                "Expected identifier or string after 'spawn'".to_string()
+            );
+        };
+
+        return Statement {
+            kind: StatementKind::Spawn,
+            value,
+            indent: current_token.indent,
+            line: current_token.line,
+            column: current_token.column,
+        };
+}

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

@@ -0,0 +1,65 @@
+use std::collections::HashMap;
+
+use crate::core::{
+    lexer::token::{ Token, TokenKind },
+    parser::{ driver::Parser, statement::{ Statement, StatementKind } },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_synth_token(
+    parser: &mut Parser,
+    current_token: Token,
+    global_store: &mut GlobalStore
+) -> Statement {
+    parser.advance(); // consume 'synth'
+
+    let Some(synth_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    // Expect an identifier (synth waveform)
+    let Some(identifier_token) = parser.peek_clone() else {
+        return Statement::error(synth_token, "Expected identifier after 'synth'".to_string());
+    };
+
+    let synth_waveform = identifier_token.lexeme.clone();
+
+    parser.advance(); // consume identifier
+
+    // Expect synth optional parameters map
+    let mut parameters = HashMap::new();
+
+    if let Some(params) = parser.parse_map_value() {
+        // If parameters are provided, we expect a map
+        if let Value::Map(map) = params {
+            parameters = map;
+        } else {
+            return Statement::error(synth_token, "Expected a map for synth parameters".to_string());
+        }
+    } else {
+        // If no parameters are provided, we can still create the statement with an empty map
+        parameters = HashMap::new();
+    }
+
+    Statement {
+        kind: StatementKind::Synth,
+        value: Value::Map(
+            HashMap::from([
+                ("entity".to_string(), Value::String("synth".to_string())),
+                (
+                    "value".to_string(),
+                    Value::Map(
+                        HashMap::from([
+                            ("waveform".to_string(), Value::String(synth_waveform)),
+                            ("parameters".to_string(), Value::Map(parameters)),
+                        ])
+                    ),
+                ),
+            ])
+        ),
+        indent: synth_token.indent,
+        line: synth_token.line,
+        column: synth_token.column,
+    }
+}

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

@@ -2,58 +2,64 @@ use std::collections::HashMap;
 
 use crate::core::{
     lexer::{ token::TokenKind },
-    parser::{ statement::{ Statement, StatementKind }, Parser },
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
     shared::value::Value,
     store::global::GlobalStore,
 };
 
 pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
     parser.advance(); // consume 'loop'
-
     let Some(loop_token) = parser.previous_clone() else {
         return Statement::unknown();
     };
 
-    // Expect an identifier (iterator)
     let Some(iterator_token) = parser.peek_clone() else {
-        return Statement::error(loop_token, "Expected identifier after 'loop'".to_string());
+        return Statement::error(loop_token, "Expected number or identifier after 'loop'".to_string());
     };
 
-    let iterator_name = iterator_token.lexeme.clone();
-    parser.advance(); // consume iterator
+    let iterator_value = match iterator_token.kind {
+        TokenKind::Number => {
+            let val = iterator_token.lexeme.parse::<f32>().unwrap_or(1.0);
+            parser.advance();
+            Value::Number(val)
+        }
+        TokenKind::Identifier => {
+            let val = iterator_token.lexeme.clone();
+            parser.advance();
+            Value::Identifier(val)
+        }
+        _ => {
+            return Statement::error(
+                iterator_token.clone(),
+                "Expected a number or identifier as loop count".to_string()
+            );
+        }
+    };
 
     // Expect colon
     let Some(colon_token) = parser.peek_clone() else {
-        return Statement::error(iterator_token.clone(), "Expected ':' after iterator".to_string());
+        return Statement::error(iterator_token.clone(), "Expected ':' after loop count".to_string());
     };
 
     if colon_token.kind != TokenKind::Colon {
-        let message = format!("Expected ':' after iterator, got {:?}", colon_token.kind);
+        let message = format!("Expected ':' after loop count, got {:?}", colon_token.kind);
         return Statement::error(colon_token.clone(), message);
     }
 
     parser.advance(); // consume ':'
 
-    // Collect all indented statements
-    let tokens = parser.collect_until(
-        |t| (t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF)
-    );
+    // Collect body
+    let tokens = parser.collect_until(|t| t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF);
     let loop_body = parser.parse_block(tokens.clone(), global_store);
 
-    // Peek for dedent
     if let Some(token) = parser.peek() {
         if token.kind == TokenKind::Dedent {
             parser.advance();
-        } else {
-            // Unexpected token after loop body
         }
-    } else {
-        // EOF or unexpected end of input
     }
 
     let mut value_map = HashMap::new();
-
-    value_map.insert("iterator".to_string(), Value::Identifier(iterator_name));
+    value_map.insert("iterator".to_string(), iterator_value);
     value_map.insert("body".to_string(), Value::Block(loop_body.clone()));
 
     Statement {

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

@@ -3,4 +3,6 @@ pub mod identifier;
 pub mod dot;
 pub mod tempo;
 pub mod bank;
-pub mod loop_;
+pub mod loop_;
+pub mod condition;
+pub mod arrow_call;

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

@@ -1,6 +1,6 @@
 use crate::core::{
     lexer::token::TokenKind,
-    parser::{ statement::{ Statement, StatementKind }, Parser },
+    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
     shared::value::Value,
     store::global::GlobalStore,
 };

package/rust/core/parser/mod.rs

@@ -1,238 +1,4 @@
-pub mod statement;
-pub mod handler;
-
-use crate::core::{
-    lexer::token::{ Token, TokenKind },
-    parser::{
-        handler::{
-            at::parse_at_token,
-            bank::parse_bank_token,
-            dot::parse_dot_token,
-            identifier::parse_identifier_token,
-            loop_::parse_loop_token,
-            tempo::parse_tempo_token,
-        },
-        statement::{ Statement, StatementKind },
-    },
-    shared::value::Value,
-    store::global::GlobalStore,
-};
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Parser {
-    pub resolve_modules: bool,
-    pub tokens: Vec<Token>,
-    pub token_index: usize,
-    pub current_module: String,
-    pub previous: Option<Token>,
-}
-
-impl Parser {
-    pub fn new() -> Self {
-        Parser {
-            resolve_modules: false,
-            tokens: Vec::new(),
-            token_index: 0,
-            current_module: String::new(),
-            previous: None,
-        }
-    }
-
-    pub fn set_current_module(&mut self, module_path: String) {
-        self.current_module = module_path;
-    }
-
-    pub fn advance(&mut self) -> Option<&Token> {
-        if self.is_eof() {
-            return None;
-        }
-
-        self.previous = self.tokens.get(self.token_index).cloned(); // mémorise avant de bouger
-        self.token_index += 1;
-
-        self.tokens.get(self.token_index - 1)
-    }
-
-    pub fn match_token(&mut self, kind: TokenKind) -> bool {
-        if let Some(tok) = self.peek() {
-            if tok.kind == kind {
-                self.advance();
-                return true;
-            }
-        }
-        false
-    }
-
-    pub fn previous_clone(&self) -> Option<Token> {
-        self.previous.clone()
-    }
-
-    pub fn parse_block(
-        &self,
-        tokens: Vec<Token>,
-        global_store: &mut GlobalStore
-    ) -> Vec<Statement> {
-        let mut inner_parser = Parser {
-            resolve_modules: self.resolve_modules,
-            tokens,
-            token_index: 0,
-            current_module: self.current_module.clone(),
-            previous: None,
-        };
-
-        inner_parser.parse_tokens(inner_parser.tokens.clone(), global_store)
-    }
-
-    pub fn parse_tokens(
-        &mut self,
-        tokens: Vec<Token>,
-        global_store: &mut GlobalStore
-    ) -> Vec<Statement> {
-        self.tokens = tokens;
-        self.token_index = 0;
-
-        let mut statements = Vec::new();
-
-        while !self.is_eof() {
-            let token = match self.peek() {
-                Some(t) => t.clone(),
-                None => {
-                    break;
-                }
-            };
-
-            let mut statement = match &token.kind {
-                TokenKind::At => parse_at_token(self, global_store),
-                TokenKind::Identifier => 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),
-                TokenKind::Loop => parse_loop_token(self, global_store),
-
-                | TokenKind::Comment
-                | TokenKind::Equals
-                | TokenKind::Colon
-                | TokenKind::Number
-                | TokenKind::String
-                | TokenKind::LBrace
-                | TokenKind::RBrace
-                | TokenKind::Comma
-                | TokenKind::Newline
-                | TokenKind::Dedent
-                | TokenKind::Indent => {
-                    self.advance();
-                    continue;
-                }
-
-                TokenKind::EOF => {
-                    break;
-                }
+pub mod driver;
 
-                _ => {
-                    println!("Unhandled token: {:?}", token);
-                    self.advance();
-                    Statement::unknown()
-                }
-            };
-
-            statements.push(statement);
-        }
-
-        statements
-    }
-
-    pub fn check_token(&self, kind: TokenKind) -> bool {
-        self.peek().map_or(false, |t| t.kind == kind)
-    }
-
-    pub fn parse_map_value(&mut self) -> Option<Value> {
-        if !self.match_token(TokenKind::LBrace) {
-            return None;
-        }
-
-        let mut map = std::collections::HashMap::new();
-
-        while !self.check_token(TokenKind::RBrace) && !self.is_eof() {
-            let key = if let Some(token) = self.advance() {
-                token.lexeme.clone()
-            } else {
-                break;
-            };
-
-            if !self.match_token(TokenKind::Colon) {
-                println!("Expected ':' after map key '{}'", key);
-                break;
-            }
-
-            let value = if let Some(token) = self.peek_clone() {
-                match token.kind {
-                    TokenKind::String => {
-                        self.advance();
-                        Value::String(token.lexeme.clone())
-                    }
-                    TokenKind::Number => {
-                        self.advance();
-                        Value::Number(token.lexeme.parse().unwrap_or(0.0))
-                    }
-                    TokenKind::Identifier => {
-                        self.advance();
-                        Value::Identifier(token.lexeme.clone())
-                    }
-                    _ => {
-                        println!("Unexpected token in map value: {:?}", token);
-                        Value::Null
-                    }
-                }
-            } else {
-                Value::Null
-            };
-
-            map.insert(key, value);
-        }
-
-        if !self.match_token(TokenKind::RBrace) {
-            println!("Expected '}}' at end of map");
-        }
-
-        Some(Value::Map(map))
-    }
-
-    pub fn peek(&self) -> Option<&Token> {
-        self.tokens.get(self.token_index)
-    }
-
-    pub fn peek_clone(&self) -> Option<Token> {
-        self.tokens.get(self.token_index).cloned()
-    }
-
-    pub fn expect(&mut self, kind: TokenKind) -> Result<&Token, String> {
-        let tok = self.advance().ok_or("Unexpected end of input")?;
-        if tok.kind == kind {
-            Ok(tok)
-        } else {
-            Err(format!("Expected {:?}, got {:?}", kind, tok.kind))
-        }
-    }
-
-    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 {
-                break;
-            }
-            if condition(token) {
-                break;
-            }
-            collected.push(self.advance().unwrap().clone());
-        }
-        collected
-    }
-
-    pub fn is_eof(&self) -> bool {
-        self.token_index >= self.tokens.len()
-    }
-}
+pub mod statement;
+pub mod handler;