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

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

@@ -1,72 +1,194 @@
-use std::collections::HashMap;
-
-use crate::core::{
-    lexer::{ token::TokenKind },
-    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();
-    };
-
-    let Some(iterator_token) = parser.peek_clone() else {
-        return Statement::error(loop_token, "Expected number or identifier after 'loop'".to_string());
-    };
-
-    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 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);
-    }
-
-    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();
-    value_map.insert("iterator".to_string(), iterator_value);
-    value_map.insert("body".to_string(), Value::Block(loop_body.clone()));
-
-    Statement {
-        kind: StatementKind::Loop,
-        value: Value::Map(value_map),
-        indent: loop_token.indent,
-        line: loop_token.line,
-        column: loop_token.column,
-    }
-}
+use devalang_types::Value;
+
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{
+        driver::Parser,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+
+pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+    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_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 {
+        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)
+        }
+        TokenKind::String => {
+            // strings that are numeric (e.g. "10")
+            let s = iterator_token.lexeme.clone();
+            parser.advance();
+            Value::String(s)
+        }
+        _ => {
+            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(),
+            );
+        }
+    };
+
+    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,
+        );
+    }
+
+    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("iterator".to_string(), iterator_value);
+    value_map.insert("body".to_string(), Value::Block(loop_body.clone()));
+
+    Statement {
+        kind: StatementKind::Loop,
+        value: Value::Map(value_map),
+        indent: loop_token.indent,
+        line: loop_token.line,
+        column: loop_token.column,
+    }
+}

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

@@ -1,8 +1,9 @@
-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 arrow_call;
+pub mod at;
+pub mod bank;
+pub mod condition;
+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,
+        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,47 +1,57 @@
-use crate::core::{
-    lexer::token::TokenKind,
-    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
-    shared::value::Value,
-    store::global::GlobalStore,
-};
-
-pub fn parse_tempo_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
-    parser.advance(); // consume 'bpm'
-
-    let Some(tempo_token) = parser.previous_clone() else {
-        return Statement::unknown();
-    };
-
-    // 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()
-        );
-    };
-
-    let value = match value_token.kind {
-        TokenKind::Number => {
-            parser.advance();
-            Value::Number(value_token.lexeme.parse().unwrap_or(0.0))
-        }
-        TokenKind::Identifier => {
-            parser.advance();
-            Value::Identifier(value_token.lexeme.clone())
-        }
-        _ => {
-            return Statement::error(
-                value_token.clone(),
-                format!("Expected a number or identifier after 'bpm', got {:?}", value_token.kind)
-            );
-        }
-    };
-
-    Statement {
-        kind: StatementKind::Tempo,
-        value,
-        indent: tempo_token.indent,
-        line: tempo_token.line,
-        column: tempo_token.column,
-    }
-}
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{
+        driver::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'
+
+    let Some(tempo_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    // Expect a number or identifier
+    let Some(value_token) = parser.peek_clone() else {
+        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 => {
+            parser.advance();
+            Value::Number(value_token.lexeme.parse().unwrap_or(0.0))
+        }
+        TokenKind::Identifier => {
+            parser.advance();
+            Value::Identifier(value_token.lexeme.clone())
+        }
+        _ => {
+            return Statement::error_with_pos(
+                value_token.indent,
+                value_token.line,
+                value_token.column,
+                format!(
+                    "Expected a number or identifier after 'bpm', got {:?}",
+                    value_token.kind
+                ),
+            );
+        }
+    };
+
+    Statement {
+        kind: StatementKind::Tempo,
+        value,
+        indent: tempo_token.indent,
+        line: tempo_token.line,
+        column: tempo_token.column,
+    }
+}

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,11 @@
-use serde::{ Deserialize, Serialize };
-use crate::core::{ lexer::token::Token, shared::{ duration::Duration, value::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,
-}
-
-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,
-        }
-    }
-}
-
-#[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,
-    },
-}
+use crate::core::lexer::token::Token;
+
+pub use devalang_types::{Duration, Statement, StatementKind, Value};
+
+pub fn unknown_from_token(token: &Token) -> Statement {
+    Statement::unknown_with_pos(token.indent, token.line, token.column)
+}
+
+pub fn error_from_token(token: Token, message: String) -> Statement {
+    Statement::error_with_pos(token.indent, token.line, token.column, message)
+}