ruchy 4.2.1

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
110
111
112
113
114
115

#![allow(missing_docs)]
//! RED TEST for Issue #39: Match with if-else in arm causes parser error
//!
//! BUG: Parser fails when match arm contains if-else block
//! Error: "Expected `RightBrace`, found Match"
//!
//! Extreme TDD: RED → GREEN → REFACTOR

use assert_cmd::Command;

fn ruchy_cmd() -> Command {
    assert_cmd::cargo::cargo_bin_cmd!("ruchy")
}

/// RED TEST: Minimal reproduction of Issue #39
/// Parser should accept match with if-else in arm
#[test]
fn test_issue_39_match_with_if_else_in_arm() {
    let code = r#"
enum Result {
    Ok(i32),
    Err(String)
}

fun test() {
    match Result::Ok(42) {
        Result::Ok(x) => {
            if x > 0 {
                println("positive")
            } else {
                println("negative")
            }
        },
        Result::Err(msg) => println(msg)
    }
}

test()
"#;

    // RED: This test will FAIL with parser error
    ruchy_cmd().arg("-e").arg(code).assert().success(); // Expected: parser accepts the code
}

/// RED TEST: Original Issue #39 case with Box and recursive call
#[test]
#[ignore = "Box in enum variants not fully supported"]
fn test_issue_39_algorithm_w_lookup_pattern() {
    let code = r#"
enum TypeEnv {
    Empty,
    Extend(String, Box<TypeEnv>)
}

enum InferResult {
    Success,
    Failure(String)
}

fun lookup(env: TypeEnv, name: String) -> InferResult {
    match env {
        TypeEnv::Empty => InferResult::Failure("Not found".to_string()),
        TypeEnv::Extend(var, rest) => {
            if var == name {
                InferResult::Success
            } else {
                lookup(*rest, name)
            }
        }
    }
}

fun main() {
    let env = TypeEnv::Extend("x".to_string(), Box::new(TypeEnv::Empty));
    let result = lookup(env, "x".to_string());
    println("Done");
}

main();
"#;

    // RED: This test will FAIL with parser error
    ruchy_cmd().arg("-e").arg(code).assert().success();
}

/// RED TEST: Match with nested if-else-if chain
#[test]
fn test_issue_39_match_with_nested_if_else_if() {
    let code = r#"
enum Color {
    RGB(i32, i32, i32)
}

fun classify(c: Color) {
    match c {
        Color::RGB(r, g, b) => {
            if r > 200 {
                println("bright red")
            } else if g > 200 {
                println("bright green")
            } else if b > 200 {
                println("bright blue")
            } else {
                println("dark")
            }
        }
    }
}

classify(Color::RGB(255, 0, 0))
"#;

    // RED: This test will FAIL with parser error
    ruchy_cmd().arg("-e").arg(code).assert().success();
}