vyder 0.3.4

Create custom libraries for vyder.
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

use std::process::ExitCode;

use vyder_core::{values, Error, Span, ValueEnum, ValueResult};

pub type Function = fn(&[ValueResult], Span) -> Result<(ValueResult, Option<ExitCode>), Error>;

/// A collection of `Function` and child `Module`'s.
pub struct Module {
    pub(crate) functions: Vec<(String, Function, bool)>,
    pub(crate) modules: Vec<(String, Module)>,
}

impl Module {
    /// Create a `ModuleBuilder` to help make a module.
    pub fn builder() -> ModuleBuilder {
        ModuleBuilder {
            functions: vec![],
            modules: vec![],
        }
    }

    pub fn to_value_enum(&self) -> ValueEnum {
        let mut values = vec![];

        for (identifier, module) in &self.modules {
            values.push((
                values::Str {
                    value: identifier.to_string(),
                }
                .into(),
                module.to_value_enum(),
            ))
        }

        for (identifier, function, can_be_error) in &self.functions {
            values.push((
                values::Str {
                    value: identifier.to_string(),
                }
                .into(),
                values::Callable::Lib {
                    function: *function,
                    can_be_error: *can_be_error,
                }
                .into(),
            ))
        }

        values::Map { values }.into()
    }
}

pub struct ModuleBuilder {
    functions: Vec<(String, Function, bool)>,
    modules: Vec<(String, Module)>,
}

impl ModuleBuilder {
    pub fn build(self) -> Module {
        Module {
            functions: self.functions,
            modules: self.modules,
        }
    }

    pub fn function(mut self, identifier: &str, function: Function, can_be_error: bool) -> Self {
        self.functions
            .push((identifier.to_string(), function, can_be_error));
        self
    }

    pub fn module(mut self, identifier: &str, module: Module) -> Self {
        self.modules.push((identifier.to_string(), module));
        self
    }
}