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

#![allow(clippy::uninlined_format_args, clippy::print_stdout)]
use ruchy::{Parser, Transpiler};

fn main() {
    let inputs = vec!["let x = 10", "x", "let y = 20", "x + y"];

    for input in inputs {
        println!("\n=== Testing: {} ===", input);
        let mut parser = Parser::new(input);
        match parser.parse() {
            Ok(ast) => {
                println!("AST kind: {:?}", ast.kind);

                let mut transpiler = Transpiler::new();
                match transpiler.transpile(&ast) {
                    Ok(tokens) => {
                        let code = tokens.to_string();
                        println!("Transpiled: '{}'", code);
                        println!("Length: {}", code.len());
                        println!("Ends with semicolon: {}", code.ends_with(';'));

                        // Check if it's a let statement
                        if matches!(ast.kind, ruchy::ExprKind::Let { .. }) {
                            println!("This is a let statement, needs semicolon!");
                            if !code.ends_with(';') {
                                let fixed = format!("{};", code);
                                println!("Fixed: '{}'", fixed);
                            }
                        }
                    }
                    Err(e) => println!("Transpile error: {}", e),
                }
            }
            Err(e) => println!("Parse error: {}", e),
        }
    }
}