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

// std/testing - Testing utilities and assertions
// Simple testing framework for Windjammer

// Assert that a condition is true
pub fn assert(condition: bool) {
    if !condition {
        panic!("Assertion failed")
    }
}

// Assert with custom message
pub fn assert_with_message(condition: bool, message: string) {
    if !condition {
        panic!("{}", message)
    }
}

// Assert equality
pub fn assert_eq<T: PartialEq + Debug>(left: T, right: T) {
    if left != right {
        panic!("Assertion failed: {:?} != {:?}", left, right)
    }
}

// Assert inequality
pub fn assert_ne<T: PartialEq + Debug>(left: T, right: T) {
    if left == right {
        panic!("Assertion failed: {:?} == {:?}", left, right)
    }
}

// Explicitly fail a test
pub fn fail(message: string) {
    panic!("{}", message)
}

// Assert that value is Some
pub fn assert_some<T>(value: Option<T>) -> T {
    match value {
        Some(v) => v,
        None => {
            panic!("Expected Some, got None")
        }
    }
}

// Assert that value is None
pub fn assert_none<T>(value: Option<T>) {
    match value {
        Some(_) => panic!("Expected None, got Some"),
        None => {}
    }
}

// Assert that value is Ok
pub fn assert_ok<T, E: Debug>(value: Result<T, E>) -> T {
    match value {
        Ok(v) => v,
        Err(e) => {
            panic!("Expected Ok, got Err: {:?}", e)
        }
    }
}

// Assert that value is Err
pub fn assert_err<T, E>(value: Result<T, E>) -> E {
    match value {
        Ok(_) => panic!("Expected Err, got Ok"),
        Err(e) => e
    }
}

// Assert that two floats are approximately equal
pub fn assert_approx_eq(left: float, right: float, epsilon: float) {
    let diff = if left > right { left - right } else { right - left }
    if diff > epsilon {
        panic!("Assertion failed: {} not approximately equal to {} (epsilon: {})", left, right, epsilon)
    }
}

// Assert that a value is greater than another
pub fn assert_gt<T: PartialOrd + Debug>(left: T, right: T) {
    if !(left > right) {
        panic!("Assertion failed: {:?} not > {:?}", left, right)
    }
}

// Assert that a value is less than another
pub fn assert_lt<T: PartialOrd + Debug>(left: T, right: T) {
    if !(left < right) {
        panic!("Assertion failed: {:?} not < {:?}", left, right)
    }
}

// Assert that a value is greater than or equal to another
pub fn assert_ge<T: PartialOrd + Debug>(left: T, right: T) {
    if !(left >= right) {
        panic!("Assertion failed: {:?} not >= {:?}", left, right)
    }
}

// Assert that a value is less than or equal to another
pub fn assert_le<T: PartialOrd + Debug>(left: T, right: T) {
    if !(left <= right) {
        panic!("Assertion failed: {:?} not <= {:?}", left, right)
    }
}