--- a/src/ast_convert.rs
+++ b/src/ast_convert.rs
@@ -3,6 +3,12 @@ use python_ast::{Module, Statement, Expr
 use cpython::{Python, PyObject};
 use cpython::ObjectProtocol; //for call method
 
+fn get_str(py: Python, object: PyObject) -> String {
+    let pystring = object.str(py).unwrap();
+    let mut string = pystring.to_string(py).unwrap();
+    string.to_mut().to_string()
+}
+
 fn parse_expr_vec(py: Python, ast: PyObject) -> Vec<Expr> {
     let builtins_module = py.import("builtins").unwrap();
     let isinstance = builtins_module.get(py, "isinstance").unwrap();
@@ -84,44 +90,24 @@ fn parse_expr(py: Python, ast: PyObject)
     assert!(is_instance(&ast, &ast_type));
 
     if is_instance(&ast, &arg_type) {
-        let arg = {
-            let arg = ast.getattr(py, "arg").unwrap();
-            let arg = arg.str(py).unwrap();
-            let mut arg = arg.to_string(py).unwrap();
-            arg.to_mut().to_string()
-        };
+        let arg = ast.getattr(py, "arg").unwrap();
+        let arg = get_str(py, arg);
         Expr::Name(arg)
     } else if is_instance(&ast, &name_type) {
-        let id = {
-            let id = ast.getattr(py, "id").unwrap();
-            let id = id.str(py).unwrap();
-            let mut id = id.to_string(py).unwrap();
-            id.to_mut().to_string()
-        };
+        let id = ast.getattr(py, "id").unwrap();
+        let id = get_str(py, id);
         Expr::Name(id)
     } else if is_instance(&ast, &name_constant_type) {
-        let value = {
-            let value = ast.getattr(py, "value").unwrap();
-            let value = value.str(py).unwrap();
-            let mut value = value.to_string(py).unwrap();
-            value.to_mut().to_string()
-        };
+        let value = ast.getattr(py, "value").unwrap();
+        let value = get_str(py, value);
         Expr::NameConstant(value)
     } else if is_instance(&ast, &num_type) {
-        let n = {
-            let n = ast.getattr(py, "n").unwrap();
-            let n = n.str(py).unwrap();
-            let mut n = n.to_string(py).unwrap();
-            n.to_mut().to_string()
-        };
+        let n = ast.getattr(py, "n").unwrap();
+        let n = get_str(py, n);
         Expr::Num(n)
     } else if is_instance(&ast, &str_type) {
-        let s = {
-            let s = ast.getattr(py, "s").unwrap();
-            let s = s.str(py).unwrap();
-            let mut s = s.to_string(py).unwrap();
-            s.to_mut().to_string()
-        };
+        let s = ast.getattr(py, "s").unwrap();
+        let s = get_str(py, s);
         Expr::Str(s)
     } else if is_instance(&ast, &bin_op_type) {
         let left = ast.getattr(py, "left").unwrap();
@@ -151,21 +137,11 @@ fn parse_expr(py: Python, ast: PyObject)
         let name = ast.getattr(py, "name").unwrap();
         let asname = ast.getattr(py, "asname").unwrap();
 
-        let name = {
-            let name = name.str(py).unwrap();
-            let mut name = name.to_string(py).unwrap();
-            name.to_mut().to_string()
-        };
-
-        let asname = {
-            let asname = asname.str(py).unwrap();
-            let mut asname = asname.to_string(py).unwrap();
-            let asname = asname.to_mut().to_string();
-            if asname == "None" {
-                "".to_string()
-            } else {
-                asname
-            }
+        let name = get_str(py, name);
+        let asname = if asname == py.None() {
+            None
+        } else {
+            Some(get_str(py, asname))
         };
 
         Expr::Alias(name, asname)
@@ -241,12 +217,7 @@ fn parse_statement(py: Python, ast: PyOb
         let args = ast.getattr(py, "args").unwrap();
         let body = ast.getattr(py, "body").unwrap();
 
-        let name = {
-            let name = name.str(py).unwrap();
-            let mut name = name.to_string(py).unwrap();
-            name.to_mut().to_string()
-        };
-
+        let name = get_str(py, name);
         let args = parse_expr_vec(py, args);
         /*
         let mut arguments = vec!();
@@ -268,11 +239,8 @@ fn parse_statement(py: Python, ast: PyOb
 
         let mut globals = vec!();
         for name in names.iter(py).unwrap() {
-            let name = {
-                let name = name.unwrap().str(py).unwrap();
-                let mut name = name.to_string(py).unwrap();
-                name.to_mut().to_string()
-            };
+            let name = name.unwrap();
+            let name = get_str(py, name);
             globals.push(name);
         }
 
@@ -286,13 +254,15 @@ fn parse_statement(py: Python, ast: PyOb
 
         let mut statements = vec!();
         for statement in body.iter(py).unwrap() {
-            let statement = parse_statement(py, statement.unwrap());
+            let statement = statement.unwrap();
+            let statement = parse_statement(py, statement);
             statements.push(statement);
         }
 
         let mut orelse_ = vec!();
         for statement in orelse.iter(py).unwrap() {
-            let statement = parse_statement(py, statement.unwrap());
+            let statement = statement.unwrap();
+            let statement = parse_statement(py, statement);
             orelse_.push(statement);
         }
 
@@ -303,7 +273,8 @@ fn parse_statement(py: Python, ast: PyOb
 
         let mut arguments = vec!();
         for target in targets.iter(py).unwrap() {
-            let target = parse_expr(py, target.unwrap());
+            let target = target.unwrap();
+            let target = parse_expr(py, target);
             arguments.push(target);
         }
 
@@ -315,11 +286,7 @@ fn parse_statement(py: Python, ast: PyOb
         let names = ast.getattr(py, "names").unwrap();
         //let level = ast.getattr(py, "level").unwrap();
 
-        let module = {
-            let module = module.str(py).unwrap();
-            let mut module = module.to_string(py).unwrap();
-            module.to_mut().to_string()
-        };
+        let module = get_str(py, module);
 
         let mut names_ = vec!();
         for alias in names.iter(py).unwrap() {