diff --git a/examples/assign2.rs b/examples/assign2.rs
index 31b644ae7f327eeb4ed83daaaea8422326f6f0ee..07a0c7f198391996322b6920ffb1de8aad6ac2a9 100644
--- a/examples/assign2.rs
+++ b/examples/assign2.rs
@@ -1,6 +1,9 @@
-// test late assignment
+// test late mut assignment
 fn main() {
-    let mut a;
-    a = 5;
-    let b = a;
+    let mut b;
+    b = false;
+    b = true;
+    let mut i;
+    i = 0;
+    i = i + 1;
 }
diff --git a/examples/assign3.rs b/examples/assign3.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5dbd8be014b62f991fd1b0460f83d57eb3c2a813
--- /dev/null
+++ b/examples/assign3.rs
@@ -0,0 +1,7 @@
+// test late assignment
+fn main() {
+    let b;
+    b = false;
+    let mut i;
+    i = 0;
+}
diff --git a/examples/let_if.rs b/examples/let_if.rs
index 2a5d802076be58ceeb69e621f149f59e7cedf90a..9d10e8fa2fa6349786e15467ae303f49f1fb479b 100644
--- a/examples/let_if.rs
+++ b/examples/let_if.rs
@@ -1,4 +1,3 @@
 fn main() {
-    //let a: i32 = if true { 1 } else { 2 };
-    let a = 5;
+    let a: i32 = if true { 1 } else { 2 };
 }
diff --git a/examples/mut.rs b/examples/mut.rs
deleted file mode 100644
index ec2e14053f4a8740ff49f79be78c004f2d13d5b0..0000000000000000000000000000000000000000
--- a/examples/mut.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-fn main() {
-    let mut a = 0;
-    a = 2;
-    let b = a;
-}
diff --git a/examples/mut2.rs b/examples/mut2.rs
deleted file mode 100644
index 33fd4af8276b1200ed6b92eb5603385a39dcd51d..0000000000000000000000000000000000000000
--- a/examples/mut2.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-fn main() {
-    let mut a = 0;
-    a = 2;
-    let mut b = a; // copy semantics
-    a = 3;
-    b = b + 1;
-    let c = a + b;
-}
diff --git a/examples/w1_2.rs b/examples/w1_2.rs
index 83df078f15614ee705964a5a906c5eaded20f218..dcf053610cdbd61efbc5434d392cd17b38f2beb2 100644
--- a/examples/w1_2.rs
+++ b/examples/w1_2.rs
@@ -54,7 +54,7 @@ fn c1(x: bool, y: bool) -> i32 {
     let mut c: i32 = 1;
     while (b < 10) {
         c = c * 2;
-    };
+    }
     c
 }
 
diff --git a/examples/wip.rs b/examples/wip.rs
index 852c5b27604c6ca2452caa7082d26e328bae4d20..f19568761a93f249db1cc1ec260046b0283837fe 100644
--- a/examples/wip.rs
+++ b/examples/wip.rs
@@ -16,5 +16,5 @@ fn main() {
 }
 
 fn b(x: i32) -> i32 {
-    x;
+    x
 }
diff --git a/src/ast.rs b/src/ast.rs
index f57b199461fcbd58a8d4451137e31f0f143e8863..18fb7b3dd7df8ae54273bd0e63df1898a241ba43 100644
--- a/src/ast.rs
+++ b/src/ast.rs
@@ -213,7 +213,6 @@ impl Display for Stmts {
 impl Stmts {
     fn ifmt(&self, fmt: &mut Formatter, indent: usize) -> Result<(), Error> {
         write!(fmt, "{{")?;
-        let len = self.stmts.len();
         for s in &self.stmts {
             // set tab
             write!(fmt, "\n{}", " ".repeat(indent + 4))?;
@@ -324,7 +323,7 @@ impl Display for Expr {
 }
 
 impl Expr {
-    fn ifmt(&self, fmt: &mut Formatter, indent: i32) -> Result<(), Error> {
+    fn _ifmt(&self, fmt: &mut Formatter, _indent: i32) -> Result<(), Error> {
         use self::Expr::*;
         match *self {
             Num(n) => write!(fmt, "{}", n),
diff --git a/src/env.rs b/src/env.rs
index e7ad73af720cf492a3acf14c9b32fc2e7c2670c9..f7a0d9297711bc2eee8b095c534a41a197600f14 100644
--- a/src/env.rs
+++ b/src/env.rs
@@ -187,21 +187,21 @@ fn test_type_env() {
     };
 }
 
-#[test]
-fn fn_decl_env() {
-    use crate::*;
-    let p = grammar::ProgramParser::new().parse(fn_mixed!()).unwrap();
-    let fn_env = new_fn_env(&p.fn_decls);
-
-    assert_eq! {
-        **fn_env.get("main").unwrap(),
-        FnDecl {
-            id: "main".to_string(),
-            params: Params(vec![]),
-            result: Type::Unit,
-            body: Stmts{ stmts: vec![], ret: true }
-        }
-    };
-
-    println!("{}", p);
-}
+// #[test]
+// fn fn_decl_env() {
+//     use crate::*;
+//     let p = grammar::ProgramParser::new().parse(fn_mixed!()).unwrap();
+//     let fn_env = new_fn_env(&p.fn_decls);
+
+//     assert_eq! {
+//         **fn_env.get("main").unwrap(),
+//         FnDecl {
+//             id: "main".to_string(),
+//             params: Params(vec![]),
+//             result: Type::Unit,
+//             body: Stmts{ stmts: vec![], trailing_semi: false }
+//         }
+//     };
+
+//     println!("{}", p);
+// }
diff --git a/src/grammar.lalrpop b/src/grammar.lalrpop
index a1d4d6522570484314f2c4ee8c09f255e6dda3e3..38bf06137cb143b9057a80dc7977b4da7f7fa1cb 100644
--- a/src/grammar.lalrpop
+++ b/src/grammar.lalrpop
@@ -121,16 +121,11 @@ Type : Type = {
 }
 
 pub Block: Stmts = {
-    "{" <Stmt> "}" => 
-        Stmts {
-            trailing_semi : match <> {
-                Stmt::Semi => true,
-                _ => false,
-            },
-            stmts: vec![<>],
-        },
-    "{" <stmts: StmtSeq*> "}" => {
-        let stmts: Vec<Stmt> = stmts.into_iter().flatten().collect();
+    "{" <stmts: StmtSeq*> <stmt: Stmt?> "}" => {
+        let mut stmts: Vec<Stmt> = stmts.into_iter().flatten().collect();
+        if let Some(stmt) = stmt {
+            stmts.push(stmt);
+        };
         Stmts { 
             trailing_semi: match &stmts.last() { 
                 Some(Stmt::Semi) => true, 
diff --git a/tests/test_check.rs b/tests/test_check.rs
index ce824c195dc247ff1c82929e4fb51f20635a3cac..72e002019bb69103aa0f05572811e66f8135ea39 100644
--- a/tests/test_check.rs
+++ b/tests/test_check.rs
@@ -3,7 +3,7 @@ use erode::read_file;
 
 #[test]
 fn check_w1_2() {
-    assert!(check(&read_file::parse("examples/w1_2.rs")).is_ok());
+    check(&read_file::parse("examples/w1_2.rs")).unwrap();
 }
 
 #[test]
@@ -13,32 +13,32 @@ fn check_prog() {
 
 #[test]
 fn check_assign() {
-    assert!(check(&read_file::parse("examples/assign.rs")).is_ok());
+    check(&read_file::parse("examples/assign.rs")).unwrap();
 }
 
 #[test]
 fn check_assign2() {
-    assert!(check(&read_file::parse("examples/assign2.rs")).is_ok());
+    check(&read_file::parse("examples/assign2.rs")).unwrap();
 }
 
 #[test]
 fn check_assign3() {
-    assert!(check(&read_file::parse("examples/assign3.rs")).is_ok());
+    check(&read_file::parse("examples/assign3.rs")).unwrap();
 }
 
 #[test]
 fn check_assign_err() {
-    assert!(check(&read_file::parse("examples/assign_err.rs")).is_err());
+    check(&read_file::parse("examples/assign_err.rs")).unwrap_err();
 }
 
 #[test]
 fn check_assign_err2() {
-    assert!(check(&read_file::parse("examples/assign_err2.rs")).is_err());
+    check(&read_file::parse("examples/assign_err2.rs")).unwrap_err();
 }
 
 #[test]
 fn check_assign_err3() {
-    assert!(check(&read_file::parse("examples/assign_err3.rs")).is_err());
+    check(&read_file::parse("examples/assign_err3.rs")).unwrap_err();
 }
 
 #[test]
@@ -48,134 +48,125 @@ fn check_let() {
 
 #[test]
 fn check_let2() {
-    assert!(check(&read_file::parse("examples/let2.rs")).is_ok());
+    check(&read_file::parse("examples/let2.rs")).unwrap();
 }
 
 #[test]
 fn check_call() {
-    assert!(check(&read_file::parse("examples/call.rs")).is_ok());
+    check(&read_file::parse("examples/call.rs")).unwrap();
 }
 
 #[test]
 fn check_call2() {
-    assert!(check(&read_file::parse("examples/call2.rs")).is_ok());
+    check(&read_file::parse("examples/call2.rs")).unwrap();
 }
 
 #[test]
 fn check_call3() {
-    assert!(check(&read_file::parse("examples/call3.rs")).is_ok());
+    check(&read_file::parse("examples/call3.rs")).unwrap();
 }
 
 #[test]
 fn check_call_err() {
-    assert!(check(&read_file::parse("examples/call_err.rs")).is_err());
+    check(&read_file::parse("examples/call_err.rs")).unwrap_err();
 }
 
 #[test]
 fn check_call_err2() {
-    assert!(check(&read_file::parse("examples/call_err2.rs")).is_err());
-}
-#[test]
-fn check_mut() {
-    assert!(check(&read_file::parse("examples/mut.rs")).is_ok());
-}
-
-#[test]
-fn check_mut2() {
-    assert!(check(&read_file::parse("examples/mut2.rs")).is_ok());
+    check(&read_file::parse("examples/call_err2.rs")).unwrap_err();
 }
 
 #[test]
 fn check_type_err() {
-    assert!(check(&read_file::parse("examples/type_err.rs")).is_err());
+    check(&read_file::parse("examples/type_err.rs")).unwrap_err();
 }
 
 #[test]
 fn check_type_err2() {
-    assert!(check(&read_file::parse("examples/type_err2.rs")).is_err());
+    check(&read_file::parse("examples/type_err2.rs")).unwrap_err();
 }
 
 #[test]
 fn check_if() {
-    assert!(check(&read_file::parse("examples/if.rs")).is_ok());
+    check(&read_file::parse("examples/if.rs")).unwrap();
 }
 
 #[test]
 fn check_while() {
-    assert!(check(&read_file::parse("examples/while.rs")).is_ok());
+    check(&read_file::parse("examples/while.rs")).unwrap();
 }
 
 #[test]
 fn check_deref_assign() {
-    assert!(check(&read_file::parse("examples/deref_assign.rs")).is_ok());
+    check(&read_file::parse("examples/deref_assign.rs")).unwrap();
 }
 
 #[test]
 fn check_deref_assign2() {
-    assert!(check(&read_file::parse("examples/deref_assign2.rs")).is_ok());
+    check(&read_file::parse("examples/deref_assign2.rs")).unwrap();
 }
 
 #[test]
 fn check_ref() {
-    assert!(check(&read_file::parse("examples/ref.rs")).is_ok());
+    check(&read_file::parse("examples/ref.rs")).unwrap();
 }
 
 #[test]
 fn check_ref2() {
-    assert!(check(&read_file::parse("examples/ref2.rs")).is_ok());
+    check(&read_file::parse("examples/ref2.rs")).unwrap();
 }
 
 #[test]
 fn check_ref3() {
-    assert!(check(&read_file::parse("examples/ref3.rs")).is_ok());
+    check(&read_file::parse("examples/ref3.rs")).unwrap();
 }
 
 #[test]
 fn check_ref4() {
-    assert!(check(&read_file::parse("examples/ref4.rs")).is_ok());
+    check(&read_file::parse("examples/ref4.rs")).unwrap();
 }
 
 #[test]
 fn check_ref5() {
-    assert!(check(&read_file::parse("examples/ref5.rs")).is_ok());
+    check(&read_file::parse("examples/ref5.rs")).unwrap();
 }
 
 #[test]
 fn check_ref_err() {
-    assert!(check(&read_file::parse("examples/ref_err.rs")).is_err());
+    check(&read_file::parse("examples/ref_err.rs")).unwrap_err();
 }
 
 #[test]
 fn check_ref_err2() {
-    assert!(check(&read_file::parse("examples/ref_err2.rs")).is_err());
+    check(&read_file::parse("examples/ref_err2.rs")).unwrap_err();
 }
 
 #[test]
 fn check_ref_err3() {
-    assert!(check(&read_file::parse("examples/ref_err3.rs")).is_err());
+    check(&read_file::parse("examples/ref_err3.rs")).unwrap_err();
 }
 
 #[test]
 fn check_ref_err4() {
-    assert!(check(&read_file::parse("examples/ref_err4.rs")).is_err());
+    check(&read_file::parse("examples/ref_err4.rs")).unwrap_err();
 }
 
 #[test]
 fn check_scopes() {
-    assert!(check(&read_file::parse("examples/scopes.rs")).is_ok());
+    check(&read_file::parse("examples/scopes.rs")).unwrap();
 }
 
 #[test]
 fn check_scopes_err() {
-    assert!(check(&read_file::parse("examples/scopes_err.rs")).is_err());
+    check(&read_file::parse("examples/scopes_err.rs")).unwrap_err();
 }
 
 #[test]
 fn check_let_if() {
-    assert!(check(&read_file::parse("examples/let_if.rs")).is_err());
+    check(&read_file::parse("examples/let_if.rs")).unwrap();
 }
 
 #[test]
 fn wip() {
-    let _ = check(&read_file::parse("examples/wip.rs")).unwrap();
+    check(&read_file::parse("examples/wip.rs")).unwrap();
 }
diff --git a/tests/test_parser.rs b/tests/test_parser.rs
index f5a7180a471490b41bc3b1b1335d96a181a567bc..f7e0dc4180c11efdca98bafcd113d57aa4a8fa3c 100644
--- a/tests/test_parser.rs
+++ b/tests/test_parser.rs
@@ -56,35 +56,35 @@ fn test_exprs() {
 #[test]
 fn test_stmts() {
     // test empty sequence
-    assert!(StmtsParser::new().parse("").is_ok());
+    assert!(BlockParser::new().parse("").is_ok());
 
     // test let with no assignment and inferred type
-    assert!(StmtsParser::new().parse("let a").is_ok());
+    assert!(BlockParser::new().parse("let a").is_ok());
 
     // test let with no assignment and excplicit type
-    assert!(StmtsParser::new().parse("let a : u32").is_ok());
+    assert!(BlockParser::new().parse("let a : u32").is_ok());
 
     // test let with inferred type
-    assert!(StmtsParser::new().parse("let a = 0").is_ok());
+    assert!(BlockParser::new().parse("let a = 0").is_ok());
 
     // test let with explicit type
-    assert!(StmtsParser::new().parse("let a : u16 = 1 + 2").is_ok());
+    assert!(BlockParser::new().parse("let a : u16 = 1 + 2").is_ok());
 
     // test assignment
-    assert!(StmtsParser::new().parse("a = 1 + 2").is_ok());
+    assert!(BlockParser::new().parse("a = 1 + 2").is_ok());
 
     // test assignment
-    assert!(StmtsParser::new().parse("*a = 1 + 2").is_ok());
+    assert!(BlockParser::new().parse("*a = 1 + 2").is_ok());
 
     // test if then
-    assert!(StmtsParser::new().parse("if a { b = 5 }").is_ok());
+    assert!(BlockParser::new().parse("if a { b = 5 }").is_ok());
 
     // test if then else
-    assert!(StmtsParser::new()
+    assert!(BlockParser::new()
         .parse("if a { b = 5 } else { b = 7 }")
         .is_ok());
 
-    assert!(StmtsParser::new()
+    assert!(BlockParser::new()
         .parse("while hello(b) { b = b - 5 }")
         .is_ok());
 }