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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Examples demonstrating async/await functionality in Ruchy
//!
//! Run with: `cargo run --example async_await`
#![allow(clippy::print_stdout)] // Examples should print output
#![allow(clippy::unwrap_used)] // Examples can use unwrap for simplicity

use ruchy::backend::transpiler::Transpiler;
use ruchy::frontend::ast::ExprKind;
use ruchy::frontend::parser::Parser;

fn main() {
    println!("=== Ruchy Async/Await Examples ===\n");

    // Example 1: Async function
    example_async_function();

    // Example 2: Await expression
    example_await();

    // Example 3: Async with error handling
    example_async_error_handling();

    // Example 4: Multiple async operations
    example_multiple_async();
}

fn example_async_function() {
    println!("1. Async Function");
    println!("-----------------");

    let input = r#"
        async fun fetch_data() -> String {
            "data from server"
        }
    "#;
    println!("Input: {input}");

    let ast = Parser::new(input).parse().unwrap();
    let mut transpiler = Transpiler::new();
    let output = transpiler.transpile(&ast).unwrap();

    println!("Transpiled to Rust async function:");
    let output_str = output.to_string();
    if output_str.len() > 100 {
        println!("{}", &output_str[..100]);
    } else {
        println!("{output_str}");
    }
    println!();
}

fn example_await() {
    println!("2. Await Expression");
    println!("-------------------");

    let input = "await fetch_data()";
    println!("Input: {input}");

    let ast = Parser::new(input).parse().unwrap();

    if let ExprKind::Await { expr } = &ast.kind {
        println!("Awaiting expression: {expr:?}");
    }

    let mut transpiler = Transpiler::new();
    let output = transpiler.transpile(&ast).unwrap();
    println!("Transpiled: {output}");
    println!();
}

fn example_async_error_handling() {
    println!("3. Async with Error Handling");
    println!("-----------------------------");

    let input = r"
        async fun fetch_with_retry() -> Result<String, Error> {
            let result = await fetch_data()?
            Ok(result)
        }
    ";
    println!("Input: {input}");

    match Parser::new(input).parse() {
        Ok(ast) => {
            let mut transpiler = Transpiler::new();
            match transpiler.transpile(&ast) {
                Ok(tokens) => {
                    println!("✓ Successfully transpiled async function with error handling");
                    let output = tokens.to_string();
                    if output.contains("async") && output.contains(".await") {
                        println!("  Contains async and .await ✓");
                    }
                }
                Err(e) => println!("✗ Transpilation error: {e}"),
            }
        }
        Err(e) => println!("✗ Parse error: {e}"),
    }
    println!();
}

fn example_multiple_async() {
    println!("4. Multiple Async Operations");
    println!("-----------------------------");

    let examples = vec![
        ("Async block", "async { 42 }"),
        ("Await in expression", "let x = await get_value()"),
        ("Chained await", "await fetch().process()"),
        ("Async lambda", "async |x| x + 1"),
    ];

    for (description, input) in examples {
        println!("{description}: {input}");

        match Parser::new(input).parse() {
            Ok(ast) => {
                let mut transpiler = Transpiler::new();
                match transpiler.transpile(&ast) {
                    Ok(tokens) => {
                        let output = tokens.to_string();
                        if output.contains("async") || output.contains(".await") {
                            println!("  ✓ Contains async/await constructs");
                        } else {
                            println!("  Output: {}", &output[..output.len().min(50)]);
                        }
                    }
                    Err(e) => println!("  ✗ Transpilation error: {e}"),
                }
            }
            Err(e) => println!("  ✗ Parse error: {e}"),
        }
    }

    println!("\n=== Async/Await Examples Complete ===");
}