devalang 0.2.0

Write music with code. Devalang is a domain-specific language (DSL) for sound designers and music hackers. Compose, automate, and control sound — in plain text.
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

use super::*;
use crate::language::syntax::ast::StatementKind;

#[test]
fn test_print_cases() {
    let mut interp = AudioInterpreter::new(44100);

    // Avoid emitting prints to stdout during the test run
    interp.suppress_print = true;

    // string
    handler::execute_print(&mut interp, &Value::String("hello".to_string())).unwrap();
    // verify log entry recorded
    match interp.events.logs.last().unwrap() {
        (time, message) => {
            assert_eq!(message, "hello");
            assert_eq!(*time, interp.cursor_time);
        }
    }

    // number
    handler::execute_print(&mut interp, &Value::Number(2.75)).unwrap();
    match interp.events.logs.last().unwrap() {
        (_time, message) => {
            assert_eq!(message, "2.75");
        }
    }

    // identifier resolved after let
    handler::handle_let(&mut interp, "x", &Value::Number(7.0)).unwrap();
    handler::execute_print(&mut interp, &Value::Identifier("x".to_string())).unwrap();
    match interp.events.logs.last().unwrap() {
        (_time, message) => {
            assert_eq!(message, "7");
        }
    }

    // array concatenation
    handler::execute_print(
        &mut interp,
        &Value::Array(vec![
            Value::String("a".to_string()),
            Value::Identifier("x".to_string()),
        ]),
    )
    .unwrap();
    match interp.events.logs.last().unwrap() {
        (_time, message) => {
            assert_eq!(message, "a7");
        }
    }

    // map
    let mut m = std::collections::HashMap::new();
    m.insert("k".to_string(), Value::Number(2.0));
    handler::execute_print(&mut interp, &Value::Map(m)).unwrap();
    match interp.events.logs.last().unwrap() {
        (_time, message) => {
            // map debug format should be present
            assert!(message.contains("k"));
        }
    }

    // function call expression
    // create a simple function that returns "pong"
    let ret_stmt = Statement::new(
        StatementKind::Return {
            value: Some(Box::new(Value::String("pong".to_string()))),
        },
        Value::Null,
        0,
        1,
        1,
    );
    let func = Statement::new(
        StatementKind::Function {
            name: "ping".to_string(),
            parameters: Vec::new(),
            body: vec![ret_stmt.clone()],
        },
        Value::Identifier("ping".to_string()),
        0,
        1,
        1,
    );
    interp
        .variables
        .insert("ping".to_string(), Value::Statement(Box::new(func)));

    // Evaluate call expression and print its result
    let call_val = Value::Call {
        name: "ping".to_string(),
        args: Vec::new(),
    };
    handler::execute_print(&mut interp, &call_val).unwrap();
    match interp.events.logs.last().unwrap() {
        (_time, message) => {
            assert_eq!(message, "pong");
        }
    }
}