typr-core 0.5.1

Core type checking and transpilation logic for TypR - a typed superset of R
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use crate::components::context::Context;
use crate::components::language::argument_value::ArgumentValue;
use crate::components::language::Lang;
use std::ops::Add;

pub trait TranslateAppendable {
    fn to_translatable(self) -> Translatable;
}

pub trait RTranslatable<T: TranslateAppendable> {
    fn to_r(&self, context: &Context) -> T;
}

pub struct Translatable {
    context: Context,
    code: String,
}

impl Translatable {
    pub fn to_r<T: TranslateAppendable>(self, lang: &impl RTranslatable<T>) -> Translatable {
        let res = lang.to_r(&self.context);
        self.append(res)
    }

    pub fn to_r_safe<T: TranslateAppendable>(self, lang: &impl RTranslatable<T>) -> Translatable {
        let res = lang.to_r(&self.context);
        self.append_safe(res)
    }

    pub fn reset_context(self) -> Translatable {
        Translatable {
            context: Context::default(),
            ..self
        }
    }

    pub fn to_r_arg_val(self, arg_val: &ArgumentValue, joint: &str) -> Translatable {
        let res = arg_val.to_r(&self.context);
        self.add(&res).add(joint)
    }

    #[allow(clippy::should_implement_trait)]
    pub fn add(self, s: &str) -> Translatable {
        Translatable {
            code: self.code + s,
            ..self
        }
    }

    pub fn append(self, val: impl TranslateAppendable) -> Translatable {
        self + val.to_translatable()
    }

    pub fn append_safe(self, val: impl TranslateAppendable) -> Translatable {
        self + val.to_translatable().reset_context()
    }

    pub fn get_code(&self) -> String {
        self.code.clone()
    }

    pub fn join(self, vals: &[Lang], joint: &str) -> Translatable {
        if !vals.is_empty() {
            vals.iter()
                .fold(self, |trans, val| trans.to_r(val).add(joint))
                .sub(joint.len())
        } else {
            self
        }
    }

    pub fn join_arg_val(self, vals: &[ArgumentValue], joint: &str) -> Translatable {
        vals.iter()
            .fold(self, |trans, val| trans.to_r_arg_val(val, joint))
            .sub(joint.len())
    }

    #[allow(clippy::should_implement_trait)]
    pub fn sub(self, len: usize) -> Translatable {
        let new_code = if self.code.len() > len {
            &self.code[0..(self.code.len() - len)]
        } else {
            &self.code
        };
        Translatable {
            code: new_code.to_string(),
            ..self
        }
    }
}

impl Add for Translatable {
    type Output = Translatable;

    fn add(self, other: Self) -> Self::Output {
        let new_context = if other.context == Context::default() {
            self.context
        } else {
            other.context
        };
        Translatable {
            context: new_context,
            code: self.code + &other.code,
        }
    }
}

impl From<Context> for Translatable {
    fn from(val: Context) -> Self {
        Translatable {
            context: val,
            code: "".to_string(),
        }
    }
}

impl From<Translatable> for (String, Context) {
    fn from(val: Translatable) -> Self {
        (val.code, val.context)
    }
}

impl TranslateAppendable for (String, Context) {
    fn to_translatable(self) -> Translatable {
        Translatable {
            context: self.1,
            code: self.0,
        }
    }
}

impl TranslateAppendable for String {
    fn to_translatable(self) -> Translatable {
        Translatable {
            context: Context::default(),
            code: self,
        }
    }
}

impl RTranslatable<(String, Context)> for Box<Lang> {
    fn to_r(&self, context: &Context) -> (String, Context) {
        (**self).to_r(context)
    }
}