diff --git a/src/ast/types.rs b/src/ast/types.rs
index 293b6cd..d4d4401 100644
--- a/src/ast/types.rs
+++ b/src/ast/types.rs
@@ -48,6 +48,7 @@ pub enum Op {
 pub enum Statement {
     Expr(Expr),
     Let(Definition),
+    Return(Option<Expr>),
 }
 
 #[derive(PartialEq, PartialOrd, Debug, Clone)]
diff --git a/src/interpret/interpret.rs b/src/interpret/interpret.rs
index 9facf9f..cbdbc86 100644
--- a/src/interpret/interpret.rs
+++ b/src/interpret/interpret.rs
@@ -39,6 +39,7 @@ fn eval_statement(
             expr_env.insert(name.clone(), result.clone());
             Ok(result)
         }
+        ast::Statement::Return(_) => todo!(),
     }
 }
 
diff --git a/src/parser/parser.rs b/src/parser/parser.rs
index 306d40f..91dc3b0 100644
--- a/src/parser/parser.rs
+++ b/src/parser/parser.rs
@@ -133,6 +133,21 @@ fn parse_statement(tokens: &mut Tokens) -> ParseResult<ast::Statement> {
     tokens.one_of(vec![
         |tokens| Ok(parse_expr(tokens)?.map(ast::Statement::Expr)),
         |tokens| Ok(parse_definition(tokens)?.map(ast::Statement::Let)),
+        |tokens| {
+            if let Some(_) = tokens.next_if(&Token::Return) {
+                let expr = parse_expr(tokens)?;
+                if let Some(_) = tokens.next_if(&Token::Semicolon) {
+                    Ok(Some(ast::Statement::Return(expr)))
+                } else {
+                    Err(Error::UnexpectedToken {
+                        expected: (Token::Return),
+                        got: tokens.next(),
+                    })
+                }
+            } else {
+                Ok(None)
+            }
+        },
     ])
 }
 
@@ -334,11 +349,11 @@ mod tests {
 let init = fn() {
   return {
     player: { position: { x: 10, y: 20 }, },
-  }
+  };
 };
 
 let update = fn(state, events) {
-  return state';
+  return state2;
 };
 
 let draw = fn(frame, state) {
diff --git a/src/parser/types.rs b/src/parser/types.rs
index 85ddacd..44dddc3 100644
--- a/src/parser/types.rs
+++ b/src/parser/types.rs
@@ -112,10 +112,7 @@ impl Tokens {
                 if let Some(result) = parser(self)? {
                     results.push(result);
                 } else {
-                    return Err(Error::UnexpectedTokenForParser(
-                        "sep_by_many".into(),
-                        self.next(),
-                    ));
+                    break;
                 }
             }
             Ok(Some(results))