yao 0.1.4

a fast, tiny, extensiable workflow engine
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

use crate::{env::Enviroment, Engine};
use rhai::{export_module, plugin::*};

impl Enviroment {
    pub fn registry_collection_module(&self, _engine: &Engine) {
        let mut module = Module::new();
        combine_with_exported_module!(&mut module, "g", collection);
        self.register_global_module(module)
    }
}

#[export_module]
mod collection {
    use rhai::plugin::*;

    #[export_fn]
    pub fn intersect(a: Vec<Dynamic>, b: Vec<Dynamic>) -> Vec<String> {
        let b = b
            .iter()
            .map(|i| i.clone().to_string())
            .collect::<Vec<String>>();
        let a = a
            .iter()
            .map(|i| i.clone().to_string())
            .collect::<Vec<String>>();

        let ret = a
            .iter()
            .filter(|i| b.contains(i))
            .map(|i| i.clone())
            .collect::<Vec<_>>();

        ret
    }

    #[export_fn]
    pub fn union(a: Vec<Dynamic>, b: Vec<Dynamic>) -> rhai::Array {
        let b = b
            .iter()
            .map(|i| i.clone().to_string())
            .collect::<Vec<String>>();
        let a = a
            .iter()
            .map(|i| i.clone().to_string())
            .collect::<Vec<String>>();

        let ret = a
            .iter()
            .filter(|i| !b.contains(i))
            .chain(&b)
            .map(|i| Dynamic::from(i.clone()))
            .collect::<Vec<_>>();
        ret
    }

    #[export_fn]
    pub fn minus(a: Vec<Dynamic>, b: Vec<Dynamic>) -> Vec<String> {
        let b = b
            .iter()
            .map(|i| i.clone().to_string())
            .collect::<Vec<String>>();
        let a = a
            .iter()
            .map(|i| i.clone().to_string())
            .collect::<Vec<String>>();

        let ret: Vec<String> = a
            .iter()
            .filter(|i| !b.contains(i))
            .map(|i| i.to_string())
            .collect::<Vec<_>>();

        ret
    }
}