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

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

@@ -23,11 +23,16 @@ pub fn interprete_call_arrow_statement(
         .unwrap_or(0.0);
 
     if let StatementKind::ArrowCall { target, method, args } = &stmt.kind {
-        let Some(Value::Map(synth_map)) = variable_table.get(target) else {
+        let Some(Value::Statement(synth_stmt)) = variable_table.get(target) else {
             println!("❌ Synth '{}' not found in variable table", target);
             return (*max_end_time, cursor_copy);
         };
 
+        let Value::Map(synth_map) = &synth_stmt.value else {
+            println!("❌ Invalid synth statement for '{}', expected a map.", target);
+            return (*max_end_time, cursor_copy);
+        };
+
         let Some(Value::String(entity)) = synth_map.get("entity") else {
             println!("❌ Missing 'entity' key in synth '{}'.", target);
             return (*max_end_time, cursor_copy);
@@ -53,37 +58,51 @@ pub fn interprete_call_arrow_statement(
             return (*max_end_time, cursor_copy);
         };
 
-        let freq = extract_f32(params, "freq", base_bpm).unwrap_or(440.0);
-        let amp = extract_f32(params, "amp", base_bpm).unwrap_or(1.0);
+        // Synth parameters
+    let synth_params = params.clone();
+    let amp = extract_f32(&synth_params, "amp", base_bpm).unwrap_or(1.0);
 
         if method == "note" {
-            let Some(Value::Identifier(note_name)) = args.get(0) else {
+            let filtered_args: Vec<_> = args
+                .iter()
+                .filter(|arg| !matches!(arg, Value::Unknown))
+                .collect();
+
+            let Some(Value::Identifier(note_name)) = filtered_args.get(0).map(|v| (*v).clone()) else {
                 println!("❌ Invalid or missing argument for 'note' method on '{}'.", target);
                 return (*max_end_time, cursor_copy);
             };
 
-            let mut final_note_params = HashMap::new();
-            if let Some(Value::Map(note_params)) = args.get(1) {
-                for (key, value) in note_params {
-                    final_note_params.insert(key.clone(), value.clone());
+            let mut note_params = HashMap::new();
+            if let Some(arg1) = filtered_args.get(1) {
+                match (*arg1).clone() {
+                    Value::Map(map) => {
+                        for (key, value) in map {
+                            note_params.insert(key, value);
+                        }
+                    }
+                    _ => {}
                 }
             }
 
-            let duration_ms = extract_f32(&final_note_params, "duration", base_bpm).unwrap_or(
-                base_duration
-            );
+            // Note parameters and calculations
+            let amp_note = extract_f32(&note_params, "amp", base_bpm).unwrap_or(amp);
+            let duration_ms = extract_f32(&note_params, "duration", base_bpm)
+                .unwrap_or(base_duration * 1000.0);
+            
             let duration_secs = duration_ms / 1000.0;
-
-            let final_freq = note_to_freq(note_name);
+            let final_freq = note_to_freq(&note_name);
             let start_time = cursor_copy;
             let end_time = start_time + duration_secs;
 
             audio_engine.insert_note(
                 waveform.clone(),
                 final_freq,
-                amp,
+                amp_note,
                 start_time * 1000.0,
-                duration_ms
+                duration_ms,
+                synth_params,
+                note_params
             );
 
             *max_end_time = (*max_end_time).max(end_time);

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

@@ -1,70 +1,95 @@
 use crate::core::{
-    audio::{ engine::AudioEngine, interpreter::{ driver::execute_audio_block } },
-    parser::statement::{ Statement, StatementKind },
-    shared::{ duration::Duration, value::Value },
-    store::variable::VariableTable,
+    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_call_statement(
     stmt: &Statement,
-    audio_engine: AudioEngine,
-    variable_table: VariableTable,
+    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,
-    all_statements: &Vec<Statement>
-) -> (AudioEngine, f32, f32, f32) {
-    match &stmt.value {
-        Value::String(identifier) | Value::Identifier(identifier) => {
-            if
-                let Some(group_stmt) = all_statements
-                    .iter()
-                    .find(|s| {
-                        matches!(s.kind, StatementKind::Group) &&
-                            s.value.get("identifier") == Some(&Value::String(identifier.clone()))
-                    })
-            {
-                if let Some(Value::Block(block)) = group_stmt.value.get("body") {
-                    let (eng, _, end_time) = execute_audio_block(
-                        audio_engine,
-                        variable_table,
-                        block.clone(),
-                        base_bpm,
-                        base_duration,
-                        max_end_time,
-                        cursor_time
+) -> (f32, f32) {
+    match &stmt.kind {
+        StatementKind::Call { name, args } => {
+            // Classic function call 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 (eng, max_end_time.max(end_time), end_time, cursor_time);
-                } else {
-                    eprintln!("❌ Group '{}' found but no valid body block", identifier);
+                    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());
                 }
-            } else {
-                eprintln!("❌ Group '{}' not found in statements", identifier);
-            }
-        }
 
-        Value::Map(map) => {
-            if let Some(Value::Block(block)) = map.get("body") {
-                let (eng, _, end_time) = execute_audio_block(
+                return execute_audio_block(
                     audio_engine,
-                    variable_table,
-                    block.clone(),
+                    global_store,
+                    local_vars,
+                    functions.clone(),
+                    func.body.clone(),
                     base_bpm,
                     base_duration,
                     max_end_time,
-                    cursor_time
+                    cursor_time,
                 );
-                return (eng, max_end_time.max(end_time), end_time, cursor_time);
-            } else {
-                eprintln!("❌ Call map has no 'body' block");
             }
-        }
 
-        other => {
-            eprintln!("❌ Invalid call statement: expected identifier or map, found {:?}", other);
+            // 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") {
+                        return execute_audio_block(
+                            audio_engine,
+                            global_store,
+                            variable_table.clone(),
+                            functions.clone(),
+                            body.clone(),
+                            base_bpm,
+                            base_duration,
+                            max_end_time,
+                            cursor_time,
+                        );
+                    }
+                }
+            }
+
+            eprintln!("❌ Function or group '{}' not found", name);
         }
+
+        _ => eprintln!("❌ interprete_call_statement expected Call, got {:?}", stmt.kind),
     }
 
-    (audio_engine, base_bpm, max_end_time, cursor_time)
+    (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/condition.rs

@@ -6,20 +6,20 @@ use crate::core::{
     },
     parser::statement::Statement,
     shared::value::Value,
-    store::variable::VariableTable,
+    store::{ function::FunctionTable, global::GlobalStore, variable::VariableTable },
 };
 
 pub fn interprete_condition_statement(
     stmt: &Statement,
-    audio_engine: AudioEngine,
-    variable_table: VariableTable,
+    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
-) -> (AudioEngine, f32, f32) {
-    let mut engine = audio_engine.clone();
-    let mut vars = variable_table.clone();
+) -> (f32, f32) {
     let mut cur_time = cursor_time;
     let mut max_time = max_end_time;
 
@@ -32,23 +32,25 @@ pub fn interprete_condition_statement(
 
         let should_execute = match map.get("condition") {
             Some(Value::Boolean(b)) => *b,
-            Some(Value::String(expr)) => evaluate_condition_string(expr, &vars),
+            Some(Value::String(expr)) => evaluate_condition_string(expr, &variable_table.clone()),
             Some(_) => false,
             None => true,
         };
 
         if should_execute {
             if let Some(Value::Block(block)) = map.get("body") {
-                let (new_engine, _, new_max) = execute_audio_block(
-                    engine,
-                    vars,
+                let (new_max, cursor_time) = execute_audio_block(
+                    audio_engine,
+                    global_store,
+                    variable_table.clone(),
+                    functions_table.clone(),
                     block.clone(),
                     base_bpm,
                     base_duration,
                     max_time,
                     cur_time
                 );
-                return (new_engine, new_max, new_max);
+                return (new_max, cursor_time);
             } else {
                 break;
             }
@@ -65,5 +67,5 @@ pub fn interprete_condition_statement(
         }
     }
 
-    (audio_engine, max_end_time, cursor_time)
+    (max_end_time, cursor_time)
 }

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

@@ -1,3 +1,6 @@
+use rayon::prelude::*;
+use std::sync::{ Arc, Mutex };
+
 use crate::core::{
     audio::{
         engine::AudioEngine,
@@ -5,6 +8,7 @@ use crate::core::{
             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,
             loop_::interprete_loop_statement,
@@ -15,37 +19,26 @@ use crate::core::{
         },
     },
     parser::statement::{ Statement, StatementKind },
-    store::variable::VariableTable,
+    store::{ function::FunctionTable, global::GlobalStore, variable::VariableTable },
 };
 
 pub fn run_audio_program(
     statements: &Vec<Statement>,
-    mut audio_engine: AudioEngine,
+    audio_engine: &mut AudioEngine,
     entry: String,
-    output: String
-) -> (AudioEngine, f32, f32) {
+    output: String,
+    mut module_variables: VariableTable,
+    mut module_functions: FunctionTable,
+    global_store: &mut GlobalStore
+) -> (f32, f32) {
     let mut base_bpm = 120.0;
     let mut base_duration = 60.0 / base_bpm;
 
-    let mut variable_table = audio_engine.variables.clone();
-
-    for stmt in statements {
-        if let StatementKind::Let { .. } = stmt.kind {
-            if
-                let Some(new_table) =
-                    interprete_let_statement(
-                        stmt,
-                        &mut variable_table
-                    )
-            {
-                variable_table = new_table;
-            }
-        }
-    }
-
-    let (updated_audio_engine, base_bpm, max_end_time) = execute_audio_block(
+    let (max_end_time, cursor_time) = execute_audio_block(
         audio_engine,
-        variable_table,
+        global_store,
+        global_store.variables.clone(),
+        global_store.functions.clone(),
         statements.clone(),
         base_bpm,
         base_duration,
@@ -53,112 +46,65 @@ pub fn run_audio_program(
         0.0
     );
 
-    (updated_audio_engine, base_bpm, max_end_time)
+    (max_end_time, cursor_time)
 }
 
 pub fn execute_audio_block(
-    mut audio_engine: AudioEngine,
+    audio_engine: &mut AudioEngine,
+    global_store: &GlobalStore,
     mut variable_table: VariableTable,
-    mut statements: Vec<Statement>,
+    mut functions_table: FunctionTable,
+    statements: Vec<Statement>,
     mut base_bpm: f32,
     mut base_duration: f32,
     mut max_end_time: f32,
     mut cursor_time: f32
-) -> (AudioEngine, f32, f32) {
-    let initial_cursor_time = cursor_time;
+) -> (f32, f32) {
+    let (spawns, others): (Vec<_>, Vec<_>) = statements
+        .into_iter()
+        .partition(|stmt| matches!(stmt.kind, StatementKind::Spawn { .. }));
 
-    for stmt in statements.clone() {
+    // Execute sequential statements first
+    for stmt in others {
         match &stmt.kind {
             StatementKind::Load { .. } => {
-                if
-                    let Some(new_variable_table) = interprete_load_statement(
-                        &stmt,
-                        &mut variable_table
-                    )
-                {
-                    variable_table = new_variable_table;
-                } else {
-                    eprintln!("❌ Failed to interpret load statement: {:?}", stmt);
+                if let Some(new_table) = interprete_load_statement(&stmt, &mut variable_table) {
+                    variable_table = new_table;
                 }
             }
-
             StatementKind::Let { .. } => {
-                if
-                    let Some(new_variable_table) = interprete_let_statement(
-                        &stmt,
-                        &mut variable_table
-                    )
+                if let Some(new_table) = interprete_let_statement(&stmt, &mut variable_table) {
+                    variable_table = new_table;
+                }
+            }
+            StatementKind::Function { .. } => {
+                if let Some(new_functions) =
+                    interprete_function_statement(&stmt, &mut functions_table)
                 {
-                    variable_table = new_variable_table;
-                } else {
-                    eprintln!("❌ Failed to interpret let statement: {:?}", stmt);
+                    functions_table = new_functions;
                 }
             }
-
             StatementKind::Tempo => {
                 if let Some((new_bpm, new_duration)) = interprete_tempo_statement(&stmt) {
                     base_bpm = new_bpm;
                     base_duration = new_duration;
-                } else {
-                    eprintln!("❌ Failed to interpret tempo statement: {:?}", stmt);
                 }
             }
-
             StatementKind::Trigger { .. } => {
                 if
-                    let Some((new_cursor_time, new_max_end_time, updated_engine)) =
-                        interprete_trigger_statement(
-                            &stmt,
-                            &mut audio_engine,
-                            &variable_table,
-                            base_duration,
-                            cursor_time,
-                            max_end_time
-                        )
-                {
-                    cursor_time = new_cursor_time;
-                    max_end_time = new_max_end_time;
-                    audio_engine = updated_engine;
-                } else {
-                    eprintln!("❌ Failed to interpret trigger statement: {:?}", stmt);
-                }
-            }
-
-            StatementKind::Spawn => {
-                let mut temp_engine = AudioEngine::new(audio_engine.module_name.clone());
-
-                if
-                    let Some((_cur, _max, updated_engine)) = interprete_spawn_statement(
+                    let Some((new_cursor, new_max, _)) = interprete_trigger_statement(
                         &stmt,
-                        temp_engine,
+                        audio_engine,
                         &variable_table,
-                        base_bpm,
                         base_duration,
-                        initial_cursor_time,
+                        cursor_time,
                         max_end_time
                     )
                 {
-                    audio_engine.merge_with(updated_engine);
+                    cursor_time = new_cursor;
+                    max_end_time = new_max;
                 }
             }
-
-            StatementKind::Call => {
-                let (call_engine, new_max, end_time, new_cursor) = interprete_call_statement(
-                    &stmt,
-                    audio_engine.clone(),
-                    variable_table.clone(),
-                    base_bpm,
-                    base_duration,
-                    max_end_time,
-                    cursor_time,
-                    &statements 
-                );
-
-                audio_engine.merge_with(call_engine);
-                cursor_time = new_cursor;
-                max_end_time = new_max;
-            }
-
             StatementKind::Sleep => {
                 let (new_cursor, new_max) = interprete_sleep_statement(
                     &stmt,
@@ -168,42 +114,40 @@ pub fn execute_audio_block(
                 cursor_time = new_cursor;
                 max_end_time = new_max;
             }
-
             StatementKind::Loop => {
-                let (loop_engine, new_max, new_cursor) = interprete_loop_statement(
+                let (new_max, new_cursor) = interprete_loop_statement(
                     &stmt,
-                    audio_engine.clone(),
-                    variable_table.clone(),
+                    audio_engine,
+                    global_store,
+                    &variable_table,
+                    &functions_table,
                     base_bpm,
                     base_duration,
                     max_end_time,
                     cursor_time
                 );
-                audio_engine = loop_engine;
                 cursor_time = new_cursor;
                 max_end_time = new_max;
             }
-
-            StatementKind::If | StatementKind::ElseIf | StatementKind::Else => {
-                let (condition_engine, new_max, new_cursor) = interprete_condition_statement(
+            StatementKind::Call { .. } => {
+                let (new_max, _) = interprete_call_statement(
                     &stmt,
-                    audio_engine.clone(),
-                    variable_table.clone(),
+                    audio_engine,
+                    &variable_table,
+                    &functions_table,
+                    global_store,
                     base_bpm,
                     base_duration,
                     max_end_time,
-                    cursor_time
+                    cursor_time,
                 );
-
-                audio_engine = condition_engine;
-                cursor_time = new_cursor;
+                cursor_time = new_max;
                 max_end_time = new_max;
             }
-
             StatementKind::ArrowCall { .. } => {
-                let (new_max_end_time, new_cursor_time) = interprete_call_arrow_statement(
+                let (new_max, new_cursor) = interprete_call_arrow_statement(
                     &stmt,
-                    &mut audio_engine,
+                    audio_engine,
                     &variable_table,
                     base_bpm,
                     base_duration,
@@ -212,25 +156,43 @@ pub fn execute_audio_block(
                     true
                 );
 
-                cursor_time = new_cursor_time;
-                max_end_time = new_max_end_time;
-            }
-
-            | StatementKind::Bank
-            | StatementKind::Import { .. }
-            | StatementKind::Export { .. }
-            | StatementKind::Group
-            | StatementKind::Unknown => {
-                // NOTE: Ignoring unsupported statement kinds for now.
-            }
-
-            _ => {
-                eprintln!("Unsupported audio statement kind: {:?}", stmt);
+                cursor_time = new_cursor;
+                
+                if new_max > max_end_time {
+                    max_end_time = new_max;
+                }
             }
+            _ => {}
         }
     }
 
-    audio_engine.set_variables(variable_table);
+    // Execute parallel spawns (collect results)
+    let spawn_results: Vec<(AudioEngine, f32)> = spawns
+        .par_iter()
+        .map(|stmt| {
+            let mut local_engine = AudioEngine::new(audio_engine.module_name.clone());
+            let (spawn_max, _) = interprete_spawn_statement(
+                stmt,
+                &mut local_engine,
+                &variable_table,
+                &functions_table,
+                global_store,
+                base_bpm,
+                base_duration,
+                0.0,
+                0.0
+            );
+            (local_engine, spawn_max)
+        })
+        .collect();
+
+    // Finally, merge results from all spawns
+    for (local_engine, spawn_max) in spawn_results {
+        audio_engine.merge_with(local_engine);
+        if spawn_max > max_end_time {
+            max_end_time = spawn_max;
+        }
+    }
 
-    (audio_engine, base_bpm, max_end_time)
+    (max_end_time.max(cursor_time), cursor_time)
 }

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

@@ -0,0 +1,21 @@
+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/load.rs

@@ -9,7 +9,7 @@ pub fn interprete_load_statement(
     variable_table: &mut VariableTable
 ) -> Option<VariableTable> {
     if let StatementKind::Load { source, alias } = &stmt.kind {
-        variable_table.set(alias.to_string(), Value::String(source.clone()));
+        variable_table.set(alias.to_string(), Value::Sample(source.clone()));
 
         return Some(variable_table.clone());
     }