remove in

example/ex.hyc

@@ -1,6 +1,6 @@
-let foo = 1 + 1 in 2 + foo;
+let foo = 1 + 1;
 
-if foo == 4 then
+if foo == 2 then
     do
         foo + 1;
     end

src/front/parse.rs

@@ -16,7 +16,7 @@ pub enum Token {
 
     // Keywords
     Import,
-    Let, In, Fun,
+    Let, Fun,
     If, Then, Else, End,
     Do,
 }
@@ -74,7 +74,6 @@ 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,
@@ -117,7 +116,6 @@ pub enum Expr {
     Let {
         name: String,
         value: Box<Self>,
-        then: Box<Option<Self>>,
     },
     Fun {
         name: String,
@@ -141,7 +139,6 @@ fn expr_parser() -> impl Parser<Token, Expr, Error = Simple<Token>> + Clone {
         _ => Err(Simple::expected_input_found(span, Vec::new(), Some(token))),
     }).labelled("identifier");
 
-    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())),
@@ -150,6 +147,7 @@ fn expr_parser() -> impl Parser<Token, Expr, Error = Simple<Token>> + Clone {
         _ => Err(Simple::expected_input_found(span, Vec::new(), Some(token))),
     }).labelled("literal");
 
+    let expr = recursive(|expr| {
         let args = expr.clone()
             .repeated()
             .or_not()
@@ -246,15 +244,9 @@ fn expr_parser() -> impl Parser<Token, Expr, Error = Simple<Token>> + Clone {
                 do_block.clone()
                     .or(decl.clone())
             )
-            .then(just(Token::In)
+            .map(|(name, value)| Expr::Let {
-                .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)
@@ -330,13 +322,8 @@ impl Expr {
             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, then } => {
+            Self::Let{ name, value } => out.push_str(
-                let then = match *then.clone() {
+                &format!("(let\n  {}\n  {})", name, value.clone().to_sexpr())),
-                    Some(v) => format!("\n  (do {})", v.to_sexpr()),
-                    None => "".to_string(),
-                };
-                out.push_str(&format!("(let\n  {}\n  {}{})", name, value.clone().to_sexpr(), then))
-            },
             Self::Fun{ name, args, body } => out.push_str(
                 &format!("(fun\n  ({})\n  {}\n {})", name, args.join(" "), body.to_sexpr())),
 
@@ -345,6 +332,7 @@ impl Expr {
             
             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"));
+                            println!("{}", ast.iter().map(|e| e.to_sexpr()).collect::<Vec<String>>().join("\n\n"));
                         },
                         None => println!("no ast :("),
                     };