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

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

@@ -14,13 +14,41 @@ pub fn parse_bank_token(parser: &mut Parser, _global_store: &mut GlobalStore) ->
 
     let bank_value = if let Some(token) = parser.peek_clone() {
         match token.kind {
-            TokenKind::Identifier => {
-                parser.advance();
-                Value::Identifier(token.lexeme.clone())
-            }
-            TokenKind::Number => {
-                parser.advance();
-                Value::Number(token.lexeme.parse::<f32>().unwrap_or(0.0))
+            TokenKind::Identifier | TokenKind::Number => {
+                parser.advance(); // consume identifier or number
+
+                let mut value = token.lexeme.clone();
+
+                // Support namespaced banks: <author>.<bank_name>
+                if let Some(next) = parser.peek_clone() {
+                    if next.kind == TokenKind::Dot {
+                        parser.advance(); // consume '.'
+                        if let Some(last) = parser.peek_clone() {
+                            match last.kind {
+                                TokenKind::Identifier | TokenKind::Number => {
+                                    parser.advance();
+                                    value = format!("{}.{}", value, last.lexeme);
+                                    Value::String(value)
+                                }
+                                _ => Value::Unknown,
+                            }
+                        } else {
+                            Value::Unknown
+                        }
+                    } else {
+                        match token.kind {
+                            TokenKind::Identifier => Value::Identifier(value),
+                            TokenKind::Number => Value::Number(value.parse::<f32>().unwrap_or(0.0)),
+                            _ => Value::Unknown,
+                        }
+                    }
+                } else {
+                    match token.kind {
+                        TokenKind::Identifier => Value::Identifier(value),
+                        TokenKind::Number => Value::Number(value.parse::<f32>().unwrap_or(0.0)),
+                        _ => Value::Unknown,
+                    }
+                }
             }
             _ => Value::Unknown,
         }

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

@@ -16,13 +16,23 @@ pub fn parse_dot_token(
 
     // Parse a single entity (namespace-friendly, stops at newline)
     let mut parts = Vec::new();
+    let current_line = dot_token.line;
 
     while let Some(token) = parser.peek_clone() {
+        // Never cross a newline
+        if token.line != current_line {
+            break;
+        }
         match token.kind {
             TokenKind::Identifier | TokenKind::Number => {
                 parts.push(token.lexeme.clone());
                 parser.advance();
-                if parser.peek_kind() != Some(TokenKind::Dot) {
+                // The separator must be a '.' on the same line, otherwise stop
+                if let Some(next) = parser.peek_clone() {
+                    if next.line != current_line || next.kind != TokenKind::Dot {
+                        break;
+                    }
+                } else {
                     break;
                 }
             }
@@ -51,42 +61,53 @@ pub fn parse_dot_token(
     let mut value = Value::Null;
 
     if let Some(token) = parser.peek_clone() {
-        match token.kind {
+    // Duration and effects map are only valid on the same line
+        if token.line == current_line {
+            match token.kind {
             TokenKind::Number => {
                 let numerator = token.lexeme.clone();
                 parser.advance();
-                if let Some(TokenKind::Slash) = parser.peek_kind() {
-                    parser.advance();
-                    if let Some(denominator_token) = parser.peek_clone() {
-                        if denominator_token.kind == TokenKind::Number {
-                            let denominator = denominator_token.lexeme.clone();
-                            parser.advance();
-                            duration = Duration::Beat(format!("{}/{}", numerator, denominator));
+                    if let Some(peek) = parser.peek_clone() {
+                        if peek.line == current_line {
+                            if let Some(TokenKind::Slash) = parser.peek_kind() {
+                                parser.advance();
+                                if let Some(denominator_token) = parser.peek_clone() {
+                                    if denominator_token.line == current_line && denominator_token.kind == TokenKind::Number {
+                                        let denominator = denominator_token.lexeme.clone();
+                                        parser.advance();
+                                        duration = Duration::Beat(format!("{}/{}", numerator, denominator));
+                                    }
+                                }
+                            } else {
+                                duration = parse_duration(numerator);
+                            }
+                        } else {
+                            duration = parse_duration(numerator);
                         }
+                    } else {
+                        duration = parse_duration(numerator);
                     }
-                } else {
-                    duration = parse_duration(numerator);
-                }
-                if let Some(next) = parser.peek_clone() {
-                    if next.kind == TokenKind::LBrace {
-                        value = parser.parse_map_value().unwrap_or(Value::Null);
+                    if let Some(next) = parser.peek_clone() {
+                        if next.line == current_line && next.kind == TokenKind::LBrace {
+                            value = parser.parse_map_value().unwrap_or(Value::Null);
+                        }
                     }
-                }
             }
             TokenKind::Identifier => {
                 let id = token.lexeme.clone();
                 parser.advance();
                 duration = parse_duration(id);
-                if let Some(next) = parser.peek_clone() {
-                    if next.kind == TokenKind::LBrace {
-                        value = parser.parse_map_value().unwrap_or(Value::Null);
+                    if let Some(next) = parser.peek_clone() {
+                        if next.line == current_line && next.kind == TokenKind::LBrace {
+                            value = parser.parse_map_value().unwrap_or(Value::Null);
+                        }
                     }
-                }
             }
             TokenKind::LBrace => {
-                value = parser.parse_map_value().unwrap_or(Value::Null);
+                    value = parser.parse_map_value().unwrap_or(Value::Null);
+            }
+                _ => {}
             }
-            _ => {}
         }
     }
 

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

@@ -0,0 +1,194 @@
+use std::collections::HashMap;
+
+use crate::core::{
+    lexer::token::{Token, TokenKind},
+    parser::{driver::Parser, statement::{Statement, StatementKind}},
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+// Grammar:
+// automate <identifier>:
+//     param <name> { <percent>% = <number> ... }
+// Produces StatementKind::Automate with value map:
+// { target: Identifier, params: Map<paramName, Map<percent, Number>> }
+pub fn parse_automate_token(
+    parser: &mut Parser,
+    current_token: Token,
+    _global_store: &mut GlobalStore,
+) -> Statement {
+    parser.advance(); // consume 'automate'
+
+    // Expect target identifier
+    let Some(target_token) = parser.peek_clone() else {
+        return Statement::error(current_token, "Expected target after 'automate'".to_string());
+    };
+
+    if target_token.kind != TokenKind::Identifier && target_token.kind != TokenKind::String {
+        return Statement::error(target_token, "Expected valid target after 'automate'".to_string());
+    }
+    parser.advance(); // consume target
+
+    // Expect ':'
+    let Some(colon_token) = parser.peek_clone() else {
+        return Statement::error(target_token, "Expected ':' after automate target".to_string());
+    };
+    if colon_token.kind != TokenKind::Colon {
+        return Statement::error(colon_token, "Expected ':' after automate target".to_string());
+    }
+    parser.advance(); // consume ':'
+
+    let base_indent = current_token.indent;
+
+    // Collect tokens inside block (indented > base_indent)
+    let mut index = parser.token_index;
+    let mut tokens_inside = Vec::new();
+    while index < parser.tokens.len() {
+        let tok = parser.tokens[index].clone();
+        if tok.indent <= base_indent && tok.kind != TokenKind::Newline {
+            break;
+        }
+        tokens_inside.push(tok);
+        index += 1;
+    }
+    parser.token_index = index;
+
+    // Now parse block manually to capture 'param' entries without reusing general parser kinds
+    let mut local = Parser {
+        resolve_modules: parser.resolve_modules,
+        tokens: tokens_inside,
+        token_index: 0,
+        current_module: parser.current_module.clone(),
+        previous: None,
+    };
+
+    let mut params: HashMap<String, Value> = HashMap::new();
+
+    while let Some(tok) = local.peek_clone() {
+        match tok.kind {
+            TokenKind::Identifier if tok.lexeme == "param" => {
+                local.advance(); // consume 'param'
+                // param name
+                let Some(name_tok) = local.peek_clone() else {
+                    return Statement::error(tok, "Expected parameter name after 'param'".to_string());
+                };
+                if name_tok.kind != TokenKind::Identifier && name_tok.kind != TokenKind::String {
+                    return Statement::error(name_tok, "Expected valid parameter name".to_string());
+                }
+                local.advance(); // consume name
+
+                // Expect '{'
+                if !local.match_token(TokenKind::LBrace) {
+                    return Statement::error(name_tok, "Expected '{' to start parameter block".to_string());
+                }
+
+                // Collect entries like: 0% = 0.0
+                let mut envelope: HashMap<String, Value> = HashMap::new();
+                while let Some(inner) = local.peek_clone() {
+                    if inner.kind == TokenKind::RBrace { local.advance(); break; }
+                    // Skip formatting tokens inside the param block
+                    if matches!(inner.kind, TokenKind::Newline | TokenKind::Indent | TokenKind::Dedent | TokenKind::Comma) {
+                        local.advance();
+                        continue;
+                    }
+
+                    // Read percentage token: could be number followed by '%' as Dot or Identifier? '%' not defined.
+                    // Our lexer has no Percent token, so accept either Number or Identifier containing e.g. '0%'.
+                    let percent_token = inner.clone();
+                    local.advance();
+
+                    let percent_key = percent_token.lexeme.clone();
+
+                    // Expect '='
+                    // Skip any stray formatting between key and '='
+                    while let Some(t) = local.peek_kind() {
+                        if matches!(t, TokenKind::Indent | TokenKind::Dedent | TokenKind::Newline) { local.advance(); continue; }
+                        break;
+                    }
+                    if !local.match_token(TokenKind::Equals) {
+                        return Statement::error(percent_token, "Expected '=' in param entry".to_string());
+                    }
+
+                    // Read value (number or identifier)
+                    // Skip formatting before value
+                    while let Some(t) = local.peek_kind() {
+                        if matches!(t, TokenKind::Indent | TokenKind::Dedent | TokenKind::Newline) { local.advance(); continue; }
+                        break;
+                    }
+
+                    let value = if let Some(vtok) = local.peek_clone() {
+                        match vtok.kind {
+                            // Handle negative numbers where '-' is lexed as Arrow
+                            TokenKind::Arrow => {
+                                // Check if next token is a number
+                                let mut num_str = String::from("-");
+                                local.advance(); // consume '-'
+                                if let Some(ntok) = local.peek_clone() {
+                                    if ntok.kind == TokenKind::Number {
+                                        num_str.push_str(&ntok.lexeme);
+                                        local.advance(); // consume number
+                                        if let Some(dot) = local.peek_clone() {
+                                            if dot.kind == TokenKind::Dot {
+                                                local.advance();
+                                                if let Some(frac) = local.peek_clone() {
+                                                    if frac.kind == TokenKind::Number {
+                                                        num_str.push('.');
+                                                        num_str.push_str(&frac.lexeme);
+                                                        local.advance();
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        Value::Number(num_str.parse::<f32>().unwrap_or(0.0))
+                                    } else {
+                                        Value::Unknown
+                                    }
+                                } else {
+                                    Value::Unknown
+                                }
+                            }
+                            TokenKind::Number => {
+                                // Possibly a float with dot
+                                let mut number_str = vtok.lexeme.clone();
+                                local.advance();
+                                if let Some(dot) = local.peek_clone() {
+                                    if dot.kind == TokenKind::Dot {
+                                        local.advance();
+                                        if let Some(frac) = local.peek_clone() {
+                                            if frac.kind == TokenKind::Number {
+                                                number_str.push('.');
+                                                number_str.push_str(&frac.lexeme);
+                                                local.advance();
+                                            }
+                                        }
+                                    }
+                                }
+                                Value::Number(number_str.parse::<f32>().unwrap_or(0.0))
+                            }
+                            TokenKind::Identifier => { local.advance(); Value::Identifier(vtok.lexeme.clone()) }
+                            TokenKind::String => { local.advance(); Value::String(vtok.lexeme.clone()) }
+                            _ => { local.advance(); Value::Unknown }
+                        }
+                    } else { Value::Null };
+
+                    envelope.insert(percent_key, value);
+                }
+
+                params.insert(name_tok.lexeme.clone(), Value::Map(envelope));
+            }
+            _ => { local.advance(); }
+        }
+    }
+
+    let mut value_map = HashMap::new();
+    value_map.insert("target".to_string(), Value::String(target_token.lexeme.clone()));
+    value_map.insert("params".to_string(), Value::Map(params));
+
+    Statement {
+        kind: StatementKind::Automate { target: target_token.lexeme.clone() },
+        value: Value::Map(value_map),
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    }
+}

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

@@ -29,7 +29,6 @@ pub fn parse_function_token(parser: &mut Parser, global_store: &mut GlobalStore)
     parser.advance(); // consume function name
 
     let mut parameters = Vec::new();
-    let mut body = Vec::new();
 
     // Expect '('
     if parser.peek_kind() != Some(TokenKind::LParen) {
@@ -68,8 +67,8 @@ pub fn parse_function_token(parser: &mut Parser, global_store: &mut GlobalStore)
         body_tokens.push(parser.advance().unwrap().clone());
     }
 
-    // arse those tokens into block statements
-    body = parser.parse_block(body_tokens.clone(), global_store);
+    // Parse those tokens into block statements
+    let body = parser.parse_block(body_tokens.clone(), global_store);
 
     // Skip Dedent if present
     if let Some(tok) = parser.peek() {

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

@@ -33,6 +33,22 @@ pub fn parse_let_token(
         return Statement::error(current_token, "Expected '=' after identifier".to_string());
     }
 
+    // If RHS begins with '$' or contains expression tokens ('+', '-', '*', '/', '(', '['),
+    // collect the rest of the line as a raw expression string.
+    if let Some(tok) = parser.peek_clone() {
+        let line = tok.line;
+        if tok.lexeme.starts_with('$') || matches!(tok.kind, TokenKind::Identifier | TokenKind::Number | TokenKind::LParen | TokenKind::LBracket) {
+            // Collect tokens until end of the current line
+            let collected = parser.collect_until(|t| t.line != line || matches!(t.kind, TokenKind::Newline | TokenKind::EOF));
+            let mut text = String::new();
+            for t in collected.iter() {
+                if matches!(t.kind, TokenKind::Newline | TokenKind::EOF) { break; }
+                text.push_str(&t.lexeme);
+            }
+            return Statement { kind: StatementKind::Let { name: identifier }, value: Value::String(text.trim().to_string()), indent: current_token.indent, line: current_token.line, column: current_token.column };
+        }
+    }
+
     let value = match parser.peek_clone() {
         Some(token) if token.kind == TokenKind::Dot => {
             let dot_stmt = parse_dot_token(parser, global_store);

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 }
 }