--- a/src/ast_dump.rs
+++ b/src/ast_dump.rs
@@ -2,6 +2,10 @@ use python_ast::{Module, stmt, expr, boo
 
 use std::iter;
 
+trait to_string_able {
+    fn to_string(&self) -> String;
+}
+
 impl boolop {
     fn to_string(&self) -> &'static str {
         match *self {
@@ -59,23 +63,15 @@ impl cmpop {
     }
 }
 
-fn args_to_strings(args: Vec<expr>) -> Vec<String> {
-    let mut arguments = vec!();
-    for arg in args {
-        arguments.push(arg.to_string());
+fn vec_to_strings_vec<T: to_string_able>(values: Vec<T>) -> Vec<String> {
+    let mut vector = vec!();
+    for value in values {
+        vector.push(value.to_string());
     }
-    arguments
+    vector
 }
 
-fn args_to_string(args: Vec<expr>) -> String {
-    let mut arguments = vec!();
-    for arg in args {
-        arguments.push(arg.to_string());
-    }
-    arguments.join(", ")
-}
-
-impl keyword {
+impl to_string_able for keyword {
     fn to_string(&self) -> String {
         match self.arg.clone() {
             Some(arg) => format!("{}={}", arg, self.value.to_string()),
@@ -84,22 +80,6 @@ impl keyword {
     }
 }
 
-fn kwargs_to_strings(kwargs: Vec<keyword>) -> Vec<String> {
-    let mut arguments = vec!();
-    for kwarg in kwargs {
-        arguments.push(kwarg.to_string());
-    }
-    arguments
-}
-
-fn arguments_to_string(args: arguments) -> String {
-    let mut arguments = vec!();
-    for arg in args.args {
-        arguments.push(arg.arg);
-    }
-    arguments.join(", ")
-}
-
 fn statements_to_string(indent: usize, body: Vec<stmt>) -> String {
     let mut statements = vec!();
     for statement in body {
@@ -127,7 +107,8 @@ fn generators_to_string(generators: Vec<
     }
     result.join(" ")
 }
-impl expr {
+
+impl to_string_able for expr {
     fn to_string(&self) -> String {
         match self.clone() {
             expr::BoolOp(op, values) => {
@@ -162,8 +143,8 @@ impl expr {
             }),
             expr::Call(func, args, keywords) => format!("{}({})", func.to_string(), {
                 let mut arguments = vec!();
-                let args = args_to_strings(args);
-                let keywords = kwargs_to_strings(keywords);
+                let args = vec_to_strings_vec(args);
+                let keywords = vec_to_strings_vec(keywords);
                 arguments.extend(args);
                 arguments.extend(keywords);
                 arguments.join(", ")
@@ -173,16 +154,16 @@ impl expr {
             expr::NameConstant(name) => format!("{}", name),
             expr::Attribute(value, attr, ctx) => format!("{}.{}", value.to_string(), attr),
             expr::Name(name, ctx) => format!("{}", name),
-            expr::List(elts, ctx) => format!("[{}]", args_to_string(elts)),
+            expr::List(elts, ctx) => format!("[{}]", vec_to_strings_vec(elts).join(", ")),
             expr::ListComp(elt, generators) => format!("[{} {}]", elt.to_string(), generators_to_string(generators)),
             expr::DictComp(key, value, generators) => format!("{{{}: {} {}}}", key.to_string(), value.to_string(), generators_to_string(generators)),
-            expr::Tuple(elts, ctx) => format!("({})", args_to_string(elts)),
+            expr::Tuple(elts, ctx) => format!("({})", vec_to_strings_vec(elts).join(", ")),
             expr::Ellipsis => format!("..."),
         }
     }
 }
 
-impl arguments {
+impl to_string_able for arguments {
     fn to_string(&self) -> String {
         let mut args = vec!();
         for arg in self.args.clone() {
@@ -200,14 +181,14 @@ impl stmt {
     fn to_string(&self, indent: usize) -> String {
         let current_indent = make_indent(indent);
         match self.clone() {
-            stmt::ClassDef(name, bases, keywords, body, decorator_list) => format!("{}class {}({}):\n{}", current_indent, name, args_to_string(bases), statements_to_string(indent, body)),
-            stmt::FunctionDef(name, arguments, body, decorator_list, returns) => format!("{}def {}({}):\n{}", current_indent, name, arguments_to_string(arguments), statements_to_string(indent, body)),
+            stmt::ClassDef(name, bases, keywords, body, decorator_list) => format!("{}class {}({}):\n{}", current_indent, name, vec_to_strings_vec(bases).join(", "), statements_to_string(indent, body)),
+            stmt::FunctionDef(name, arguments, body, decorator_list, returns) => format!("{}def {}({}):\n{}", current_indent, name, arguments.to_string(), statements_to_string(indent, body)),
             stmt::Global(names) => format!("{}global {}", current_indent, names.join(", ")),
             stmt::Nonlocal(names) => format!("{}nonlocal {}", current_indent, names.join(", ")),
             stmt::If(test, body, orelse) => format!("{}if {}:\n{}", current_indent, test.to_string(), if_else_statements_to_string(indent, body, orelse)),
             stmt::While(test, body, orelse) => format!("{}while {}:\n{}", current_indent, test.to_string(), if_else_statements_to_string(indent, body, orelse)),
             stmt::For(target, iter, body, orelse) => format!("{}for {} in {}:\n{}", current_indent, target.to_string(), iter.to_string(), if_else_statements_to_string(indent, body, orelse)),
-            stmt::Assign(targets, value) => format!("{}{} = {}", current_indent, args_to_string(targets), value.to_string()),
+            stmt::Assign(targets, value) => format!("{}{} = {}", current_indent, vec_to_strings_vec(targets).join(", "), value.to_string()),
             stmt::AugAssign(target, op, value) => format!("{}{} {}= {}", current_indent, target.to_string(), op.to_string(), value.to_string()),
             stmt::Return(expr) => format!("{}return{}", current_indent, match expr {
                 Some(expr) => format!(" {}", expr.to_string()),
@@ -247,7 +228,7 @@ impl stmt {
             }),
             stmt::Expr(expr) => format!("{}{}", current_indent, expr.to_string()),
             stmt::Break => format!("{}break", current_indent),
-            stmt::Delete(targets) => format!("{}del {}", current_indent, args_to_string(targets)),
+            stmt::Delete(targets) => format!("{}del {}", current_indent, vec_to_strings_vec(targets).join(", ")),
             stmt::Pass => format!("{}pass", current_indent),
             stmt::Continue => format!("{}continue", current_indent)
         }