Skip to main content

mimium_lang/ast/
builder.rs

1pub use crate::ast::{Expr, Literal};
2
3use super::Symbol;
4
5pub fn str_to_symbol<T: ToString>(x: T) -> Symbol {
6    use crate::interner::ToSymbol;
7    x.to_string().to_symbol()
8}
9
10#[macro_export]
11macro_rules! dummy_span {
12    () => {
13        0..0
14    };
15}
16
17#[macro_export]
18macro_rules! number {
19    ($n:literal) => {
20        Expr::Literal(Literal::Float($crate::ast::builder::str_to_symbol($n)))
21            .into_id_without_span()
22    };
23}
24
25#[macro_export]
26macro_rules! string {
27    ($n:expr) => {
28        Expr::Literal(Literal::String($n)).into_id_without_span()
29    };
30}
31#[macro_export]
32macro_rules! var {
33    ($n:literal) => {
34        Expr::Var($crate::ast::builder::str_to_symbol($n)).into_id_without_span()
35    };
36}
37
38#[macro_export]
39macro_rules! app {
40    ($a:expr,$b:expr) => {
41        Expr::Apply($a, $b).into_id_without_span()
42    };
43}
44
45#[macro_export]
46macro_rules! lambda_args {
47    ($args:expr) => {
48        //expect vec![id]
49        $args
50            .iter()
51            .map(|a| TypedId {
52                id: $crate::ast::builder::str_to_symbol(a),
53                ty: $crate::types::Type::Unknown.into_id_with_span(0..0),
54            })
55            .collect::<Vec<_>>()
56    };
57}
58
59#[macro_export]
60macro_rules! lambda {
61    ($args:expr,$body:expr) => {
62        Expr::Lambda(
63            $args
64                .iter()
65                .map(|a: &&'static str| {
66                    $crate::pattern::TypedId::new(
67                        $crate::ast::builder::str_to_symbol(a),
68                        $crate::types::Type::Unknown.into_id(),
69                    )
70                })
71                .collect::<Vec<_>>(),
72            None,
73            $body,
74        )
75        .into_id_without_span()
76    };
77}
78
79#[macro_export]
80macro_rules! let_ {
81    ($id:literal,$body:expr,$then:expr) => {
82        Expr::Let(
83            $crate::pattern::TypedPattern {
84                pat: $crate::pattern::Pattern::Single($crate::ast::builder::str_to_symbol($id)),
85                ty: $crate::types::Type::Unknown.into_id(),
86                default_value: None,
87            },
88            $body,
89            Some($then),
90        )
91        .into_id_without_span()
92    };
93    ($id:literal,$body:expr) => {
94        Expr::Let(
95            $crate::pattern::TypedPattern {
96                pat: $crate::pattern::Pattern::Single($crate::ast::builder::str_to_symbol($id)),
97                ty: $crate::types::Type::Unknown.into_id_with_span(0..0),
98            },
99            Box::new($body),
100            None,
101        )
102        .into_id(0..0)
103    };
104}
105
106#[macro_export]
107macro_rules! letrec {
108    ($id:literal,$ty:expr,$body:expr,$then:expr) => {
109        Expr::LetRec(
110            TypedId::new(
111                $crate::ast::builder::str_to_symbol($id),
112                $ty.unwrap_or($crate::types::Type::Unknown.into_id()),
113            ),
114            $body,
115            $then,
116        )
117        .into_id_without_span()
118    };
119}
120
121#[macro_export]
122macro_rules! assign {
123    ($lhs:literal,$rhs:expr) => {
124        Expr::Assign($crate::ast::builder::str_to_symbol($lhs), Box::new($rhs)).into_id(0..0)
125    };
126}
127#[macro_export]
128macro_rules! then {
129    ($first:expr,$second:expr) => {
130        Expr::Then(Box::new($first), Box::new($second)).into_id(0..0)
131    };
132}
133
134#[macro_export]
135macro_rules! ifexpr {
136    ($cond:expr,$then:expr,$else_:expr) => {
137        Expr::If($cond, $then, Some($else_)).into_id_without_span()
138    };
139}