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

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

@@ -1,21 +1,26 @@
-use crate::core::{
-    parser::statement::{ Statement, StatementKind },
-    store::function::{ FunctionDef, FunctionTable },
-};
-
-pub fn interprete_function_statement(
-    stmt: &Statement,
-    functions_table: &mut FunctionTable
-) -> Option<FunctionTable> {
-    if let StatementKind::Function { name, parameters, body } = &stmt.kind {
-        functions_table.add_function(FunctionDef {
-            name: name.clone(),
-            parameters: parameters.clone(),
-            body: body.clone(),
-        });
-
-        return Some(functions_table.clone());
-    }
-
-    None
-}
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    store::function::{FunctionDef, FunctionTable},
+};
+
+pub fn interprete_function_statement(
+    stmt: &Statement,
+    functions_table: &mut FunctionTable,
+) -> Option<FunctionTable> {
+    if let StatementKind::Function {
+        name,
+        parameters,
+        body,
+    } = &stmt.kind
+    {
+        functions_table.add_function(FunctionDef {
+            name: name.clone(),
+            parameters: parameters.clone(),
+            body: body.clone(),
+        });
+
+        return Some(functions_table.clone());
+    }
+
+    None
+}

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

@@ -1,19 +1,38 @@
-use crate::core::{
-    audio::engine::AudioEngine,
-    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());
-
-        return Some(variable_table.clone())
-    } 
-    
-    None
-}
+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 {
+        // 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());
+    }
+
+    None
+}

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

@@ -1,18 +1,18 @@
-use crate::core::{
-    parser::statement::{ Statement, StatementKind },
-    shared::value::Value,
-    store::variable::VariableTable,
-};
-
-pub fn interprete_load_statement(
-    stmt: &Statement,
-    variable_table: &mut VariableTable
-) -> Option<VariableTable> {
-    if let StatementKind::Load { source, alias } = &stmt.kind {
-        variable_table.set(alias.to_string(), Value::Sample(source.clone()));
-
-        return Some(variable_table.clone());
-    }
-
-    None
-}
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    shared::value::Value,
+    store::variable::VariableTable,
+};
+
+pub fn interprete_load_statement(
+    stmt: &Statement,
+    variable_table: &mut VariableTable,
+) -> Option<VariableTable> {
+    if let StatementKind::Load { source, alias } = &stmt.kind {
+        variable_table.set(alias.to_string(), Value::Sample(source.clone()));
+
+        return Some(variable_table.clone());
+    }
+
+    None
+}

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

@@ -1,73 +1,113 @@
-use crate::core::{
-    audio::{ engine::AudioEngine, interpreter::driver::execute_audio_block },
-    parser::statement::{ Statement, StatementKind },
-    shared::{ duration::Duration, value::Value },
-    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
-};
-
-pub fn interprete_loop_statement(
-    stmt: &Statement,
-    audio_engine: &mut AudioEngine,
-    global_store: &GlobalStore,
-    variable_table: &VariableTable,
-    functions_table: &FunctionTable,
-    base_bpm: f32,
-    base_duration: f32,
-    max_end_time: f32,
-    cursor_time: f32
-) -> (f32, f32) {
-    if let Value::Map(loop_value) = &stmt.value {
-        let loop_count = match loop_value.get("iterator") {
-            Some(Value::Number(n)) => *n as usize,
-            Some(Value::Identifier(ident)) => {
-                if let Some(Value::Number(n)) = variable_table.get(ident) {
-                    *n as usize
-                } else {
-                    eprintln!("❌ Loop iterator must be a number, found: {:?}", ident);
-                    return (max_end_time, cursor_time);
-                }
-            }
-            _ => {
-                eprintln!(
-                    "❌ Loop iterator must be a number, found: {:?}",
-                    loop_value.get("iterator")
-                );
-                return (max_end_time, cursor_time);
-            }
-        };
-
-        let loop_body = match loop_value.get("body") {
-            Some(Value::Block(body)) => body.clone(),
-            _ => {
-                eprintln!("❌ Loop body must be a block, found: {:?}", loop_value.get("body"));
-                return (max_end_time, cursor_time);
-            }
-        };
-
-        let mut engine = audio_engine;
-        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(
-                &mut engine,
-                global_store,
-                variable_table.clone(),
-                functions_table.clone(),
-                loop_body.clone(),
-                base_bpm,
-                base_duration,
-                max_time,
-                cur_time
-            );
-
-            cur_time = block_end_time;
-            max_time = max_time.max(cur_time);
-        }
-
-        return (max_time, cur_time);
-    }
-
-    eprintln!("❌ Loop statement value is not a map");
-    (max_end_time, cursor_time)
-}
+use crate::core::{
+    audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
+    parser::statement::Statement,
+    shared::value::Value,
+    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
+};
+
+pub fn interprete_loop_statement(
+    stmt: &Statement,
+    audio_engine: &mut AudioEngine,
+    global_store: &GlobalStore,
+    variable_table: &VariableTable,
+    functions_table: &FunctionTable,
+    base_bpm: f32,
+    base_duration: f32,
+    max_end_time: f32,
+    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)) => {
+                if let Some(Value::Number(n)) = variable_table.get(ident) {
+                    *n as usize
+                } else {
+                    eprintln!("❌ Loop iterator must be a number, found: {:?}", ident);
+                    return (max_end_time, cursor_time);
+                }
+            }
+            _ => {
+                eprintln!(
+                    "❌ Loop iterator must be a number, found: {:?}",
+                    loop_value.get("iterator")
+                );
+                return (max_end_time, cursor_time);
+            }
+        };
+
+        let loop_body = match loop_value.get("body") {
+            Some(Value::Block(body)) => body.clone(),
+            _ => {
+                eprintln!(
+                    "❌ Loop body must be a block, found: {:?}",
+                    loop_value.get("body")
+                );
+                return (max_end_time, cursor_time);
+            }
+        };
+
+        let mut engine = audio_engine;
+        let mut cur_time = cursor_time;
+        let mut max_time = max_end_time;
+
+        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,
+                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);
+    }
+
+    eprintln!("❌ Loop statement value is not a map");
+    (max_end_time, cursor_time)
+}

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

@@ -1,13 +1,14 @@
-pub mod driver;
-
-pub mod load;
-pub mod let_;
-pub mod tempo;
-pub mod trigger;
-pub mod spawn;
-pub mod sleep;
-pub mod loop_;
-pub mod call;
-pub mod condition;
-pub mod arrow_call;
-pub mod function;
+pub mod driver;
+
+pub mod arrow_call;
+pub mod automate;
+pub mod call;
+pub mod condition;
+pub mod function;
+pub mod let_;
+pub mod load;
+pub mod loop_;
+pub mod sleep;
+pub mod spawn;
+pub mod tempo;
+pub mod trigger;

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

@@ -1,30 +1,27 @@
-use crate::core::{
-    audio::{ engine::AudioEngine, loader::trigger::load_trigger },
-    parser::statement::{ Statement, StatementKind },
-    shared::{ duration::Duration, value::Value },
-    store::variable::VariableTable,
-};
-
-pub fn interprete_sleep_statement(
-    stmt: &Statement,
-    cursor_time: f32,
-    max_end_time: f32,
-) -> (f32, f32) {
-    let duration_secs = match &stmt.value {
-        Value::Number(ms) => *ms / 1000.0,
-        Value::String(s) if s.ends_with("ms") => {
-            s.trim_end_matches("ms").parse::<f32>().map(|ms| ms / 1000.0).unwrap_or_else(|_| {
-                eprintln!("❌ Invalid sleep value (ms): {}", s);
-                0.0
-            })
-        }
-        other => {
-            eprintln!("❌ Invalid sleep value: {:?}", other);
-            0.0
-        }
-    };
-
-    let new_cursor = cursor_time + duration_secs;
-    let new_max = max_end_time.max(new_cursor);
-    (new_cursor, new_max)
-}
+use crate::core::{parser::statement::Statement, shared::value::Value};
+
+pub fn interprete_sleep_statement(
+    stmt: &Statement,
+    cursor_time: f32,
+    max_end_time: f32,
+) -> (f32, f32) {
+    let duration_secs = match &stmt.value {
+        Value::Number(ms) => *ms / 1000.0,
+        Value::String(s) if s.ends_with("ms") => s
+            .trim_end_matches("ms")
+            .parse::<f32>()
+            .map(|ms| ms / 1000.0)
+            .unwrap_or_else(|_| {
+                eprintln!("❌ Invalid sleep value (ms): {}", s);
+                0.0
+            }),
+        other => {
+            eprintln!("❌ Invalid sleep value: {:?}", other);
+            0.0
+        }
+    };
+
+    let new_cursor = cursor_time + duration_secs;
+    let new_max = max_end_time.max(new_cursor);
+    (new_cursor, new_max)
+}

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

@@ -1,102 +1,105 @@
-use crate::core::{
-    audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
-    parser::statement::{Statement, StatementKind},
-    shared::value::Value,
-    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
-};
-
-pub fn interprete_spawn_statement(
-    stmt: &Statement,
-    audio_engine: &mut AudioEngine,
-    variable_table: &VariableTable,
-    functions: &FunctionTable,
-    global_store: &GlobalStore,
-    base_bpm: f32,
-    base_duration: f32,
-    max_end_time: f32,
-    cursor_time: f32,
-) -> (f32, f32) {
-    match &stmt.kind {
-        StatementKind::Spawn { name, args } => {
-            let mut local_engine = AudioEngine::new(audio_engine.module_name.clone());
-
-            // Function case
-            if let Some(func) = functions.functions.get(name) {
-                if func.parameters.len() != args.len() {
-                    eprintln!(
-                        "❌ Function '{}' expects {} args, got {}",
-                        name,
-                        func.parameters.len(),
-                        args.len()
-                    );
-                    return (max_end_time, cursor_time);
-                }
-
-                let mut local_vars = VariableTable::with_parent(variable_table.clone());
-                for (param, arg) in func.parameters.iter().zip(args) {
-                    local_vars.set(param.clone(), arg.clone());
-                }
-
-                let (spawn_max, _) = execute_audio_block(
-                    &mut local_engine,
-                    global_store,
-                    local_vars,
-                    functions.clone(),
-                    func.body.clone(),
-                    base_bpm,
-                    base_duration,
-                    0.0,
-                    0.0,
-                );
-
-                audio_engine.merge_with(local_engine);
-                return (spawn_max.max(max_end_time), cursor_time);
-            }
-
-            // Group case
-            if let Some(group_stmt) = find_group(name, variable_table, global_store) {
-                if let Value::Map(map) = &group_stmt.value {
-                    if let Some(Value::Block(body)) = map.get("body") {
-                        let (spawn_max, _) = execute_audio_block(
-                            &mut local_engine,
-                            global_store,
-                            variable_table.clone(),
-                            functions.clone(),
-                            body.clone(),
-                            base_bpm,
-                            base_duration,
-                            0.0,
-                            0.0,
-                        );
-                        audio_engine.merge_with(local_engine);
-                        return (spawn_max.max(max_end_time), cursor_time);
-                    }
-                }
-            }
-
-            eprintln!("❌ Function or group '{}' not found", name);
-        }
-
-        _ => eprintln!("❌ interprete_spawn_statement expected Spawn, got {:?}", stmt.kind),
-    }
-
-    (max_end_time, cursor_time)
-}
-
-fn find_group<'a>(
-    name: &str,
-    variable_table: &'a VariableTable,
-    global_store: &'a GlobalStore,
-) -> Option<&'a Statement> {
-    if let Some(Value::Statement(stmt_box)) = variable_table.get(name) {
-        if let StatementKind::Group = stmt_box.kind {
-            return Some(stmt_box);
-        }
-    }
-    if let Some(Value::Statement(stmt_box)) = global_store.variables.variables.get(name) {
-        if let StatementKind::Group = stmt_box.kind {
-            return Some(stmt_box);
-        }
-    }
-    None
-}
+use crate::core::{
+    audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
+    parser::statement::{Statement, StatementKind},
+    shared::value::Value,
+    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
+};
+
+pub fn interprete_spawn_statement(
+    stmt: &Statement,
+    audio_engine: &mut AudioEngine,
+    variable_table: &VariableTable,
+    functions: &FunctionTable,
+    global_store: &GlobalStore,
+    base_bpm: f32,
+    base_duration: f32,
+    max_end_time: f32,
+    cursor_time: f32,
+) -> (f32, f32) {
+    match &stmt.kind {
+        StatementKind::Spawn { name, args } => {
+            let mut local_engine = AudioEngine::new(audio_engine.module_name.clone());
+
+            // Function case
+            if let Some(func) = functions.functions.get(name) {
+                if func.parameters.len() != args.len() {
+                    eprintln!(
+                        "❌ Function '{}' expects {} args, got {}",
+                        name,
+                        func.parameters.len(),
+                        args.len()
+                    );
+                    return (max_end_time, cursor_time);
+                }
+
+                let mut local_vars = VariableTable::with_parent(variable_table.clone());
+                for (param, arg) in func.parameters.iter().zip(args) {
+                    local_vars.set(param.clone(), arg.clone());
+                }
+
+                let (spawn_max, _) = execute_audio_block(
+                    &mut local_engine,
+                    global_store,
+                    local_vars,
+                    functions.clone(),
+                    &func.body,
+                    base_bpm,
+                    base_duration,
+                    0.0,
+                    0.0,
+                );
+
+                audio_engine.merge_with(local_engine);
+                return (spawn_max.max(max_end_time), cursor_time);
+            }
+
+            // Group case
+            if let Some(group_stmt) = find_group(name, variable_table, global_store) {
+                if let Value::Map(map) = &group_stmt.value {
+                    if let Some(Value::Block(body)) = map.get("body") {
+                        let (spawn_max, _) = execute_audio_block(
+                            &mut local_engine,
+                            global_store,
+                            variable_table.clone(),
+                            functions.clone(),
+                            &body,
+                            base_bpm,
+                            base_duration,
+                            0.0,
+                            0.0,
+                        );
+                        audio_engine.merge_with(local_engine);
+                        return (spawn_max.max(max_end_time), cursor_time);
+                    }
+                }
+            }
+
+            eprintln!("❌ Function or group '{}' not found", name);
+        }
+
+        _ => eprintln!(
+            "❌ interprete_spawn_statement expected Spawn, got {:?}",
+            stmt.kind
+        ),
+    }
+
+    (max_end_time, cursor_time)
+}
+
+fn find_group<'a>(
+    name: &str,
+    variable_table: &'a VariableTable,
+    global_store: &'a GlobalStore,
+) -> Option<&'a Statement> {
+    if let Some(Value::Statement(stmt_box)) = variable_table.get(name) {
+        if let StatementKind::Group = stmt_box.kind {
+            return Some(stmt_box);
+        }
+    }
+    if let Some(Value::Statement(stmt_box)) = global_store.variables.variables.get(name) {
+        if let StatementKind::Group = stmt_box.kind {
+            return Some(stmt_box);
+        }
+    }
+    None
+}

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

@@ -1,16 +1,19 @@
-use crate::core::{ parser::statement::{ Statement, StatementKind }, shared::value::Value };
-
-pub fn interprete_tempo_statement(stmt: &Statement) -> Option<(f32, f32)> {
-    if let StatementKind::Tempo = &stmt.kind {
-        if let Value::Number(bpm) = &stmt.value {
-            let bpm = *bpm as f32;
-            let duration = 60.0 / bpm;
-
-            return Some((bpm, duration));
-        } else {
-            eprintln!("❌ Invalid tempo value: {:?}", stmt.value);
-        }
-    }
-
-    None
-}
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    shared::value::Value,
+};
+
+pub fn interprete_tempo_statement(stmt: &Statement) -> Option<(f32, f32)> {
+    if let StatementKind::Tempo = &stmt.kind {
+        if let Value::Number(bpm) = &stmt.value {
+            let bpm = *bpm as f32;
+            let duration = 60.0 / bpm;
+
+            return Some((bpm, duration));
+        } else {
+            eprintln!("❌ Invalid tempo value: {:?}", stmt.value);
+        }
+    }
+
+    None
+}