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

//! Function call examples for Ruchy REPL
//!
//! This example demonstrates various function call patterns
//! that are supported in the Ruchy REPL.

#![allow(clippy::print_stdout)] // Examples need to print
#![allow(clippy::uninlined_format_args)] // Examples for clarity

use ruchy::runtime::Repl;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🎯 Ruchy Function Call Examples");
    println!("{}", "=".repeat(50));

    let mut repl = Repl::new(std::env::temp_dir())?;

    basic_println_examples(&mut repl)?;
    variable_examples(&mut repl)?;
    expression_examples(&mut repl)?;
    formatting_examples(&mut repl)?;
    print_vs_println_examples(&mut repl)?;
    control_flow_examples(&mut repl)?;
    error_handling_examples(&mut repl);

    println!("\n🎉 Function call examples completed!");
    println!("All function calls returned unit type '()' as expected.");

    Ok(())
}

/// Basic println examples
fn basic_println_examples(repl: &mut Repl) -> Result<(), Box<dyn std::error::Error>> {
    println!("\n📝 Basic println Examples:");

    println!("1. Simple string:");
    repl.eval(r#"println("Hello, World!")"#)?;

    println!("2. Multiple arguments:");
    repl.eval(r#"println("Hello", "World", "!")"#)?;

    println!("3. Different types:");
    repl.eval("println(42, 3.14, true, \"mixed\")")?;

    Ok(())
}

/// Variables in function calls
fn variable_examples(repl: &mut Repl) -> Result<(), Box<dyn std::error::Error>> {
    println!("\n🔗 Variables in Function Calls:");

    repl.eval("let name = \"Alice\"")?;
    repl.eval("let age = 30")?;
    repl.eval("let score = 95.5")?;

    println!("4. Variables as arguments:");
    repl.eval(r#"println("Name:", name, "Age:", age, "Score:", score)"#)?;

    Ok(())
}

/// Expressions in function calls
fn expression_examples(repl: &mut Repl) -> Result<(), Box<dyn std::error::Error>> {
    println!("\n🧮 Expressions in Function Calls:");

    println!("5. Arithmetic expressions:");
    repl.eval("println(\"Sum:\", 10 + 20)")?;
    repl.eval("println(\"Product:\", 6 * 7)")?;

    println!("6. Complex expressions:");
    repl.eval("println(\"Result:\", (5 + 3) * 2 - 1)")?;

    Ok(())
}

/// String formatting patterns
fn formatting_examples(repl: &mut Repl) -> Result<(), Box<dyn std::error::Error>> {
    println!("\n📋 String Formatting Patterns:");

    println!("7. Formatted output:");
    repl.eval("let x = 42")?;
    repl.eval("let y = 58")?;
    repl.eval(r#"println("x =", x, ", y =", y, ", x + y =", x + y)"#)?;

    Ok(())
}

/// Print vs println examples
fn print_vs_println_examples(repl: &mut Repl) -> Result<(), Box<dyn std::error::Error>> {
    println!("\n🖨️  Print vs Println:");

    println!("8. Print without newline:");
    repl.eval(r#"print("A")"#)?;
    repl.eval(r#"print("B")"#)?;
    repl.eval(r#"println("C")"#)?;

    println!("9. Building output incrementally:");
    repl.eval(r#"print("Result: ")"#)?;
    repl.eval("print(2 + 2)")?;
    repl.eval(r#"println(" (calculated)")"#)?;

    Ok(())
}

/// Function calls in control flow
fn control_flow_examples(repl: &mut Repl) -> Result<(), Box<dyn std::error::Error>> {
    println!("\n🔄 Function Calls in Control Flow:");

    println!("10. Function calls in if expressions:");
    repl.eval(r#"if true { println("True branch") } else { println("False branch") }"#)?;

    println!("11. Function calls with boolean logic:");
    repl.eval("let debug = true")?;
    repl.eval(r#"if debug { println("Debug: Variables loaded successfully") }"#)?;

    Ok(())
}

/// Error handling examples
fn error_handling_examples(repl: &mut Repl) {
    println!("\n⚠️  Error Handling:");

    println!("12. Unknown function (should error):");
    match repl.eval("unknown_function()") {
        Ok(_) => println!("   Unexpected success!"),
        Err(e) => println!("   ✅ Correctly errored: {e}"),
    }
}