ruchy 4.2.0

A systems scripting language that transpiles to idiomatic Rust with extreme quality engineering
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

#![cfg(test)]
#![allow(missing_docs)]
#![allow(warnings)]
#![allow(clippy::assertions_on_constants)]
#![allow(clippy::unreadable_literal)]
#![allow(clippy::unwrap_used)]
//! Critical REPL Feature Tests
//! These tests MUST pass or the product is broken

use ruchy::runtime::repl::Repl;
use ruchy::runtime::Value;
use std::env;
use std::sync::Arc;

#[test]
fn test_one_liner_execution() {
    let mut repl = Repl::new(std::env::temp_dir()).unwrap();
    let result = repl.evaluate_expr_str("2 + 2", None).unwrap();
    assert_eq!(result, Value::Integer(4));
}

#[test]
fn test_function_definition_and_call() {
    let mut repl = Repl::new(std::env::temp_dir()).unwrap();
    // Define function
    repl.evaluate_expr_str("fun add(a: i32, b: i32) -> i32 { a + b }", None)
        .unwrap();

    // Call function
    let result = repl.evaluate_expr_str("add(5, 3)", None).unwrap();
    assert_eq!(result, Value::Integer(8));
}

#[test]
fn test_match_expressions() {
    let mut repl = Repl::new(std::env::temp_dir()).unwrap();
    let result = repl
        .evaluate_expr_str(r#"match 2 { 1 => "one", 2 => "two", _ => "other" }"#, None)
        .unwrap();
    assert_eq!(result, Value::String(Arc::from("two")));
}

#[test]
fn test_block_returns_last_value() {
    let mut repl = Repl::new(std::env::temp_dir()).unwrap();
    let result = repl
        .evaluate_expr_str("{ let a = 5; let b = 10; a + b }", None)
        .unwrap();
    assert_eq!(result, Value::Integer(15));
}

#[test]
fn test_for_loops() {
    let mut repl = Repl::new(std::env::temp_dir()).unwrap();
    // For loop should return unit
    let result = repl
        .evaluate_expr_str("for i in [1, 2, 3] { println(i) }", None)
        .unwrap();
    assert_eq!(result, Value::Nil);
}

#[test]
fn test_while_loops() {
    let mut repl = Repl::new(std::env::temp_dir()).unwrap();
    repl.evaluate_expr_str("let mut x = 0", None).unwrap();
    repl.evaluate_expr_str("while x < 3 { x = x + 1 }", None)
        .unwrap();
    let result = repl.evaluate_expr_str("x", None).unwrap();
    assert_eq!(result, Value::Integer(3));
}

#[test]
fn test_string_interpolation() {
    let mut repl = Repl::new(std::env::temp_dir()).unwrap();
    repl.evaluate_expr_str(r#"let name = "World""#, None)
        .unwrap();
    let result = repl.evaluate_expr_str(r#"f"Hello {name}""#, None).unwrap();
    assert_eq!(result, Value::String(Arc::from("Hello World")));
}

#[test]
fn test_list_display() {
    let mut repl = Repl::new(std::env::temp_dir()).unwrap();
    let result = repl.evaluate_expr_str("[1, 2, 3]", None).unwrap();
    assert_eq!(
        result,
        Value::Array(vec![Value::Integer(1), Value::Integer(2), Value::Integer(3)].into())
    );
}

#[test]
fn test_variable_persistence() {
    let mut repl = Repl::new(std::env::temp_dir()).unwrap();
    repl.evaluate_expr_str("let x = 42", None).unwrap();
    repl.evaluate_expr_str("let y = 58", None).unwrap();
    let result = repl.evaluate_expr_str("x + y", None).unwrap();
    assert_eq!(result, Value::Integer(100));
}

#[test]
fn test_nested_functions() {
    let mut repl = Repl::new(std::env::temp_dir()).unwrap();
    repl.evaluate_expr_str("fun double(x: i32) -> i32 { x * 2 }", None)
        .unwrap();
    repl.evaluate_expr_str("fun quadruple(x: i32) -> i32 { double(double(x)) }", None)
        .unwrap();
    let result = repl.evaluate_expr_str("quadruple(5)", None).unwrap();
    assert_eq!(result, Value::Integer(20));
}