@devaloop/devalang 0.0.1-beta.2 → 0.0.1-beta.3

package/rust/core/lexer/handler/string.rs

@@ -1,63 +1,63 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_string_lexer(
-    ch: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    _indent_stack: &mut [usize],
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize,
-) {
-    let quote_char = ch;
-
-    let start_column = *column;
-    let start_line = *line;
-
-    *column += 1;
-
-    let mut string_content = String::new();
-
-    while let Some(&next_ch) = chars.peek() {
-        if next_ch == quote_char {
-            chars.next();
-            *column += 1;
-            break;
-        } else if next_ch == '\\' {
-            chars.next();
-            *column += 1;
-
-            if let Some(escaped) = chars.next() {
-                match escaped {
-                    'n' => string_content.push('\n'),
-                    't' => string_content.push('\t'),
-                    '\\' => string_content.push('\\'),
-                    '"' => string_content.push('"'),
-                    '\'' => string_content.push('\''),
-                    other => {
-                        string_content.push('\\');
-                        string_content.push(other);
-                    }
-                }
-                *column += 1;
-            }
-        } else {
-            chars.next();
-            if next_ch == '\n' {
-                *line += 1;
-                *column = 1;
-            } else {
-                *column += 1;
-            }
-            string_content.push(next_ch);
-        }
-    }
-
-    tokens.push(Token {
-        kind: TokenKind::String,
-        lexeme: string_content,
-        indent: *current_indent,
-        line: start_line,
-        column: start_column,
-    });
-}
+use crate::core::lexer::token::{Token, TokenKind};
+
+pub fn handle_string_lexer(
+    ch: char,
+    chars: &mut std::iter::Peekable<std::str::Chars>,
+    current_indent: &mut usize,
+    _indent_stack: &mut [usize],
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize,
+) {
+    let quote_char = ch;
+
+    let start_column = *column;
+    let start_line = *line;
+
+    *column += 1;
+
+    let mut string_content = String::new();
+
+    while let Some(&next_ch) = chars.peek() {
+        if next_ch == quote_char {
+            chars.next();
+            *column += 1;
+            break;
+        } else if next_ch == '\\' {
+            chars.next();
+            *column += 1;
+
+            if let Some(escaped) = chars.next() {
+                match escaped {
+                    'n' => string_content.push('\n'),
+                    't' => string_content.push('\t'),
+                    '\\' => string_content.push('\\'),
+                    '"' => string_content.push('"'),
+                    '\'' => string_content.push('\''),
+                    other => {
+                        string_content.push('\\');
+                        string_content.push(other);
+                    }
+                }
+                *column += 1;
+            }
+        } else {
+            chars.next();
+            if next_ch == '\n' {
+                *line += 1;
+                *column = 1;
+            } else {
+                *column += 1;
+            }
+            string_content.push(next_ch);
+        }
+    }
+
+    tokens.push(Token {
+        kind: TokenKind::String,
+        lexeme: string_content,
+        indent: *current_indent,
+        line: start_line,
+        column: start_column,
+    });
+}

package/rust/core/lexer/mod.rs

@@ -1,3 +1,3 @@
-pub mod driver;
-pub mod handler;
-pub mod token;
+pub mod driver;
+pub mod handler;
+pub mod token;

package/rust/core/mod.rs

@@ -1,9 +1,9 @@
-pub mod audio;
-pub mod builder;
-pub mod debugger;
-pub mod error;
-pub mod lexer;
-pub mod parser;
-pub mod plugin;
-pub mod preprocessor;
-pub mod store;
+pub mod audio;
+pub mod builder;
+pub mod debugger;
+pub mod error;
+pub mod lexer;
+pub mod parser;
+pub mod plugin;
+pub mod preprocessor;
+pub mod store;

package/rust/core/parser/driver/block.rs

@@ -1,111 +1,111 @@
-use crate::core::lexer::token::Token;
-use crate::core::lexer::token::TokenKind;
-use crate::core::store::global::GlobalStore;
-
-pub fn collect_block_tokens(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-    base_indent: usize,
-) -> Vec<Token> {
-    let mut tokens = Vec::new();
-
-    while let Some(tok) = parser.peek() {
-        if tok.indent <= base_indent && tok.kind != TokenKind::Newline {
-            break;
-        }
-        if let Some(t) = parser.advance() {
-            tokens.push(t.clone());
-        } else {
-            // Unexpected EOF while collecting block tokens: stop collecting
-            break;
-        }
-    }
-
-    tokens
-}
-
-pub fn collect_until<F>(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-    condition: F,
-) -> Vec<Token>
-where
-    F: Fn(&Token) -> bool,
-{
-    let mut collected = Vec::new();
-    while let Some(token) = parser.peek() {
-        if condition(token) {
-            break;
-        }
-        if token.kind == TokenKind::EOF {
-            break;
-        }
-        if let Some(t) = parser.advance() {
-            collected.push(t.clone());
-        } else {
-            break;
-        }
-    }
-
-    collected
-}
-
-pub fn parse_block(
-    parser: &crate::core::parser::driver::parser::Parser,
-    tokens: Vec<Token>,
-    global_store: &mut GlobalStore,
-) -> Vec<crate::core::parser::statement::Statement> {
-    let mut inner_parser = crate::core::parser::driver::parser::Parser {
-        resolve_modules: parser.resolve_modules,
-        tokens,
-        token_index: 0,
-        current_module: parser.current_module.clone(),
-        previous: None,
-    };
-
-    inner_parser.parse_tokens(inner_parser.tokens.clone(), global_store)
-}
-
-pub fn parse_block_until_next_else(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-    base_indent: usize,
-    global_store: &mut GlobalStore,
-) -> Vec<crate::core::parser::statement::Statement> {
-    let mut block_tokens = Vec::new();
-
-    while let Some(tok) = parser.peek() {
-        // Stop if we encounter an 'else' at same indent level
-        if tok.lexeme == "else" && tok.indent == base_indent {
-            break;
-        }
-        if let Some(t) = parser.advance() {
-            block_tokens.push(t.clone());
-        } else {
-            break;
-        }
-    }
-
-    parse_block(parser, block_tokens, global_store)
-}
-
-pub fn parse_block_until_else_or_dedent(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-    base_indent: usize,
-    global_store: &mut GlobalStore,
-) -> Vec<crate::core::parser::statement::Statement> {
-    let mut tokens = Vec::new();
-
-    while let Some(tok) = parser.peek() {
-        if tok.lexeme == "else" && tok.indent == base_indent {
-            break;
-        }
-        if tok.indent < base_indent && tok.kind != TokenKind::Newline {
-            break;
-        }
-        if let Some(t) = parser.advance() {
-            tokens.push(t.clone());
-        } else {
-            break;
-        }
-    }
-
-    parse_block(parser, tokens, global_store)
-}
+use crate::core::lexer::token::Token;
+use crate::core::lexer::token::TokenKind;
+use crate::core::store::global::GlobalStore;
+
+pub fn collect_block_tokens(
+    parser: &mut crate::core::parser::driver::parser::Parser,
+    base_indent: usize,
+) -> Vec<Token> {
+    let mut tokens = Vec::new();
+
+    while let Some(tok) = parser.peek() {
+        if tok.indent <= base_indent && tok.kind != TokenKind::Newline {
+            break;
+        }
+        if let Some(t) = parser.advance() {
+            tokens.push(t.clone());
+        } else {
+            // Unexpected EOF while collecting block tokens: stop collecting
+            break;
+        }
+    }
+
+    tokens
+}
+
+pub fn collect_until<F>(
+    parser: &mut crate::core::parser::driver::parser::Parser,
+    condition: F,
+) -> Vec<Token>
+where
+    F: Fn(&Token) -> bool,
+{
+    let mut collected = Vec::new();
+    while let Some(token) = parser.peek() {
+        if condition(token) {
+            break;
+        }
+        if token.kind == TokenKind::EOF {
+            break;
+        }
+        if let Some(t) = parser.advance() {
+            collected.push(t.clone());
+        } else {
+            break;
+        }
+    }
+
+    collected
+}
+
+pub fn parse_block(
+    parser: &crate::core::parser::driver::parser::Parser,
+    tokens: Vec<Token>,
+    global_store: &mut GlobalStore,
+) -> Vec<crate::core::parser::statement::Statement> {
+    let mut inner_parser = crate::core::parser::driver::parser::Parser {
+        resolve_modules: parser.resolve_modules,
+        tokens,
+        token_index: 0,
+        current_module: parser.current_module.clone(),
+        previous: None,
+    };
+
+    inner_parser.parse_tokens(inner_parser.tokens.clone(), global_store)
+}
+
+pub fn parse_block_until_next_else(
+    parser: &mut crate::core::parser::driver::parser::Parser,
+    base_indent: usize,
+    global_store: &mut GlobalStore,
+) -> Vec<crate::core::parser::statement::Statement> {
+    let mut block_tokens = Vec::new();
+
+    while let Some(tok) = parser.peek() {
+        // Stop if we encounter an 'else' at same indent level
+        if tok.lexeme == "else" && tok.indent == base_indent {
+            break;
+        }
+        if let Some(t) = parser.advance() {
+            block_tokens.push(t.clone());
+        } else {
+            break;
+        }
+    }
+
+    parse_block(parser, block_tokens, global_store)
+}
+
+pub fn parse_block_until_else_or_dedent(
+    parser: &mut crate::core::parser::driver::parser::Parser,
+    base_indent: usize,
+    global_store: &mut GlobalStore,
+) -> Vec<crate::core::parser::statement::Statement> {
+    let mut tokens = Vec::new();
+
+    while let Some(tok) = parser.peek() {
+        if tok.lexeme == "else" && tok.indent == base_indent {
+            break;
+        }
+        if tok.indent < base_indent && tok.kind != TokenKind::Newline {
+            break;
+        }
+        if let Some(t) = parser.advance() {
+            tokens.push(t.clone());
+        } else {
+            break;
+        }
+    }
+
+    parse_block(parser, tokens, global_store)
+}

package/rust/core/parser/driver/cursor.rs

@@ -1,82 +1,82 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn advance_impl(parser: &mut crate::core::parser::driver::parser::Parser) -> Option<&Token> {
-    if is_eof_impl(parser) {
-        return None;
-    }
-
-    parser.previous = parser.tokens.get(parser.token_index).cloned();
-    parser.token_index += 1;
-
-    parser.tokens.get(parser.token_index - 1)
-}
-
-pub fn peek_impl(parser: &crate::core::parser::driver::parser::Parser) -> Option<&Token> {
-    parser.tokens.get(parser.token_index)
-}
-
-pub fn peek_clone_impl(parser: &crate::core::parser::driver::parser::Parser) -> Option<Token> {
-    parser.tokens.get(parser.token_index).cloned()
-}
-
-pub fn peek_nth_impl(
-    parser: &crate::core::parser::driver::parser::Parser,
-    n: usize,
-) -> Option<&Token> {
-    if parser.token_index + n < parser.tokens.len() {
-        parser.tokens.get(parser.token_index + n)
-    } else {
-        None
-    }
-}
-
-pub fn peek_nth_kind_impl(
-    parser: &crate::core::parser::driver::parser::Parser,
-    n: usize,
-) -> Option<TokenKind> {
-    peek_nth_impl(parser, n).map(|t| t.kind.clone())
-}
-
-pub fn is_eof_impl(parser: &crate::core::parser::driver::parser::Parser) -> bool {
-    parser.token_index >= parser.tokens.len()
-}
-
-pub fn previous_clone_impl(parser: &crate::core::parser::driver::parser::Parser) -> Option<Token> {
-    parser.previous.clone()
-}
-
-pub fn match_token_impl(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-    kind: TokenKind,
-) -> bool {
-    if let Some(tok) = peek_impl(parser) {
-        if tok.kind == kind {
-            advance_impl(parser);
-            return true;
-        }
-    }
-    false
-}
-
-pub fn advance_if_impl(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-    kind: TokenKind,
-) -> bool {
-    match_token_impl(parser, kind)
-}
-
-pub fn peek_is_impl(parser: &crate::core::parser::driver::parser::Parser, expected: &str) -> bool {
-    peek_impl(parser).is_some_and(|t| t.lexeme == expected)
-}
-
-pub fn expect_impl(
-    parser: &mut crate::core::parser::driver::parser::Parser,
-    kind: TokenKind,
-) -> Result<&Token, String> {
-    let tok = advance_impl(parser).ok_or("Unexpected end of input")?;
-    if tok.kind == kind {
-        Ok(tok)
-    } else {
-        Err(format!("Expected {:?}, got {:?}", kind, tok.kind))
-    }
-}
+use crate::core::lexer::token::{Token, TokenKind};
+
+pub fn advance_impl(parser: &mut crate::core::parser::driver::parser::Parser) -> Option<&Token> {
+    if is_eof_impl(parser) {
+        return None;
+    }
+
+    parser.previous = parser.tokens.get(parser.token_index).cloned();
+    parser.token_index += 1;
+
+    parser.tokens.get(parser.token_index - 1)
+}
+
+pub fn peek_impl(parser: &crate::core::parser::driver::parser::Parser) -> Option<&Token> {
+    parser.tokens.get(parser.token_index)
+}
+
+pub fn peek_clone_impl(parser: &crate::core::parser::driver::parser::Parser) -> Option<Token> {
+    parser.tokens.get(parser.token_index).cloned()
+}
+
+pub fn peek_nth_impl(
+    parser: &crate::core::parser::driver::parser::Parser,
+    n: usize,
+) -> Option<&Token> {
+    if parser.token_index + n < parser.tokens.len() {
+        parser.tokens.get(parser.token_index + n)
+    } else {
+        None
+    }
+}
+
+pub fn peek_nth_kind_impl(
+    parser: &crate::core::parser::driver::parser::Parser,
+    n: usize,
+) -> Option<TokenKind> {
+    peek_nth_impl(parser, n).map(|t| t.kind.clone())
+}
+
+pub fn is_eof_impl(parser: &crate::core::parser::driver::parser::Parser) -> bool {
+    parser.token_index >= parser.tokens.len()
+}
+
+pub fn previous_clone_impl(parser: &crate::core::parser::driver::parser::Parser) -> Option<Token> {
+    parser.previous.clone()
+}
+
+pub fn match_token_impl(
+    parser: &mut crate::core::parser::driver::parser::Parser,
+    kind: TokenKind,
+) -> bool {
+    if let Some(tok) = peek_impl(parser) {
+        if tok.kind == kind {
+            advance_impl(parser);
+            return true;
+        }
+    }
+    false
+}
+
+pub fn advance_if_impl(
+    parser: &mut crate::core::parser::driver::parser::Parser,
+    kind: TokenKind,
+) -> bool {
+    match_token_impl(parser, kind)
+}
+
+pub fn peek_is_impl(parser: &crate::core::parser::driver::parser::Parser, expected: &str) -> bool {
+    peek_impl(parser).is_some_and(|t| t.lexeme == expected)
+}
+
+pub fn expect_impl(
+    parser: &mut crate::core::parser::driver::parser::Parser,
+    kind: TokenKind,
+) -> Result<&Token, String> {
+    let tok = advance_impl(parser).ok_or("Unexpected end of input")?;
+    if tok.kind == kind {
+        Ok(tok)
+    } else {
+        Err(format!("Expected {:?}, got {:?}", kind, tok.kind))
+    }
+}

package/rust/core/parser/driver/driver_impl.rs

@@ -1,4 +1,5 @@
 use crate::core::lexer::token::TokenKind;
+use crate::core::parser::statement::StatementKind;
 use crate::core::store::global::GlobalStore;
 use devalang_types::Value;
 
@@ -30,7 +31,25 @@ pub fn parse_tokens_impl(
             continue;
         }
 
-        let statement = match &token.kind {
+        // If the line starts with an Arrow ("->"), treat it as a continuation of the
+        // previous arrow call: reuse the target from the last parsed ArrowCall statement
+        // so chained effects on subsequent lines are supported.
+        let statement = if token.kind == TokenKind::Arrow {
+            // find previous ArrowCall target if any
+            let prev_target = statements.last().and_then(
+                |s: &crate::core::parser::statement::Statement| match &s.kind {
+                    StatementKind::ArrowCall { target, .. } => Some(target.clone()),
+                    _ => None,
+                },
+            );
+
+            crate::core::parser::handler::arrow_call::parse_arrow_continuation(
+                parser,
+                global_store,
+                prev_target,
+            )
+        } else {
+            match &token.kind {
             TokenKind::At => crate::core::parser::handler::at::parse_at_token(parser, global_store),
             TokenKind::Identifier => {
                 if
@@ -112,6 +131,7 @@ pub fn parse_tokens_impl(
                     token.column
                 )
             }
+            }
         };
 
         statements.push(statement);

package/rust/core/parser/driver/mod.rs

@@ -1,6 +1,6 @@
-pub mod block;
-pub mod cursor;
-pub mod driver_impl;
-pub mod parse_array;
-pub mod parse_map;
-pub mod parser;
+pub mod block;
+pub mod cursor;
+pub mod driver_impl;
+pub mod parse_array;
+pub mod parse_map;
+pub mod parser;