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

// TDD Test: Method self-by-value incorrectly infers &mut
// Bug: Methods that take `self` (owned) are being called with `&mut`
//
// Pattern from game engine math:
//   impl Mat4 {
//       fn multiply(self, other: Mat4) -> Mat4 { ... }
//   }
//   let result = identity.multiply(other)  // Should move identity, not borrow

struct Transform {
    x: f32,
    y: f32,
    rotation: f32,
}

impl Transform {
    fn new() -> Transform {
        Transform { x: 0.0, y: 0.0, rotation: 0.0 }
    }
    
    // Takes self by value (consumes self)
    fn translate(self, dx: f32, dy: f32) -> Transform {
        Transform {
            x: self.x + dx,
            y: self.y + dy,
            rotation: self.rotation,
        }
    }
    
    // Takes self by value (consumes self)
    fn rotate(self, angle: f32) -> Transform {
        Transform {
            x: self.x,
            y: self.y,
            rotation: self.rotation + angle,
        }
    }
}

pub fn test_method_chain_by_value() {
    // Builder pattern: each method consumes self and returns new value
    let transform = Transform::new()
        .translate(10.0, 20.0)
        .rotate(45.0)
        .translate(5.0, 5.0)
    
    assert_eq!(transform.x, 15.0)
    assert_eq!(transform.y, 25.0)
    assert_eq!(transform.rotation, 45.0)
}

pub fn test_single_method_by_value() {
    let t1 = Transform::new()
    let t2 = t1.translate(100.0, 200.0)  // t1 is moved, not borrowed
    
    assert_eq!(t2.x, 100.0)
    assert_eq!(t2.y, 200.0)
    
    // This should NOT compile (t1 was moved):
    // let t3 = t1.rotate(90.0)  
}