@devaloop/devalang 0.0.1-alpha.14 → 0.0.1-alpha.16

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

@@ -1,72 +1,170 @@
-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 crate::core::{
+    lexer::token::TokenKind,
+    parser::{
+        driver::Parser,
+        statement::{Statement, StatementKind},
+    },
+    shared::value::Value,
+    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(loop_token, "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(
+                        loop_token,
+                        "Expected array, number, string or identifier after 'in'".to_string(),
+                    );
+                }
+            }
+        } else {
+            return Statement::error(
+                loop_token,
+                "Expected array, number, string or identifier after 'in'".to_string(),
+            );
+        };
+
+        // Expect ':'
+        if !parser.match_token(TokenKind::Colon) {
+            return Statement::error(loop_token, "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(),
+        );
+    };
+
+    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(
+                iterator_token.clone(),
+                "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(loop_token.clone(), 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,8 @@
-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 tempo;

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

@@ -1,47 +1,53 @@
-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},
+    },
+    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,
+    }
+}

package/rust/core/parser/mod.rs

@@ -1,4 +1,4 @@
-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,108 +1,142 @@
-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>,
-    },
-    Function {
-        name: String,
-        parameters: Vec<String>,
-        body: Vec<Statement>,
-    },
-
-    // ───── Instruments ─────
-    Synth,
-
-    // ───── Playback / Scheduling ─────
-    Trigger {
-        entity: String,
-        duration: Duration,
-        effects: Option<Value>,
-    },
-    Sleep,
-    Call {
-        name: String,
-        args: Vec<Value>,
-    },
-    Spawn {
-        name: String,
-        args: Vec<Value>,
-    },
-    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,
+    shared::{duration::Duration, value::Value},
+};
+use serde::{Deserialize, Serialize};
+
+#[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 unknown_from_token(token: &Token) -> Self {
+        Statement {
+            kind: StatementKind::Unknown,
+            value: Value::Null,
+            indent: token.indent,
+            line: token.line,
+            column: token.column,
+        }
+    }
+
+    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 {
+        alias: Option<String>,
+    },
+    Print,
+    Load {
+        source: String,
+        alias: String,
+    },
+    Use {
+        name: String,
+        alias: Option<String>,
+    },
+    Let {
+        name: String,
+    },
+    Automate {
+        target: String,
+    },
+    ArrowCall {
+        target: String,
+        method: String,
+        args: Vec<Value>,
+    },
+    Function {
+        name: String,
+        parameters: Vec<String>,
+        body: Vec<Statement>,
+    },
+
+    // ───── Instruments ─────
+    Synth,
+
+    // ───── Playback / Scheduling ─────
+    Trigger {
+        entity: String,
+        duration: Duration,
+        effects: Option<Value>,
+    },
+    Sleep,
+    Call {
+        name: String,
+        args: Vec<Value>,
+    },
+    Spawn {
+        name: String,
+        args: Vec<Value>,
+    },
+    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,
+
+    // ───── Events / Live coding ─────
+    On {
+        event: String,
+        args: Option<Vec<Value>>,
+        body: Vec<Statement>,
+    },
+    Emit {
+        event: String,
+        payload: Option<Value>,
+    },
+
+    // ───── Error Handling ─────
+    Unknown,
+    Error {
+        message: String,
+    },
+}