geam 0.1.1

Experimental Rust-embedded execution runtime for typed Gleam programs
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258

use crate::plan::{
    BoolExpr, BoolFunctionExpr, FloatExpr, FloatFunctionExpr, FunctionFunctionExpr, IntExpr,
    IntFunctionExpr, NilExpr, NilFunctionExpr, StringExpr, StringFunctionExpr,
};
use crate::planner::dsl::expression::{
    Bool, BoolFunction, Float, FloatFunction, FunctionFunction, Int, IntFunction, Nil, NilFunction,
    String, StringFunction,
};

pub(crate) fn bool_case_int(subject: Bool, true_: Int, false_: Int) -> Int {
    Int(IntExpr::bool_case(
        subject.into(),
        true_.into(),
        false_.into(),
    ))
}

pub(crate) fn bool_case_string(subject: Bool, true_: String, false_: String) -> String {
    String(StringExpr::bool_case(
        subject.into(),
        true_.into(),
        false_.into(),
    ))
}

pub(crate) fn bool_case_float(subject: Bool, true_: Float, false_: Float) -> Float {
    Float(FloatExpr::bool_case(
        subject.into(),
        true_.into(),
        false_.into(),
    ))
}

pub(crate) fn bool_case_bool(subject: Bool, true_: Bool, false_: Bool) -> Bool {
    Bool(BoolExpr::bool_case(
        subject.into(),
        true_.into(),
        false_.into(),
    ))
}

pub(crate) fn bool_case_nil(subject: Bool, true_: Nil, false_: Nil) -> Nil {
    Nil(NilExpr::bool_case(
        subject.into(),
        true_.into(),
        false_.into(),
    ))
}

pub(crate) fn bool_case_int_function(
    subject: Bool,
    true_: IntFunction,
    false_: IntFunction,
) -> IntFunction {
    IntFunction(IntFunctionExpr::bool_case(
        subject.into(),
        true_.into(),
        false_.into(),
    ))
}

pub(crate) fn bool_case_string_function(
    subject: Bool,
    true_: StringFunction,
    false_: StringFunction,
) -> StringFunction {
    StringFunction(StringFunctionExpr::bool_case(
        subject.into(),
        true_.into(),
        false_.into(),
    ))
}

pub(crate) fn bool_case_float_function(
    subject: Bool,
    true_: FloatFunction,
    false_: FloatFunction,
) -> FloatFunction {
    FloatFunction(FloatFunctionExpr::bool_case(
        subject.into(),
        true_.into(),
        false_.into(),
    ))
}

pub(crate) fn bool_case_bool_function(
    subject: Bool,
    true_: BoolFunction,
    false_: BoolFunction,
) -> BoolFunction {
    BoolFunction(BoolFunctionExpr::bool_case(
        subject.into(),
        true_.into(),
        false_.into(),
    ))
}

pub(crate) fn bool_case_nil_function(
    subject: Bool,
    true_: NilFunction,
    false_: NilFunction,
) -> NilFunction {
    NilFunction(NilFunctionExpr::bool_case(
        subject.into(),
        true_.into(),
        false_.into(),
    ))
}

pub(crate) fn bool_case_function_function(
    subject: Bool,
    true_: FunctionFunction,
    false_: FunctionFunction,
) -> FunctionFunction {
    FunctionFunction(FunctionFunctionExpr::bool_case(
        subject.into(),
        true_.into(),
        false_.into(),
    ))
}

#[cfg(test)]
mod tests {
    use super::{
        bool_case_bool, bool_case_bool_function, bool_case_float, bool_case_float_function,
        bool_case_function_function, bool_case_int, bool_case_int_function, bool_case_nil,
        bool_case_nil_function, bool_case_string, bool_case_string_function,
    };
    use crate::plan::{
        BoolExpr, BoolFunctionExpr, FloatExpr, FloatFunctionExpr, FunctionFunctionExpr,
        FunctionFunctionId, FunctionType, IntExpr, IntFunctionExpr, IntFunctionFunctionId, NilExpr,
        NilFunctionExpr, ParamLocal, StringExpr, StringFunctionExpr, ValueType,
    };
    use crate::planner::dsl::expression::{
        bool_, bool_function_ref, float, float_function_ref, function_function_ref, int,
        int_function_ref, nil, nil_function_ref, string, string_function_ref,
    };

    #[test]
    fn bool_case_helpers_build_result_family_shapes() {
        assert_eq!(
            bool_case_int(bool_(true), int(1), int(0)).0,
            IntExpr::bool_case(bool_(true).into(), int(1).into(), int(0).into()),
        );
        assert_eq!(
            bool_case_string(bool_(true), string("a"), string("b")).0,
            StringExpr::bool_case(bool_(true).into(), string("a").into(), string("b").into()),
        );
        assert_eq!(
            bool_case_float(bool_(true), float(1.0), float(0.0)).0,
            FloatExpr::bool_case(bool_(true).into(), float(1.0).into(), float(0.0).into()),
        );
        assert_eq!(
            bool_case_bool(bool_(true), bool_(true), bool_(false)).0,
            BoolExpr::bool_case(bool_(true).into(), bool_(true).into(), bool_(false).into()),
        );
        assert_eq!(
            bool_case_nil(bool_(true), nil(), nil()).0,
            NilExpr::bool_case(bool_(true).into(), nil().into(), nil().into()),
        );
        assert_eq!(
            bool_case_int_function(
                bool_(true),
                int_function_ref(0, Vec::<ParamLocal>::new()),
                int_function_ref(1, Vec::<ParamLocal>::new()),
            )
            .0,
            IntFunctionExpr::bool_case(
                bool_(true).into(),
                int_function_ref(0, Vec::<ParamLocal>::new()).into(),
                int_function_ref(1, Vec::<ParamLocal>::new()).into(),
            ),
        );
        assert_eq!(
            bool_case_string_function(
                bool_(true),
                string_function_ref(0, Vec::<ParamLocal>::new()),
                string_function_ref(1, Vec::<ParamLocal>::new()),
            )
            .0,
            StringFunctionExpr::bool_case(
                bool_(true).into(),
                string_function_ref(0, Vec::<ParamLocal>::new()).into(),
                string_function_ref(1, Vec::<ParamLocal>::new()).into(),
            ),
        );
        assert_eq!(
            bool_case_float_function(
                bool_(true),
                float_function_ref(0, Vec::<ParamLocal>::new()),
                float_function_ref(1, Vec::<ParamLocal>::new()),
            )
            .0,
            FloatFunctionExpr::bool_case(
                bool_(true).into(),
                float_function_ref(0, Vec::<ParamLocal>::new()).into(),
                float_function_ref(1, Vec::<ParamLocal>::new()).into(),
            ),
        );
        assert_eq!(
            bool_case_bool_function(
                bool_(true),
                bool_function_ref(0, Vec::<ParamLocal>::new()),
                bool_function_ref(1, Vec::<ParamLocal>::new()),
            )
            .0,
            BoolFunctionExpr::bool_case(
                bool_(true).into(),
                bool_function_ref(0, Vec::<ParamLocal>::new()).into(),
                bool_function_ref(1, Vec::<ParamLocal>::new()).into(),
            ),
        );
        assert_eq!(
            bool_case_nil_function(
                bool_(true),
                nil_function_ref(0, Vec::<ParamLocal>::new()),
                nil_function_ref(1, Vec::<ParamLocal>::new()),
            )
            .0,
            NilFunctionExpr::bool_case(
                bool_(true).into(),
                nil_function_ref(0, Vec::<ParamLocal>::new()).into(),
                nil_function_ref(1, Vec::<ParamLocal>::new()).into(),
            ),
        );
        assert_eq!(
            bool_case_function_function(
                bool_(true),
                function_function_ref(
                    FunctionFunctionId::Int(IntFunctionFunctionId(0)),
                    Vec::<ParamLocal>::new(),
                    FunctionType::new(vec![ValueType::Int], ValueType::Int),
                ),
                function_function_ref(
                    FunctionFunctionId::Int(IntFunctionFunctionId(1)),
                    Vec::<ParamLocal>::new(),
                    FunctionType::new(vec![ValueType::Int], ValueType::Int),
                ),
            )
            .0,
            FunctionFunctionExpr::bool_case(
                bool_(true).into(),
                function_function_ref(
                    FunctionFunctionId::Int(IntFunctionFunctionId(0)),
                    Vec::<ParamLocal>::new(),
                    FunctionType::new(vec![ValueType::Int], ValueType::Int),
                )
                .into(),
                function_function_ref(
                    FunctionFunctionId::Int(IntFunctionFunctionId(1)),
                    Vec::<ParamLocal>::new(),
                    FunctionType::new(vec![ValueType::Int], ValueType::Int),
                )
                .into(),
            ),
        );
    }
}