nbcl 0.2.0

Configuration language designed to be easy and understandable.
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
114
115
116
117
118
119
120
121
122

use crate::ast::utils::{Type, Value};
use crate::error::NbclError;
use crate::registry::Registry;

/// Register a set of core functions like print.
pub(crate) fn register_builtin_functions(registry: &mut Registry) {
    // == basic functions == //
    // print(Any) -> Null
    registry.add_native_fn("print", vec![Type::Any], Type::Null, |args| {
        crate::print(format!("{}", args[0]));
        Ok(Value::Null)
    });

    // to_string(Any) -> Str
    registry.add_native_fn("to_string", vec![Type::Any], Type::Str, |args| {
        Ok(Value::Str(args[0].to_string()))
    });

    // as_int(Any) -> Int
    registry.add_native_fn("as_int", vec![Type::Any], Type::Int, |args| match args[0].as_int() {
        Some(i) => Ok(Value::Int(i)),
        None => {
            return Err(NbclError::Runtime {
                message: format!("as_float() not supported for type {}", args[0].type_name()),
                hint: None,
                span: None,
            });
        }
    });

    // as_float(Any) -> Float
    registry.add_native_fn("as_float", vec![Type::Any], Type::Float, |args| {
        match args[0].as_float() {
            Some(f) => Ok(Value::Float(f)),
            None => {
                return Err(NbclError::Runtime {
                    message: format!("as_float() not supported for type {}", args[0].type_name()),
                    hint: None,
                    span: None,
                });
            }
        }
    });

    // type_of(Any) -> Str
    registry.add_native_fn("type_of", vec![Type::Any], Type::Str, |args| {
        Ok(Value::Str(args[0].type_name().to_string()))
    });

    // len(Any) -> Int
    registry.add_native_fn("len", vec![Type::Any], Type::Int, |args| {
        let length = match &args[0] {
            Value::Str(s) => s.len() as i64,
            Value::List(l) => l.len() as i64,
            Value::Map(m) => m.len() as i64,
            _ => {
                return Err(NbclError::Runtime {
                    message: format!("len() not supported for type {}", args[0].type_name()),
                    hint: None,
                    span: None,
                });
            }
        };
        Ok(Value::Int(length))
    });

    // contains(List/Str, Any) -> Bool
    registry.add_native_fn("contains", vec![Type::Any, Type::Any], Type::Bool, |args| {
        match &args[0] {
            Value::List(v) => Ok(Value::Bool(v.contains(&args[1]))),
            Value::Str(s) => match &args[1] {
                Value::Str(sub) => Ok(Value::Bool(s.contains(sub.as_str()))),
                _ => Ok(Value::Bool(false))
            },
            _ => Err(NbclError::Runtime {
                message: format!("contains() not supported for type {}", args[0].type_name()),
                hint: None, span: None,
            })
        }
    });

    // == list functions == //

    // push(List, Any) -> List
    registry.add_native_fn("push", vec![Type::List, Type::Any], Type::List, |mut args| {
        let val = args.remove(1);
        match args.remove(0) {
            Value::List(mut v) => { v.push(val); Ok(Value::List(v)) }
            _ => unreachable!()
        }
    });

    // pop(List) -> Any
    registry.add_native_fn("pop", vec![Type::List], Type::Any, |mut args| {
        match args.remove(0) {
            Value::List(mut v) => Ok(v.pop().unwrap_or(Value::Null)),
            _ => unreachable!()
        }
    });

    // == map functions == //

    // keys(Map) -> List
    registry.add_native_fn("keys", vec![Type::Map], Type::List, |args| {
        match &args[0] {
            Value::Map(m) => Ok(Value::List(
                m.iter().map(|(k, _)| Value::Str(k.clone())).collect()
            )),
            _ => unreachable!()
        }
    });

    // values(Map) -> List
    registry.add_native_fn("values", vec![Type::Map], Type::List, |args| {
        match &args[0] {
            Value::Map(m) => Ok(Value::List(
                m.iter().map(|(_, v)| v.clone()).collect()
            )),
            _ => unreachable!()
        }
    });
}