vyder_core/expression/
expressions.rs

1use crate::prelude::*;
2
3#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
4pub struct Number {
5    pub value: f64,
6}
7
8#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
9pub struct Str {
10    pub value: String,
11}
12
13#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
14pub struct Identifier {
15    pub value: String,
16}
17
18#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
19pub struct False;
20
21#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
22pub struct True;
23
24#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
25pub struct Nil;
26
27#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
28pub struct Group {
29    pub value: Box<Expression>,
30}
31
32#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
33pub struct Map {
34    // [2 + 3] = 10
35    pub expression_value: Vec<(Expression, Expression)>,
36    // foo = 10 (=> ["foo"] = 10)
37    pub identifier_value: Vec<(crate::Identifier, Expression)>,
38    // foo (=> ["foo"] = foo)
39    pub same_name_identifier: Vec<crate::Identifier>,
40}
41
42#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
43pub struct Block {
44    pub statements: Vec<Statement>,
45}
46
47#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
48pub struct If {
49    pub can_be_error: bool,
50    /// 0: condition, 1: body
51    pub branches: Vec<(Expression, Expression)>,
52    pub else_branch: Option<Box<Expression>>,
53}
54
55#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
56pub struct While {
57    pub can_be_error: bool,
58    pub condition: Box<Expression>,
59    pub body: Box<Expression>,
60}
61
62#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
63pub struct Function {
64    pub can_be_error: bool,
65    pub parameters: Vec<crate::Identifier>,
66    pub body: Box<Expression>,
67}
68
69#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
70pub struct Check {
71    pub can_be_error: bool,
72    pub expression_to_check: Box<Expression>,
73    pub alias: Option<crate::Identifier>,
74    pub body: Box<Expression>,
75    pub else_body: Option<Box<Expression>>,
76    pub else_alias: Option<crate::Identifier>,
77}
78
79#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
80pub struct For {
81    pub can_be_error: bool,
82    pub identifier: crate::Identifier,
83    pub to_loop_over: Box<Expression>,
84    pub body: Box<Expression>,
85}
86
87#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
88pub struct Assignment {
89    pub identifier: crate::Identifier,
90    pub expression: Box<Expression>,
91}
92
93impl Assignment {
94    pub fn new_as_expression(
95        identifier: crate::Identifier,
96        expression: Expression,
97        span: Span,
98    ) -> Expression {
99        Expression {
100            span,
101            value: Self {
102                identifier,
103                expression: Box::new(expression),
104            }
105            .into(),
106        }
107    }
108}
109
110#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
111pub struct AdditionAssignment {
112    pub identifier: crate::Identifier,
113    pub expression: Box<Expression>,
114}
115
116impl AdditionAssignment {
117    pub fn new_as_expression(
118        identifier: crate::Identifier,
119        expression: Expression,
120        span: Span,
121    ) -> Expression {
122        Expression {
123            span,
124            value: Self {
125                identifier,
126                expression: Box::new(expression),
127            }
128            .into(),
129        }
130    }
131}
132
133#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
134pub struct SubtractionAssignment {
135    pub identifier: crate::Identifier,
136    pub expression: Box<Expression>,
137}
138
139impl SubtractionAssignment {
140    pub fn new_as_expression(
141        identifier: crate::Identifier,
142        expression: Expression,
143        span: Span,
144    ) -> Expression {
145        Expression {
146            span,
147            value: Self {
148                identifier,
149                expression: Box::new(expression),
150            }
151            .into(),
152        }
153    }
154}
155
156#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
157pub struct MultiplicationAssignment {
158    pub identifier: crate::Identifier,
159    pub expression: Box<Expression>,
160}
161
162impl MultiplicationAssignment {
163    pub fn new_as_expression(
164        identifier: crate::Identifier,
165        expression: Expression,
166        span: Span,
167    ) -> Expression {
168        Expression {
169            span,
170            value: Self {
171                identifier,
172                expression: Box::new(expression),
173            }
174            .into(),
175        }
176    }
177}
178
179#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
180pub struct DivisionAssignment {
181    pub identifier: crate::Identifier,
182    pub expression: Box<Expression>,
183}
184
185impl DivisionAssignment {
186    pub fn new_as_expression(
187        identifier: crate::Identifier,
188        expression: Expression,
189        span: Span,
190    ) -> Expression {
191        Expression {
192            span,
193            value: Self {
194                identifier,
195                expression: Box::new(expression),
196            }
197            .into(),
198        }
199    }
200}
201
202#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
203pub struct ModuloAssignment {
204    pub identifier: crate::Identifier,
205    pub expression: Box<Expression>,
206}
207
208impl ModuloAssignment {
209    pub fn new_as_expression(
210        identifier: crate::Identifier,
211        expression: Expression,
212        span: Span,
213    ) -> Expression {
214        Expression {
215            span,
216            value: Self {
217                identifier,
218                expression: Box::new(expression),
219            }
220            .into(),
221        }
222    }
223}
224
225#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
226pub struct And {
227    pub lhs: Box<Expression>,
228    pub rhs: Box<Expression>,
229}
230
231impl And {
232    pub fn new_as_expression(lhs: Expression, rhs: Expression, span: Span) -> Expression {
233        Expression {
234            span,
235            value: Self {
236                lhs: Box::new(lhs),
237                rhs: Box::new(rhs),
238            }
239            .into(),
240        }
241    }
242}
243
244#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
245pub struct Or {
246    pub lhs: Box<Expression>,
247    pub rhs: Box<Expression>,
248}
249
250impl Or {
251    pub fn new_as_expression(lhs: Expression, rhs: Expression, span: Span) -> Expression {
252        Expression {
253            span,
254            value: Self {
255                lhs: Box::new(lhs),
256                rhs: Box::new(rhs),
257            }
258            .into(),
259        }
260    }
261}
262
263#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
264pub struct Equal {
265    pub lhs: Box<Expression>,
266    pub rhs: Box<Expression>,
267}
268
269impl Equal {
270    pub fn new_as_expression(lhs: Expression, rhs: Expression, span: Span) -> Expression {
271        Expression {
272            span,
273            value: Self {
274                lhs: Box::new(lhs),
275                rhs: Box::new(rhs),
276            }
277            .into(),
278        }
279    }
280}
281#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
282pub struct NotEqual {
283    pub lhs: Box<Expression>,
284    pub rhs: Box<Expression>,
285}
286
287impl NotEqual {
288    pub fn new_as_expression(lhs: Expression, rhs: Expression, span: Span) -> Expression {
289        Expression {
290            span,
291            value: Self {
292                lhs: Box::new(lhs),
293                rhs: Box::new(rhs),
294            }
295            .into(),
296        }
297    }
298}
299
300#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
301pub struct Greater {
302    pub lhs: Box<Expression>,
303    pub rhs: Box<Expression>,
304}
305
306impl Greater {
307    pub fn new_as_expression(lhs: Expression, rhs: Expression, span: Span) -> Expression {
308        Expression {
309            span,
310            value: Self {
311                lhs: Box::new(lhs),
312                rhs: Box::new(rhs),
313            }
314            .into(),
315        }
316    }
317}
318
319#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
320pub struct GreaterEqual {
321    pub lhs: Box<Expression>,
322    pub rhs: Box<Expression>,
323}
324
325impl GreaterEqual {
326    pub fn new_as_expression(lhs: Expression, rhs: Expression, span: Span) -> Expression {
327        Expression {
328            span,
329            value: Self {
330                lhs: Box::new(lhs),
331                rhs: Box::new(rhs),
332            }
333            .into(),
334        }
335    }
336}
337
338#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
339pub struct Less {
340    pub lhs: Box<Expression>,
341    pub rhs: Box<Expression>,
342}
343
344impl Less {
345    pub fn new_as_expression(lhs: Expression, rhs: Expression, span: Span) -> Expression {
346        Expression {
347            span,
348            value: Self {
349                lhs: Box::new(lhs),
350                rhs: Box::new(rhs),
351            }
352            .into(),
353        }
354    }
355}
356
357#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
358pub struct LessEqual {
359    pub lhs: Box<Expression>,
360    pub rhs: Box<Expression>,
361}
362
363impl LessEqual {
364    pub fn new_as_expression(lhs: Expression, rhs: Expression, span: Span) -> Expression {
365        Expression {
366            span,
367            value: Self {
368                lhs: Box::new(lhs),
369                rhs: Box::new(rhs),
370            }
371            .into(),
372        }
373    }
374}
375
376#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
377pub enum Range {
378    Closed {
379        rhs: Box<Expression>,
380        lhs: Box<Expression>,
381    },
382    From {
383        lhs: Box<Expression>,
384    },
385    To {
386        rhs: Box<Expression>,
387    },
388}
389
390#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
391pub struct Addition {
392    pub lhs: Box<Expression>,
393    pub rhs: Box<Expression>,
394}
395
396impl Addition {
397    pub fn new_as_expression(lhs: Expression, rhs: Expression, span: Span) -> Expression {
398        Expression {
399            span,
400            value: Self {
401                lhs: Box::new(lhs),
402                rhs: Box::new(rhs),
403            }
404            .into(),
405        }
406    }
407}
408
409#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
410pub struct Subtraction {
411    pub lhs: Box<Expression>,
412    pub rhs: Box<Expression>,
413}
414
415impl Subtraction {
416    pub fn new_as_expression(lhs: Expression, rhs: Expression, span: Span) -> Expression {
417        Expression {
418            span,
419            value: Self {
420                lhs: Box::new(lhs),
421                rhs: Box::new(rhs),
422            }
423            .into(),
424        }
425    }
426}
427
428#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
429pub struct Multiplication {
430    pub lhs: Box<Expression>,
431    pub rhs: Box<Expression>,
432}
433
434impl Multiplication {
435    pub fn new_as_expression(lhs: Expression, rhs: Expression, span: Span) -> Expression {
436        Expression {
437            span,
438            value: Self {
439                lhs: Box::new(lhs),
440                rhs: Box::new(rhs),
441            }
442            .into(),
443        }
444    }
445}
446
447#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
448pub struct Division {
449    pub lhs: Box<Expression>,
450    pub rhs: Box<Expression>,
451}
452
453impl Division {
454    pub fn new_as_expression(lhs: Expression, rhs: Expression, span: Span) -> Expression {
455        Expression {
456            span,
457            value: Self {
458                lhs: Box::new(lhs),
459                rhs: Box::new(rhs),
460            }
461            .into(),
462        }
463    }
464}
465
466#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
467pub struct Modulo {
468    pub lhs: Box<Expression>,
469    pub rhs: Box<Expression>,
470}
471
472impl Modulo {
473    pub fn new_as_expression(lhs: Expression, rhs: Expression, span: Span) -> Expression {
474        Expression {
475            span,
476            value: Self {
477                lhs: Box::new(lhs),
478                rhs: Box::new(rhs),
479            }
480            .into(),
481        }
482    }
483}
484
485#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
486pub struct Not {
487    pub expression: Box<Expression>,
488}
489
490impl Not {
491    pub fn new_as_expression(expression: Expression, span: Span) -> Expression {
492        Expression {
493            span,
494            value: Self {
495                expression: Box::new(expression),
496            }
497            .into(),
498        }
499    }
500}
501
502#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
503pub struct Negate {
504    pub expression: Box<Expression>,
505}
506
507impl Negate {
508    pub fn new_as_expression(expression: Expression, span: Span) -> Expression {
509        Expression {
510            span,
511            value: Self {
512                expression: Box::new(expression),
513            }
514            .into(),
515        }
516    }
517}
518
519/// ~value
520#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
521pub struct AsError {
522    pub expression: Box<Expression>,
523}
524
525impl AsError {
526    pub fn new_as_expression(expression: Expression, span: Span) -> Expression {
527        Expression {
528            span,
529            value: Self {
530                expression: Box::new(expression),
531            }
532            .into(),
533        }
534    }
535}
536
537/// ?value
538#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
539pub struct Expect {
540    pub expression: Box<Expression>,
541}
542
543impl Expect {
544    pub fn new_as_expression(expression: Expression, span: Span) -> Expression {
545        Expression {
546            span,
547            value: Self {
548                expression: Box::new(expression),
549            }
550            .into(),
551        }
552    }
553}
554
555#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
556pub struct FieldAccess {
557    pub expression: Box<Expression>,
558    pub field: crate::Identifier,
559}
560
561#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
562pub struct Index {
563    pub expression: Box<Expression>,
564    pub index: Box<Expression>,
565}
566
567#[derive(Clone, Debug, IntoExpressionEnum, PartialEq)]
568pub struct Call {
569    pub expression: Box<Expression>,
570    pub arguments: Vec<Expression>,
571}
vyder_core/expression/expressions.rs

vyder_core/expression/
expressions.rs
