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

package/rust/core/audio/special/modulator.rs

@@ -0,0 +1,120 @@
+use crate::core::store::variable::VariableTable;
+
+fn lfo_sine(rate_per_beat: f32, beat: f32) -> f32 {
+    // Output in [-1,1]
+    (2.0 * std::f32::consts::PI * rate_per_beat * beat).sin()
+}
+
+fn lfo_triangle(rate_per_beat: f32, beat: f32) -> f32 {
+    // Triangle in [-1,1]
+    let phase = (rate_per_beat * beat).fract();
+    // Map [0,1]->[-1,1] tri
+    4.0 * (phase - 0.5).abs() - 1.0
+}
+
+fn adsr_envelope_value_t(attack: f32, decay: f32, sustain: f32, release: f32, t: f32) -> f32 {
+    let a = attack.max(0.0);
+    let d = decay.max(0.0);
+    let r = release.max(0.0);
+    let s = sustain.clamp(0.0, 1.0);
+
+    // Normalize phases so that the whole ADSR spans t in [0,1]
+    let total = (a + d + r).max(1e-6);
+    let ap = a / total; let dp = d / total; let rp = r / total;
+
+    if t < ap {
+        // attack (0->1)
+        if ap > 0.0 { t / ap } else { 1.0 }
+    } else if t < ap + dp {
+        // decay (1->sustain)
+        let u = (t - ap) / dp.max(1e-6);
+        1.0 - (1.0 - s) * u
+    } else if t < 1.0 - rp {
+        // sustain
+        s
+    } else {
+        // release (sustain->0)
+        let u = (t - (1.0 - rp)) / rp.max(1e-6);
+        s * (1.0 - u)
+    }
+}
+
+fn eval_mod_func(func: &str, args: &[f32], beat: f32) -> Option<f32> {
+    match func {
+        "lfo.sine" => {
+            let rate = args.get(0).copied().unwrap_or(1.0);
+            Some(lfo_sine(rate, beat))
+        }
+        "lfo.tri" | "lfo.triangle" => {
+            let rate = args.get(0).copied().unwrap_or(1.0);
+            Some(lfo_triangle(rate, beat))
+        }
+        // ADSR envelope normalized over t in [0,1]
+        // $mod.envelope(attack, decay, sustain, release, t)
+        "envelope" | "mod.envelope" => {
+            if args.len() >= 5 {
+                Some(adsr_envelope_value_t(args[0], args[1], args[2], args[3], args[4].clamp(0.0, 1.0)))
+            } else { None }
+        }
+        _ => None,
+    }
+}
+
+fn parse_top_level_args(s: &str) -> Vec<&str> {
+    let mut args = Vec::new();
+    let mut depth = 0i32;
+    let mut start = 0usize;
+    for (i, ch) in s.char_indices() {
+        match ch {
+            '(' => depth += 1,
+            ')' => depth -= 1,
+            ',' if depth == 0 => { args.push(s[start..i].trim()); start = i + 1; }
+            _ => {}
+        }
+    }
+    let last = s[start..].trim();
+    if !last.is_empty() { args.push(last); }
+    args
+}
+
+// Find and evaluate the first $mod.<fn>(...) occurrence in the string.
+pub fn find_and_eval_first_mod_call<EvalFn>(
+    s: &str,
+    eval: EvalFn,
+    vars: &VariableTable,
+    bpm: f32,
+    beat: f32,
+) -> Option<String>
+where
+    EvalFn: Fn(&str, &VariableTable, f32, f32) -> Option<f32>,
+{
+    let start = s.find("$mod.")?;
+    let open_rel = s[start..].find('(')?;
+    let open = start + open_rel;
+    let func = &s[start + 5..open];
+
+    // matching close
+    let mut depth: i32 = 0;
+    let mut close_abs: Option<usize> = None;
+    for (i, ch) in s[open..].char_indices() {
+        match ch {
+            '(' => depth += 1,
+            ')' => { depth -= 1; if depth == 0 { close_abs = Some(open + i); break; } }
+            _ => {}
+        }
+    }
+    let close = close_abs?;
+
+    let inner = &s[open + 1..close];
+    let raw_args = parse_top_level_args(inner);
+    let mut args: Vec<f32> = Vec::with_capacity(raw_args.len());
+    for a in raw_args { args.push(eval(a, vars, bpm, beat)?); }
+
+    let result = eval_mod_func(func, &args, beat)?;
+
+    let mut replaced = String::new();
+    replaced.push_str(&s[..start]);
+    replaced.push_str(&result.to_string());
+    replaced.push_str(&s[close + 1..]);
+    Some(replaced)
+}

package/rust/core/debugger/store.rs

@@ -27,7 +27,7 @@ pub fn write_function_log_file(output_dir: &str, file_name: &str, functions: Fun
     let log_directory = format!("{}/logs", output_dir);
     create_dir_all(&log_directory).expect("Failed to create log directory");
 
-    for (index, function) in functions.functions {
+    for (_index, function) in functions.functions {
         content.push_str(
             &format!("'{}' = [{:?}] => {:?}\n", function.name, function.parameters, function.body)
         );

package/rust/core/error/mod.rs

@@ -1,15 +1,18 @@
 use crate::core::parser::{ statement::{ Statement, StatementKind }, driver::Parser };
+use serde::{Serialize, Deserialize};
 
 pub struct ErrorHandler {
     errors: Vec<Error>,
 }
 
+#[derive(Serialize, Deserialize, Clone)]
 pub struct ErrorResult {
     pub message: String,
     pub line: usize,
     pub column: usize,
 }
 
+#[derive(Clone)]
 pub struct Error {
     pub message: String,
     pub line: usize,
@@ -42,7 +45,7 @@ impl ErrorHandler {
         self.errors.clear();
     }
 
-    pub fn detect_from_statements(&mut self, parser: &mut Parser, statements: &[Statement]) {
+    pub fn detect_from_statements(&mut self, _parser: &mut Parser, statements: &[Statement]) {
         for stmt in statements {
             match &stmt.kind {
                 StatementKind::Unknown => {

package/rust/core/lexer/handler/arrow.rs

@@ -1,29 +1,80 @@
 use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_arrow_lexer(
-    char: char,
+    ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
 ) {
-    let mut arrow_call = char.to_string();
-
-    while let Some(&c) = chars.peek() {
+    // If next char is '>', this is an arrow '->'.
+    if let Some(&c) = chars.peek() {
         if c == '>' {
+            let mut arrow_call = ch.to_string();
             chars.next();
             arrow_call.push(c);
             *column += 1;
-        } else {
-            break;
+
+            tokens.push(Token {
+                kind: TokenKind::Arrow,
+                lexeme: arrow_call,
+                line: *line,
+                column: *column,
+                indent: *current_indent,
+            });
+            return;
+        }
+    }
+
+    // Otherwise, treat '-' as the start of a negative number if followed by digits.
+    let mut lexeme = String::from("-");
+    if let Some(&next) = chars.peek() {
+        if next.is_ascii_digit() {
+            // consume digits
+            while let Some(&d) = chars.peek() {
+                if d.is_ascii_digit() {
+                    chars.next();
+                    lexeme.push(d);
+                    *column += 1;
+                } else {
+                    break;
+                }
+            }
+            // optional decimal part
+            if let Some(&dot) = chars.peek() {
+                if dot == '.' {
+                    chars.next();
+                    lexeme.push(dot);
+                    *column += 1;
+                    while let Some(&d) = chars.peek() {
+                        if d.is_ascii_digit() {
+                            chars.next();
+                            lexeme.push(d);
+                            *column += 1;
+                        } else {
+                            break;
+                        }
+                    }
+                }
+            }
+
+            tokens.push(Token {
+                kind: TokenKind::Number,
+                lexeme,
+                line: *line,
+                column: *column,
+                indent: *current_indent,
+            });
+            return;
         }
     }
 
+    // Fallback: lone '-' not part of '->' or a number; emit Unknown to avoid mis-parsing as Arrow
     tokens.push(Token {
-        kind: TokenKind::Arrow,
-        lexeme: arrow_call,
+        kind: TokenKind::Unknown,
+        lexeme: "-".to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,

package/rust/core/lexer/handler/at.rs

@@ -1,17 +1,17 @@
 use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_at_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
 ) {
     tokens.push(Token {
         kind: TokenKind::At,
-        lexeme: char.to_string(),
+        lexeme: ch.to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,

package/rust/core/lexer/handler/brace.rs

@@ -1,17 +1,17 @@
 use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_rbrace_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
 ) {
     tokens.push(Token {
         kind: TokenKind::RBrace,
-        lexeme: char.to_string(),
+        lexeme: ch.to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,
@@ -21,17 +21,17 @@ pub fn handle_rbrace_lexer(
 }
 
 pub fn handle_lbrace_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
 ) {
     tokens.push(Token {
         kind: TokenKind::LBrace,
-        lexeme: char.to_string(),
+        lexeme: ch.to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,

package/rust/core/lexer/handler/colon.rs

@@ -1,17 +1,17 @@
 use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_colon_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
 ) {
     tokens.push(Token {
         kind: TokenKind::Colon,
-        lexeme: char.to_string(),
+        lexeme: ch.to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,

package/rust/core/lexer/handler/comment.rs

@@ -1,10 +1,10 @@
 use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_comment_lexer(
-    char: char,
+    _char: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize

package/rust/core/lexer/handler/dot.rs

@@ -1,17 +1,17 @@
 use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_dot_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
 ) {
     tokens.push(Token {
         kind: TokenKind::Dot,
-        lexeme: char.to_string(),
+        lexeme: ch.to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,

package/rust/core/lexer/handler/driver.rs

@@ -7,7 +7,7 @@ use crate::core::lexer::{
 
 fn advance_char<I: Iterator<Item = char>>(
     chars: &mut std::iter::Peekable<I>,
-    line: &mut usize,
+    _line: &mut usize,
     column: &mut usize
 ) -> Option<char> {
     while let Some(c) = chars.next() {
@@ -90,7 +90,7 @@ pub fn handle_content_lexing(content: String) -> Result<Vec<Token>, String> {
                     &mut column
                 );
             }
-            '=' | '!' | '<' | '>' => {
+            '=' | '!' | '<' | '>' | '+' | '*' => {
                 handle_operator_lexer(
                     ch,
                     &mut chars,
@@ -122,6 +122,20 @@ pub fn handle_content_lexing(content: String) -> Result<Vec<Token>, String> {
                     &mut line,
                     &mut column
                 );
+                // If not parsed as arrow or number, fallback as Minus token
+                if let Some(last) = tokens.last() {
+                    if last.kind == TokenKind::Unknown && last.lexeme == "-" {
+                        // replace last with Minus
+                        let _ = tokens.pop();
+                        tokens.push(Token {
+                            kind: TokenKind::Minus,
+                            lexeme: "-".to_string(),
+                            line,
+                            column,
+                            indent: current_indent,
+                        });
+                    }
+                }
             }
             '{' => {
                 handle_lbrace_lexer(
@@ -145,6 +159,9 @@ pub fn handle_content_lexing(content: String) -> Result<Vec<Token>, String> {
                     &mut column
                 );
             }
+            '[' => { tokens.push(Token { kind: TokenKind::LBracket, lexeme: "[".to_string(), line, column, indent: current_indent }); }
+            ']' => { tokens.push(Token { kind: TokenKind::RBracket, lexeme: "]".to_string(), line, column, indent: current_indent }); }
+            ',' => { tokens.push(Token { kind: TokenKind::Comma, lexeme: ",".to_string(), line, column, indent: current_indent }); }
             '(' => {
                 handle_lparen_lexer(
                     ch,
@@ -189,37 +206,49 @@ pub fn handle_content_lexing(content: String) -> Result<Vec<Token>, String> {
                     &mut column
                 );
             }
-            '\"' | '\'' => {
-                handle_string_lexer(
+            '$' => {
+                // Treat `$` as start of a special identifier like `$env` or `$math`
+                let mut ident = String::from("$");
+                while let Some(&c) = chars.peek() {
+                    if c.is_ascii_alphanumeric() || c == '_' {
+                        ident.push(c);
+                        chars.next();
+                        column += 1;
+                    } else { break; }
+                }
+                tokens.push(Token { kind: TokenKind::Identifier, lexeme: ident, line, column, indent: current_indent });
+            }
+            '0'..='9' => {
+                handle_number_lexer(
                     ch,
                     &mut chars,
                     &mut current_indent,
                     &mut indent_stack,
                     &mut tokens,
                     &mut line,
-                    &mut column
+                    &mut column,
                 );
             }
-            c if c.is_ascii_digit() => {
-                handle_number_lexer(
-                    c,
+            'a'..='z' | 'A'..='Z' | '_' => {
+                handle_identifier_lexer(
+                    ch,
                     &mut chars,
                     &mut current_indent,
                     &mut indent_stack,
                     &mut tokens,
                     &mut line,
-                    &mut column
+                    &mut column,
                 );
             }
-            c if c.is_ascii_alphabetic() => {
-                handle_identifier_lexer(
-                    c,
+            '"' | '\'' => {
+                handle_string_lexer(
+                    ch,
                     &mut chars,
                     &mut current_indent,
                     &mut indent_stack,
                     &mut tokens,
                     &mut line,
-                    &mut column
+                    &mut column,
                 );
             }
             _ => {

package/rust/core/lexer/handler/identifier.rs

@@ -1,15 +1,15 @@
 use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_identifier_lexer(
-    char: char,
+    ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
 ) {
-    let mut ident = char.to_string();
+    let mut ident = ch.to_string();
 
     while let Some(&c) = chars.peek() {
         if c.is_ascii_alphanumeric() || c == '_' {
@@ -26,7 +26,8 @@ pub fn handle_identifier_lexer(
         "else" => TokenKind::Else,
         "bank" => TokenKind::Bank,
         "bpm" => TokenKind::Tempo,
-        "loop" => TokenKind::Loop,
+    "loop" => TokenKind::Loop,
+    "for" => TokenKind::Loop,
         "synth" => TokenKind::Synth,
         "fn" => TokenKind::Function,
         _ => TokenKind::Identifier,

package/rust/core/lexer/handler/newline.rs

@@ -2,7 +2,7 @@ use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_newline_lexer(
     ch: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize,

package/rust/core/lexer/handler/number.rs

@@ -1,15 +1,15 @@
 use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_number_lexer(
-    char: char,
+    ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
 ) {
-    let mut number = char.to_string();
+    let mut number = ch.to_string();
 
     while let Some(&c) = chars.peek() {
         if c.is_ascii_digit() {

package/rust/core/lexer/handler/operator.rs

@@ -4,7 +4,7 @@ pub fn handle_operator_lexer(
     ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
@@ -16,6 +16,8 @@ pub fn handle_operator_lexer(
         ('!', Some('=')) => (TokenKind::NotEquals, 2),
         ('>', Some('=')) => (TokenKind::GreaterEqual, 2),
         ('<', Some('=')) => (TokenKind::LessEqual, 2),
+        ('+', _) => (TokenKind::Plus, 1),
+        ('*', _) => (TokenKind::Asterisk, 1),
         ('=', _) => (TokenKind::Equals, 1),
         ('>', _) => (TokenKind::Greater, 1),
         ('<', _) => (TokenKind::Less, 1),

package/rust/core/lexer/handler/parenthesis.rs

@@ -1,17 +1,17 @@
 use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_rparen_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
 ) {
     tokens.push(Token {
         kind: TokenKind::RParen,
-        lexeme: char.to_string(),
+        lexeme: ch.to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,
@@ -21,17 +21,17 @@ pub fn handle_rparen_lexer(
 }
 
 pub fn handle_lparen_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
 ) {
     tokens.push(Token {
         kind: TokenKind::LParen,
-        lexeme: char.to_string(),
+        lexeme: ch.to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,

package/rust/core/lexer/handler/slash.rs

@@ -1,21 +1,21 @@
 use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_slash_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
 ) {
-    let mut slash = char.to_string();
+    let slash = ch.to_string();
 
     tokens.push(Token {
         kind: TokenKind::Slash,
         lexeme: slash,
         line: *line,
         column: *column,
-        indent: *current_indent,
+    indent: *current_indent,
     });
 }

package/rust/core/lexer/handler/string.rs

@@ -4,7 +4,7 @@ pub fn handle_string_lexer(
     ch: char,
     chars: &mut std::iter::Peekable<std::str::Chars>,
     current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
+    _indent_stack: &mut Vec<usize>,
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize

package/rust/core/lexer/mod.rs

@@ -2,7 +2,7 @@ pub mod handler;
 pub mod token;
 
 use std::fs;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use crate::core::{
     lexer::{ handler::driver::handle_content_lexing, token::Token },
     utils::path::normalize_path,

package/rust/core/lexer/token.rs

@@ -51,6 +51,9 @@ pub enum TokenKind {
     Equals,
     Dot,
     Slash,
+    Plus,
+    Asterisk,
+    Minus,
 
     // ───── Operators ─────
     DoubleEquals,