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
137
138
139
140
141
142
143
144
145
146
147
148

#![allow(missing_docs)]
// DEFECT-PARSER-007: Where Clause Syntax
// Bug: Parser failed with "Unexpected token: Where" when encountering where clauses
// Fix: Added parse_where_clause() to parse and skip trait bounds after function signature

use assert_cmd::Command;
use predicates::prelude::*;

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

// Test 1: Basic where clause with single trait bound
#[test]
#[ignore = "Where clause trait bounds not yet fully supported"]
fn test_parser_007_where_single_bound() {
    let code = r"
fn map_over<T, U, F>(items: Vec<T>, f: F) -> Vec<U>
where F: Fn(T) -> U
{
    items.into_iter().map(f).collect()
}
";
    std::fs::write("/tmp/test_parser_007_single.ruchy", code).unwrap();

    ruchy_cmd()
        .arg("check")
        .arg("/tmp/test_parser_007_single.ruchy")
        .assert()
        .success()
        .stdout(predicate::str::contains("✓ Syntax is valid"));
}

// Test 2: Where clause with multiple trait bounds
#[test]
#[ignore = "Where clause trait bounds not yet fully supported"]
fn test_parser_007_where_multiple_bounds() {
    let code = r"
fn process<T, U>(a: T, b: U) -> i32
where
    T: Display,
    U: Clone
{
    42
}
";
    std::fs::write("/tmp/test_parser_007_multiple.ruchy", code).unwrap();

    ruchy_cmd()
        .arg("check")
        .arg("/tmp/test_parser_007_multiple.ruchy")
        .assert()
        .success();
}

// Test 3: Where clause with complex trait bound (Fn trait)
#[test]
#[ignore = "Where clause trait bounds not yet fully supported"]
fn test_parser_007_where_fn_bound() {
    let code = r"
fn apply<T, F>(value: T, func: F) -> T
where F: Fn(T) -> T
{
    func(value)
}
";
    std::fs::write("/tmp/test_parser_007_fn_bound.ruchy", code).unwrap();

    ruchy_cmd()
        .arg("check")
        .arg("/tmp/test_parser_007_fn_bound.ruchy")
        .assert()
        .success();
}

// Test 4: Where clause with function type syntax
#[test]
#[ignore = "Where clause trait bounds not yet fully supported"]
fn test_parser_007_where_fn_signature() {
    let code = r#"
fn map_over<T, U, F>(items: Vec<T>, f: F) -> Vec<U>
where F: Fn(T) -> U
{
    items.into_iter().map(f).collect()
}

fn main() {
    let nums = vec![1, 2, 3];
    let doubled = map_over(nums, |x| x * 2);
    println!("Result: {:?}", doubled);
}
"#;
    std::fs::write("/tmp/test_parser_007_complete.ruchy", code).unwrap();

    ruchy_cmd()
        .arg("check")
        .arg("/tmp/test_parser_007_complete.ruchy")
        .assert()
        .success();
}

// Test 5: Book example (appendix-b-syntax-reference_example_16)
#[test]
#[ignore = "Where clause trait bounds not yet fully supported"]
fn test_parser_007_book_example() {
    let code = r"
// Function as parameter
fn apply_operation(x: i32, y: i32, op: fn(i32, i32) -> i32) -> i32 {
    op(x, y)
}

// Function returning function
fn make_adder(n: i32) -> impl Fn(i32) -> i32 {
    move |x| x + n
}

// Generic function with where clause
fn map_over<T, U, F>(items: Vec<T>, f: F) -> Vec<U>
where F: Fn(T) -> U
{
    items.into_iter().map(f).collect()
}
";
    std::fs::write("/tmp/test_parser_007_book.ruchy", code).unwrap();

    ruchy_cmd()
        .arg("check")
        .arg("/tmp/test_parser_007_book.ruchy")
        .assert()
        .success();
}

// Test 6: Function without where clause still works
#[test]
fn test_parser_007_no_where_clause() {
    let code = r"
fn identity<T>(value: T) -> T {
    value
}
";
    std::fs::write("/tmp/test_parser_007_no_where.ruchy", code).unwrap();

    ruchy_cmd()
        .arg("check")
        .arg("/tmp/test_parser_007_no_where.ruchy")
        .assert()
        .success();
}