nodespeak 0.2.1

A JIT-ish compiler for number-crunching applications.
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

use super::{DataType, KnownData, Program, VariableId};
use crate::shared::ProxyMode;

use std::fmt::{self, Debug, Formatter};

#[derive(Clone)]
pub enum ValueBase {
    Literal(KnownData),
    Variable(VariableId),
}

impl Debug for ValueBase {
    fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
        match self {
            Self::Literal(data) => write!(formatter, "{:?}", data),
            Self::Variable(var) => write!(formatter, "{:?}", var),
        }
    }
}

impl ValueBase {
    pub fn get_type(&self, program: &Program) -> DataType {
        match self {
            Self::Literal(data) => data.get_type(),
            Self::Variable(var) => program[*var].borrow_type().clone(),
        }
    }
}

#[derive(Clone)]
pub struct Value {
    pub base: ValueBase,
    pub dimensions: Vec<(usize, ProxyMode)>,
}

impl Value {
    fn new(base: ValueBase, base_type: &DataType) -> Value {
        Value {
            base,
            dimensions: base_type
                .collect_dimensions()
                .iter()
                .map(|len| (*len, ProxyMode::Keep))
                .collect(),
        }
    }

    pub fn variable(variable: VariableId, program: &Program) -> Value {
        Self::new(
            ValueBase::Variable(variable),
            program[variable].borrow_type(),
        )
    }

    pub fn literal(data: KnownData) -> Value {
        let base_type = data.get_type();
        Self::new(ValueBase::Literal(data), &base_type)
    }

    pub fn get_type(&self, program: &Program) -> DataType {
        self.base.get_type(program)
    }

    pub fn inflate(&mut self, dimensions: &[usize]) {
        let mut new_dimensions = Vec::new();
        for (index, target_dimension) in dimensions.iter().cloned().enumerate() {
            if index >= self.dimensions.len() {
                new_dimensions.push((target_dimension, ProxyMode::Discard));
            } else if self.dimensions[index].0 == target_dimension {
                new_dimensions.push(self.dimensions[index].clone());
            } else {
                assert!(
                    self.dimensions[index].0 == 1,
                    "Illegal inflation should have been caught earlier."
                );
                new_dimensions.push((target_dimension, ProxyMode::Collapse));
            }
        }
        self.dimensions = new_dimensions;
    }
}

impl Debug for Value {
    fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
        if self.dimensions.len() == 0 {
            write!(formatter, "{:?}", self.base)?;
        } else {
            write!(formatter, "{{")?;
            for (index, (len, mode)) in self.dimensions.iter().enumerate() {
                match mode {
                    ProxyMode::Keep => write!(formatter, "{}", len)?,
                    ProxyMode::Discard => write!(formatter, "{}>X", len)?,
                    ProxyMode::Collapse => write!(formatter, "{}>1", len)?,
                }
                if index < self.dimensions.len() - 1 {
                    write!(formatter, ", ")?;
                }
            }
            write!(formatter, "}}{:?}", self.base)?;
        }
        write!(formatter, "")
    }
}