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

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

@@ -1,33 +1,36 @@
-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,
-    };
-}
+use crate::core::{
+    lexer::token::{Token, TokenKind},
+    parser::{
+        driver::Parser,
+        statement::{Statement, StatementKind},
+    },
+    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

@@ -1,88 +1,91 @@
-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"
-
-    // Expect function name
-    let name_token = match parser.peek_clone() {
-        Some(t) => t,
-        None => {
-            return Statement::error(
-                current_token,
-                "Expected function name after 'spawn'".to_string()
-            );
-        }
-    };
-
-    if name_token.kind != TokenKind::Identifier {
-        return Statement::error(
-            name_token,
-            "Expected function name to be an identifier".to_string()
-        );
-    }
-
-    let func_name = name_token.lexeme.clone();
-    parser.advance(); // consume function name
-
-    // Expect '('
-    let mut args: Vec<Value> = Vec::new();
-    if let Some(open_paren) = parser.peek_clone() {
-        if open_paren.kind == TokenKind::LParen {
-            parser.advance(); // consume '('
-
-            // Collect args until ')'
-            while let Some(token) = parser.peek_clone() {
-                if token.kind == TokenKind::RParen {
-                    parser.advance(); // consume ')'
-                    break;
-                }
-
-                match token.kind {
-                    TokenKind::Number => {
-                        if let Ok(num) = token.lexeme.parse::<f32>() {
-                            args.push(Value::Number(num));
-                        }
-                        parser.advance();
-                    }
-                    TokenKind::String => {
-                        args.push(Value::String(token.lexeme.clone()));
-                        parser.advance();
-                    }
-                    TokenKind::Identifier => {
-                        args.push(Value::Identifier(token.lexeme.clone()));
-                        parser.advance();
-                    }
-                    TokenKind::Comma => {
-                        parser.advance(); // skip comma
-                    }
-                    _ => {
-                        return Statement::error(
-                            token,
-                            "Unexpected token in spawn arguments".to_string()
-                        );
-                    }
-                }
-            }
-        }
-    }
-
-    Statement {
-        kind: StatementKind::Spawn {
-            name: func_name,
-            args,
-        },
-        value: Value::Null,
-        indent: current_token.indent,
-        line: current_token.line,
-        column: current_token.column,
-    }
-}
+use crate::core::{
+    lexer::token::{Token, TokenKind},
+    parser::{
+        driver::Parser,
+        statement::{Statement, StatementKind},
+    },
+    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"
+
+    // Expect function name
+    let name_token = match parser.peek_clone() {
+        Some(t) => t,
+        None => {
+            return Statement::error(
+                current_token,
+                "Expected function name after 'spawn'".to_string(),
+            );
+        }
+    };
+
+    if name_token.kind != TokenKind::Identifier {
+        return Statement::error(
+            name_token,
+            "Expected function name to be an identifier".to_string(),
+        );
+    }
+
+    let func_name = name_token.lexeme.clone();
+    parser.advance(); // consume function name
+
+    // Expect '('
+    let mut args: Vec<Value> = Vec::new();
+    if let Some(open_paren) = parser.peek_clone() {
+        if open_paren.kind == TokenKind::LParen {
+            parser.advance(); // consume '('
+
+            // Collect args until ')'
+            while let Some(token) = parser.peek_clone() {
+                if token.kind == TokenKind::RParen {
+                    parser.advance(); // consume ')'
+                    break;
+                }
+
+                match token.kind {
+                    TokenKind::Number => {
+                        if let Ok(num) = token.lexeme.parse::<f32>() {
+                            args.push(Value::Number(num));
+                        }
+                        parser.advance();
+                    }
+                    TokenKind::String => {
+                        args.push(Value::String(token.lexeme.clone()));
+                        parser.advance();
+                    }
+                    TokenKind::Identifier => {
+                        args.push(Value::Identifier(token.lexeme.clone()));
+                        parser.advance();
+                    }
+                    TokenKind::Comma => {
+                        parser.advance(); // skip comma
+                    }
+                    _ => {
+                        return Statement::error(
+                            token,
+                            "Unexpected token in spawn arguments".to_string(),
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    Statement {
+        kind: StatementKind::Spawn {
+            name: func_name,
+            args,
+        },
+        value: Value::Null,
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    }
+}

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

@@ -1,63 +1,65 @@
-use std::collections::HashMap;
-
-use crate::core::{
-    lexer::token::Token,
-    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 parameters = if let Some(params) = parser.parse_map_value() {
-        // If parameters are provided, we expect a map
-        if let Value::Map(map) = params {
-            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
-        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,
-    }
-}
+use std::collections::HashMap;
+
+use crate::core::{
+    lexer::token::Token,
+    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 parameters = if let Some(params) = parser.parse_map_value() {
+        // If parameters are provided, we expect a map
+        if let Value::Map(map) = params {
+            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
+        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

@@ -1,89 +1,170 @@
-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' 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 literal
-        let array_val = if let Some(v) = parser.parse_array_value() { v } else {
-            return Statement::error(loop_token, "Expected array literal 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) }
-        _ => { return Statement::error(iterator_token.clone(), "Expected a number 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 }
-}
+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,
+    }
+}