@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.2

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

@@ -1,16 +1,21 @@
 use std::collections::HashMap;
 
+use devalang_types::Value;
+
 use crate::core::{
-    lexer::token::{ Token, TokenKind },
-    parser::{ driver::Parser, statement::{ Statement, StatementKind } },
-    shared::value::Value,
+    lexer::token::Token,
+    parser::{
+        driver::parser::Parser,
+        handler::dot::parse_dot_token,
+        statement::{Statement, StatementKind},
+    },
     store::global::GlobalStore,
 };
 
 pub fn parse_synth_token(
     parser: &mut Parser,
-    current_token: Token,
-    global_store: &mut GlobalStore
+    _current_token: Token,
+    _global_store: &mut GlobalStore,
 ) -> Statement {
     parser.advance(); // consume 'synth'
 
@@ -18,46 +23,111 @@ pub fn parse_synth_token(
         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());
-    };
+    // Expect a provider/waveform identifier (can be dotted: alias.synth)
+    // Also accept a dot-led entity by delegating to the dot parser (e.g. .module.export)
+    let synth_waveform = if let Some(first_token) = parser.peek_clone() {
+        use crate::core::lexer::token::TokenKind;
 
-    let synth_waveform = identifier_token.lexeme.clone();
+        if first_token.kind == TokenKind::Dot {
+            // Parse dot-entity and extract its entity string
+            let dot_stmt = parse_dot_token(parser, _global_store);
+            // Extract entity if the parsed statement is a Trigger
+            match dot_stmt.kind {
+                StatementKind::Trigger { entity, .. } => entity,
+                _ => String::new(),
+            }
+        } else {
+            if first_token.kind != crate::core::lexer::token::TokenKind::Identifier
+                && first_token.kind != crate::core::lexer::token::TokenKind::Number
+                && first_token.kind != crate::core::lexer::token::TokenKind::Synth
+            {
+                return crate::core::parser::statement::error_from_token(
+                    first_token.clone(),
+                    "Expected identifier after 'synth'".to_string(),
+                );
+            }
 
-    parser.advance(); // consume identifier
+            // Collect dotted parts on the same line
+            let mut parts: Vec<String> = Vec::new();
+            let current_line = first_token.line;
+            loop {
+                let Some(tok) = parser.peek_clone() else {
+                    break;
+                };
+                if tok.line != current_line {
+                    break;
+                }
+                match tok.kind {
+                    crate::core::lexer::token::TokenKind::Identifier
+                    | crate::core::lexer::token::TokenKind::Number
+                    | crate::core::lexer::token::TokenKind::Synth => {
+                        parts.push(tok.lexeme.clone());
+                        parser.advance();
+                        // If next isn't a dot on same line, stop
+                        if let Some(next) = parser.peek_clone() {
+                            if !(next.line == current_line
+                                && next.kind == crate::core::lexer::token::TokenKind::Dot)
+                            {
+                                break;
+                            }
+                        } else {
+                            break;
+                        }
+                    }
+                    crate::core::lexer::token::TokenKind::Dot => {
+                        parser.advance();
+                    }
+                    _ => break,
+                }
+            }
 
-    // Expect synth optional parameters map
-    let mut parameters = HashMap::new();
+            parts.join(".")
+        }
+    } else {
+        return crate::core::parser::statement::error_from_token(
+            synth_token,
+            "Expected identifier after 'synth'".to_string(),
+        );
+    };
+
+    // Skip formatting before optional parameters map
+    while parser.check_token(crate::core::lexer::token::TokenKind::Newline)
+        || parser.check_token(crate::core::lexer::token::TokenKind::Indent)
+        || parser.check_token(crate::core::lexer::token::TokenKind::Dedent)
+        || parser.check_token(crate::core::lexer::token::TokenKind::Whitespace)
+    {
+        parser.advance();
+    }
 
-    if let Some(params) = parser.parse_map_value() {
+    // Expect synth optional parameters map
+    let parameters = if let Some(params) = parser.parse_map_value() {
         // If parameters are provided, we expect a map
         if let Value::Map(map) = params {
-            parameters = map;
+            map
         } else {
-            return Statement::error(synth_token, "Expected a map for synth parameters".to_string());
+            return crate::core::parser::statement::error_from_token(
+                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();
-    }
+        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)),
-                        ])
-                    ),
-                ),
-            ])
-        ),
+        value: Value::Map(HashMap::from([
+            ("entity".to_string(), Value::String("synth".to_string())),
+            (
+                "value".to_string(),
+                Value::Map(HashMap::from([
+                    // Store waveform as identifier to allow resolution from variables/exports
+                    ("waveform".to_string(), Value::Identifier(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

@@ -1,20 +1,135 @@
-use std::collections::HashMap;
+use devalang_types::Value;
 
 use crate::core::{
-    lexer::{ token::TokenKind },
-    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
-    shared::value::Value,
+    lexer::token::TokenKind,
+    parser::{
+        driver::parser::Parser,
+        statement::{Statement, StatementKind},
+    },
     store::global::GlobalStore,
 };
 
 pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
-    parser.advance(); // consume 'loop'
+    parser.advance(); // consume 'loop' or 'for' (aliased in lexer)
     let Some(loop_token) = parser.previous_clone() else {
         return Statement::unknown();
     };
 
+    // Support two forms:
+    // 1) loop <count>:
+    // 2) for <ident> in [a,b,c]:
+
+    // Peek next to decide
+    let Some(next_token) = parser.peek_clone() else {
+        return Statement::error_with_pos(
+            loop_token.indent,
+            loop_token.line,
+            loop_token.column,
+            "Expected iterator after loop/for".to_string(),
+        );
+    };
+
+    // Try to detect 'for <ident> in [array]:' form
+    let mut foreach_ident: Option<String> = None;
+    if let TokenKind::Identifier = next_token.kind {
+        // Could be either count identifier (old form) or foreach variable
+        // Look ahead for 'in'
+        let name = next_token.lexeme.clone();
+        // don't consume yet; we'll branch
+        if let Some(t2) = parser.peek_nth(1) {
+            if t2.kind == TokenKind::Identifier && t2.lexeme == "in" {
+                // foreach form
+                foreach_ident = Some(name);
+                // consume ident and 'in'
+                parser.advance();
+                parser.advance();
+            }
+        }
+    }
+
+    if let Some(var_name) = foreach_ident {
+        // Expect [array] OR number OR string OR identifier after 'in'
+        let array_val = if let Some(tok) = parser.peek_clone() {
+            match tok.kind {
+                TokenKind::LBracket => {
+                    if let Some(v) = parser.parse_array_value() {
+                        v
+                    } else {
+                        Value::Array(vec![])
+                    }
+                }
+                TokenKind::Number => {
+                    parser.advance();
+                    let n = tok.lexeme.parse::<f32>().unwrap_or(0.0);
+                    Value::Number(n)
+                }
+                TokenKind::String => {
+                    parser.advance();
+                    Value::String(tok.lexeme.clone())
+                }
+                TokenKind::Identifier => {
+                    parser.advance();
+                    Value::Identifier(tok.lexeme.clone())
+                }
+                _ => {
+                    return Statement::error_with_pos(
+                        loop_token.indent,
+                        loop_token.line,
+                        loop_token.column,
+                        "Expected array, number, string or identifier after 'in'".to_string(),
+                    );
+                }
+            }
+        } else {
+            return Statement::error_with_pos(
+                loop_token.indent,
+                loop_token.line,
+                loop_token.column,
+                "Expected array, number, string or identifier after 'in'".to_string(),
+            );
+        };
+
+        // Expect ':'
+        if !parser.match_token(TokenKind::Colon) {
+            return Statement::error_with_pos(
+                loop_token.indent,
+                loop_token.line,
+                loop_token.column,
+                "Expected ':' after foreach header".to_string(),
+            );
+        }
+
+        let tokens =
+            parser.collect_until(|t| t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF);
+        let loop_body = parser.parse_block(tokens.clone(), global_store);
+        if let Some(token) = parser.peek() {
+            if token.kind == TokenKind::Dedent {
+                parser.advance();
+            }
+        }
+
+        let mut value_map = std::collections::HashMap::new();
+        value_map.insert("foreach".to_string(), Value::Identifier(var_name));
+        value_map.insert("array".to_string(), array_val);
+        value_map.insert("body".to_string(), Value::Block(loop_body.clone()));
+
+        return Statement {
+            kind: StatementKind::Loop,
+            value: Value::Map(value_map),
+            indent: loop_token.indent,
+            line: loop_token.line,
+            column: loop_token.column,
+        };
+    }
+
+    // Fallback to legacy: loop <count>:
     let Some(iterator_token) = parser.peek_clone() else {
-        return Statement::error(loop_token, "Expected number or identifier after 'loop'".to_string());
+        return Statement::error_with_pos(
+            loop_token.indent,
+            loop_token.line,
+            loop_token.column,
+            "Expected number or identifier after 'loop'".to_string(),
+        );
     };
 
     let iterator_value = match iterator_token.kind {
@@ -28,37 +143,44 @@ pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) ->
             parser.advance();
             Value::Identifier(val)
         }
+        TokenKind::String => {
+            // strings that are numeric (e.g. "10")
+            let s = iterator_token.lexeme.clone();
+            parser.advance();
+            Value::String(s)
+        }
         _ => {
-            return Statement::error(
-                iterator_token.clone(),
-                "Expected a number or identifier as loop count".to_string()
+            return Statement::error_with_pos(
+                iterator_token.clone().indent,
+                iterator_token.clone().line,
+                iterator_token.clone().column,
+                "Expected a number, string 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 loop count".to_string());
-    };
-
-    if colon_token.kind != TokenKind::Colon {
-        let message = format!("Expected ':' after loop count, got {:?}", colon_token.kind);
-        return Statement::error(colon_token.clone(), message);
+    if !parser.match_token(TokenKind::Colon) {
+        let message = format!(
+            "Expected ':' after loop count, got {:?}",
+            parser.peek_kind()
+        );
+        return Statement::error_with_pos(
+            loop_token.clone().indent,
+            loop_token.clone().line,
+            loop_token.clone().column,
+            message,
+        );
     }
 
-    parser.advance(); // consume ':'
-
-    // 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);
-
     if let Some(token) = parser.peek() {
         if token.kind == TokenKind::Dedent {
             parser.advance();
         }
     }
 
-    let mut value_map = HashMap::new();
+    let mut value_map = std::collections::HashMap::new();
     value_map.insert("iterator".to_string(), iterator_value);
     value_map.insert("body".to_string(), Value::Block(loop_body.clone()));
 

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

@@ -1,8 +1,9 @@
+pub mod arrow_call;
 pub mod at;
-pub mod identifier;
-pub mod dot;
-pub mod tempo;
 pub mod bank;
-pub mod loop_;
 pub mod condition;
-pub mod arrow_call;
+pub mod dot;
+pub mod identifier;
+pub mod loop_;
+pub mod pattern;
+pub mod tempo;

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

@@ -0,0 +1,74 @@
+use devalang_types::Value;
+
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{
+        driver::parser::Parser,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+
+pub fn parse_pattern_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+    // consume 'pattern'
+    parser.advance();
+
+    let Some(tok) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    // Parse pattern name
+    let mut name = String::new();
+    if let Some(next) = parser.peek_clone() {
+        if next.kind == TokenKind::Identifier {
+            parser.advance();
+            name = next.lexeme.clone();
+        }
+    }
+
+    // optional 'with <target>' sequence
+    let mut target: Option<String> = None;
+    if parser.peek_is("with") {
+        parser.advance(); // consume 'with'
+        if let Some(tok2) = parser.peek_clone() {
+            // target can be identifier or dotted identifier
+            if tok2.kind == TokenKind::Identifier {
+                parser.advance();
+                let mut base = tok2.lexeme.clone();
+                if let Some(dot) = parser.peek_clone() {
+                    if dot.kind == TokenKind::Dot {
+                        parser.advance();
+                        if let Some(suf) = parser.peek_clone() {
+                            if suf.kind == TokenKind::Identifier || suf.kind == TokenKind::Number {
+                                parser.advance();
+                                base.push('.');
+                                base.push_str(&suf.lexeme);
+                            }
+                        }
+                    }
+                }
+                target = Some(base);
+            }
+        }
+    }
+
+    // optional '=' and pattern string
+    let mut value: Value = Value::Null;
+    if parser.peek_is("=") {
+        parser.advance();
+        if let Some(tok3) = parser.peek_clone() {
+            if tok3.kind == TokenKind::String {
+                parser.advance();
+                value = Value::String(tok3.lexeme.clone());
+            }
+        }
+    }
+
+    Statement {
+        kind: StatementKind::Pattern { name, target },
+        value,
+        indent: tok.indent,
+        line: tok.line,
+        column: tok.column,
+    }
+}

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

@@ -1,9 +1,12 @@
 use crate::core::{
     lexer::token::TokenKind,
-    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
-    shared::value::Value,
+    parser::{
+        driver::parser::Parser,
+        statement::{Statement, StatementKind},
+    },
     store::global::GlobalStore,
 };
+use devalang_types::Value;
 
 pub fn parse_tempo_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
     parser.advance(); // consume 'bpm'
@@ -14,25 +17,80 @@ pub fn parse_tempo_token(parser: &mut Parser, _global_store: &mut GlobalStore) -
 
     // Expect a number or identifier
     let Some(value_token) = parser.peek_clone() else {
-        return Statement::error(
-            tempo_token,
-            "Expected a number or identifier after 'bpm'".to_string()
+        return Statement::error_with_pos(
+            tempo_token.indent,
+            tempo_token.line,
+            tempo_token.column,
+            "Expected a number or identifier after 'bpm'".to_string(),
         );
     };
 
     let value = match value_token.kind {
         TokenKind::Number => {
+            // support decimals and fraction forms
+            let mut num = value_token.lexeme.clone();
             parser.advance();
-            Value::Number(value_token.lexeme.parse().unwrap_or(0.0))
+            if let Some(dot) = parser.peek_clone() {
+                if dot.kind == TokenKind::Dot {
+                    if let Some(next) = parser.peek_nth(1).cloned() {
+                        if next.kind == TokenKind::Number {
+                            parser.advance();
+                            parser.advance();
+                            num.push('.');
+                            num.push_str(&next.lexeme);
+                        }
+                    }
+                }
+            }
+
+            if let Some(slash) = parser.peek_clone() {
+                if slash.kind == TokenKind::Slash {
+                    parser.advance();
+                    if let Some(den) = parser.peek_clone() {
+                        if den.kind == TokenKind::Number || den.kind == TokenKind::Identifier {
+                            let frac = format!("{}/{}", num, den.lexeme);
+                            parser.advance();
+                            Value::Duration(devalang_types::Duration::Beat(frac))
+                        } else {
+                            return Statement::error_with_pos(
+                                slash.indent,
+                                slash.line,
+                                slash.column,
+                                "Expected denominator after '/' in bpm".to_string(),
+                            );
+                        }
+                    } else {
+                        return Statement::error_with_pos(
+                            slash.indent,
+                            slash.line,
+                            slash.column,
+                            "Expected denominator after '/' in bpm".to_string(),
+                        );
+                    }
+                } else {
+                    Value::Number(num.parse().unwrap_or(0.0))
+                }
+            } else {
+                Value::Number(num.parse().unwrap_or(0.0))
+            }
         }
         TokenKind::Identifier => {
             parser.advance();
             Value::Identifier(value_token.lexeme.clone())
         }
+        TokenKind::String => {
+            parser.advance();
+            Value::String(value_token.lexeme.clone())
+        }
         _ => {
-            return Statement::error(
-                value_token.clone(),
-                format!("Expected a number or identifier after 'bpm', got {:?}", value_token.kind)
+            return Statement::error_with_pos(
+                value_token.indent,
+                value_token.line,
+                value_token.column,
+                format!(
+                    "Expected a number, string or identifier after 'bpm', got {:?}",
+                    value_token.kind
+                ),
             );
         }
     };

package/rust/core/parser/mod.rs

@@ -1,4 +1,3 @@
-pub mod driver;
-
-pub mod statement;
-pub mod handler;
+pub mod driver;
+pub mod handler;
+pub mod statement;

package/rust/core/parser/statement.rs

@@ -1,96 +1,10 @@
-use serde::{ Deserialize, Serialize };
-use crate::core::{ lexer::token::Token, shared::{ duration::Duration, value::Value } };
+use crate::core::lexer::token::Token;
+pub use devalang_types::{Duration, Statement, StatementKind, Value};
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct Statement {
-    pub kind: StatementKind,
-    pub value: Value,
-    pub indent: usize,
-    pub line: usize,
-    pub column: usize,
+pub fn unknown_from_token(token: &Token) -> Statement {
+    Statement::unknown_with_pos(token.indent, token.line, token.column)
 }
 
-impl Statement {
-    pub fn unknown() -> Self {
-        Statement {
-            kind: StatementKind::Unknown,
-            value: Value::Null,
-            indent: 0,
-            line: 0,
-            column: 0,
-        }
-    }
-
-    pub fn error(token: Token, message: String) -> Self {
-        Statement {
-            kind: StatementKind::Error { message },
-            value: Value::Null,
-            indent: token.indent,
-            line: token.line,
-            column: token.column,
-        }
-    }
+pub fn error_from_token(token: Token, message: String) -> Statement {
+    Statement::error_with_pos(token.indent, token.line, token.column, message)
 }
-
-#[derive(Debug, Serialize, Clone, Deserialize, PartialEq)]
-pub enum StatementKind {
-    // ───── Core Instructions ─────
-    Tempo,
-    Bank,
-    Load {
-        source: String,
-        alias: String,
-    },
-    Let {
-        name: String,
-    },
-    ArrowCall {
-        target: String,
-        method: String,
-        args: Vec<Value>,
-    },
-
-    // ───── Instruments ─────
-    Synth,
-
-    // ───── Playback / Scheduling ─────
-    Trigger {
-        entity: String,
-        duration: Duration,
-    },
-    Sleep,
-    Call,
-    Spawn,
-    Loop,
-    
-    // ───── Structure & Logic ─────
-    Group,
-
-    // ───── Module System ─────
-    Include(String),
-    Export {
-        names: Vec<String>,
-        source: String,
-    },
-    Import {
-        names: Vec<String>,
-        source: String,
-    },
-
-    // ───── Conditions ─────
-    If,
-    Else,
-    ElseIf,
-
-    // ───── Internal / Utility ─────
-    Comment,
-    Indent,
-    Dedent,
-    NewLine,
-
-    // ───── Error Handling ─────
-    Unknown,
-    Error {
-        message: String,
-    },
-}