@devaloop/devalang 0.0.1-beta.3 → 0.1.1

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

@@ -1,96 +0,0 @@
-use devalang_types::Value;
-
-use crate::core::{
-    lexer::token::{Token, TokenKind},
-    parser::{
-        driver::parser::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-
-pub fn parse_sleep_token(
-    parser: &mut Parser,
-    current_token: Token,
-    _global_store: &mut GlobalStore,
-) -> Statement {
-    parser.advance(); // consume "sleep"
-
-    // Accept number, decimal, fraction like 1/4 (-> Duration::Beat), string, or identifier
-    let duration_value = if let Some(token) = parser.peek_clone() {
-        match token.kind {
-            TokenKind::Number => {
-                let mut num = token.lexeme.clone();
-                parser.advance();
-                // decimal part
-                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(); // consume dot
-                                parser.advance(); // consume next number
-                                num.push('.');
-                                num.push_str(&next.lexeme);
-                            }
-                        }
-                    }
-                }
-
-                // fraction form 1/4 -> Duration::Beat("1/4")
-                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 crate::core::parser::statement::error_from_token(
-                                    slash,
-                                    "Expected denominator after '/' in sleep".to_string(),
-                                );
-                            }
-                        } else {
-                            return crate::core::parser::statement::error_from_token(
-                                slash,
-                                "Expected denominator after '/' in sleep".to_string(),
-                            );
-                        }
-                    } else {
-                        Value::Number(num.parse().unwrap_or(0.0))
-                    }
-                } else {
-                    Value::Number(num.parse().unwrap_or(0.0))
-                }
-            }
-            TokenKind::String => {
-                parser.advance();
-                Value::String(token.lexeme.clone())
-            }
-            TokenKind::Identifier => {
-                parser.advance();
-                Value::Identifier(token.lexeme.clone())
-            }
-            _ => {
-                return crate::core::parser::statement::error_from_token(
-                    token,
-                    "Expected duration after 'sleep'".to_string(),
-                );
-            }
-        }
-    } else {
-        return crate::core::parser::statement::error_from_token(
-            current_token,
-            "Expected duration after 'sleep'".to_string(),
-        );
-    };
-
-    Statement {
-        kind: StatementKind::Sleep,
-        value: duration_value,
-        indent: current_token.indent,
-        line: current_token.line,
-        column: current_token.column,
-    }
-}

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

@@ -1,91 +0,0 @@
-use crate::core::{
-    lexer::token::{Token, TokenKind},
-    parser::{
-        driver::parser::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-
-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 crate::core::parser::statement::error_from_token(
-                current_token,
-                "Expected function name after 'spawn'".to_string(),
-            );
-        }
-    };
-
-    if name_token.kind != TokenKind::Identifier {
-        return crate::core::parser::statement::error_from_token(
-            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 crate::core::parser::statement::error_from_token(
-                            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,171 +0,0 @@
-use std::collections::HashMap;
-
-use devalang_types::Value;
-
-use crate::core::{
-    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,
-) -> Statement {
-    parser.advance(); // consume 'synth'
-
-    let Some(synth_token) = parser.previous_clone() else {
-        return Statement::unknown();
-    };
-
-    // Expect a provider or waveform identifier (can be dotted: alias.synth)
-    // Also accept a dot-led entity by delegating to the dot parser (e.g. .module.export)
-    // Support optional explicit waveform after a dotted provider: `synth alias.synth saw {}`
-    let synth_waveform = if let Some(first_token) = parser.peek_clone() {
-        use crate::core::lexer::token::TokenKind;
-
-        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(),
-                );
-            }
-
-            // 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,
-                }
-            }
-
-            // The joined parts form either:
-            // - a simple waveform name (e.g. "sine")
-            // - a provider entity (e.g. "author.synth")
-            let first = parts.join(".");
-
-            // If this looks like a dotted provider, try to consume an optional explicit
-            // waveform identifier on the same line (e.g. `synth author.synth saw`). If none
-            // is provided, fall back to the original behaviour (use the joined string as
-            // the waveform identifier) to remain backward-compatible.
-            if first.contains('.') {
-                // peek next token on same line
-                if let Some(next_tok) = parser.peek_clone() {
-                    if next_tok.line == current_line
-                        && matches!(
-                            next_tok.kind,
-                            crate::core::lexer::token::TokenKind::Identifier
-                                | crate::core::lexer::token::TokenKind::Number
-                                | crate::core::lexer::token::TokenKind::Synth
-                        )
-                    {
-                        // consume waveform token
-                        let waveform = next_tok.lexeme.clone();
-                        parser.advance();
-                        // store as "provider.waveform" style? keep only waveform for compatibility
-                        waveform
-                    } else {
-                        // no explicit waveform -> use the provider string (old behaviour)
-                        first
-                    }
-                } else {
-                    first
-                }
-            } else {
-                // simple waveform name
-                first
-            }
-        }
-    } 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();
-    }
-
-    // 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 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
-        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([
-                    // 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,194 +0,0 @@
-use devalang_types::Value;
-
-use crate::core::{
-    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' 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,9 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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 inline options map like { swing: 0.08 }
-    let mut options: Option<Value> = None;
-    if parser.check_token(TokenKind::LBrace) {
-        options = parser.parse_map_value();
-    }
-
-    // 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();
-                let pat_str = Value::String(tok3.lexeme.clone());
-                if let Some(opts) = options {
-                    // merge options map with pattern key
-                    if let Value::Map(mut m) = opts {
-                        m.insert("pattern".to_string(), pat_str);
-                        value = Value::Map(m);
-                    } else {
-                        // unexpected, wrap into a map
-                        let mut m = std::collections::HashMap::new();
-                        m.insert("pattern".to_string(), pat_str);
-                        value = Value::Map(m);
-                    }
-                } else {
-                    value = Value::String(tok3.lexeme.clone());
-                }
-            }
-        }
-    } else if let Some(opts) = options {
-        // only options were provided, store them as the value
-        value = opts;
-    }
-
-    Statement {
-        kind: StatementKind::Pattern { name, target },
-        value,
-        indent: tok.indent,
-        line: tok.line,
-        column: tok.column,
-    }
-}