ruwren 0.4.10

Rusty bindings to Wren programming language
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

use ruwren::{
    get_slot_checked, send_foreign, wren_impl, Class, ModuleLibrary, VMConfig, WrenObject, VM,
};

#[derive(WrenObject, Debug, Clone)]
struct Vector {
    x: f64,
    y: f64,
}

impl Drop for VectorInstance {
    fn drop(&mut self) {
        println!("Dropping Vector {} {}", self.x, self.y)
    }
}

#[wren_impl]
impl Vector {
    #[wren_impl(allocator)]
    fn alloc() {
        VectorClass {}
    }

    #[wren_impl(constructor)]
    fn construct(_class: &VectorClass) -> _ {
        Err("Cannot initialize from Wren code".to_string())
    }

    #[wren_impl(instance)]
    fn copy(&self) -> Vector {
        self.into()
    }

    #[wren_impl(instance, getter)]
    fn x(&self) -> f64 {
        self.x
    }

    #[wren_impl(instance, getter)]
    fn y(&self) -> f64 {
        self.y
    }

    #[wren_impl(instance, setter)]
    fn x(&mut self, x: f64) {
        self.x = x;
    }

    #[wren_impl(instance, setter)]
    fn y(&mut self, y: f64) {
        self.y = y;
    }

    // Valid object types are T, Option<T>, and Vec<Option<T>>
    #[wren_impl(object(vecs))]
    fn read(&self, vecs: Vec<Option<Vector>>) -> Option<Vec<Vector>> {
        dbg!(&vecs);
        vecs.into_iter().collect()
    }
}

struct Math;

impl Class for Math {
    fn initialize(_: &VM) -> Self {
        panic!("Math is a purely static class");
    }
}

impl Math {
    fn new_vector(vm: &VM) {
        let x = get_slot_checked!(vm => num 1);
        let y = get_slot_checked!(vm => num 2);
        send_foreign!(vm, "maths", "Vector", VectorInstance { x, y } => 0);
    }
}

mod v1 {
    use ruwren::create_module;
    create_module!(
        class("Math") crate::Math => math {
            static(fn "new_vector", 2) new_vector
        }

        module => maths
    );
}

mod v2 {
    use ruwren::wren_module;
    wren_module! {
        pub mod maths {
            pub crate::Vector;
        }
    }
}

static MATHS_MODULE_SRC: &str = include_str!("basic_integration/maths.wren");

fn main() {
    let mut lib = ModuleLibrary::new();
    v1::maths::publish_module(&mut lib);
    v2::maths::publish_module(&mut lib);
    let vm = VMConfig::new().library(&lib).build();
    vm.interpret("maths", MATHS_MODULE_SRC).unwrap(); // Should succeed

    let res = vm.interpret("main", include_str!("basic_integration/main.wren"));

    if let Err(err) = res {
        eprintln!("{}", err);
    }
}