example/ex.hyc

@@ -1,9 +1 @@
-let foo = 1 + 1;
+let foo = 1 + 1 in 2 + foo;
-
-if foo == 2 then
-    do
-        foo + 1;
-    end
-else
-    foo - 1;
-end;

src/front/parse.rs

@@ -16,7 +16,7 @@ pub enum Token {
 
     // Keywords
     Import,
-    Let, Fun,
+    Let, In, Fun,
     If, Then, Else, End,
     Do,
 }
@@ -74,6 +74,7 @@ pub fn lexer() -> impl Parser<char, Vec<(Token, Span)>, Error = Simple<char>> {
 
         "import" => Token::Import,
         "let" => Token::Let,
+        "in" => Token::In,
         "fun" => Token::Fun,
         "if" => Token::If,
         "then" => Token::Then,
@@ -116,6 +117,7 @@ pub enum Expr {
     Let {
         name: String,
         value: Box<Self>,
+        then: Box<Option<Self>>,
     },
     Fun {
         name: String,
@@ -139,15 +141,15 @@ fn expr_parser() -> impl Parser<Token, Expr, Error = Simple<Token>> + Clone {
         _ => Err(Simple::expected_input_found(span, Vec::new(), Some(token))),
     }).labelled("identifier");
 
-    let literal = filter_map(|span, token| match token {
-        Token::Int(i) => Ok(Expr::Int(i)),
-        Token::Float(f) => Ok(Expr::Float(f.parse().unwrap())),
-        Token::Boolean(b) => Ok(Expr::Boolean(b)),
-        Token::String(s) => Ok(Expr::String(s)),
-        _ => Err(Simple::expected_input_found(span, Vec::new(), Some(token))),
-    }).labelled("literal");
-
     let expr = recursive(|expr| {
+        let literal = filter_map(|span, token| match token {
+            Token::Int(i) => Ok(Expr::Int(i)),
+            Token::Float(f) => Ok(Expr::Float(f.parse().unwrap())),
+            Token::Boolean(b) => Ok(Expr::Boolean(b)),
+            Token::String(s) => Ok(Expr::String(s)),
+            _ => Err(Simple::expected_input_found(span, Vec::new(), Some(token))),
+        }).labelled("literal");
+
         let args = expr.clone()
             .repeated()
             .or_not()
@@ -244,9 +246,15 @@ fn expr_parser() -> impl Parser<Token, Expr, Error = Simple<Token>> + Clone {
                 do_block.clone()
                     .or(decl.clone())
             )
-            .map(|(name, value)| Expr::Let {
+            .then(just(Token::In)
+                .ignore_then(do_block.clone()
+                    .or(decl.clone()))
+                .or_not()
+            )
+            .map(|((name, value), then)| Expr::Let {
                 name,
                 value: Box::new(value),
+                then: Box::new(then),
             }).labelled("variable");
 
         let declare_fun = just(Token::Fun)
@@ -319,20 +327,16 @@ impl Expr {
             Self::Binary{ op, left, right } => out.push_str(
                 &format!("({} {} {})", op, left.to_sexpr(), right.to_sexpr())
             ),
-            Self::Call{ name, args } => out.push_str(
-                &format!("({} {})", name.to_sexpr(), args.iter().map(|x| x.to_sexpr()).collect::<Vec<_>>().join(" "))),
 
-            Self::Let{ name, value } => out.push_str(
+            Self::Let{ name, value, then } => {
-                &format!("(let\n  {}\n  {})", name, value.clone().to_sexpr())),
+                let then = match *then.clone() {
-            Self::Fun{ name, args, body } => out.push_str(
+                    Some(v) => format!("\n  (do {})", v.to_sexpr()),
-                &format!("(fun\n  ({})\n  {}\n {})", name, args.join(" "), body.to_sexpr())),
+                    None => "".to_string(),
+                };
+                out.push_str(&format!("(let\n  {}\n  {}{})", name, value.clone().to_sexpr(), then))
+            },
 
-            Self::If { cond, then, else_ } => out.push_str(
+            // TODO: finish the rest of the Expr, I'm going to sleep, goodnight.
-                &format!("(if {}\n  {}\n  {})", cond.to_sexpr(), then.to_sexpr(), else_.to_sexpr())),
-            
-            Self::Do { body } => out.push_str(
-                &format!("(do {})", body.iter().map(|x| x.to_sexpr()).collect::<Vec<_>>().join(" "))),
-            
             _ => todo!(), 
         }
         out

src/main.rs

@@ -24,7 +24,7 @@ fn main() {
                 if parse_error.is_empty() {
                     match ast {
                         Some(ast) => {
-                            println!("{}", ast.iter().map(|e| e.to_sexpr()).collect::<Vec<String>>().join("\n\n"));
+                            println!("{}", ast.iter().map(|e| e.to_sexpr()).collect::<String>())
                         },
                         None => println!("no ast :("),
                     };