return keyword

crates/lexer/src/lib.rs

@@ -6,6 +6,7 @@ pub enum Token {
     KwLet, KwFun,
     KwDo, KwEnd,
     KwIf, KwThen, KwElse,
+    KwReturn,
 
     // Literals
     Int(i64), Float(String), Boolean(bool),
@@ -32,6 +33,7 @@ impl std::fmt::Display for Token {
             Token::KwIf => write!(f, "if"),
             Token::KwThen => write!(f, "then"),
             Token::KwElse => write!(f, "else"),
+            Token::KwReturn => write!(f, "return"),
 
             Token::Int(i) => write!(f, "{}", i),
             Token::Float(s) => write!(f, "{}", s),
@@ -105,6 +107,7 @@ pub fn lexer() -> impl Parser<char, Vec<(Token, Span)>, Error = Simple<char>> {
         "if" => Token::KwIf,
         "then" => Token::KwThen,
         "else" => Token::KwElse,
+        "return" => Token::KwReturn,
         _ => Token::Identifier(s),
     });
 

crates/main/src/main.rs

@@ -84,6 +84,9 @@ fn main() {
                                             .fg(Color::Red)
                                     ))
                                     .with_color(Color::Red)
+                            )
+                            .with_help(
+                                "You might have forgotten to end a previous line with semicolon"
                             ),
                         _ => {
                             println!("{:?}", e);

crates/parser/src/lib.rs

@@ -23,6 +23,7 @@ pub enum Expr {
         args: Spanned<Vec<(Spanned<String>, Spanned<String>)>>,
         body: Box<Spanned<Self>>
     },
+    Return { expr: Box<Spanned<Self>> },
     
     If {
         cond: Box<Spanned<Self>>,
@@ -193,6 +194,17 @@ fn expr_parser() -> impl Parser<Token, Vec<Spanned<Expr>>, Error = Simple<Token>
                 )
             });
 
+        let return_ = just(Token::KwReturn)
+            .ignore_then(expr.clone())
+            .map(|(expr, span)| {
+                (
+                    Expr::Return {
+                        expr: Box::new((expr, span.clone())),
+                    },
+                    span.start..span.end,
+                )
+            });
+
         let do_block = just(Token::KwDo)
             .ignore_then(
                 expr.clone()
@@ -211,6 +223,7 @@ fn expr_parser() -> impl Parser<Token, Vec<Spanned<Expr>>, Error = Simple<Token>
 
         let_
             .or(fun)
+            .or(return_)
             .or(do_block)
             .or(compare)
     }).labelled("expression");

example/ex.hades

@@ -7,4 +7,11 @@ fun add (lhs: Int) (rhs: Int): Int = lhs + rhs;
 fun add_2 (lhs: Int) (rhs: Int): Int = do
     let a: Int = lhs + rhs;
     let b: Int = a + lhs;
+    return b;
+end;
+
+-- Entry point (maybe)
+fun main: Void = do
+    print(add(34, 35));
+    return 0;
 end;