rune 0.14.2

The Rune Language, an embeddable dynamic programming language for Rust.
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

//! Tests for derive(Any) generates the necessary metadata to match over fields.

prelude!();

#[test]
fn struct_match() {
    #[derive(Any, Clone, Copy)]
    struct Struct {
        #[rune(get)]
        a: u32,
        #[rune(get)]
        b: u32,
    }

    fn make_module() -> Result<Module, ContextError> {
        let mut module = Module::new();
        module.ty::<Struct>()?;
        Ok(module)
    }

    let m = make_module().expect("failed make module");

    let e = Struct { a: 40, b: 41 };

    let n: u32 = rune_n! {
        mod m,
        (e,),
        pub fn main(v) { match v { Struct { .. } => 2, _ => 0 } }
    };

    assert_eq!(n, 2);

    let n: u32 = rune_n! {
        mod m,
        (e,),
        pub fn main(v) { match v { Struct { a, .. } => a, _ => 0 } }
    };

    assert_eq!(n, 40);

    let n: u32 = rune_n! {
        mod m,
        (e,),
        pub fn main(v) { match v { Struct { b, .. } => b, _ => 0 } }
    };

    assert_eq!(n, 41);

    let n: u32 = rune_n! {
        mod m,
        (e,),
        pub fn main(v) { match v { Struct { a, b } => a + b, _ => 0 } }
    };

    assert_eq!(n, 81);
}

#[test]
fn enum_match() {
    #[derive(Debug, Any, Clone, Copy)]
    enum Enum {
        Success,
        Failed,
        Aborted,
        Errored,
    }

    fn make_module() -> Result<Module, ContextError> {
        let mut module = Module::new();
        module.ty::<Enum>()?;
        Ok(module)
    }

    let m = make_module().expect("failed make module");

    macro_rules! test {
        ($expected:ident, $other:ident) => {{
            let e = Enum::$expected;

            let n: u32 = rune_n! {
                mod m,
                (e,),
                pub fn main(v) { match v { Enum::$expected => 1, Enum::$other => 2, _ => 0 } }
            };

            assert_eq!(n, 1);

            let n: u32 = rune_n! {
                mod m,
                (e,),
                pub fn main(v) { match v { Enum::$expected { .. } => 1, Enum::$other => 2, _ => 0 } }
            };

            assert_eq!(n, 1);

            let e = Enum::$other;

            let n: u32 = rune_n! {
                mod m,
                (e,),
                pub fn main(v) { match v { Enum::$expected => 1, Enum::$other => 2, _ => 0 } }
            };

            assert_eq!(n, 2);
        }}
    }

    // Do a trip around the enum.
    test!(Success, Failed);
    test!(Failed, Aborted);
    test!(Aborted, Errored);
    test!(Errored, Success);
}