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

package/rust/core/audio/interpreter/driver.rs

@@ -1,13 +1,11 @@
 use rayon::prelude::*;
-use std::sync::{ Arc, Mutex };
 
-use crate::core::{
+use crate::{core::{
     audio::{
         engine::AudioEngine,
         interpreter::{
             arrow_call::interprete_call_arrow_statement,
             call::interprete_call_statement,
-            condition::interprete_condition_statement,
             function::interprete_function_statement,
             let_::interprete_let_statement,
             load::interprete_load_statement,
@@ -17,29 +15,27 @@ use crate::core::{
             tempo::interprete_tempo_statement,
             trigger::interprete_trigger_statement,
         },
-    },
-    parser::statement::{ Statement, StatementKind },
-    store::{ function::FunctionTable, global::GlobalStore, variable::VariableTable },
-};
+    }, parser::statement::{ Statement, StatementKind }, shared::value::Value, store::{ function::FunctionTable, global::GlobalStore, variable::VariableTable }
+}, utils::logger::{LogLevel, Logger}};
 
 pub fn run_audio_program(
     statements: &Vec<Statement>,
     audio_engine: &mut AudioEngine,
-    entry: String,
-    output: String,
-    mut module_variables: VariableTable,
-    mut module_functions: FunctionTable,
+    _entry: String,
+    _output: String,
+    _module_variables: VariableTable,
+    _module_functions: FunctionTable,
     global_store: &mut GlobalStore
 ) -> (f32, f32) {
-    let mut base_bpm = 120.0;
-    let mut base_duration = 60.0 / base_bpm;
+    let base_bpm = 120.0;
+    let base_duration = 60.0 / base_bpm;
 
     let (max_end_time, cursor_time) = execute_audio_block(
         audio_engine,
         global_store,
         global_store.variables.clone(),
         global_store.functions.clone(),
-        statements.clone(),
+        &statements,
         base_bpm,
         base_duration,
         0.0,
@@ -54,14 +50,14 @@ pub fn execute_audio_block(
     global_store: &GlobalStore,
     mut variable_table: VariableTable,
     mut functions_table: FunctionTable,
-    statements: Vec<Statement>,
+    statements: &[Statement],
     mut base_bpm: f32,
     mut base_duration: f32,
     mut max_end_time: f32,
     mut cursor_time: f32
 ) -> (f32, f32) {
     let (spawns, others): (Vec<_>, Vec<_>) = statements
-        .into_iter()
+        .iter()
         .partition(|stmt| matches!(stmt.kind, StatementKind::Spawn { .. }));
 
     // Execute sequential statements first
@@ -162,6 +158,43 @@ pub fn execute_audio_block(
                     max_end_time = new_max;
                 }
             }
+            StatementKind::Automate { .. } => {
+                if let Some(new_table) = crate::core::audio::interpreter::automate::interprete_automate_statement(&stmt, &mut variable_table) {
+                    variable_table = new_table;
+                }
+            }
+            StatementKind::Print => {
+                // Print debug output; if the string contains special expressions, evaluate them.
+                let logger = Logger::new();
+                match &stmt.value {
+                    Value::String(s) => {
+                        let bpm = if let Some(Value::Number(n)) = variable_table.get("bpm") { *n } else { 120.0 };
+                        let beat = if let Some(Value::Number(n)) = variable_table.get("beat") { *n } else { 0.0 };
+                        // If the string is exactly a variable name, print its value
+                        if let Some(val) = variable_table.get(&s) {
+                            logger.log_message(LogLevel::Print, &format!("{:?}", val));
+                        } else if s.contains("$env") || s.contains("$math") || s.parse::<f32>().is_ok() {
+                            let v = crate::core::audio::evaluator::evaluate_rhs_into_value(s, &variable_table, bpm, beat);
+                            match v { Value::Number(n) => logger.log_message(LogLevel::Print, &format!("{}", n)), _ => logger.log_message(LogLevel::Print, s) }
+                        } else {
+                            logger.log_message(LogLevel::Print, s)
+                        }
+                    }
+                    Value::Identifier(name) => {
+                        if let Some(val) = variable_table.get(name) {
+                            match val {
+                                Value::Number(n) => logger.log_message(LogLevel::Print, &format!("{}", n)),
+                                Value::String(s) => logger.log_message(LogLevel::Print, s),
+                                Value::Boolean(b) => logger.log_message(LogLevel::Print, &format!("{}", b)),
+                                other => logger.log_message(LogLevel::Print, &format!("{:?}", other)),
+                            }
+                        } else {
+                            logger.log_message(LogLevel::Print, name)
+                        }
+                    }
+                    v => logger.log_message(LogLevel::Print, &format!("{:?}", v)),
+                }
+            }
             _ => {}
         }
     }

package/rust/core/audio/interpreter/let_.rs

@@ -1,16 +1,23 @@
-use crate::core::{
-    audio::engine::AudioEngine,
-    parser::statement::{ Statement, StatementKind },
-    shared::value::Value,
-    store::variable::VariableTable,
-};
+use crate::core::{ parser::statement::{ Statement, StatementKind }, shared::value::Value, store::variable::VariableTable };
 
 pub fn interprete_let_statement(
     stmt: &Statement,
     variable_table: &mut VariableTable
 ) -> Option<VariableTable> {
     if let StatementKind::Let { name } = &stmt.kind {
-        variable_table.set(name.to_string(), stmt.value.clone());
+        // If RHS is a string and looks like an expression, evaluate it
+        let evaluated = match &stmt.value {
+            Value::String(s) if s.contains("$env") || s.contains("$math") => {
+                // We don't have direct env here; use defaults or infer from table
+                let bpm = if let Some(Value::Number(n)) = variable_table.get("bpm") { *n } else { 120.0 };
+                // Try to infer beat from time-based variables if any, else 0.0
+                let beat = if let Some(Value::Number(n)) = variable_table.get("beat") { *n } else { 0.0 };
+                crate::core::audio::evaluator::evaluate_rhs_into_value(s, variable_table, bpm, beat)
+            }
+            other => other.clone(),
+        };
+
+        variable_table.set(name.to_string(), evaluated);
 
         return Some(variable_table.clone())
     } 

package/rust/core/audio/interpreter/loop_.rs

@@ -1,7 +1,7 @@
 use crate::core::{
     audio::{ engine::AudioEngine, interpreter::driver::execute_audio_block },
-    parser::statement::{ Statement, StatementKind },
-    shared::{ duration::Duration, value::Value },
+    parser::statement::Statement,
+    shared::value::Value,
     store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
 };
 
@@ -17,6 +17,39 @@ pub fn interprete_loop_statement(
     cursor_time: f32
 ) -> (f32, f32) {
     if let Value::Map(loop_value) = &stmt.value {
+        // Foreach form: { foreach: Identifier(name), array: Array([...]), body: Block }
+        if let (Some(Value::Identifier(var_name)), Some(Value::Array(items)), Some(Value::Block(loop_body))) = (
+            loop_value.get("foreach"),
+            loop_value.get("array"),
+            loop_value.get("body"),
+        ) {
+            let mut engine = audio_engine;
+            let mut cur_time = cursor_time;
+            let mut max_time = max_end_time;
+
+            for item in items {
+                let mut scoped_vars = variable_table.clone();
+                scoped_vars.set(var_name.clone(), item.clone());
+
+                let (block_end_time, new_cursor) = execute_audio_block(
+                    &mut engine,
+                    global_store,
+                    scoped_vars,
+                    functions_table.clone(),
+                    &loop_body,
+                    base_bpm,
+                    base_duration,
+                    max_time,
+                    cur_time,
+                );
+
+                cur_time = new_cursor.max(block_end_time);
+                max_time = max_time.max(cur_time);
+            }
+
+            return (max_time, cur_time);
+        }
+
         let loop_count = match loop_value.get("iterator") {
             Some(Value::Number(n)) => *n as usize,
             Some(Value::Identifier(ident)) => {
@@ -48,20 +81,20 @@ pub fn interprete_loop_statement(
         let mut cur_time = cursor_time;
         let mut max_time = max_end_time;
 
-        for i in 0..loop_count {
-            let (block_end_time, cursor_time) = execute_audio_block(
+        for _ in 0..loop_count {
+            let (block_end_time, new_cursor) = execute_audio_block(
                 &mut engine,
                 global_store,
                 variable_table.clone(),
                 functions_table.clone(),
-                loop_body.clone(),
+                &loop_body,
                 base_bpm,
                 base_duration,
                 max_time,
                 cur_time
             );
 
-            cur_time = block_end_time;
+            cur_time = new_cursor.max(block_end_time);
             max_time = max_time.max(cur_time);
         }
 

package/rust/core/audio/interpreter/mod.rs

@@ -10,4 +10,5 @@ pub mod loop_;
 pub mod call;
 pub mod condition;
 pub mod arrow_call;
-pub mod function;
+pub mod function;
+pub mod automate;

package/rust/core/audio/interpreter/sleep.rs

@@ -1,8 +1,6 @@
 use crate::core::{
-    audio::{ engine::AudioEngine, loader::trigger::load_trigger },
-    parser::statement::{ Statement, StatementKind },
-    shared::{ duration::Duration, value::Value },
-    store::variable::VariableTable,
+    parser::statement::Statement,
+    shared::value::Value,
 };
 
 pub fn interprete_sleep_statement(

package/rust/core/audio/interpreter/spawn.rs

@@ -42,7 +42,7 @@ pub fn interprete_spawn_statement(
                     global_store,
                     local_vars,
                     functions.clone(),
-                    func.body.clone(),
+                    &func.body,
                     base_bpm,
                     base_duration,
                     0.0,
@@ -62,7 +62,7 @@ pub fn interprete_spawn_statement(
                             global_store,
                             variable_table.clone(),
                             functions.clone(),
-                            body.clone(),
+                            &body,
                             base_bpm,
                             base_duration,
                             0.0,

package/rust/core/audio/loader/trigger.rs

@@ -7,7 +7,7 @@ use crate::core::{
 pub fn load_trigger(
     trigger: &Value,
     duration: &Duration,
-    effects: &Option<Value>,
+    _effects: &Option<Value>,
     base_duration: f32,
     variable_table: VariableTable
 ) -> (String, f32) {
@@ -37,7 +37,7 @@ pub fn load_trigger(
             trigger_path = src.to_string();
         }
         Value::Statement(stmt) => {
-            if let StatementKind::Trigger { entity, duration, effects } = &stmt.kind {
+            if let StatementKind::Trigger { entity, duration: _, effects: _ } = &stmt.kind {
                 trigger_path = entity.clone();
             } else {
                 eprintln!("❌ Trigger statement must be of type 'Trigger', found: {:?}", stmt.kind);
@@ -88,9 +88,6 @@ pub fn load_trigger(
             }
         }
 
-        _ => {
-            eprintln!("❌ Invalid duration type. Expected an identifier.");
-        }
     }
 
     (trigger_path, duration_as_secs)

package/rust/core/audio/mod.rs

@@ -3,4 +3,5 @@ pub mod interpreter;
 pub mod loader;
 pub mod player;
 pub mod renderer;
-pub mod evaluator;
+pub mod evaluator;
+pub mod special;

package/rust/core/audio/renderer.rs

@@ -22,7 +22,7 @@ pub fn render_audio_with_modules(
         // Apply global variables to the initial engine
         if let Some(module) = global_store.get_module(&module_name) {
             // interprete statements to fill the audio buffer
-            let (module_max_end_time, cursor_time) = run_audio_program(
+            let (module_max_end_time, _cursor_time) = run_audio_program(
                 &statements,
                 &mut audio_engine,
                 module_name.clone(),

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

@@ -0,0 +1,120 @@
+use crate::core::store::variable::VariableTable;
+
+// Basic easing functions operating on t in [0,1]
+fn easing_value(func: &str, t: f32) -> Option<f32> {
+    let x = t.clamp(0.0, 1.0);
+    match func {
+        "linear" => Some(x),
+        "easeInQuad" => Some(x * x),
+        "easeOutQuad" => Some(x * (2.0 - x)),
+        "easeInOutQuad" => {
+            if x < 0.5 { Some(2.0 * x * x) } else { Some(-1.0 + (4.0 - 2.0 * x) * x) }
+        }
+        // Cubic
+        "easeInCubic" => Some(x * x * x),
+        "easeOutCubic" => Some(1.0 - (1.0 - x).powi(3)),
+        "easeInOutCubic" => {
+            if x < 0.5 { Some(4.0 * x * x * x) } else { Some(1.0 - (-2.0 * x + 2.0).powi(3) / 2.0) }
+        }
+        // Quartic
+        "easeInQuart" => Some(x.powi(4)),
+        "easeOutQuart" => Some(1.0 - (1.0 - x).powi(4)),
+        "easeInOutQuart" => {
+            if x < 0.5 { Some(8.0 * x.powi(4)) } else { Some(1.0 - (-2.0 * x + 2.0).powi(4) / 2.0) }
+        }
+        // Exponential
+        "easeInExpo" => Some(if x <= 0.0 { 0.0 } else { 2.0_f32.powf(10.0 * x - 10.0) }),
+        "easeOutExpo" => Some(if x >= 1.0 { 1.0 } else { 1.0 - 2.0_f32.powf(-10.0 * x) }),
+        "easeInOutExpo" => Some(if x <= 0.0 { 0.0 } else if x >= 1.0 { 1.0 } else if x < 0.5 { 2.0_f32.powf(20.0 * x - 10.0) / 2.0 } else { (2.0 - 2.0_f32.powf(-20.0 * x + 10.0)) / 2.0 }),
+        // Back (overshoot c ~ 1.70158)
+        "easeInBack" => { let c = 1.70158; Some((c + 1.0) * x * x * x - c * x * x) }
+        "easeOutBack" => { let c = 1.70158; let y = 1.0 - x; Some(1.0 - ((c + 1.0) * y * y * y - c * y * y)) }
+        "easeInOutBack" => {
+            let c1 = 1.70158; let c2 = c1 * 1.525; let x2 = x * 2.0;
+            if x2 < 1.0 { Some((x2 * x2 * ((c2 + 1.0) * x2 - c2)) / 2.0) } else {
+                let x2 = x2 - 2.0; Some((x2 * x2 * ((c2 + 1.0) * x2 + c2)) / 2.0 + 1.0)
+            }
+        }
+        // Elastic
+        "easeInElastic" => {
+            if x == 0.0 { Some(0.0) } else if x == 1.0 { Some(1.0) } else {
+                let c = 2.0 * std::f32::consts::PI / 3.0;
+                Some(- (2.0_f32.powf(10.0 * x - 10.0)) * ((x * 10.0 - 10.75) * c).sin())
+            }
+        }
+        "easeOutElastic" => {
+            if x == 0.0 { Some(0.0) } else if x == 1.0 { Some(1.0) } else {
+                let c = 2.0 * std::f32::consts::PI / 3.0;
+                Some(2.0_f32.powf(-10.0 * x) * ((x * 10.0 - 0.75) * c).sin() + 1.0)
+            }
+        }
+        "easeInOutElastic" => {
+            if x == 0.0 { Some(0.0) } else if x == 1.0 { Some(1.0) } else {
+                let c = 2.0 * std::f32::consts::PI / 4.5;
+                if x < 0.5 {
+                    Some(-(2.0_f32.powf(20.0 * x - 10.0)) * ((20.0 * x - 11.125) * c).sin() / 2.0)
+                } else {
+                    Some(2.0_f32.powf(-20.0 * x + 10.0) * ((20.0 * x - 11.125) * c).sin() / 2.0 + 1.0)
+                }
+            }
+        }
+        // Bounce helpers
+        "easeInBounce" => Some(1.0 - bounce_out(1.0 - x)),
+        "easeOutBounce" => Some(bounce_out(x)),
+        "easeInOutBounce" => Some(if x < 0.5 { (1.0 - bounce_out(1.0 - 2.0 * x)) / 2.0 } else { (1.0 + bounce_out(2.0 * x - 1.0)) / 2.0 }),
+        _ => None,
+    }
+}
+
+fn bounce_out(x: f32) -> f32 {
+    let n1 = 7.5625; let d1 = 2.75;
+    if x < 1.0 / d1 {
+        n1 * x * x
+    } else if x < 2.0 / d1 {
+        let x = x - 1.5 / d1; n1 * x * x + 0.75
+    } else if x < 2.5 / d1 {
+        let x = x - 2.25 / d1; n1 * x * x + 0.9375
+    } else {
+        let x = x - 2.625 / d1; n1 * x * x + 0.984375
+    }
+}
+
+// Find and evaluate the first $easing.<fn>(...) occurrence in the string.
+// Accepts a single argument expression producing t in [0,1].
+pub fn find_and_eval_first_easing_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("$easing.")?;
+    let open_rel = s[start..].find('(')?;
+    let open = start + open_rel;
+    let func = &s[start + 9..open];
+
+    // Find matching close parenthesis
+    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 t = eval(inner, vars, bpm, beat)?;
+    let result = easing_value(func, t)?;
+
+    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/env.rs

@@ -0,0 +1,41 @@
+use crate::core::store::variable::VariableTable;
+use std::sync::OnceLock;
+use std::time::{ SystemTime, UNIX_EPOCH };
+
+static SESSION_SEED: OnceLock<f32> = OnceLock::new();
+
+pub fn get_session_seed() -> f32 {
+    *SESSION_SEED.get_or_init(|| {
+        let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default();
+        // Build a stable 0..1 seed from nanos
+        let nanos = now.subsec_nanos();
+        ((nanos as f32) / 1_000_000_000.0).clamp(0.0, 1.0)
+    })
+}
+
+// Resolve special environment variables like $env.bpm, $env.beat, $env.position
+// For now, $env.position is treated as an alias of beat.
+pub fn resolve_env_atom(atom: &str, bpm: f32, beat: f32) -> Option<f32> {
+    match atom {
+        "$env.bpm" => Some(bpm),
+        "$env.beat" => Some(beat),
+        "$env.position" => Some(beat),
+        // Optional seed for deterministic randomness
+        "$env.seed" => Some(get_session_seed()),
+        _ => None,
+    }
+}
+
+// Utility: resolve an identifier or numeric literal to f32 using the variable table
+pub fn resolve_atom_or_var(atom: &str, vars: &VariableTable, bpm: f32, beat: f32) -> Option<f32> {
+    if let Some(v) = resolve_env_atom(atom, bpm, beat) {
+        return Some(v);
+    }
+    if let Ok(n) = atom.parse::<f32>() {
+        return Some(n);
+    }
+    if let Some(crate::core::shared::value::Value::Number(n)) = vars.get(atom) {
+        return Some(*n);
+    }
+    None
+}

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;