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

package/rust/core/parser/handler/identifier/mod.rs

@@ -5,21 +5,23 @@ pub mod spawn;
 pub mod sleep;
 pub mod synth;
 pub mod function;
+pub mod automate;
+pub mod print;
 
 use crate::core::{
     parser::{
         driver::Parser,
-        handler::{
-            identifier::{
-                call::parse_call_token,
-                group::parse_group_token,
-                let_::parse_let_token,
-                sleep::parse_sleep_token,
-                spawn::parse_spawn_token,
-                synth::parse_synth_token
-            },
+        handler::identifier::{
+            automate::parse_automate_token,
+            call::parse_call_token,
+            group::parse_group_token,
+            let_::parse_let_token,
+            print::parse_print_token,
+            sleep::parse_sleep_token,
+            spawn::parse_spawn_token,
+            synth::parse_synth_token,
         },
-        statement::Statement,
+        statement::{ Statement },
     },
     store::global::GlobalStore,
 };
@@ -39,6 +41,8 @@ pub fn parse_identifier_token(parser: &mut Parser, global_store: &mut GlobalStor
         "spawn" => parse_spawn_token(parser, current_token_clone, global_store),
         "sleep" => parse_sleep_token(parser, current_token_clone, global_store),
         "synth" => parse_synth_token(parser, current_token_clone, global_store),
+        "automate" => parse_automate_token(parser, current_token_clone, global_store),
+        "print" => parse_print_token(parser, current_token_clone, global_store),
         _ => {
             parser.advance(); // consume identifier
 

package/rust/core/parser/handler/identifier/print.rs

@@ -0,0 +1,29 @@
+use crate::core::{
+    lexer::token::{ Token, TokenKind },
+    parser::{ driver::Parser, statement::{ Statement, StatementKind } },
+    store::global::GlobalStore,
+};
+
+pub fn parse_print_token(
+    parser: &mut Parser,
+    current_token: Token,
+    _global_store: &mut GlobalStore
+) -> Statement {
+    // consume 'print'
+    parser.advance();
+
+    let collected = parser.collect_until(|t| matches!(t.kind, TokenKind::Newline | TokenKind::EOF));
+    // If single identifier, store as Identifier; else store as String of concatenated lexemes
+    let value = if collected.len() == 1 && collected[0].kind == TokenKind::Identifier {
+        crate::core::shared::value::Value::Identifier(collected[0].lexeme.clone())
+    } else {
+        let mut text = String::new();
+        for t in collected.iter() {
+            if matches!(t.kind, TokenKind::Newline | TokenKind::EOF) { break; }
+            text.push_str(&t.lexeme);
+        }
+        crate::core::shared::value::Value::String(text.trim().to_string())
+    };
+
+    Statement { kind: StatementKind::Print, value, indent: current_token.indent, line: current_token.line, column: current_token.column }
+}

package/rust/core/parser/handler/identifier/sleep.rs

@@ -8,7 +8,7 @@ use crate::core::{
 pub fn parse_sleep_token(
     parser: &mut Parser,
     current_token: Token,
-    global_store: &mut GlobalStore
+    _global_store: &mut GlobalStore
 ) -> Statement {
     parser.advance(); // consume "sleep"
 

package/rust/core/parser/handler/identifier/synth.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use crate::core::{
-    lexer::token::{ Token, TokenKind },
+    lexer::token::Token,
     parser::{ driver::Parser, statement::{ Statement, StatementKind } },
     shared::value::Value,
     store::global::GlobalStore,
@@ -9,8 +9,8 @@ use crate::core::{
 
 pub fn parse_synth_token(
     parser: &mut Parser,
-    current_token: Token,
-    global_store: &mut GlobalStore
+    _current_token: Token,
+    _global_store: &mut GlobalStore
 ) -> Statement {
     parser.advance(); // consume 'synth'
 
@@ -28,19 +28,17 @@ pub fn parse_synth_token(
     parser.advance(); // consume identifier
 
     // Expect synth optional parameters map
-    let mut parameters = HashMap::new();
-
-    if let Some(params) = parser.parse_map_value() {
+    let parameters = if let Some(params) = parser.parse_map_value() {
         // If parameters are provided, we expect a map
         if let Value::Map(map) = params {
-            parameters = map;
+            map
         } else {
             return Statement::error(synth_token, "Expected a map for synth parameters".to_string());
         }
     } else {
         // If no parameters are provided, we can still create the statement with an empty map
-        parameters = HashMap::new();
-    }
+        HashMap::new()
+    };
 
     Statement {
         kind: StatementKind::Synth,

package/rust/core/parser/handler/loop_.rs

@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
 use crate::core::{
     lexer::{ token::TokenKind },
     parser::{ statement::{ Statement, StatementKind }, driver::Parser },
@@ -8,65 +6,84 @@ use crate::core::{
 };
 
 pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
-    parser.advance(); // consume 'loop'
+    parser.advance(); // consume 'loop' or 'for' (aliased in lexer)
     let Some(loop_token) = parser.previous_clone() else {
         return Statement::unknown();
     };
 
-    let Some(iterator_token) = parser.peek_clone() else {
-        return Statement::error(loop_token, "Expected number or identifier after 'loop'".to_string());
+    // Support two forms:
+    // 1) loop <count>:
+    // 2) for <ident> in [a,b,c]:
+
+    // Peek next to decide
+    let Some(next_token) = parser.peek_clone() else {
+        return Statement::error(loop_token, "Expected iterator after loop/for".to_string());
     };
 
-    let iterator_value = match iterator_token.kind {
-        TokenKind::Number => {
-            let val = iterator_token.lexeme.parse::<f32>().unwrap_or(1.0);
-            parser.advance();
-            Value::Number(val)
-        }
-        TokenKind::Identifier => {
-            let val = iterator_token.lexeme.clone();
-            parser.advance();
-            Value::Identifier(val)
+    // Try to detect 'for <ident> in [array]:' form
+    let mut foreach_ident: Option<String> = None;
+    if let TokenKind::Identifier = next_token.kind {
+        // Could be either count identifier (old form) or foreach variable
+        // Look ahead for 'in'
+        let name = next_token.lexeme.clone();
+        // don't consume yet; we'll branch
+        if let Some(t2) = parser.peek_nth(1) {
+            if t2.kind == TokenKind::Identifier && t2.lexeme == "in" {
+                // foreach form
+                foreach_ident = Some(name);
+                // consume ident and 'in'
+                parser.advance();
+                parser.advance();
+            }
         }
-        _ => {
-            return Statement::error(
-                iterator_token.clone(),
-                "Expected a number or identifier as loop count".to_string()
-            );
+    }
+
+    if let Some(var_name) = foreach_ident {
+        // Expect array literal
+        let array_val = if let Some(v) = parser.parse_array_value() { v } else {
+            return Statement::error(loop_token, "Expected array literal after 'in'".to_string());
+        };
+
+        // Expect ':'
+        if !parser.match_token(TokenKind::Colon) {
+            return Statement::error(loop_token, "Expected ':' after foreach header".to_string());
         }
+
+        let tokens = parser.collect_until(|t| t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF);
+        let loop_body = parser.parse_block(tokens.clone(), global_store);
+        if let Some(token) = parser.peek() { if token.kind == TokenKind::Dedent { parser.advance(); } }
+
+        let mut value_map = std::collections::HashMap::new();
+        value_map.insert("foreach".to_string(), Value::Identifier(var_name));
+        value_map.insert("array".to_string(), array_val);
+        value_map.insert("body".to_string(), Value::Block(loop_body.clone()));
+
+        return Statement { kind: StatementKind::Loop, value: Value::Map(value_map), indent: loop_token.indent, line: loop_token.line, column: loop_token.column };
+    }
+
+    // Fallback to legacy: loop <count>:
+    let Some(iterator_token) = parser.peek_clone() else {
+        return Statement::error(loop_token, "Expected number or identifier after 'loop'".to_string());
     };
 
-    // Expect colon
-    let Some(colon_token) = parser.peek_clone() else {
-        return Statement::error(iterator_token.clone(), "Expected ':' after loop count".to_string());
+    let iterator_value = match iterator_token.kind {
+        TokenKind::Number => { let val = iterator_token.lexeme.parse::<f32>().unwrap_or(1.0); parser.advance(); Value::Number(val) }
+        TokenKind::Identifier => { let val = iterator_token.lexeme.clone(); parser.advance(); Value::Identifier(val) }
+        _ => { return Statement::error(iterator_token.clone(), "Expected a number or identifier as loop count".to_string()); }
     };
 
-    if colon_token.kind != TokenKind::Colon {
-        let message = format!("Expected ':' after loop count, got {:?}", colon_token.kind);
-        return Statement::error(colon_token.clone(), message);
+    if !parser.match_token(TokenKind::Colon) {
+        let message = format!("Expected ':' after loop count, got {:?}", parser.peek_kind());
+        return Statement::error(loop_token.clone(), message);
     }
 
-    parser.advance(); // consume ':'
-
-    // Collect body
     let tokens = parser.collect_until(|t| t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF);
     let loop_body = parser.parse_block(tokens.clone(), global_store);
+    if let Some(token) = parser.peek() { if token.kind == TokenKind::Dedent { parser.advance(); } }
 
-    if let Some(token) = parser.peek() {
-        if token.kind == TokenKind::Dedent {
-            parser.advance();
-        }
-    }
-
-    let mut value_map = HashMap::new();
+    let mut value_map = std::collections::HashMap::new();
     value_map.insert("iterator".to_string(), iterator_value);
     value_map.insert("body".to_string(), Value::Block(loop_body.clone()));
 
-    Statement {
-        kind: StatementKind::Loop,
-        value: Value::Map(value_map),
-        indent: loop_token.indent,
-        line: loop_token.line,
-        column: loop_token.column,
-    }
+    Statement { kind: StatementKind::Loop, value: Value::Map(value_map), indent: loop_token.indent, line: loop_token.line, column: loop_token.column }
 }

package/rust/core/parser/statement.rs

@@ -37,6 +37,7 @@ pub enum StatementKind {
     // ───── Core Instructions ─────
     Tempo,
     Bank,
+    Print,
     Load {
         source: String,
         alias: String,
@@ -44,6 +45,10 @@ pub enum StatementKind {
     Let {
         name: String,
     },
+    // Automation of parameters over time (percent-based envelopes)
+    Automate {
+        target: String,
+    },
     ArrowCall {
         target: String,
         method: String,

package/rust/core/preprocessor/loader.rs

@@ -188,7 +188,7 @@ impl ModuleLoader {
 
         // Inject triggers for each bank used in module
         for bank_name in self.extract_bank_names(&statements) {
-            self.inject_bank_triggers(&mut module, &bank_name);
+            let _ = self.inject_bank_triggers(&mut module, &bank_name);
         }
 
         // Inject module variables and functions into global store

package/rust/core/preprocessor/processor.rs

@@ -1,14 +1,14 @@
 use std::{ collections::HashMap, path::Path };
 
 use crate::core::{
-    parser::{ driver::Parser, statement::StatementKind },
-    preprocessor::{ loader::ModuleLoader, resolver::group },
+    parser::statement::StatementKind,
+    preprocessor::loader::ModuleLoader,
     shared::value::Value,
     store::global::GlobalStore,
     utils::path::{ normalize_path, resolve_relative_path },
 };
 
-pub fn process_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
+pub fn process_modules(_module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
     for module in global_store.modules.values_mut() {
         for stmt in &module.statements {
             match &stmt.kind {
@@ -52,7 +52,7 @@ pub fn process_modules(module_loader: &ModuleLoader, global_store: &mut GlobalSt
                     );
                 }
 
-                StatementKind::Export { names, source } => {
+                StatementKind::Export { names, source: _ } => {
                     for name in names {
                         if let Some(val) = module.variable_table.get(name) {
                             module.export_table.add_export(name.clone(), val.clone());

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

@@ -11,12 +11,11 @@ use crate::{
 pub fn resolve_bank(
     stmt: &Statement,
     module: &Module,
-    path: &str,
+    _path: &str,
     _global_store: &GlobalStore
 ) -> Statement {
     let mut new_stmt = stmt.clone();
     let logger = Logger::new();
-
     match &stmt.value {
         Value::Identifier(ident) => {
             if let Some(val) = module.variable_table.get(ident) {

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

@@ -1,7 +1,7 @@
 use crate::{
     core::{
         parser::statement::{ Statement, StatementKind },
-        preprocessor::{ module::Module, resolver::driver::resolve_statement },
+        preprocessor::module::Module,
         shared::value::Value,
         store::global::GlobalStore,
     },
@@ -13,7 +13,7 @@ pub fn resolve_call(
     name: String,
     args: Vec<Value>,
     module: &Module,
-    path: &str,
+    _path: &str,
     global_store: &mut GlobalStore
 ) -> Statement {
     let logger = Logger::new();
@@ -78,23 +78,24 @@ pub fn resolve_call(
                 ..stmt.clone()
             }
         }
-        _ => error_stmt(&logger, module, stmt, "Expected StatementKind::Call in resolve_call()"),
-    }
-}
-
-fn get_group_body(stmt_box: &Statement) -> Vec<Statement> {
-    if let Value::Block(body) = &stmt_box.value { body.clone() } else { vec![] }
-}
-
-fn error_stmt(logger: &Logger, module: &Module, stmt: &Statement, message: &str) -> Statement {
-    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-    logger.log_message(LogLevel::Error, &format!("{message}\n  → at {stacktrace}"));
+        _ => {
+            let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+            logger.log_message(
+                LogLevel::Error,
+                &format!(
+                    "Expected StatementKind::Call in resolve_call()\n  → at {stacktrace}"
+                )
+            );
 
-    Statement {
-        kind: StatementKind::Error {
-            message: message.to_string(),
+            Statement {
+                kind: StatementKind::Error {
+                    message: "Expected StatementKind::Call in resolve_call()".to_string(),
+                },
+                value: Value::Null,
+                ..stmt.clone()
+            }
         },
-        value: Value::Null,
-        ..stmt.clone()
     }
 }
+
+// (removed unused helpers get_group_body, error_stmt)

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

@@ -25,7 +25,7 @@ use crate::{
 };
 
 pub fn resolve_all_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
-    for module in global_store.clone().modules.values_mut() {
+    for _module in global_store.clone().modules.values_mut() {
         resolve_imports(module_loader, global_store);
     }
 }
@@ -80,10 +80,12 @@ fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore)
                 return resolve_value(&export_val, module, global_store);
             }
 
-            eprintln!("⚠️ Unresolved identifier '{}'", name);
-            Value::Null
+            // Leave unresolved identifiers as-is; they might be runtime-bound (e.g., foreach vars)
+            Value::Identifier(name.clone())
         }
 
+        Value::String(s) => Value::String(s.clone()),
+
         Value::Beat(beat_str) => {
             println!("[warn] '{:?}': unresolved beat '{}'", module.path, beat_str);
             Value::Beat(beat_str.clone())
@@ -118,7 +120,7 @@ fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
     None
 }
 
-pub fn resolve_imports(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
+pub fn resolve_imports(_module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
     for (module_path, module) in global_store.clone().modules.iter_mut() {
         for (name, source_path) in &module.import_table.imports {
             match source_path {
@@ -260,7 +262,7 @@ pub fn resolve_and_flatten_all_modules(
                     resolved.push(resolved_stmt);
                 }
 
-                StatementKind::Function { name, parameters, body } => {
+                StatementKind::Function { name: _, parameters: _, body: _ } => {
                     let resolved_function = resolve_function(&stmt, &module, &path, global_store);
                     resolved.push(resolved_function);
                 }

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

@@ -1,13 +1,12 @@
-use std::collections::HashMap;
 
 use crate::{
     core::{
         parser::statement::{ Statement, StatementKind },
         preprocessor::{ module::Module, resolver::driver::resolve_statement },
         shared::value::Value,
-        store::{ function::FunctionDef, global::GlobalStore, variable::VariableTable },
+        store::{ function::FunctionDef, global::GlobalStore },
     },
-    utils::logger::{ LogLevel, Logger },
+    
 };
 
 pub fn resolve_function(
@@ -66,13 +65,4 @@ fn resolve_block_statements(
         .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()
-    }
-}
+// (removed unused helper type_error)

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

@@ -32,6 +32,36 @@ pub fn resolve_loop(
         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")) {
+        // Resolve array elements
+        let resolved_array = match array_val {
+            Value::Array(items) => Value::Array(items.iter().map(|v| resolve_value(v, module, global_store)).collect()),
+            other => resolve_value(other, module, global_store),
+        };
+
+        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(other) => {
@@ -49,7 +79,7 @@ pub fn resolve_loop(
         }
     };
 
-    let body_value = match resolved_map.remove("body") {
+    let body_value = match resolved_map.get("body") {
         Some(Value::Block(stmts)) => {
             let resolved = stmts
                 .iter()

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

@@ -1,11 +1,7 @@
 use crate::{
     core::{
         parser::statement::{ Statement, StatementKind },
-        preprocessor::{
-            module::Module,
-            resolver::driver::resolve_statement,
-            resolver::value::resolve_value,
-        },
+        preprocessor::module::Module,
         shared::value::Value,
         store::global::GlobalStore,
     },
@@ -17,7 +13,7 @@ pub fn resolve_spawn(
     name: String,
     args: Vec<Value>,
     module: &Module,
-    path: &str,
+    _path: &str,
     global_store: &mut GlobalStore
 ) -> Statement {
     let logger = Logger::new();
@@ -74,19 +70,4 @@ pub fn resolve_spawn(
     }
 }
 
-fn get_group_body(stmt_box: &Statement) -> Vec<Statement> {
-    if let Value::Block(body) = &stmt_box.value { body.clone() } else { vec![] }
-}
-
-fn error_stmt(logger: &Logger, module: &Module, stmt: &Statement, message: &str) -> Statement {
-    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-    logger.log_message(LogLevel::Error, &format!("{message}\n  → at {stacktrace}"));
-
-    Statement {
-        kind: StatementKind::Error {
-            message: message.to_string(),
-        },
-        value: Value::Null,
-        ..stmt.clone()
-    }
-}
+// (removed unused helpers get_group_body, error_stmt)

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

@@ -11,7 +11,7 @@ use crate::{
 pub fn resolve_tempo(
     stmt: &Statement,
     module: &Module,
-    path: &str,
+    _path: &str,
     _global_store: &GlobalStore
 ) -> Statement {
     let mut new_stmt = stmt.clone();

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

@@ -14,7 +14,7 @@ pub fn resolve_trigger(
     stmt: &Statement,
     entity: &str,
     duration: &mut Duration,
-    effects: Option<Value>,
+    _effects: Option<Value>,
     module: &Module,
     path: &str,
     global_store: &GlobalStore
@@ -22,7 +22,6 @@ pub fn resolve_trigger(
     let logger = Logger::new();
 
     let mut final_duration = duration.clone();
-    let mut final_value = stmt.value.clone();
 
     // Duration resolution
     if let Duration::Identifier(ident) = duration {
@@ -43,7 +42,7 @@ pub fn resolve_trigger(
     }
 
     // Params value resolution
-    final_value = match &stmt.value {
+    let final_value = match &stmt.value {
         Value::Identifier(ident) => {
             println!("Resolving identifier: {}", ident);
 

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

@@ -1,14 +1,10 @@
 use std::collections::HashMap;
 
-use crate::{
-    core::{
-        parser::statement::{ Statement, StatementKind },
+use crate::core::{
         preprocessor::{ module::Module, resolver::driver::resolve_statement },
         shared::value::Value,
-        store::{ global::GlobalStore, variable::VariableTable },
-    },
-    utils::logger::{ LogLevel, Logger },
-};
+        store::global::GlobalStore,
+    };
 
 fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
     for (_path, module) in &global_store.modules {
@@ -23,8 +19,7 @@ fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
 pub fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
     match value {
         Value::String(s) => {
-            println!("Resolving value: {}", s);
-
+            // Keep raw strings as-is; they may be runtime-evaluated (e.g., expressions)
             Value::String(s.clone())
         },
 
@@ -37,9 +32,8 @@ pub fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalSt
                 return resolve_value(&export_val, module, global_store);
             }
 
-            println!("⚠️ Unresolved identifier '{}'", name);
-
-            Value::Null
+            // Leave unresolved identifiers as-is; may be runtime-bound (e.g., foreach variable)
+            Value::Identifier(name.clone())
         }
 
         Value::Map(map) => {

package/rust/core/shared/bank.rs

@@ -1,4 +1,4 @@
-use serde::{ Deserialize, Serialize };
+use serde::Deserialize;
 
 #[derive(Debug, Deserialize)]
 pub struct BankInfo {

package/rust/core/utils/path.rs

@@ -1,4 +1,4 @@
-use std::path::{ Component, Path, PathBuf };
+use std::path::{ Path, PathBuf };
 
 pub fn find_entry_file(entry: &str) -> Option<String> {
     let path = Path::new(entry);

package/rust/core/utils/validation.rs

@@ -1,4 +1,3 @@
-use crate::core::{ preprocessor::module::Module, shared::value::Value, store::global::GlobalStore };
 
 // NOTE: Deprecated functions, kept for reference
 

package/rust/installer/bank.rs

@@ -59,7 +59,7 @@ pub async fn install_bank(name: &str, target_dir: &Path) -> Result<(), String> {
         format!("Failed to extract: {}", e)
     )?;
 
-    add_bank_to_config(&mut config, &extract_path, &dependency_path);
+    add_bank_to_config(&mut config, &extract_path, dependency_path);
 
     Ok(())
 }