vexity 0.0.4

Tiny scripting language for hacking on abstractions of financial markets.
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

use vexity::{
    interpreter::{Interpreter, VarValue},
    parser::parse,
};

#[test]
fn test_map_to_hashmaps() {
    let script = r#"
        let nums = [10, 20]
        let result = nums.map(|x| {
            val: x,
            double: x * 2
        })
    "#;

    let statements = parse(script).expect("Parsing failed");
    let mut interpreter = Interpreter::new();
    interpreter.run(statements);

    let result = interpreter
        .vars
        .get("result")
        .and_then(|v| match v {
            VarValue::Array(a) => Some(a),
            _ => None,
        })
        .expect("Expected result array");

    assert_eq!(result.len(), 2);

    let first = match &result[0] {
        VarValue::HashMap(m) => m,
        _ => panic!("Expected HashMap"),
    };
    assert_eq!(
        first.get("val").map(|x| match x {
            VarValue::Int(x) => *x,
            _ => panic!("Expected VarValue::Int"),
        }),
        Some(10)
    );
    assert_eq!(
        first.get("double").map(|x| match x {
            VarValue::Int(x) => *x,
            _ => panic!("Expected VarValue::Int"),
        }),
        Some(20)
    );

    let second = match &result[1] {
        VarValue::HashMap(m) => m,
        _ => panic!("Expected HashMap"),
    };
    assert_eq!(
        second.get("val").map(|x| match x {
            VarValue::Int(x) => *x,
            _ => panic!("Expected VarValue::Int"),
        }),
        Some(20)
    );
    assert_eq!(
        second.get("double").map(|x| match x {
            VarValue::Int(x) => *x,
            _ => panic!("Expected VarValue::Int"),
        }),
        Some(40)
    );
}

#[test]
fn test_map_with_function() {
    let script = r#"
        fn add_one(x) {
            x + 1
        }

        let nums = [1, 2, 3]
        let incremented = nums.map(add_one)
    "#;

    let statements = parse(script).expect("Parsing failed");
    let mut interpreter = Interpreter::new();
    interpreter.run(statements);

    let incremented = interpreter
        .vars
        .get("incremented")
        .and_then(|v| match v {
            VarValue::Array(a) => Some(
                a.iter()
                    .map(|v| match v {
                        VarValue::Int(i) => *i,
                        _ => panic!("Expected Int"),
                    })
                    .collect::<Vec<i32>>(),
            ),
            _ => None,
        })
        .expect("Expected array of incremented values");

    assert_eq!(incremented, vec![2, 3, 4]);
}