@devaloop/devalang 0.0.1-beta.1 → 0.0.1-beta.3

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

@@ -5,7 +5,7 @@ use devalang_types::Value;
 use crate::core::{
     lexer::token::Token,
     parser::{
-        driver::Parser,
+        driver::parser::Parser,
         handler::dot::parse_dot_token,
         statement::{Statement, StatementKind},
     },
@@ -23,8 +23,9 @@ pub fn parse_synth_token(
         return Statement::unknown();
     };
 
-    // Expect a provider/waveform identifier (can be dotted: alias.synth)
+    // 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;
 
@@ -81,7 +82,42 @@ pub fn parse_synth_token(
                 }
             }
 
-            parts.join(".")
+            // 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(

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

@@ -1,194 +1,194 @@
-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,
-    }
-}
+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/pattern.rs

@@ -3,7 +3,7 @@ use devalang_types::Value;
 use crate::core::{
     lexer::token::TokenKind,
     parser::{
-        driver::Parser,
+        driver::parser::Parser,
         statement::{Statement, StatementKind},
     },
     store::global::GlobalStore,
@@ -52,6 +52,12 @@ pub fn parse_pattern_token(parser: &mut Parser, _global_store: &mut GlobalStore)
         }
     }
 
+    // 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("=") {
@@ -59,9 +65,26 @@ pub fn parse_pattern_token(parser: &mut Parser, _global_store: &mut GlobalStore)
         if let Some(tok3) = parser.peek_clone() {
             if tok3.kind == TokenKind::String {
                 parser.advance();
-                value = Value::String(tok3.lexeme.clone());
+                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 {

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

@@ -1,57 +1,105 @@
-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,
-    }
-}
+use crate::core::{
+    lexer::token::TokenKind,
+    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'
+
+    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 => {
+            // support decimals and fraction forms
+            let mut num = value_token.lexeme.clone();
+            parser.advance();
+            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_with_pos(
+                value_token.indent,
+                value_token.line,
+                value_token.column,
+                format!(
+                    "Expected a number, string 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,
+    }
+}