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

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

@@ -0,0 +1,92 @@
+use crate::core::store::variable::VariableTable;
+
+// Parse comma-separated arguments at top level (no nested parentheses split)
+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
+}
+
+fn eval_math_func(func: &str, args: &[f32], fallback_seed: f32) -> Option<f32> {
+    match func {
+        "sin" => args.get(0).copied().map(f32::sin),
+        "cos" => args.get(0).copied().map(f32::cos),
+        "random" => {
+            // deterministic pseudo-random based on provided seed or a fallback session seed
+            let seed = args.get(0).copied().unwrap_or(fallback_seed);
+            let x = (seed * 12.9898).sin() * 43758.5453;
+            Some((x.fract() * 2.0 - 1.0).clamp(-1.0, 1.0))
+        }
+        "lerp" => {
+            if args.len() >= 3 { Some(args[0] + (args[1] - args[0]) * args[2]) } else { None }
+        }
+        _ => None,
+    }
+}
+
+// Find and evaluate the first $math.<fn>(...) occurrence in the string, replacing it with a number.
+// Supports multi-argument functions by splitting on top-level commas.
+pub fn find_and_eval_first_math_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("$math.")?;
+    let open_rel = s[start..].find('(')?;
+    let open = start + open_rel;
+    let func = &s[start + 6..open];
+
+    // Find matching close parenthesis, handling nesting
+    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 {
+        if let Some(v) = eval(a, vars, bpm, beat) { args.push(v); } else { return None; }
+    }
+
+    // If no explicit seed is provided, use $env.seed via fallback
+    let fallback_seed = eval("$env.seed", vars, bpm, beat).unwrap_or(0.0);
+    let result = eval_math_func(func, &args, fallback_seed)?;
+
+    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/audio/special/mod.rs

@@ -0,0 +1,9 @@
+pub mod env;
+pub mod math;
+pub mod easing;
+pub mod modulator;
+
+pub use env::resolve_env_atom;
+pub use math::find_and_eval_first_math_call;
+pub use easing::find_and_eval_first_easing_call;
+pub use modulator::find_and_eval_first_mod_call;

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/builder/mod.rs

@@ -3,7 +3,6 @@ use crate::core::parser::statement::Statement;
 use crate::core::store::global::GlobalStore;
 use std::{ collections::HashMap, fs::create_dir_all };
 use std::io::Write;
-
 use crate::utils::logger::Logger;
 
 pub struct Builder {}
@@ -13,7 +12,12 @@ impl Builder {
         Builder {}
     }
 
-    pub fn build_ast(&self, modules: &HashMap<String, Vec<Statement>>, out_dir: &str) {
+    pub fn build_ast(
+        &self,
+        modules: &HashMap<String, Vec<Statement>>,
+        out_dir: &str,
+        compress: bool
+    ) {
         for (name, statements) in modules {
             let formatted_name = name.split("/").last().unwrap_or(name);
             let formatted_name = formatted_name.replace(".deva", "");
@@ -22,10 +26,11 @@ impl Builder {
 
             let file_path = format!("{}/ast/{}.json", out_dir, formatted_name);
             let mut file = std::fs::File::create(file_path).expect("Failed to create AST file");
-
-            let content = serde_json
-                ::to_string_pretty(&statements)
-                .expect("Failed to serialize AST");
+            let content = if compress {
+                serde_json::to_string(&statements).expect("Failed to serialize AST")
+            } else {
+                serde_json::to_string_pretty(&statements).expect("Failed to serialize AST")
+            };
 
             file.write_all(content.as_bytes()).expect("Failed to write AST to file");
         }

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,