@@ -7,11 +7,18 @@ int main(int argc, char **argv) {
   person.insert("name", "Adit");
   person.insert("age", 20);
 
-  json::object launguages;
-  launguages.push_back("English");
-  launguages.push_back("Hindi");
-  launguages.push_back("French");
-  person.insert("launguages", launguages);
+  json::object languages;
+  languages.push_back("c++");
+  languages.push_back("python");
+  languages.push_back("javascript");
+  person.insert("languages", languages);
+
+  json::object socials;
+  socials.insert("github", "https://github.com/Jadit19");
+  socials.insert("instagram", "https://instagram.com/jadit_19");
+  person.insert("socials", socials);
+
+  person.dumps("../person.json", 2);
 
   return 0;
 }
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <algorithm>
+#include <fstream>
 #include <map>
 #include <stdexcept>
 #include <string>
@@ -23,8 +25,6 @@ class object {
   void setArrayIfNull();
   void setObjectIfNull();
 
-  static type getType(value &data);
-
 public:
   object();
   object(value &data);
@@ -40,6 +40,8 @@ class object {
   bool isArray() const;
   bool isObject() const;
 
+  static type getType(value &data);
+
   // For arrays
   void push_back(value &data);
   void push_back(value data);
@@ -55,6 +57,10 @@ class object {
 
   // For arrays and objects
   size_t size();
+
+  // Overall
+  std::string dump(int indent = 0, int baseline = 0);
+  void dumps(const std::string &filePath, int indent = 0);
 };
 
 } // namespace json
@@ -24,6 +24,14 @@ bool json::object::isString() const { return this->_type == type::String; }
 bool json::object::isArray() const { return this->_type == type::Array; }
 bool json::object::isObject() const { return this->_type == type::Object; }
 
+void json::object::setArrayIfNull() {
+  if (this->isNull()) {
+    this->_type = type::Array;
+    this->_value = std::vector<object>();
+  }
+  return;
+}
+
 void json::object::push_back(value &data) {
   this->setArrayIfNull();
   if (!this->isArray()) {
@@ -147,13 +155,74 @@ size_t json::object::size() {
   return 0;
 }
 
-void json::object::setArrayIfNull() {
+std::string json::object::dump(int indent, int baseline) {
+  std::string result = "";
+  indent = indent < 0 ? 0 : indent;
+
   if (this->isNull()) {
-    this->_type = type::Array;
-    this->_value = std::vector<object>();
+    result += "null";
+  } else if (this->isBoolean()) {
+    result += std::get<bool>(this->_value) ? "true" : "false";
+  } else if (this->isInteger()) {
+    result += std::to_string(std::get<int>(this->_value));
+  } else if (this->isDouble()) {
+    result += std::to_string(std::get<double>(this->_value));
+  } else if (this->isString()) {
+    result += "\"" + std::get<std::string>(this->_value) + "\"";
+  } else if (this->isArray()) {
+    result += "[";
+    result += indent > 0 ? "\n" : "";
+    for (size_t i = 0; i < this->size(); i++) {
+      result += std::string(indent, ' ') +
+                std::get<std::vector<object>>(this->_value)[i].dump(indent * 2,
+                                                                    indent);
+      if (i != this->size() - 1) {
+        result += ",";
+      }
+      result += indent > 0 ? "\n" : "";
+    }
+    result += std::string(baseline, ' ') + "]";
+  } else if (this->isObject()) {
+    result += "{";
+    result += indent > 0 ? "\n" : "";
+    size_t i = 0;
+    for (std::pair<const std::string, object> &item :
+         std::get<std::map<std::string, object>>(this->_value)) {
+      result += std::string(indent, ' ') + "\"" + item.first +
+                "\": " + item.second.dump(indent * 2, indent);
+      if (i != this->size() - 1) {
+        result += ",";
+      }
+      result += indent > 0 ? "\n" : "";
+      i++;
+    }
+    result += std::string(baseline, ' ') + "}";
+  } else {
+    throw std::runtime_error("[ERROR] json::object::dump(int indent = 0) - "
+                             "Invalid type.");
+  }
+
+  if (indent == 0) {
+    result.erase(std::remove_if(result.begin(), result.end(), ::isspace),
+                 result.end());
   }
+  return result;
+}
+void json::object::dumps(const std::string &filePath, int indent) {
+  std::ofstream jsonFile(filePath);
+  if (!jsonFile.is_open()) {
+    throw std::runtime_error("[ERROR] json::object::dumps(const std::string "
+                             "&filePath, int indent = 0) - Cannot open " +
+                             filePath);
+  }
+
+  std::string _json = this->dump(indent);
+  jsonFile << _json;
+  jsonFile.close();
+
   return;
 }
+
 void json::object::setObjectIfNull() {
   if (this->isNull()) {
     this->_type = type::Object;