windjammer 0.48.0

A simple language inspired by Go, Ruby, and Elixir that transpiles to Rust - 80% of Rust's power with 20% of the complexity
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

// Pattern Matching Audit - Test current support level

// Simple enum (unit variants only - tuple variants not yet supported)
enum Color {
    Red,
    Green,
    Blue,
}

// Generic enum with single-field variants
enum Option<T> {
    Some(T),
    None,
}

enum Result<T, E> {
    Ok(T),
    Err(E),
}

// ============================================================================
// TEST 1: Unit enum variants
// ============================================================================

fn test_unit_variants(color: Color) -> i32 {
    match color {
        Color::Red => { return 1 }
        Color::Green => { return 2 }
        Color::Blue => { return 3 }
    }
}

// ============================================================================
// TEST 2: Enum variants with single binding
// ============================================================================

fn test_variant_bindings(opt: Option<i32>) -> i32 {
    match opt {
        Option::Some(value) => { return value }
        Option::None => { return 0 }
    }
}

// ============================================================================
// TEST 3: Nested enum patterns
// ============================================================================

fn test_nested_patterns(result: Result<i32, i32>) -> i32 {
    match result {
        Result::Ok(value) => { return value }
        Result::Err(code) => { return code }
    }
}

// ============================================================================
// TEST 4: Wildcard patterns
// ============================================================================

fn test_wildcards(value: i32) -> i32 {
    match value {
        1 => { return 100 }
        2 => { return 200 }
        _ => { return 0 }
    }
}

// ============================================================================
// TEST 5: Literal patterns (integers)
// ============================================================================

fn test_literals(value: i32) -> i32 {
    match value {
        0 => { return 0 }
        1 => { return 1 }
        42 => { return 42 }
        _ => { return -1 }
    }
}

// ============================================================================
// TEST 6: Or patterns
// ============================================================================

fn test_or_patterns(value: i32) -> i32 {
    match value {
        1 | 2 | 3 => { return 100 }
        4 | 5 => { return 200 }
        _ => { return 0 }
    }
}

// ============================================================================
// TEST 7: Wildcard in enum variant
// ============================================================================

fn test_wildcard_in_variant(opt: Option<i32>) -> i32 {
    match opt {
        Option::Some(_) => { return 1 }
        Option::None => { return 0 }
    }
}

// ============================================================================
// MAIN
// ============================================================================

fn main() {
    // Test 1: Unit variants
    let r1 = test_unit_variants(Color::Red)
    let r2 = test_unit_variants(Color::Green)
    
    // Test 2: Variant bindings
    let r3 = test_variant_bindings(Option::Some(42))
    let r4 = test_variant_bindings(Option::None)
    
    // Test 3: Result patterns
    let r5 = test_nested_patterns(Result::Ok(100))
    let r6 = test_nested_patterns(Result::Err(-1))
    
    // Test 4: Wildcards
    let r7 = test_wildcards(1)
    let r8 = test_wildcards(999)
    
    // Test 5: Literals
    let r9 = test_literals(42)
    let r10 = test_literals(100)
    
    // Test 6: Or patterns
    let r11 = test_or_patterns(2)
    let r12 = test_or_patterns(5)
    
    // Test 7: Wildcard in variant
    let r13 = test_wildcard_in_variant(Option::Some(999))
    
    println("Pattern matching audit: ALL SUPPORTED PATTERNS WORK")
}