diff --git a/Cargo.toml b/Cargo.toml
index 14a23db..0cb7b67 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,13 +1,10 @@
 [package]
 name = "clean_file"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-serde = { version = "1.0.188", features = ["derive"] }
-
-
-# serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
+serde = { version = "1.0.203", features = ["derive"] }
+serde_json = "1.0.117"
diff --git a/src/main.rs b/src/main.rs
index 0b1b441..a3a1f81 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -14,23 +14,26 @@ fn main() {
 
     println!("Filepath is: {:?}", filepath);
 
-    let myparser = parser::parser::NumberParser
-    {
-        filepath: filepath.clone()
+    let myparser = parser::parser::NumberParser {
+        filepath: filepath.clone(),
     };
 
-    println!("\nDumping files");
     let rawvalues = myparser.filedump();
 
-    println!("\nUpdating values");
     let parsed_values = myparser.updatevalues(&rawvalues);
 
-    println!("\nRemoving duplicates");
     let newupdated = myparser.removedups(&parsed_values);
 
-    println!("\nPrinting values");
-    myparser.print_values(&newupdated);
+    myparser.print_values(&newupdated, true);
 
-    println!("\nSaving file");
-    let _result = myparser.save_file(parsed_values);
+    let result = myparser.save_file(parsed_values);
+
+    match result {
+        Ok(o) => {
+            println!("Successfully saved file: {:?}", o);
+        }
+        Err(er) => {
+            println!("Error saving file: {:?}", er);
+        }
+    }
 }
diff --git a/src/parser.rs b/src/parser.rs
index b2c43b1..e046ad0 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -1,25 +1,24 @@
-
 pub mod parser {
     use std::collections::HashSet;
     use std::fs::File;
-    use std::io::{BufRead, BufReader};
     use std::io::prelude::*;
+    use std::io::{BufRead, BufReader};
 
     use serde::Deserialize;
     use serde::Serialize;
 
     #[derive(Clone, Deserialize, Serialize)]
     pub struct SomeObject {
-        pub value: String
+        pub value: String,
     }
 
-
     pub struct NumberParser {
-        pub filepath: String
+        pub filepath: String,
     }
 
     impl NumberParser {
         pub fn filedump(&self) -> Vec<SomeObject> {
+            println!("\nDumping files");
             let mut objs: Vec<SomeObject> = Vec::new();
 
             if let Ok(lines) = self.read_lines(&self.filepath) {
@@ -31,9 +30,7 @@ pub mod parser {
                             continue;
                         }
 
-                        let myobj: SomeObject = SomeObject {
-                            value: phonenumber
-                        };
+                        let myobj: SomeObject = SomeObject { value: phonenumber };
 
                         if !myobj.value.is_empty() {
                             objs.push(myobj);
@@ -46,6 +43,7 @@ pub mod parser {
         }
 
         pub fn updatevalues(&self, vals: &Vec<SomeObject>) -> Vec<SomeObject> {
+            println!("\nUpdating values");
             let mut updated: Vec<SomeObject> = Vec::new();
 
             for a in vals {
@@ -64,17 +62,17 @@ pub mod parser {
                 let updated_parsed = self.add_prefix(parsed);
 
                 let myobj: SomeObject = SomeObject {
-                    value: updated_parsed.clone()
+                    value: updated_parsed.clone(),
                 };
 
                 updated.push(myobj);
             }
 
-
             return updated;
         }
 
         pub fn removedups(&self, vals: &Vec<SomeObject>) -> Vec<SomeObject> {
+            println!("\nRemoving duplicates");
             let mut tmp: HashSet<String> = HashSet::new();
             let mut mm: Vec<SomeObject> = Vec::new();
             mm.clone_from(vals);
@@ -83,31 +81,40 @@ pub mod parser {
             let mut updated: Vec<SomeObject> = Vec::new();
 
             for t in tmp {
-                let so: SomeObject = SomeObject {
-                    value: t.clone()
-                };
+                let so: SomeObject = SomeObject { value: t.clone() };
 
                 updated.push(so);
             }
 
-            return updated
+            return updated;
         }
-        pub fn print_values(&self, vals: &Vec<SomeObject>) {
+        pub fn print_values(&self, vals: &Vec<SomeObject>, print_total: bool) {
+            println!("\nPrinting values");
+
             for o in vals {
                 println!("Value: {}", o.value);
             }
+
+            if print_total {
+                println!("\nTotal numbers: {:?}", vals.len());
+            }
         }
 
         pub fn save_file(&self, vals: Vec<SomeObject>) -> std::io::Result<()> {
+            println!("\nSaving file");
             let filename: String = String::from("numbers.json");
+            let mut all_numbers: Vec<String> = Vec::new();
 
-            let json = serde_json::to_string_pretty(&vals).unwrap();
+            for val in &vals {
+                all_numbers.push(val.value.clone());
+            }
+
+            let json = serde_json::to_string_pretty(&all_numbers).unwrap();
             let mut file = File::create(filename)?;
             file.write_all(json.as_bytes())?;
             Ok(())
         }
 
-
         fn read_lines(&self, filename: &str) -> std::io::Result<std::io::Lines<BufReader<File>>> {
             let file = File::open(filename)?;
             Ok(BufReader::new(file).lines())
@@ -154,14 +161,13 @@ pub mod parser {
                 } else {
                     parsed.insert(0, '+');
                     parsed.insert(1, '1');
-                } 
+                }
             }
 
-            return parsed
+            return parsed;
         }
     }
 
-
     #[cfg(test)]
     mod tests {
         use super::*;
@@ -169,7 +175,9 @@ pub mod parser {
         #[test]
         fn removing_text() {
             let sometext: String = String::from("a1234567890");
-            let numberparser = NumberParser { filepath: String::from("")};
+            let numberparser = NumberParser {
+                filepath: String::new(),
+            };
             let removetext = numberparser.remove_some_data(&sometext);
             let mut result = true;
 
@@ -188,7 +196,9 @@ pub mod parser {
         #[test]
         fn adding_prefix() {
             let sometext: String = String::from("1234567890");
-            let numberparser = NumberParser { filepath: String::from("")};
+            let numberparser = NumberParser {
+                filepath: String::new(),
+            };
             let modified = numberparser.add_prefix(sometext);
 
             let chars = modified.chars().clone();
@@ -200,4 +210,3 @@ pub mod parser {
         }
     }
 }
-