melodium-lang 0.10.0

Mélodium language parsing and semantic analyser
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

use crate::restitution::describe_type;
use melodium_common::descriptor::Identifier;
use melodium_engine::designer::Value;
use std::collections::BTreeMap;

pub fn value(value: &Value, names: &BTreeMap<Identifier, String>, level: usize) -> String {
    match value {
        Value::Raw(val) => val.to_string(),
        Value::Array(array) => format!(
            "[{opt_n}{opt_space}{array}{opt_n}{opt_space_n1}]",
            opt_n = if array.is_empty() { "" } else { "\n" },
            opt_space = if array.is_empty() {
                "".to_string()
            } else {
                "    ".repeat(level)
            },
            opt_space_n1 = if array.is_empty() {
                "".to_string()
            } else {
                "    ".repeat(level.saturating_sub(1))
            },
            array = array
                .iter()
                .map(|val| self::value(val, names, level + 1))
                .collect::<Vec<_>>()
                .join(&format!(",\n{}", "    ".repeat(level)))
        ),
        Value::Variable(var) => var.clone(),
        Value::Context(context, entry) => {
            format!(
                "{name}[{entry}]",
                name = names.get(context.identifier()).unwrap()
            )
        }
        Value::Function(function, generics, params) => {
            let name = names.get(function.identifier()).unwrap();

            let generics = if !function.generics().is_empty() && !generics.is_empty() {
                format!(
                    "<{}>",
                    function
                        .generics()
                        .iter()
                        .map(|generic| generics
                            .get(&generic.name)
                            .map(|desc_type| describe_type(desc_type, names))
                            .unwrap_or_else(|| "_".to_string()))
                        .collect::<Vec<_>>()
                        .join(", ")
                )
            } else {
                String::new()
            };

            let params = params
                .iter()
                .map(|p| self::value(p, names, level + 1))
                .collect::<Vec<_>>()
                .join(&format!(",\n{}", "    ".repeat(level)));

            format!(
                "{name}{generics}({opt_n}{opt_space}{params}{opt_n}{opt_space_n1})",
                opt_n = if params.is_empty() { "" } else { "\n" },
                opt_space = if params.is_empty() {
                    "".to_string()
                } else {
                    "    ".repeat(level)
                },
                opt_space_n1 = if params.is_empty() {
                    "".to_string()
                } else {
                    "    ".repeat(level.saturating_sub(1))
                }
            )
        }
    }
}