diff --git a/readme.md b/readme.md
index d42cde8..dbb44ba 100644
--- a/readme.md
+++ b/readme.md
@@ -28,7 +28,7 @@ let draw = fn(frame, state) {
 };
 
 let migrate = fn(state) {
-    return { player: { pos: state.player.position } },
+    return { player: { pos: state.player.position } };
 };
 ```
 
diff --git a/src/parser/parser.rs b/src/parser/parser.rs
index 09b9efc..ed229d0 100644
--- a/src/parser/parser.rs
+++ b/src/parser/parser.rs
@@ -399,7 +399,7 @@ let draw = fn(frame, state) {
 };
 
 let migrate = fn(state) {
-    return { player: { pos: state.player.position } },
+    return { player: { pos: state.player.position } };
 };
 "
         .to_string();
diff --git a/src/parser/snapshots/ayin__parser__parser__tests__full_program.snap b/src/parser/snapshots/ayin__parser__parser__tests__full_program.snap
new file mode 100644
index 0000000..9155220
--- /dev/null
+++ b/src/parser/snapshots/ayin__parser__parser__tests__full_program.snap
@@ -0,0 +1,217 @@
+---
+source: src/parser/parser.rs
+expression: result
+---
+Ok(
+    [
+        Definition {
+            name: Name(
+                "init",
+            ),
+            expr: Func(
+                Fn {
+                    args: [],
+                    body: Block(
+                        [
+                            Return(
+                                Some(
+                                    Value(
+                                        Record(
+                                            Record(
+                                                {
+                                                    Label(
+                                                        "player",
+                                                    ): Value(
+                                                        Record(
+                                                            Record(
+                                                                {
+                                                                    Label(
+                                                                        "position",
+                                                                    ): Value(
+                                                                        Record(
+                                                                            Record(
+                                                                                {
+                                                                                    Label(
+                                                                                        "x",
+                                                                                    ): Value(
+                                                                                        Int(
+                                                                                            10,
+                                                                                        ),
+                                                                                    ),
+                                                                                    Label(
+                                                                                        "y",
+                                                                                    ): Value(
+                                                                                        Int(
+                                                                                            20,
+                                                                                        ),
+                                                                                    ),
+                                                                                },
+                                                                            ),
+                                                                        ),
+                                                                    ),
+                                                                },
+                                                            ),
+                                                        ),
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ],
+                    ),
+                },
+            ),
+        },
+        Definition {
+            name: Name(
+                "update",
+            ),
+            expr: Func(
+                Fn {
+                    args: [
+                        Arg {
+                            name: Name(
+                                "state",
+                            ),
+                        },
+                        Arg {
+                            name: Name(
+                                "events",
+                            ),
+                        },
+                    ],
+                    body: Block(
+                        [
+                            Return(
+                                Some(
+                                    Var(
+                                        Name(
+                                            "state2",
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ],
+                    ),
+                },
+            ),
+        },
+        Definition {
+            name: Name(
+                "draw",
+            ),
+            expr: Func(
+                Fn {
+                    args: [
+                        Arg {
+                            name: Name(
+                                "frame",
+                            ),
+                        },
+                        Arg {
+                            name: Name(
+                                "state",
+                            ),
+                        },
+                    ],
+                    body: Block(
+                        [
+                            Expr(
+                                FunCall {
+                                    func: Access {
+                                        expr: Var(
+                                            Name(
+                                                "frame",
+                                            ),
+                                        ),
+                                        field: Label(
+                                            "clear",
+                                        ),
+                                    },
+                                    args: [
+                                        Value(
+                                            Int(
+                                                0,
+                                            ),
+                                        ),
+                                        Value(
+                                            Int(
+                                                0,
+                                            ),
+                                        ),
+                                        Value(
+                                            Int(
+                                                0,
+                                            ),
+                                        ),
+                                    ],
+                                },
+                            ),
+                        ],
+                    ),
+                },
+            ),
+        },
+        Definition {
+            name: Name(
+                "migrate",
+            ),
+            expr: Func(
+                Fn {
+                    args: [
+                        Arg {
+                            name: Name(
+                                "state",
+                            ),
+                        },
+                    ],
+                    body: Block(
+                        [
+                            Return(
+                                Some(
+                                    Value(
+                                        Record(
+                                            Record(
+                                                {
+                                                    Label(
+                                                        "player",
+                                                    ): Value(
+                                                        Record(
+                                                            Record(
+                                                                {
+                                                                    Label(
+                                                                        "pos",
+                                                                    ): Access {
+                                                                        expr: Access {
+                                                                            expr: Var(
+                                                                                Name(
+                                                                                    "state",
+                                                                                ),
+                                                                            ),
+                                                                            field: Label(
+                                                                                "player",
+                                                                            ),
+                                                                        },
+                                                                        field: Label(
+                                                                            "position",
+                                                                        ),
+                                                                    },
+                                                                },
+                                                            ),
+                                                        ),
+                                                    ),
+                                                },
+                                            ),
+                                        ),
+                                    ),
+                                ),
+                            ),
+                        ],
+                    ),
+                },
+            ),
+        },
+    ],
+)
diff --git a/src/parser/types.rs b/src/parser/types.rs
index 44dddc3..232116f 100644
--- a/src/parser/types.rs
+++ b/src/parser/types.rs
@@ -33,6 +33,7 @@ pub struct Tokens(pub Vec<LocatedToken>);
 
 impl From<Vec<LocatedToken>> for Tokens {
     fn from(mut tokens: Vec<LocatedToken>) -> Tokens {
+        // println!("{tokens:#?}");
         tokens.reverse();
         Tokens(tokens)
     }
@@ -60,14 +61,15 @@ impl Tokens {
                 if let Some(_end) = self.next_if(end) {
                     Ok(Some(result))
                 } else {
+                    // println!("{:#?}", self);
                     Err(Error::UnexpectedTokenForParser(
-                        "between".into(),
+                        format!("between end {start:#?} and {end:#?}"),
                         self.next(),
                     ))
                 }
             } else {
                 Err(Error::UnexpectedTokenForParser(
-                    "between".into(),
+                    "between parser".into(),
                     self.next(),
                 ))
             }