ruchy 4.1.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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

// Example: RUNTIME-092 Enum Variable Cast Support (GitHub Issue #79)
//
// Demonstrates enum variable casts to integer types
// Run with: cargo run --example runtime_092_enum_cast

fn main() {
    println!("=== RUNTIME-092: Enum Variable Cast Examples ===\n");

    // Example 1: Basic enum variable cast
    println!("Example 1: Basic enum variable cast");
    let code1 = r#"
enum LogLevel {
    Debug = 0,
    Info = 1,
    Warn = 2,
    Error = 3,
}

fun main() {
    let level = LogLevel::Info;
    let level_int = level as i32;
    println("Level value: ");
    println(level_int);
}
"#;
    run_example(code1);

    // Example 2: Multiple enum variables
    println!("\nExample 2: Multiple enum variables");
    let code2 = r#"
enum Status {
    Pending = 10,
    Active = 20,
    Complete = 30,
}

fun main() {
    let s1 = Status::Pending;
    let s2 = Status::Active;
    let s3 = Status::Complete;

    println("Pending: ");
    println(s1 as i32);
    println("Active: ");
    println(s2 as i32);
    println("Complete: ");
    println(s3 as i32);
}
"#;
    run_example(code2);

    // Example 3: Enum casts in arithmetic expressions
    println!("\nExample 3: Enum casts in arithmetic");
    let code3 = r#"
enum Priority {
    Low = 1,
    Medium = 5,
    High = 10,
}

fun main() {
    let p = Priority::Medium;
    let doubled = (p as i32) * 2;
    println("Priority doubled: ");
    println(doubled);

    let p2 = Priority::High;
    let sum = (p as i32) + (p2 as i32);
    println("Priority sum: ");
    println(sum);
}
"#;
    run_example(code3);

    // Example 4: Cast to different integer types
    println!("\nExample 4: Cast to different integer types");
    let code4 = r#"
enum Value {
    X = 42,
}

fun main() {
    let v1 = Value::X;
    let as_i32 = v1 as i32;

    let v2 = Value::X;
    let as_i64 = v2 as i64;

    let v3 = Value::X;
    let as_isize = v3 as isize;

    println("i32: ");
    println(as_i32);
    println("i64: ");
    println(as_i64);
    println("isize: ");
    println(as_isize);
}
"#;
    run_example(code4);

    // Example 5: Direct enum literal cast (v3.147.3 feature)
    println!("\nExample 5: Direct enum literal cast");
    let code5 = r#"
enum Color {
    Red = 0xFF0000,
    Green = 0x00FF00,
    Blue = 0x0000FF,
}

fun main() {
    let red_val = Color::Red as i32;
    println("Red color code: ");
    println(red_val);

    let blue = Color::Blue;
    let blue_val = blue as i32;
    println("Blue color code: ");
    println(blue_val);
}
"#;
    run_example(code5);

    println!("\n=== All examples completed successfully ===");
}

fn run_example(code: &str) {
    use std::process::{Command, Stdio};

    let child = Command::new("./target/debug/ruchy")
        .arg("-e")
        .arg(code)
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .expect("Failed to spawn ruchy process");

    let output = child
        .wait_with_output()
        .expect("Failed to wait for ruchy process");

    if output.status.success() {
        print!("{}", String::from_utf8_lossy(&output.stdout));
    } else {
        eprintln!("Error: {}", String::from_utf8_lossy(&output.stderr));
        std::process::exit(1);
    }
}