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

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

@@ -1,107 +1,107 @@
-use devalang_types::Value;
-
-use crate::core::{
-    lexer::token::TokenKind,
-    parser::{
-        driver::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-
-pub fn parse_on_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
-    // consume 'on'
-    let on_tok = match parser.peek_clone() {
-        Some(tok) => tok,
-        None => return Statement::unknown(),
-    };
-    parser.advance();
-
-    // Expect event name identifier
-    let event_tok = match parser.peek_clone() {
-        Some(tok) if tok.kind == TokenKind::Identifier => tok,
-        Some(other) => {
-            return crate::core::parser::statement::error_from_token(
-                other,
-                "Expected event name after 'on'".to_string(),
-            );
-        }
-        None => {
-            return crate::core::parser::statement::error_from_token(
-                on_tok,
-                "Expected event name after 'on'".to_string(),
-            );
-        }
-    };
-    let event_name = event_tok.lexeme.clone();
-    parser.advance();
-
-    // Optional parenthesized args on same line
-    let mut args: Option<Vec<Value>> = None;
-    if parser.peek_kind() == Some(TokenKind::LParen) {
-        parser.advance(); // '('
-        let mut collected: Vec<Value> = Vec::new();
-        // Collect tokens until ')', supporting numbers and identifiers separated by comma
-        while let Some(tok) = parser.peek_clone() {
-            match tok.kind {
-                TokenKind::RParen => {
-                    parser.advance();
-                    break;
-                }
-                TokenKind::Number => {
-                    parser.advance();
-                    collected.push(Value::Number(tok.lexeme.parse().unwrap_or(0.0)));
-                }
-                TokenKind::Identifier => {
-                    parser.advance();
-                    collected.push(Value::Identifier(tok.lexeme));
-                }
-                TokenKind::Comma => {
-                    parser.advance();
-                }
-                TokenKind::Whitespace | TokenKind::Newline => {
-                    parser.advance();
-                }
-                _ => {
-                    break;
-                }
-            }
-        }
-        if !collected.is_empty() {
-            args = Some(collected);
-        }
-    }
-
-    // Expect ':' then block
-    if parser.peek_kind() != Some(TokenKind::Colon) {
-        return crate::core::parser::statement::error_from_token(
-            event_tok,
-            "Expected ':' after event name".to_string(),
-        );
-    }
-    parser.advance(); // consume ':'
-
-    let base_indent = on_tok.indent;
-    let block_tokens = parser.collect_block_tokens(base_indent);
-    // Parse body within current store context
-    let body = parser.parse_block(block_tokens, _global_store);
-
-    let stmt = Statement {
-        kind: StatementKind::On {
-            event: event_name,
-            args,
-            body,
-        },
-        value: Value::Null,
-        indent: on_tok.indent,
-        line: on_tok.line,
-        column: on_tok.column,
-    };
-
-    // Register in global store for later emission
-    if let StatementKind::On { event, .. } = &stmt.kind {
-        _global_store.register_event_handler(event, stmt.clone());
-    }
-
-    stmt
-}
+use devalang_types::Value;
+
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{
+        driver::parser::Parser,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+
+pub fn parse_on_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+    // consume 'on'
+    let on_tok = match parser.peek_clone() {
+        Some(tok) => tok,
+        None => return Statement::unknown(),
+    };
+    parser.advance();
+
+    // Expect event name identifier
+    let event_tok = match parser.peek_clone() {
+        Some(tok) if tok.kind == TokenKind::Identifier => tok,
+        Some(other) => {
+            return crate::core::parser::statement::error_from_token(
+                other,
+                "Expected event name after 'on'".to_string(),
+            );
+        }
+        None => {
+            return crate::core::parser::statement::error_from_token(
+                on_tok,
+                "Expected event name after 'on'".to_string(),
+            );
+        }
+    };
+    let event_name = event_tok.lexeme.clone();
+    parser.advance();
+
+    // Optional parenthesized args on same line
+    let mut args: Option<Vec<Value>> = None;
+    if parser.peek_kind() == Some(TokenKind::LParen) {
+        parser.advance(); // '('
+        let mut collected: Vec<Value> = Vec::new();
+        // Collect tokens until ')', supporting numbers and identifiers separated by comma
+        while let Some(tok) = parser.peek_clone() {
+            match tok.kind {
+                TokenKind::RParen => {
+                    parser.advance();
+                    break;
+                }
+                TokenKind::Number => {
+                    parser.advance();
+                    collected.push(Value::Number(tok.lexeme.parse().unwrap_or(0.0)));
+                }
+                TokenKind::Identifier => {
+                    parser.advance();
+                    collected.push(Value::Identifier(tok.lexeme));
+                }
+                TokenKind::Comma => {
+                    parser.advance();
+                }
+                TokenKind::Whitespace | TokenKind::Newline => {
+                    parser.advance();
+                }
+                _ => {
+                    break;
+                }
+            }
+        }
+        if !collected.is_empty() {
+            args = Some(collected);
+        }
+    }
+
+    // Expect ':' then block
+    if parser.peek_kind() != Some(TokenKind::Colon) {
+        return crate::core::parser::statement::error_from_token(
+            event_tok,
+            "Expected ':' after event name".to_string(),
+        );
+    }
+    parser.advance(); // consume ':'
+
+    let base_indent = on_tok.indent;
+    let block_tokens = parser.collect_block_tokens(base_indent);
+    // Parse body within current store context
+    let body = parser.parse_block(block_tokens, _global_store);
+
+    let stmt = Statement {
+        kind: StatementKind::On {
+            event: event_name,
+            args,
+            body,
+        },
+        value: Value::Null,
+        indent: on_tok.indent,
+        line: on_tok.line,
+        column: on_tok.column,
+    };
+
+    // Register in global store for later emission
+    if let StatementKind::On { event, .. } = &stmt.kind {
+        _global_store.register_event_handler(event, stmt.clone());
+    }
+
+    stmt
+}

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

@@ -1,49 +1,49 @@
-use crate::core::{
-    lexer::token::{Token, TokenKind},
-    parser::{
-        driver::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-
-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));
-    // Accept: print <identifier|string|number|expression>
-    let value = if collected.len() == 1 {
-        match collected[0].kind {
-            TokenKind::Identifier => Value::Identifier(collected[0].lexeme.clone()),
-            TokenKind::String => Value::String(collected[0].lexeme.clone()),
-            TokenKind::Number => {
-                let n = collected[0].lexeme.parse::<f32>().unwrap_or(0.0);
-                Value::Number(n)
-            }
-            _ => Value::String(collected[0].lexeme.clone()),
-        }
-    } else {
-        // Join tokens with spaces to preserve readability for expressions/text
-        let text = collected
-            .iter()
-            .filter(|t| !matches!(t.kind, TokenKind::Newline | TokenKind::EOF))
-            .map(|t| t.lexeme.clone())
-            .collect::<Vec<_>>()
-            .join(" ");
-        Value::String(text.trim().to_string())
-    };
-
-    Statement {
-        kind: StatementKind::Print,
-        value,
-        indent: current_token.indent,
-        line: current_token.line,
-        column: current_token.column,
-    }
-}
+use crate::core::{
+    lexer::token::{Token, TokenKind},
+    parser::{
+        driver::parser::Parser,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+
+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));
+    // Accept: print <identifier|string|number|expression>
+    let value = if collected.len() == 1 {
+        match collected[0].kind {
+            TokenKind::Identifier => Value::Identifier(collected[0].lexeme.clone()),
+            TokenKind::String => Value::String(collected[0].lexeme.clone()),
+            TokenKind::Number => {
+                let n = collected[0].lexeme.parse::<f32>().unwrap_or(0.0);
+                Value::Number(n)
+            }
+            _ => Value::String(collected[0].lexeme.clone()),
+        }
+    } else {
+        // Join tokens with spaces to preserve readability for expressions/text
+        let text = collected
+            .iter()
+            .filter(|t| !matches!(t.kind, TokenKind::Newline | TokenKind::EOF))
+            .map(|t| t.lexeme.clone())
+            .collect::<Vec<_>>()
+            .join(" ");
+        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

@@ -1,43 +1,96 @@
-use devalang_types::Value;
-
-use crate::core::{
-    lexer::token::{Token, TokenKind},
-    parser::{
-        driver::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-
-pub fn parse_sleep_token(
-    parser: &mut Parser,
-    current_token: Token,
-    _global_store: &mut GlobalStore,
-) -> Statement {
-    parser.advance(); // consume "sleep"
-
-    let duration = if let Some(token) = parser.peek_clone() {
-        if token.kind == TokenKind::Number {
-            parser.advance();
-            token.lexeme.parse().unwrap_or(0.0)
-        } else {
-            return crate::core::parser::statement::error_from_token(
-                token,
-                "Expected number after 'sleep'".to_string(),
-            );
-        }
-    } else {
-        return crate::core::parser::statement::error_from_token(
-            current_token,
-            "Expected number after 'sleep'".to_string(),
-        );
-    };
-
-    Statement {
-        kind: StatementKind::Sleep,
-        value: Value::Number(duration),
-        indent: current_token.indent,
-        line: current_token.line,
-        column: current_token.column,
-    }
-}
+use devalang_types::Value;
+
+use crate::core::{
+    lexer::token::{Token, TokenKind},
+    parser::{
+        driver::parser::Parser,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+
+pub fn parse_sleep_token(
+    parser: &mut Parser,
+    current_token: Token,
+    _global_store: &mut GlobalStore,
+) -> Statement {
+    parser.advance(); // consume "sleep"
+
+    // Accept number, decimal, fraction like 1/4 (-> Duration::Beat), string, or identifier
+    let duration_value = if let Some(token) = parser.peek_clone() {
+        match token.kind {
+            TokenKind::Number => {
+                let mut num = token.lexeme.clone();
+                parser.advance();
+                // decimal part
+                if let Some(dot) = parser.peek_clone() {
+                    if dot.kind == TokenKind::Dot {
+                        if let Some(next) = parser.peek_nth(1).cloned() {
+                            if next.kind == TokenKind::Number {
+                                parser.advance(); // consume dot
+                                parser.advance(); // consume next number
+                                num.push('.');
+                                num.push_str(&next.lexeme);
+                            }
+                        }
+                    }
+                }
+
+                // fraction form 1/4 -> Duration::Beat("1/4")
+                if let Some(slash) = parser.peek_clone() {
+                    if slash.kind == TokenKind::Slash {
+                        parser.advance();
+                        if let Some(den) = parser.peek_clone() {
+                            if den.kind == TokenKind::Number || den.kind == TokenKind::Identifier {
+                                let frac = format!("{}/{}", num, den.lexeme);
+                                parser.advance();
+                                Value::Duration(devalang_types::Duration::Beat(frac))
+                            } else {
+                                return crate::core::parser::statement::error_from_token(
+                                    slash,
+                                    "Expected denominator after '/' in sleep".to_string(),
+                                );
+                            }
+                        } else {
+                            return crate::core::parser::statement::error_from_token(
+                                slash,
+                                "Expected denominator after '/' in sleep".to_string(),
+                            );
+                        }
+                    } else {
+                        Value::Number(num.parse().unwrap_or(0.0))
+                    }
+                } else {
+                    Value::Number(num.parse().unwrap_or(0.0))
+                }
+            }
+            TokenKind::String => {
+                parser.advance();
+                Value::String(token.lexeme.clone())
+            }
+            TokenKind::Identifier => {
+                parser.advance();
+                Value::Identifier(token.lexeme.clone())
+            }
+            _ => {
+                return crate::core::parser::statement::error_from_token(
+                    token,
+                    "Expected duration after 'sleep'".to_string(),
+                );
+            }
+        }
+    } else {
+        return crate::core::parser::statement::error_from_token(
+            current_token,
+            "Expected duration after 'sleep'".to_string(),
+        );
+    };
+
+    Statement {
+        kind: StatementKind::Sleep,
+        value: duration_value,
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    }
+}

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

@@ -1,91 +1,91 @@
-use crate::core::{
-    lexer::token::{Token, TokenKind},
-    parser::{
-        driver::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-
-pub fn parse_spawn_token(
-    parser: &mut Parser,
-    current_token: Token,
-    _global_store: &mut GlobalStore,
-) -> Statement {
-    parser.advance(); // consume "spawn"
-
-    // Expect function name
-    let name_token = match parser.peek_clone() {
-        Some(t) => t,
-        None => {
-            return crate::core::parser::statement::error_from_token(
-                current_token,
-                "Expected function name after 'spawn'".to_string(),
-            );
-        }
-    };
-
-    if name_token.kind != TokenKind::Identifier {
-        return crate::core::parser::statement::error_from_token(
-            name_token,
-            "Expected function name to be an identifier".to_string(),
-        );
-    }
-
-    let func_name = name_token.lexeme.clone();
-    parser.advance(); // consume function name
-
-    // Expect '('
-    let mut args: Vec<Value> = Vec::new();
-    if let Some(open_paren) = parser.peek_clone() {
-        if open_paren.kind == TokenKind::LParen {
-            parser.advance(); // consume '('
-
-            // Collect args until ')'
-            while let Some(token) = parser.peek_clone() {
-                if token.kind == TokenKind::RParen {
-                    parser.advance(); // consume ')'
-                    break;
-                }
-
-                match token.kind {
-                    TokenKind::Number => {
-                        if let Ok(num) = token.lexeme.parse::<f32>() {
-                            args.push(Value::Number(num));
-                        }
-                        parser.advance();
-                    }
-                    TokenKind::String => {
-                        args.push(Value::String(token.lexeme.clone()));
-                        parser.advance();
-                    }
-                    TokenKind::Identifier => {
-                        args.push(Value::Identifier(token.lexeme.clone()));
-                        parser.advance();
-                    }
-                    TokenKind::Comma => {
-                        parser.advance(); // skip comma
-                    }
-                    _ => {
-                        return crate::core::parser::statement::error_from_token(
-                            token,
-                            "Unexpected token in spawn arguments".to_string(),
-                        );
-                    }
-                }
-            }
-        }
-    }
-
-    Statement {
-        kind: StatementKind::Spawn {
-            name: func_name,
-            args,
-        },
-        value: Value::Null,
-        indent: current_token.indent,
-        line: current_token.line,
-        column: current_token.column,
-    }
-}
+use crate::core::{
+    lexer::token::{Token, TokenKind},
+    parser::{
+        driver::parser::Parser,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+
+pub fn parse_spawn_token(
+    parser: &mut Parser,
+    current_token: Token,
+    _global_store: &mut GlobalStore,
+) -> Statement {
+    parser.advance(); // consume "spawn"
+
+    // Expect function name
+    let name_token = match parser.peek_clone() {
+        Some(t) => t,
+        None => {
+            return crate::core::parser::statement::error_from_token(
+                current_token,
+                "Expected function name after 'spawn'".to_string(),
+            );
+        }
+    };
+
+    if name_token.kind != TokenKind::Identifier {
+        return crate::core::parser::statement::error_from_token(
+            name_token,
+            "Expected function name to be an identifier".to_string(),
+        );
+    }
+
+    let func_name = name_token.lexeme.clone();
+    parser.advance(); // consume function name
+
+    // Expect '('
+    let mut args: Vec<Value> = Vec::new();
+    if let Some(open_paren) = parser.peek_clone() {
+        if open_paren.kind == TokenKind::LParen {
+            parser.advance(); // consume '('
+
+            // Collect args until ')'
+            while let Some(token) = parser.peek_clone() {
+                if token.kind == TokenKind::RParen {
+                    parser.advance(); // consume ')'
+                    break;
+                }
+
+                match token.kind {
+                    TokenKind::Number => {
+                        if let Ok(num) = token.lexeme.parse::<f32>() {
+                            args.push(Value::Number(num));
+                        }
+                        parser.advance();
+                    }
+                    TokenKind::String => {
+                        args.push(Value::String(token.lexeme.clone()));
+                        parser.advance();
+                    }
+                    TokenKind::Identifier => {
+                        args.push(Value::Identifier(token.lexeme.clone()));
+                        parser.advance();
+                    }
+                    TokenKind::Comma => {
+                        parser.advance(); // skip comma
+                    }
+                    _ => {
+                        return crate::core::parser::statement::error_from_token(
+                            token,
+                            "Unexpected token in spawn arguments".to_string(),
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    Statement {
+        kind: StatementKind::Spawn {
+            name: func_name,
+            args,
+        },
+        value: Value::Null,
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    }
+}