blocks

readme.md

@@ -17,19 +17,19 @@ let init = fn() {
   return {
     player: { position: { x: 10, y: 20 }, },
   }
-}
+};
 
 let update = fn(state, events) {
   return state';
-}
+};
 
 let draw = fn(frame, state) {
   frame.clear(0,0,0);
-}
+};
 
 let migrate = fn(state) {
     return { player: { pos: state.player.position } },
-}
+};
 ```
 
 - dynamic software updating could occur every frame

src/parser/parser.rs

@@ -101,8 +101,13 @@ fn parse_simple_expr(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
 fn parse_fn(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
     if let Some(_) = tokens.next_if(&Token::Fn) {
         if let Some(args) = parse_args(tokens)? {
-            if let Some(body) = tokens.between(&Token::OpenCurly, &Token::CloseCurly, parse_expr)? {
+            if let Some(body) =
-                Ok(Some(ast::Expr::Func(Box::new(ast::Fn { args, body }))))
+                tokens.between(&Token::OpenCurly, &Token::CloseCurly, parse_block)?
+            {
+                Ok(Some(ast::Expr::Func(Box::new(ast::Fn {
+                    args,
+                    body: ast::Expr::Block(body),
+                }))))
             } else {
                 Err(Error::UnexpectedTokenForParser(
                     "fn_body".into(),
@@ -120,6 +125,17 @@ fn parse_fn(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
     }
 }
 
+fn parse_block(tokens: &mut Tokens) -> ParseResult<Vec<ast::Statement>> {
+    tokens.many(parse_statement)
+}
+
+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)),
+    ])
+}
+
 fn parse_args(tokens: &mut Tokens) -> ParseResult<Vec<ast::Arg>> {
     tokens.between(&Token::OpenParen, &Token::CloseParen, |ts| {
         ts.many_sep_by(&Token::Comma, parse_identifier_arg)
@@ -312,4 +328,29 @@ mod tests {
         let result = parse(&mut scan(program), parse_definition);
         insta::assert_debug_snapshot!(result);
     }
+    #[test]
+    fn full_program() {
+        let program = "
+let init = fn() {
+  return {
+    player: { position: { x: 10, y: 20 }, },
+  }
+};
+
+let update = fn(state, events) {
+  return state';
+};
+
+let draw = fn(frame, state) {
+  frame.clear(0,0,0);
+};
+
+let migrate = fn(state) {
+    return { player: { pos: state.player.position } },
+};
+"
+        .to_string();
+        let result = parse(&mut scan(program), parse_definitions);
+        insta::assert_debug_snapshot!(result);
+    }
 }

src/parser/snapshots/ayin__parser__parser__tests__fn_def.snap

@@ -22,10 +22,16 @@ Ok(
                     ),
                 },
             ],
-            body: Value(
+            body: Block(
-                Int(
+                [
-                    108,
+                    Expr(
-                ),
+                        Value(
+                            Int(
+                                108,
+                            ),
+                        ),
+                    ),
+                ],
             ),
         },
     ),

src/parser/snapshots/ayin__parser__parser__tests__paren_fncall.snap

@@ -23,10 +23,16 @@ Ok(
                         ),
                     },
                 ],
-                body: Value(
+                body: Block(
-                    Int(
+                    [
-                        108,
+                        Expr(
-                    ),
+                            Value(
+                                Int(
+                                    108,
+                                ),
+                            ),
+                        ),
+                    ],
                 ),
             },
         ),