@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.1

package/rust/core/preprocessor/resolver/group.rs

@@ -1,61 +1,94 @@
-use std::collections::HashMap;
-
-use crate::{
-    core::{
-        parser::statement::{ Statement, StatementKind },
-        preprocessor::{ module::Module, resolver::driver::resolve_statement },
-        shared::value::Value,
-        store::{ global::GlobalStore, variable::VariableTable },
-    },
-    utils::logger::{ LogLevel, Logger },
-};
-
-pub fn resolve_group(
-    stmt: &Statement,
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore
-) -> Statement {
-    let logger = Logger::new();
-
-    let Value::Map(group_map) = &stmt.value else {
-        return type_error(&logger, module, stmt, "Expected a map in group statement".to_string());
-    };
-
-    let mut resolved_map = group_map.clone();
-
-    if let Some(Value::Block(body)) = group_map.get("body") {
-        let resolved_body = resolve_block_statements(body, module, path, global_store);
-        resolved_map.insert("body".to_string(), Value::Block(resolved_body));
-    } else {
-        logger.log_message(LogLevel::Warning, "group without a body");
-    }
-
-    Statement {
-        kind: StatementKind::Group,
-        value: Value::Map(resolved_map),
-        ..stmt.clone()
-    }
-}
-
-fn resolve_block_statements(
-    body: &[Statement],
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore
-) -> Vec<Statement> {
-    body.iter()
-        .map(|stmt| resolve_statement(stmt, module, path, global_store))
-        .collect()
-}
-
-fn type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) -> Statement {
-    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-    logger.log_error_with_stacktrace(&message, &stacktrace);
-
-    Statement {
-        kind: StatementKind::Error { message },
-        value: Value::Null,
-        ..stmt.clone()
-    }
-}
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{module::Module, resolver::driver::resolve_statement},
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+use devalang_utils::logger::{LogLevel, Logger};
+
+pub fn resolve_group(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Statement {
+    let logger = Logger::new();
+
+    let Value::Map(group_map) = &stmt.value else {
+        return type_error(
+            &logger,
+            module,
+            stmt,
+            "Expected a map in group statement".to_string(),
+        );
+    };
+
+    // Check for the presence of the identifier field
+    let identifier = match group_map.get("identifier") {
+        Some(Value::String(id)) => id.clone(),
+        _ => {
+            return type_error(
+                &logger,
+                module,
+                stmt,
+                "Group statement must have an 'identifier' field".to_string(),
+            );
+        }
+    };
+
+    // Ensure the identifier does not already exist
+    if global_store.variables.variables.contains_key(&identifier) {
+        return type_error(
+            &logger,
+            module,
+            stmt,
+            format!("Group identifier '{}' already exists", identifier),
+        );
+    }
+
+    // Resolve statements in the body
+    let mut resolved_map = group_map.clone();
+    if let Some(Value::Block(body)) = group_map.get("body") {
+        let resolved_body = resolve_block_statements(body, module, path, global_store);
+        resolved_map.insert("body".to_string(), Value::Block(resolved_body));
+    } else {
+        logger.log_message(LogLevel::Warning, "Group without a body");
+    }
+
+    // Build a complete Statement for the group
+    let resolved_group_stmt = Statement {
+        kind: StatementKind::Group,
+        value: Value::Map(resolved_map.clone()),
+        ..stmt.clone()
+    };
+
+    // Store the Statement directly in the global variable_table
+    global_store.variables.variables.insert(
+        identifier.clone(),
+        Value::Statement(Box::new(resolved_group_stmt.clone())),
+    );
+
+    resolved_group_stmt
+}
+
+fn resolve_block_statements(
+    body: &[Statement],
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Vec<Statement> {
+    body.iter()
+        .map(|stmt| resolve_statement(stmt, module, path, global_store))
+        .collect()
+}
+
+fn type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) -> Statement {
+    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+    logger.log_error_with_stacktrace(&message, &stacktrace);
+
+    Statement {
+        kind: StatementKind::Error { message },
+        value: Value::Null,
+        ..stmt.clone()
+    }
+}

package/rust/core/preprocessor/resolver/let_.rs

@@ -1,31 +1,32 @@
-use crate::
-    core::{
-        parser::statement:: Statement ,
-        preprocessor::{
-            module::Module,
-            resolver:: value::resolve_value ,
-        },
-        store:: global::GlobalStore ,
-    }
-;
-
-pub fn resolve_let(
-    stmt: &Statement,
-    name: &str,
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore
-) -> Statement {
-    let resolved_value = resolve_value(&stmt.value, module, global_store);
-
-    if let Some(current_mod) = global_store.modules.get_mut(path) {
-        current_mod.variable_table.set(name.to_string(), resolved_value.clone());
-    } else {
-        eprintln!("[resolve_statement] ❌ Module path not found: {path}");
-    }
-
-    Statement {
-        value: resolved_value,
-        ..stmt.clone()
-    }
-}
+use crate::core::{
+    parser::statement::Statement,
+    preprocessor::{module::Module, resolver::value::resolve_value},
+    store::global::GlobalStore,
+};
+
+pub fn resolve_let(
+    stmt: &Statement,
+    name: &str,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Statement {
+    let resolved_value = resolve_value(&stmt.value, module, global_store);
+
+    global_store
+        .variables
+        .set(name.to_string(), resolved_value.clone());
+
+    if let Some(current_mod) = global_store.modules.get_mut(path) {
+        current_mod
+            .variable_table
+            .set(name.to_string(), resolved_value.clone());
+    } else {
+        eprintln!("[resolve_statement] ❌ Module path not found: {path}");
+    }
+
+    Statement {
+        value: resolved_value,
+        ..stmt.clone()
+    }
+}

package/rust/core/preprocessor/resolver/loop_.rs

@@ -1,91 +1,318 @@
-use std::collections::HashMap;
-
-use crate::{
-    core::{
-        parser::statement::{ Statement, StatementKind },
-        preprocessor::{
-            module::Module,
-            resolver::{ driver::resolve_statement, value::resolve_value },
-        },
-        shared::value::Value,
-        store::global::GlobalStore,
-    },
-    utils::logger::Logger,
-};
-
-pub fn resolve_loop(
-    stmt: &Statement,
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore
-) -> Statement {
-    let logger = Logger::new();
-
-    let resolved_value = resolve_value(&stmt.value, module, global_store);
-
-    let Value::Map(value_map) = &resolved_value else {
-        return error_stmt(&logger, module, stmt, "Expected a map for loop value");
-    };
-
-    let mut resolved_map: HashMap<String, Value> = HashMap::new();
-    for (key, val) in value_map {
-        resolved_map.insert(key.clone(), resolve_value(val, module, global_store));
-    }
-
-    let iterator_value = match resolved_map.get("iterator") {
-        Some(Value::Number(n)) => Value::Number(*n),
-        Some(other) => {
-            error_value(
-                &logger,
-                module,
-                stmt,
-                &format!("Loop iterator must be a number, found: {:?}", other)
-            );
-            Value::Number(1.0)
-        }
-        None => {
-            error_value(&logger, module, stmt, "Missing 'iterator' in loop");
-            Value::Number(1.0)
-        }
-    };
-
-    let body_value = match resolved_map.remove("body") {
-        Some(Value::Block(stmts)) => {
-            let resolved = stmts
-                .iter()
-                .map(|s| resolve_statement(s, module, path, global_store))
-                .collect();
-            Value::Block(resolved)
-        }
-        _ => {
-            error_value(&logger, module, stmt, "Invalid or missing loop body");
-            Value::Block(vec![])
-        }
-    };
-
-    let mut final_map = HashMap::new();
-    final_map.insert("iterator".to_string(), iterator_value);
-    final_map.insert("body".to_string(), body_value);
-
-    Statement {
-        kind: StatementKind::Loop,
-        value: Value::Map(final_map),
-        ..stmt.clone()
-    }
-}
-
-fn error_value(logger: &Logger, module: &Module, stmt: &Statement, msg: &str) {
-    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-    logger.log_error_with_stacktrace(msg, &stacktrace);
-}
-
-fn error_stmt(logger: &Logger, module: &Module, stmt: &Statement, msg: &str) -> Statement {
-    error_value(logger, module, stmt, msg);
-    Statement {
-        kind: StatementKind::Error {
-            message: msg.to_string(),
-        },
-        value: Value::Null,
-        ..stmt.clone()
-    }
-}
+use std::collections::HashMap;
+
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{
+        module::Module,
+        resolver::{driver::resolve_statement, value::resolve_value},
+    },
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+use devalang_utils::logger::Logger;
+
+pub fn resolve_loop(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Statement {
+    let logger = Logger::new();
+
+    let resolved_value = resolve_value(&stmt.value, module, global_store);
+
+    let Value::Map(value_map) = &resolved_value else {
+        return error_stmt(&logger, module, stmt, "Expected a map for loop value");
+    };
+
+    let mut resolved_map: HashMap<String, Value> = HashMap::new();
+    for (key, val) in value_map {
+        resolved_map.insert(key.clone(), resolve_value(val, module, global_store));
+    }
+
+    // Foreach form takes precedence if present
+    if let (Some(Value::Identifier(var_name)), Some(array_val)) =
+        (resolved_map.get("foreach"), resolved_map.get("array"))
+    {
+        // Normalize array_val into an iterable Array
+        let resolved_array = match array_val {
+            Value::Array(items) => Value::Array(
+                items
+                    .iter()
+                    .map(|v| resolve_value(v, module, global_store))
+                    .collect(),
+            ),
+            Value::Number(n) => {
+                // Iterate 0..n-1
+                let count = (*n).max(0.0) as usize;
+                let mut items = Vec::with_capacity(count);
+                for i in 0..count {
+                    items.push(Value::Number(i as f32));
+                }
+                Value::Array(items)
+            }
+            Value::String(s) => {
+                // Try to parse a simple comma-separated list: "a,b,c" -> ["a","b","c"]
+                // If numeric string: iterate 0..n-1
+                if let Ok(n) = s.parse::<f32>() {
+                    let count = n.max(0.0) as usize;
+                    let mut items = Vec::with_capacity(count);
+                    for i in 0..count {
+                        items.push(Value::Number(i as f32));
+                    }
+                    Value::Array(items)
+                } else if s.contains(',') {
+                    let parts: Vec<Value> = s
+                        .split(',')
+                        .map(|p| Value::String(p.trim().to_string()))
+                        .collect();
+                    Value::Array(parts)
+                } else {
+                    // Fallback: iterate characters
+                    let parts: Vec<Value> =
+                        s.chars().map(|c| Value::String(c.to_string())).collect();
+                    Value::Array(parts)
+                }
+            }
+            Value::Identifier(name) => {
+                // Resolve identifier from module variables (already resolved map above)
+                let v = if let Some(v) = module.variable_table.get(name) {
+                    v.clone()
+                } else {
+                    Value::Null
+                };
+                match v {
+                    Value::Array(items) => Value::Array(
+                        items
+                            .iter()
+                            .map(|v| resolve_value(v, module, global_store))
+                            .collect(),
+                    ),
+                    Value::Number(n) => {
+                        let count = n.max(0.0) as usize;
+                        let mut items = Vec::with_capacity(count);
+                        for i in 0..count {
+                            items.push(Value::Number(i as f32));
+                        }
+                        Value::Array(items)
+                    }
+                    Value::String(s) => {
+                        if let Ok(n) = s.parse::<f32>() {
+                            let count = n.max(0.0) as usize;
+                            let mut items = Vec::with_capacity(count);
+                            for i in 0..count {
+                                items.push(Value::Number(i as f32));
+                            }
+                            Value::Array(items)
+                        } else if s.contains(',') {
+                            let parts: Vec<Value> = s
+                                .split(',')
+                                .map(|p| Value::String(p.trim().to_string()))
+                                .collect();
+                            Value::Array(parts)
+                        } else {
+                            let parts: Vec<Value> =
+                                s.chars().map(|c| Value::String(c.to_string())).collect();
+                            Value::Array(parts)
+                        }
+                    }
+                    other => {
+                        error_value(
+                            &logger,
+                            module,
+                            stmt,
+                            &format!(
+                                "Foreach identifier '{}' resolves to unsupported value: {:?}",
+                                name, other
+                            ),
+                        );
+                        Value::Array(vec![])
+                    }
+                }
+            }
+            other => {
+                // Resolve and normalize if possible
+                let v = resolve_value(other, module, global_store);
+                match v {
+                    Value::Array(items) => Value::Array(items),
+                    Value::Number(n) => {
+                        let count = n.max(0.0) as usize;
+                        let mut items = Vec::with_capacity(count);
+                        for i in 0..count {
+                            items.push(Value::Number(i as f32));
+                        }
+                        Value::Array(items)
+                    }
+                    Value::String(s) => {
+                        if let Ok(n) = s.parse::<f32>() {
+                            let count = n.max(0.0) as usize;
+                            let mut items = Vec::with_capacity(count);
+                            for i in 0..count {
+                                items.push(Value::Number(i as f32));
+                            }
+                            Value::Array(items)
+                        } else if s.contains(',') {
+                            let parts: Vec<Value> = s
+                                .split(',')
+                                .map(|p| Value::String(p.trim().to_string()))
+                                .collect();
+                            Value::Array(parts)
+                        } else {
+                            let parts: Vec<Value> =
+                                s.chars().map(|c| Value::String(c.to_string())).collect();
+                            Value::Array(parts)
+                        }
+                    }
+                    other => {
+                        error_value(
+                            &logger,
+                            module,
+                            stmt,
+                            &format!("Unsupported foreach array value: {:?}", other),
+                        );
+                        Value::Array(vec![])
+                    }
+                }
+            }
+        };
+
+        let body_value = match resolved_map.get("body") {
+            Some(Value::Block(stmts)) => {
+                let resolved = stmts
+                    .iter()
+                    .map(|s| resolve_statement(s, module, path, global_store))
+                    .collect();
+                Value::Block(resolved)
+            }
+            _ => {
+                error_value(&logger, module, stmt, "Invalid or missing loop body");
+                Value::Block(vec![])
+            }
+        };
+
+        let mut final_map = HashMap::new();
+        final_map.insert("foreach".to_string(), Value::Identifier(var_name.clone()));
+        final_map.insert("array".to_string(), resolved_array);
+        final_map.insert("body".to_string(), body_value);
+
+        return Statement {
+            kind: StatementKind::Loop,
+            value: Value::Map(final_map),
+            ..stmt.clone()
+        };
+    }
+
+    let iterator_value = match resolved_map.get("iterator") {
+        Some(Value::Number(n)) => Value::Number(*n),
+        Some(Value::String(s)) => {
+            if let Ok(n) = s.parse::<f32>() {
+                Value::Number(n)
+            } else {
+                error_value(
+                    &logger,
+                    module,
+                    stmt,
+                    &format!("Loop iterator string not numeric: '{}'", s),
+                );
+                Value::Number(1.0)
+            }
+        }
+        Some(Value::Identifier(name)) => {
+            // Try resolving from module vars (may be number or numeric string)
+            if let Some(v) = module.variable_table.get(name) {
+                match v {
+                    Value::Number(n) => Value::Number(*n),
+                    Value::String(s) => {
+                        if let Ok(n) = s.parse::<f32>() {
+                            Value::Number(n)
+                        } else {
+                            error_value(
+                                &logger,
+                                module,
+                                stmt,
+                                &format!(
+                                    "Loop iterator '{}' resolves to non-numeric string: '{}'",
+                                    name, s
+                                ),
+                            );
+                            Value::Number(1.0)
+                        }
+                    }
+                    other => {
+                        error_value(
+                            &logger,
+                            module,
+                            stmt,
+                            &format!(
+                                "Loop iterator '{}' resolves to non-number: {:?}",
+                                name, other
+                            ),
+                        );
+                        Value::Number(1.0)
+                    }
+                }
+            } else {
+                error_value(
+                    &logger,
+                    module,
+                    stmt,
+                    &format!("Loop iterator identifier '{}' not found", name),
+                );
+                Value::Number(1.0)
+            }
+        }
+        Some(other) => {
+            error_value(
+                &logger,
+                module,
+                stmt,
+                &format!("Loop iterator must be a number, found: {:?}", other),
+            );
+            Value::Number(1.0)
+        }
+        None => {
+            error_value(&logger, module, stmt, "Missing 'iterator' in loop");
+            Value::Number(1.0)
+        }
+    };
+
+    let body_value = match resolved_map.get("body") {
+        Some(Value::Block(stmts)) => {
+            let resolved = stmts
+                .iter()
+                .map(|s| resolve_statement(s, module, path, global_store))
+                .collect();
+            Value::Block(resolved)
+        }
+        _ => {
+            error_value(&logger, module, stmt, "Invalid or missing loop body");
+            Value::Block(vec![])
+        }
+    };
+
+    let mut final_map = HashMap::new();
+    final_map.insert("iterator".to_string(), iterator_value);
+    final_map.insert("body".to_string(), body_value);
+
+    Statement {
+        kind: StatementKind::Loop,
+        value: Value::Map(final_map),
+        ..stmt.clone()
+    }
+}
+
+fn error_value(logger: &Logger, module: &Module, stmt: &Statement, msg: &str) {
+    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+    logger.log_error_with_stacktrace(msg, &stacktrace);
+}
+
+fn error_stmt(logger: &Logger, module: &Module, stmt: &Statement, msg: &str) -> Statement {
+    error_value(logger, module, stmt, msg);
+    Statement {
+        kind: StatementKind::Error {
+            message: msg.to_string(),
+        },
+        value: Value::Null,
+        ..stmt.clone()
+    }
+}

package/rust/core/preprocessor/resolver/mod.rs

@@ -1,14 +1,16 @@
-pub mod driver;
-
-pub mod value;
-
-pub mod trigger;
-pub mod loop_;
-pub mod bank;
-pub mod tempo;
-pub mod group;
-pub mod condition;
-pub mod spawn;
-pub mod call;
-pub mod synth;
-pub mod let_;
+pub mod driver;
+
+pub mod value;
+
+pub mod bank;
+pub mod call;
+pub mod condition;
+pub mod function;
+pub mod group;
+pub mod let_;
+pub mod loop_;
+pub mod pattern;
+pub mod spawn;
+pub mod synth;
+pub mod tempo;
+pub mod trigger;