diff --git a/src/json.cc b/src/json.cc
index c8adce08..0b86a148 100644
--- a/src/json.cc
+++ b/src/json.cc
@@ -21,7 +21,7 @@
 // STATIC MEMBERS //
 ////////////////////
 
-std::mutex json::_token;
+std::mutex json::token_;
 
 
 ///////////////////////////////////
@@ -29,7 +29,7 @@ std::mutex json::_token;
 ///////////////////////////////////
 
 json::value::value(array_t* _array): array(_array) {}
-json::value::value(object_t* _object): object(_object) {}
+json::value::value(object_t* object_): object(object_) {}
 json::value::value(string_t* _string): string(_string) {}
 json::value::value(boolean_t _boolean) : boolean(_boolean) {}
 json::value::value(number_t _number) : number(_number) {}
@@ -47,39 +47,39 @@ Construct an empty JSON given the type.
 
 @post Memory for array, object, and string are allocated.
 */
-json::json(const value_type t) noexcept
-    : _type(t)
+json::json(const value_type t)
+    : type_(t)
 {
-    switch (_type)
+    switch (type_)
     {
         case (value_type::array):
         {
-            _value.array = new array_t();
+            value_.array = new array_t();
             break;
         }
         case (value_type::object):
         {
-            _value.object = new object_t();
+            value_.object = new object_t();
             break;
         }
         case (value_type::string):
         {
-            _value.string = new string_t();
+            value_.string = new string_t();
             break;
         }
         case (value_type::boolean):
         {
-            _value.boolean = boolean_t();
+            value_.boolean = boolean_t();
             break;
         }
         case (value_type::number):
         {
-            _value.number = number_t();
+            value_.number = number_t();
             break;
         }
         case (value_type::number_float):
         {
-            _value.number_float = number_float_t();
+            value_.number_float = number_float_t();
             break;
         }
         default:
@@ -100,44 +100,44 @@ Construct a string JSON object.
 
 @param s  a string to initialize the JSON object with
 */
-json::json(const std::string& s) noexcept
-    : _type(value_type::string), _value(new string_t(s))
+json::json(const std::string& s)
+    : type_(value_type::string), value_(new string_t(s))
 {}
 
-json::json(std::string&& s) noexcept
-    : _type(value_type::string), _value(new string_t(std::move(s)))
+json::json(std::string&& s)
+    : type_(value_type::string), value_(new string_t(std::move(s)))
 {}
 
-json::json(const char* s) noexcept
-    : _type(value_type::string), _value(new string_t(s))
+json::json(const char* s)
+    : type_(value_type::string), value_(new string_t(s))
 {}
 
 json::json(const bool b) noexcept
-    : _type(value_type::boolean), _value(b)
+    : type_(value_type::boolean), value_(b)
 {}
 
 json::json(const int i) noexcept
-    : _type(value_type::number), _value(i)
+    : type_(value_type::number), value_(i)
 {}
 
 json::json(const double f) noexcept
-    : _type(value_type::number_float), _value(f)
+    : type_(value_type::number_float), value_(f)
 {}
 
-json::json(const array_t& a) noexcept
-    : _type(value_type::array), _value(new array_t(a))
+json::json(const array_t& a)
+    : type_(value_type::array), value_(new array_t(a))
 {}
 
-json::json(array_t&& a) noexcept
-    : _type(value_type::array), _value(new array_t(std::move(a)))
+json::json(array_t&& a)
+    : type_(value_type::array), value_(new array_t(std::move(a)))
 {}
 
-json::json(const object_t& o) noexcept
-    : _type(value_type::object), _value(new object_t(o))
+json::json(const object_t& o)
+    : type_(value_type::object), value_(new object_t(o))
 {}
 
-json::json(object_t&& o) noexcept
-    : _type(value_type::object), _value(new object_t(std::move(o)))
+json::json(object_t&& o)
+    : type_(value_type::object), value_(new object_t(std::move(o)))
 {}
 
 /*!
@@ -155,31 +155,31 @@ as is to create an array.
 @bug With the described approach, we would fail to recognize an array whose
      first element is again an arrays as array.
 */
-json::json(list_init_t a) noexcept
+json::json(list_init_t a)
 {
     // check if each element is an array with two elements whose first element
     // is a string
     for (const auto& element : a)
     {
-        if (element._type != value_type::array or
+        if (element.type_ != value_type::array or
                 element.size() != 2 or
-                element[0]._type != value_type::string)
+                element[0].type_ != value_type::string)
         {
 
             // the initializer list describes an array
-            _type = value_type::array;
-            _value = new array_t(a);
+            type_ = value_type::array;
+            value_ = new array_t(a);
             return;
         }
     }
 
     // the initializer list is a list of pairs
-    _type = value_type::object;
-    _value = new object_t();
+    type_ = value_type::object;
+    value_ = new object_t();
     for (const json& element : a)
     {
         const std::string k = element[0];
-        _value.object->emplace(std::make_pair(std::move(k),
+        value_.object->emplace(std::make_pair(std::move(k),
                                               std::move(element[1])));
     }
 }
@@ -189,39 +189,39 @@ A copy constructor for the JSON class.
 
 @param o  the JSON object to copy
 */
-json::json(const json& o) noexcept
-    : _type(o._type)
+json::json(const json& o)
+    : type_(o.type_)
 {
-    switch (_type)
+    switch (type_)
     {
         case (value_type::array):
         {
-            _value.array = new array_t(*o._value.array);
+            value_.array = new array_t(*o.value_.array);
             break;
         }
         case (value_type::object):
         {
-            _value.object = new object_t(*o._value.object);
+            value_.object = new object_t(*o.value_.object);
             break;
         }
         case (value_type::string):
         {
-            _value.string = new string_t(*o._value.string);
+            value_.string = new string_t(*o.value_.string);
             break;
         }
         case (value_type::boolean):
         {
-            _value.boolean = o._value.boolean;
+            value_.boolean = o.value_.boolean;
             break;
         }
         case (value_type::number):
         {
-            _value.number = o._value.number;
+            value_.number = o.value_.number;
             break;
         }
         case (value_type::number_float):
         {
-            _value.number_float = o._value.number_float;
+            value_.number_float = o.value_.number_float;
             break;
         }
         default:
@@ -239,11 +239,11 @@ A move constructor for the JSON class.
 @post The JSON object \p o is invalidated.
 */
 json::json(json&& o) noexcept
-    : _type(std::move(o._type)), _value(std::move(o._value))
+    : type_(std::move(o.type_)), value_(std::move(o.value_))
 {
     // invalidate payload
-    o._type = value_type::null;
-    o._value = {};
+    o.type_ = value_type::null;
+    o.value_ = {};
 }
 
 /*!
@@ -254,28 +254,28 @@ idiom.
 */
 json& json::operator=(json o) noexcept
 {
-    std::swap(_type, o._type);
-    std::swap(_value, o._value);
+    std::swap(type_, o.type_);
+    std::swap(value_, o.value_);
     return *this;
 }
 
 json::~json() noexcept
 {
-    switch (_type)
+    switch (type_)
     {
         case (value_type::array):
         {
-            delete _value.array;
+            delete value_.array;
             break;
         }
         case (value_type::object):
         {
-            delete _value.object;
+            delete value_.object;
             break;
         }
         case (value_type::string):
         {
-            delete _value.string;
+            delete value_.string;
             break;
         }
         default:
@@ -305,9 +305,9 @@ json json::parse(const char* s)
 }
 
 
-const std::string json::_typename() const noexcept
+const std::string json::type_name() const noexcept
 {
-    switch (_type)
+    switch (type_)
     {
         case (value_type::array):
         {
@@ -348,12 +348,12 @@ const std::string json::_typename() const noexcept
 template<>
 std::string json::get() const
 {
-    switch (_type)
+    switch (type_)
     {
         case (value_type::string):
-            return *_value.string;
+            return *value_.string;
         default:
-            throw std::logic_error("cannot cast " + _typename() + " to JSON string");
+            throw std::logic_error("cannot cast " + type_name() + " to JSON string");
     }
 }
 
@@ -364,14 +364,14 @@ std::string json::get() const
 template<>
 int json::get() const
 {
-    switch (_type)
+    switch (type_)
     {
         case (value_type::number):
-            return _value.number;
+            return value_.number;
         case (value_type::number_float):
-            return static_cast<number_t>(_value.number_float);
+            return static_cast<number_t>(value_.number_float);
         default:
-            throw std::logic_error("cannot cast " + _typename() + " to JSON number");
+            throw std::logic_error("cannot cast " + type_name() + " to JSON number");
     }
 }
 
@@ -382,14 +382,14 @@ int json::get() const
 template<>
 double json::get() const
 {
-    switch (_type)
+    switch (type_)
     {
         case (value_type::number):
-            return static_cast<number_float_t>(_value.number);
+            return static_cast<number_float_t>(value_.number);
         case (value_type::number_float):
-            return _value.number_float;
+            return value_.number_float;
         default:
-            throw std::logic_error("cannot cast " + _typename() + " to JSON number");
+            throw std::logic_error("cannot cast " + type_name() + " to JSON number");
     }
 }
 
@@ -400,12 +400,12 @@ double json::get() const
 template<>
 bool json::get() const
 {
-    switch (_type)
+    switch (type_)
     {
         case (value_type::boolean):
-            return _value.boolean;
+            return value_.boolean;
         default:
-            throw std::logic_error("cannot cast " + _typename() + " to JSON Boolean");
+            throw std::logic_error("cannot cast " + type_name() + " to JSON Boolean");
     }
 }
 
@@ -416,13 +416,13 @@ bool json::get() const
 template<>
 json::array_t json::get() const
 {
-    if (_type == value_type::array)
+    if (type_ == value_type::array)
     {
-        return *_value.array;
+        return *value_.array;
     }
-    if (_type == value_type::object)
+    if (type_ == value_type::object)
     {
-        throw std::logic_error("cannot cast " + _typename() + " to JSON array");
+        throw std::logic_error("cannot cast " + type_name() + " to JSON array");
     }
 
     array_t result;
@@ -437,13 +437,13 @@ json::array_t json::get() const
 template<>
 json::object_t json::get() const
 {
-    if (_type == value_type::object)
+    if (type_ == value_type::object)
     {
-        return *_value.object;
+        return *value_.object;
     }
     else
     {
-        throw std::logic_error("cannot cast " + _typename() + " to JSON object");
+        throw std::logic_error("cannot cast " + type_name() + " to JSON object");
     }
 }
 
@@ -479,35 +479,35 @@ json::operator object_t() const
 
 const std::string json::to_string() const noexcept
 {
-    switch (_type)
+    switch (type_)
     {
         case (value_type::string):
         {
-            return std::string("\"") + *_value.string + "\"";
+            return std::string("\"") + *value_.string + "\"";
         }
 
         case (value_type::boolean):
         {
-            return _value.boolean ? "true" : "false";
+            return value_.boolean ? "true" : "false";
         }
 
         case (value_type::number):
         {
-            return std::to_string(_value.number);
+            return std::to_string(value_.number);
         }
 
         case (value_type::number_float):
         {
-            return std::to_string(_value.number_float);
+            return std::to_string(value_.number_float);
         }
 
         case (value_type::array):
         {
             std::string result;
 
-            for (array_t::const_iterator i = _value.array->begin(); i != _value.array->end(); ++i)
+            for (array_t::const_iterator i = value_.array->begin(); i != value_.array->end(); ++i)
             {
-                if (i != _value.array->begin())
+                if (i != value_.array->begin())
                 {
                     result += ", ";
                 }
@@ -521,9 +521,9 @@ const std::string json::to_string() const noexcept
         {
             std::string result;
 
-            for (object_t::const_iterator i = _value.object->begin(); i != _value.object->end(); ++i)
+            for (object_t::const_iterator i = value_.object->begin(); i != value_.object->end(); ++i)
             {
-                if (i != _value.object->begin())
+                if (i != value_.object->begin())
                 {
                     result += ", ";
                 }
@@ -634,22 +634,22 @@ an array, the passed element is added to the array.
 void json::push_back(const json& o)
 {
     // push_back only works for null objects or arrays
-    if (not(_type == value_type::null or _type == value_type::array))
+    if (not(type_ == value_type::null or type_ == value_type::array))
     {
-        throw std::runtime_error("cannot add element to " + _typename());
+        throw std::runtime_error("cannot add element to " + type_name());
     }
 
-    std::lock_guard<std::mutex> lg(_token);
+    std::lock_guard<std::mutex> lg(token_);
 
     // transform null object into an array
-    if (_type == value_type::null)
+    if (type_ == value_type::null)
     {
-        _type = value_type::array;
-        _value.array = new array_t;
+        type_ = value_type::array;
+        value_.array = new array_t;
     }
 
     // add element to array
-    _value.array->push_back(o);
+    value_.array->push_back(o);
 }
 
 /*!
@@ -671,24 +671,24 @@ an array, the passed element is added to the array using move semantics.
 void json::push_back(json&& o)
 {
     // push_back only works for null objects or arrays
-    if (not(_type == value_type::null or _type == value_type::array))
+    if (not(type_ == value_type::null or type_ == value_type::array))
     {
-        throw std::runtime_error("cannot add element to " + _typename());
+        throw std::runtime_error("cannot add element to " + type_name());
     }
 
-    std::lock_guard<std::mutex> lg(_token);
+    std::lock_guard<std::mutex> lg(token_);
 
     // transform null object into an array
-    if (_type == value_type::null)
+    if (type_ == value_type::null)
     {
-        _type = value_type::array;
-        _value.array = new array_t;
+        type_ = value_type::array;
+        value_.array = new array_t;
     }
 
     // add element to array (move semantics)
-    _value.array->emplace_back(std::move(o));
+    value_.array->emplace_back(std::move(o));
     // invalidate object
-    o._type = value_type::null;
+    o.type_ = value_type::null;
 }
 
 void json::push_back(const std::string& s)
@@ -752,9 +752,9 @@ void json::push_back(list_init_t a)
     // is a string
     for (const auto& element : a)
     {
-        if (element._type != value_type::array or
+        if (element.type_ != value_type::array or
                 element.size() != 2 or
-                element[0]._type != value_type::string)
+                element[0].type_ != value_type::string)
         {
             // the initializer list describes an array
             is_array = true;
@@ -798,16 +798,16 @@ index.  Bounds will not be checked.
 json& json::operator[](const int index)
 {
     // this [] operator only works for arrays
-    if (_type != value_type::array)
+    if (type_ != value_type::array)
     {
         throw std::domain_error("cannot add entry with index " +
-                                std::to_string(index) + " to " + _typename());
+                                std::to_string(index) + " to " + type_name());
     }
 
-    std::lock_guard<std::mutex> lg(_token);
+    std::lock_guard<std::mutex> lg(token_);
 
     // return reference to element from array at given index
-    return (*_value.array)[static_cast<size_t>(index)];
+    return (*value_.array)[static_cast<size_t>(index)];
 }
 
 /*!
@@ -829,14 +829,14 @@ index.  Bounds will not be checked.
 const json& json::operator[](const int index) const
 {
     // this [] operator only works for arrays
-    if (_type != value_type::array)
+    if (type_ != value_type::array)
     {
         throw std::domain_error("cannot get entry with index " +
-                                std::to_string(index) + " from " + _typename());
+                                std::to_string(index) + " from " + type_name());
     }
 
     // return element from array at given index
-    return (*_value.array)[static_cast<size_t>(index)];
+    return (*value_.array)[static_cast<size_t>(index)];
 }
 
 /*!
@@ -859,16 +859,16 @@ index. Bounds will be checked.
 json& json::at(const int index)
 {
     // this function only works for arrays
-    if (_type != value_type::array)
+    if (type_ != value_type::array)
     {
         throw std::domain_error("cannot add entry with index " +
-                                std::to_string(index) + " to " + _typename());
+                                std::to_string(index) + " to " + type_name());
     }
 
-    std::lock_guard<std::mutex> lg(_token);
+    std::lock_guard<std::mutex> lg(token_);
 
     // return reference to element from array at given index
-    return _value.array->at(static_cast<size_t>(index));
+    return value_.array->at(static_cast<size_t>(index));
 }
 
 /*!
@@ -891,14 +891,14 @@ index. Bounds will be checked.
 const json& json::at(const int index) const
 {
     // this function only works for arrays
-    if (_type != value_type::array)
+    if (type_ != value_type::array)
     {
         throw std::domain_error("cannot get entry with index " +
-                                std::to_string(index) + " from " + _typename());
+                                std::to_string(index) + " from " + type_name());
     }
 
     // return element from array at given index
-    return _value.array->at(static_cast<size_t>(index));
+    return value_.array->at(static_cast<size_t>(index));
 }
 
 /*!
@@ -924,30 +924,30 @@ key.
 */
 json& json::operator[](const char* key)
 {
-    std::lock_guard<std::mutex> lg(_token);
+    std::lock_guard<std::mutex> lg(token_);
 
     // implicitly convert null to object
-    if (_type == value_type::null)
+    if (type_ == value_type::null)
     {
-        _type = value_type::object;
-        _value.object = new object_t;
+        type_ = value_type::object;
+        value_.object = new object_t;
     }
 
     // this [] operator only works for objects
-    if (_type != value_type::object)
+    if (type_ != value_type::object)
     {
         throw std::domain_error("cannot add entry with key " +
-                                std::string(key) + " to " + _typename());
+                                std::string(key) + " to " + type_name());
     }
 
     // if the key does not exist, create it
-    if (_value.object->find(key) == _value.object->end())
+    if (value_.object->find(key) == value_.object->end())
     {
-        (*_value.object)[key] = json();
+        (*value_.object)[key] = json();
     }
 
     // return reference to element from array at given index
-    return (*_value.object)[key];
+    return (*value_.object)[key];
 }
 
 /*!
@@ -964,17 +964,17 @@ key.
 const json& json::operator[](const std::string& key) const
 {
     // this [] operator only works for objects
-    if (_type != value_type::object)
+    if (type_ != value_type::object)
     {
         throw std::domain_error("cannot get entry with key " +
-                                std::string(key) + " from " + _typename());
+                                std::string(key) + " from " + type_name());
     }
 
     // search for the key
-    const auto it = _value.object->find(key);
+    const auto it = value_.object->find(key);
 
     // make sure the key exists in the object
-    if (it == _value.object->end())
+    if (it == value_.object->end())
     {
         throw std::out_of_range("key " + key + " not found");
     }
@@ -1006,17 +1006,17 @@ key.
 */
 json& json::at(const char* key)
 {
-    std::lock_guard<std::mutex> lg(_token);
+    std::lock_guard<std::mutex> lg(token_);
 
     // this function operator only works for objects
-    if (_type != value_type::object)
+    if (type_ != value_type::object)
     {
         throw std::domain_error("cannot add entry with key " +
-                                std::string(key) + " to " + _typename());
+                                std::string(key) + " to " + type_name());
     }
 
     // return reference to element from array at given index
-    return _value.object->at(key);
+    return value_.object->at(key);
 }
 
 /*!
@@ -1041,14 +1041,14 @@ key.
 const json& json::at(const char* key) const
 {
     // this [] operator only works for objects
-    if (_type != value_type::object)
+    if (type_ != value_type::object)
     {
         throw std::domain_error("cannot get entry with key " +
-                                std::string(key) + " from " + _typename());
+                                std::string(key) + " from " + type_name());
     }
 
     // return element from array at given key
-    return _value.object->at(key);
+    return value_.object->at(key);
 }
 
 
@@ -1063,15 +1063,15 @@ Returns the size of the JSON object.
 */
 size_t json::size() const noexcept
 {
-    switch (_type)
+    switch (type_)
     {
         case (value_type::array):
         {
-            return _value.array->size();
+            return value_.array->size();
         }
         case (value_type::object):
         {
-            return _value.object->size();
+            return value_.object->size();
         }
         case (value_type::null):
         {
@@ -1095,15 +1095,15 @@ Returns whether a JSON object is empty.
 */
 bool json::empty() const noexcept
 {
-    switch (_type)
+    switch (type_)
     {
         case (value_type::array):
         {
-            return _value.array->empty();
+            return value_.array->empty();
         }
         case (value_type::object):
         {
-            return _value.object->empty();
+            return value_.object->empty();
         }
         case (value_type::null):
         {
@@ -1125,36 +1125,36 @@ Removes all elements from compounds and resets values to default.
 */
 void json::clear() noexcept
 {
-    switch (_type)
+    switch (type_)
     {
         case (value_type::array):
         {
-            _value.array->clear();
+            value_.array->clear();
             break;
         }
         case (value_type::object):
         {
-            _value.object->clear();
+            value_.object->clear();
             break;
         }
         case (value_type::string):
         {
-            _value.string->clear();
+            value_.string->clear();
             break;
         }
         case (value_type::boolean):
         {
-            _value.boolean = {};
+            value_.boolean = {};
             break;
         }
         case (value_type::number):
         {
-            _value.number = {};
+            value_.number = {};
             break;
         }
         case (value_type::number_float):
         {
-            _value.number_float = {};
+            value_.number_float = {};
             break;
         }
         default:
@@ -1166,7 +1166,7 @@ void json::clear() noexcept
 
 json::value_type json::type() const noexcept
 {
-    return _type;
+    return type_;
 }
 
 json::iterator json::find(const std::string& key)
@@ -1181,18 +1181,18 @@ json::const_iterator json::find(const std::string& key) const
 
 json::iterator json::find(const char* key)
 {
-    if (_type != value_type::object)
+    if (type_ != value_type::object)
     {
         return end();
     }
     else
     {
-        const object_t::iterator i = _value.object->find(key);
-        if (i != _value.object->end())
+        const object_t::iterator i = value_.object->find(key);
+        if (i != value_.object->end())
         {
             json::iterator result(this);
-            delete result._oi;
-            result._oi = new object_t::iterator(i);
+            delete result.oi_;
+            result.oi_ = new object_t::iterator(i);
             return result;
         }
         else
@@ -1204,18 +1204,18 @@ json::iterator json::find(const char* key)
 
 json::const_iterator json::find(const char* key) const
 {
-    if (_type != value_type::object)
+    if (type_ != value_type::object)
     {
         return end();
     }
     else
     {
-        const object_t::const_iterator i = _value.object->find(key);
-        if (i != _value.object->end())
+        const object_t::const_iterator i = value_.object->find(key);
+        if (i != value_.object->end())
         {
             json::const_iterator result(this);
-            delete result._oi;
-            result._oi = new object_t::const_iterator(i);
+            delete result.oi_;
+            result.oi_ = new object_t::const_iterator(i);
             return result;
         }
         else
@@ -1227,27 +1227,27 @@ json::const_iterator json::find(const char* key) const
 
 bool json::operator==(const json& o) const noexcept
 {
-    switch (_type)
+    switch (type_)
     {
         case (value_type::array):
         {
-            if (o._type == value_type::array)
+            if (o.type_ == value_type::array)
             {
-                return *_value.array == *o._value.array;
+                return *value_.array == *o.value_.array;
             }
             break;
         }
         case (value_type::object):
         {
-            if (o._type == value_type::object)
+            if (o.type_ == value_type::object)
             {
-                return *_value.object == *o._value.object;
+                return *value_.object == *o.value_.object;
             }
             break;
         }
         case (value_type::null):
         {
-            if (o._type == value_type::null)
+            if (o.type_ == value_type::null)
             {
                 return true;
             }
@@ -1255,41 +1255,41 @@ bool json::operator==(const json& o) const noexcept
         }
         case (value_type::string):
         {
-            if (o._type == value_type::string)
+            if (o.type_ == value_type::string)
             {
-                return *_value.string == *o._value.string;
+                return *value_.string == *o.value_.string;
             }
             break;
         }
         case (value_type::boolean):
         {
-            if (o._type == value_type::boolean)
+            if (o.type_ == value_type::boolean)
             {
-                return _value.boolean == o._value.boolean;
+                return value_.boolean == o.value_.boolean;
             }
             break;
         }
         case (value_type::number):
         {
-            if (o._type == value_type::number)
+            if (o.type_ == value_type::number)
             {
-                return _value.number == o._value.number;
+                return value_.number == o.value_.number;
             }
-            if (o._type == value_type::number_float)
+            if (o.type_ == value_type::number_float)
             {
-                return _value.number == static_cast<number_t>(o._value.number_float);
+                return value_.number == static_cast<number_t>(o.value_.number_float);
             }
             break;
         }
         case (value_type::number_float):
         {
-            if (o._type == value_type::number)
+            if (o.type_ == value_type::number)
             {
-                return _value.number_float == static_cast<number_float_t>(o._value.number);
+                return value_.number_float == static_cast<number_float_t>(o.value_.number);
             }
-            if (o._type == value_type::number_float)
+            if (o.type_ == value_type::number_float)
             {
-                return _value.number_float == o._value.number_float;
+                return value_.number_float == o.value_.number_float;
             }
             break;
         }
@@ -1335,66 +1335,66 @@ json::const_iterator json::cend() const noexcept
 }
 
 
-json::iterator::iterator(json* j) : _object(j)
+json::iterator::iterator(json* j) : object_(j)
 {
-    if (_object != nullptr)
+    if (object_ != nullptr)
     {
-        if (_object->_type == value_type::array)
+        if (object_->type_ == value_type::array)
         {
-            _vi = new array_t::iterator(_object->_value.array->begin());
+            vi_ = new array_t::iterator(object_->value_.array->begin());
         }
-        if (_object->_type == value_type::object)
+        if (object_->type_ == value_type::object)
         {
-            _oi = new object_t::iterator(_object->_value.object->begin());
+            oi_ = new object_t::iterator(object_->value_.object->begin());
         }
     }
 }
 
-json::iterator::iterator(const json::iterator& o) : _object(o._object)
+json::iterator::iterator(const json::iterator& o) : object_(o.object_)
 {
-    if (_object != nullptr)
+    if (object_ != nullptr)
     {
-        if (_object->_type == value_type::array)
+        if (object_->type_ == value_type::array)
         {
-            _vi = new array_t::iterator(*(o._vi));
+            vi_ = new array_t::iterator(*(o.vi_));
         }
-        if (_object->_type == value_type::object)
+        if (object_->type_ == value_type::object)
         {
-            _oi = new object_t::iterator(*(o._oi));
+            oi_ = new object_t::iterator(*(o.oi_));
         }
     }
 }
 
 json::iterator::~iterator()
 {
-    delete _vi;
-    delete _oi;
+    delete vi_;
+    delete oi_;
 }
 
 json::iterator& json::iterator::operator=(json::iterator o)
 {
-    std::swap(_object, o._object);
-    std::swap(_vi, o._vi);
-    std::swap(_oi, o._oi);
+    std::swap(object_, o.object_);
+    std::swap(vi_, o.vi_);
+    std::swap(oi_, o.oi_);
     return *this;
 }
 
 bool json::iterator::operator==(const json::iterator& o) const
 {
-    if (_object != o._object)
+    if (object_ != o.object_)
     {
         return false;
     }
 
-    if (_object != nullptr)
+    if (object_ != nullptr)
     {
-        if (_object->_type == value_type::array)
+        if (object_->type_ == value_type::array)
         {
-            return (_vi == o._vi);
+            return (vi_ == o.vi_);
         }
-        if (_object->_type == value_type::object)
+        if (object_->type_ == value_type::object)
         {
-            return (_oi == o._oi);
+            return (oi_ == o.oi_);
         }
     }
 
@@ -1409,32 +1409,32 @@ bool json::iterator::operator!=(const json::iterator& o) const
 json::iterator& json::iterator::operator++()
 {
     // iterator cannot be incremented
-    if (_object == nullptr)
+    if (object_ == nullptr)
     {
         return *this;
     }
 
-    switch (_object->_type)
+    switch (object_->type_)
     {
         case (value_type::array):
         {
-            if (++(*_vi) == _object->_value.array->end())
+            if (++(*vi_) == object_->value_.array->end())
             {
-                _object = nullptr;
+                object_ = nullptr;
             }
             break;
         }
         case (value_type::object):
         {
-            if (++(*_oi) == _object->_value.object->end())
+            if (++(*oi_) == object_->value_.object->end())
             {
-                _object = nullptr;
+                object_ = nullptr;
             }
             break;
         }
         default:
         {
-            _object = nullptr;
+            object_ = nullptr;
         }
     }
     return *this;
@@ -1443,24 +1443,24 @@ json::iterator& json::iterator::operator++()
 json& json::iterator::operator*() const
 {
     // dereferencing end() is an error
-    if (_object == nullptr)
+    if (object_ == nullptr)
     {
         throw std::runtime_error("cannot get value");
     }
 
-    switch (_object->_type)
+    switch (object_->type_)
     {
         case (value_type::array):
         {
-            return **_vi;
+            return **vi_;
         }
         case (value_type::object):
         {
-            return (*_oi)->second;
+            return (*oi_)->second;
         }
         default:
         {
-            return *_object;
+            return *object_;
         }
     }
 }
@@ -1468,33 +1468,33 @@ json& json::iterator::operator*() const
 json* json::iterator::operator->() const
 {
     // dereferencing end() is an error
-    if (_object == nullptr)
+    if (object_ == nullptr)
     {
         throw std::runtime_error("cannot get value");
     }
 
-    switch (_object->_type)
+    switch (object_->type_)
     {
         case (value_type::array):
         {
-            return &(**_vi);
+            return &(**vi_);
         }
         case (value_type::object):
         {
-            return &((*_oi)->second);
+            return &((*oi_)->second);
         }
         default:
         {
-            return _object;
+            return object_;
         }
     }
 }
 
 std::string json::iterator::key() const
 {
-    if (_object != nullptr and _object->_type == value_type::object)
+    if (object_ != nullptr and object_->type_ == value_type::object)
     {
-        return (*_oi)->first;
+        return (*oi_)->first;
     }
     else
     {
@@ -1505,104 +1505,104 @@ std::string json::iterator::key() const
 json& json::iterator::value() const
 {
     // dereferencing end() is an error
-    if (_object == nullptr)
+    if (object_ == nullptr)
     {
         throw std::out_of_range("cannot get value");
     }
 
-    switch (_object->_type)
+    switch (object_->type_)
     {
         case (value_type::array):
         {
-            return **_vi;
+            return **vi_;
         }
         case (value_type::object):
         {
-            return (*_oi)->second;
+            return (*oi_)->second;
         }
         default:
         {
-            return *_object;
+            return *object_;
         }
     }
 }
 
 
-json::const_iterator::const_iterator(const json* j) : _object(j)
+json::const_iterator::const_iterator(const json* j) : object_(j)
 {
-    if (_object != nullptr)
+    if (object_ != nullptr)
     {
-        if (_object->_type == value_type::array)
+        if (object_->type_ == value_type::array)
         {
-            _vi = new array_t::const_iterator(_object->_value.array->begin());
+            vi_ = new array_t::const_iterator(object_->value_.array->begin());
         }
-        if (_object->_type == value_type::object)
+        if (object_->type_ == value_type::object)
         {
-            _oi = new object_t::const_iterator(_object->_value.object->begin());
+            oi_ = new object_t::const_iterator(object_->value_.object->begin());
         }
     }
 }
 
-json::const_iterator::const_iterator(const json::const_iterator& o) : _object(o._object)
+json::const_iterator::const_iterator(const json::const_iterator& o) : object_(o.object_)
 {
-    if (_object != nullptr)
+    if (object_ != nullptr)
     {
-        if (_object->_type == value_type::array)
+        if (object_->type_ == value_type::array)
         {
-            _vi = new array_t::const_iterator(*(o._vi));
+            vi_ = new array_t::const_iterator(*(o.vi_));
         }
-        if (_object->_type == value_type::object)
+        if (object_->type_ == value_type::object)
         {
-            _oi = new object_t::const_iterator(*(o._oi));
+            oi_ = new object_t::const_iterator(*(o.oi_));
         }
     }
 }
 
-json::const_iterator::const_iterator(const json::iterator& o) : _object(o._object)
+json::const_iterator::const_iterator(const json::iterator& o) : object_(o.object_)
 {
-    if (_object != nullptr)
+    if (object_ != nullptr)
     {
-        if (_object->_type == value_type::array)
+        if (object_->type_ == value_type::array)
         {
-            _vi = new array_t::const_iterator(*(o._vi));
+            vi_ = new array_t::const_iterator(*(o.vi_));
         }
-        if (_object->_type == value_type::object)
+        if (object_->type_ == value_type::object)
         {
-            _oi = new object_t::const_iterator(*(o._oi));
+            oi_ = new object_t::const_iterator(*(o.oi_));
         }
     }
 }
 
 json::const_iterator::~const_iterator()
 {
-    delete _vi;
-    delete _oi;
+    delete vi_;
+    delete oi_;
 }
 
 json::const_iterator& json::const_iterator::operator=(json::const_iterator o)
 {
-    std::swap(_object, o._object);
-    std::swap(_vi, o._vi);
-    std::swap(_oi, o._oi);
+    std::swap(object_, o.object_);
+    std::swap(vi_, o.vi_);
+    std::swap(oi_, o.oi_);
     return *this;
 }
 
 bool json::const_iterator::operator==(const json::const_iterator& o) const
 {
-    if (_object != o._object)
+    if (object_ != o.object_)
     {
         return false;
     }
 
-    if (_object != nullptr)
+    if (object_ != nullptr)
     {
-        if (_object->_type == value_type::array)
+        if (object_->type_ == value_type::array)
         {
-            return (_vi == o._vi);
+            return (vi_ == o.vi_);
         }
-        if (_object->_type == value_type::object)
+        if (object_->type_ == value_type::object)
         {
-            return (_oi == o._oi);
+            return (oi_ == o.oi_);
         }
     }
 
@@ -1617,32 +1617,32 @@ bool json::const_iterator::operator!=(const json::const_iterator& o) const
 json::const_iterator& json::const_iterator::operator++()
 {
     // iterator cannot be incremented
-    if (_object == nullptr)
+    if (object_ == nullptr)
     {
         return *this;
     }
 
-    switch (_object->_type)
+    switch (object_->type_)
     {
         case (value_type::array):
         {
-            if (++(*_vi) == _object->_value.array->end())
+            if (++(*vi_) == object_->value_.array->end())
             {
-                _object = nullptr;
+                object_ = nullptr;
             }
             break;
         }
         case (value_type::object):
         {
-            if (++(*_oi) == _object->_value.object->end())
+            if (++(*oi_) == object_->value_.object->end())
             {
-                _object = nullptr;
+                object_ = nullptr;
             }
             break;
         }
         default:
         {
-            _object = nullptr;
+            object_ = nullptr;
         }
     }
     return *this;
@@ -1651,24 +1651,24 @@ json::const_iterator& json::const_iterator::operator++()
 const json& json::const_iterator::operator*() const
 {
     // dereferencing end() is an error
-    if (_object == nullptr)
+    if (object_ == nullptr)
     {
         throw std::runtime_error("cannot get value");
     }
 
-    switch (_object->_type)
+    switch (object_->type_)
     {
         case (value_type::array):
         {
-            return **_vi;
+            return **vi_;
         }
         case (value_type::object):
         {
-            return (*_oi)->second;
+            return (*oi_)->second;
         }
         default:
         {
-            return *_object;
+            return *object_;
         }
     }
 }
@@ -1676,33 +1676,33 @@ const json& json::const_iterator::operator*() const
 const json* json::const_iterator::operator->() const
 {
     // dereferencing end() is an error
-    if (_object == nullptr)
+    if (object_ == nullptr)
     {
         throw std::runtime_error("cannot get value");
     }
 
-    switch (_object->_type)
+    switch (object_->type_)
     {
         case (value_type::array):
         {
-            return &(**_vi);
+            return &(**vi_);
         }
         case (value_type::object):
         {
-            return &((*_oi)->second);
+            return &((*oi_)->second);
         }
         default:
         {
-            return _object;
+            return object_;
         }
     }
 }
 
 std::string json::const_iterator::key() const
 {
-    if (_object != nullptr and _object->_type == value_type::object)
+    if (object_ != nullptr and object_->type_ == value_type::object)
     {
-        return (*_oi)->first;
+        return (*oi_)->first;
     }
     else
     {
@@ -1713,24 +1713,24 @@ std::string json::const_iterator::key() const
 const json& json::const_iterator::value() const
 {
     // dereferencing end() is an error
-    if (_object == nullptr)
+    if (object_ == nullptr)
     {
         throw std::out_of_range("cannot get value");
     }
 
-    switch (_object->_type)
+    switch (object_->type_)
     {
         case (value_type::array):
         {
-            return **_vi;
+            return **vi_;
         }
         case (value_type::object):
         {
-            return (*_oi)->second;
+            return (*oi_)->second;
         }
         default:
         {
-            return *_object;
+            return *object_;
         }
     }
 }
@@ -1743,11 +1743,11 @@ Initialize the JSON parser given a string \p s.
 
 @param s  string to parse
 
-@post \p s is copied to the buffer @ref _buffer and the first character is
+@post \p s is copied to the buffer @ref buffer_ and the first character is
       read. Whitespace is skipped.
 */
 json::parser::parser(const char* s)
-    :  _buffer(s)
+    :  buffer_(s)
 {
     // read first character
     next();
@@ -1757,7 +1757,7 @@ json::parser::parser(const char* s)
 @copydoc json::parser::parser(const char* s)
 */
 json::parser::parser(const std::string& s)
-    : _buffer(s)
+    : buffer_(s)
 {
     // read first character
     next();
@@ -1770,7 +1770,7 @@ Initialize the JSON parser given an input stream \p _is.
 
 \param _is input stream to parse
 
-@post \p _is is copied to the buffer @ref _buffer and the firsr character is
+@post \p _is is copied to the buffer @ref buffer_ and the firsr character is
       read. Whitespace is skipped.
 
 */
@@ -1780,7 +1780,7 @@ json::parser::parser(std::istream& _is)
     {
         std::string input_line;
         std::getline(_is, input_line);
-        _buffer += input_line;
+        buffer_ += input_line;
     }
 
     // read first character
@@ -1789,7 +1789,7 @@ json::parser::parser(std::istream& _is)
 
 json json::parser::parse()
 {
-    switch (_current)
+    switch (current_)
     {
         case ('{'):
         {
@@ -1799,7 +1799,7 @@ json json::parser::parse()
             next();
 
             // process nonempty object
-            if (_current != '}')
+            if (current_ != '}')
             {
                 do
                 {
@@ -1813,7 +1813,7 @@ json json::parser::parse()
                     result[std::move(key)] = parse();
                     key.clear();
                 }
-                while (_current == ',' and next());
+                while (current_ == ',' and next());
             }
 
             // closing brace
@@ -1830,13 +1830,13 @@ json json::parser::parse()
             next();
 
             // process nonempty array
-            if (_current != ']')
+            if (current_ != ']')
             {
                 do
                 {
                     result.push_back(parse());
                 }
-                while (_current == ',' and next());
+                while (current_ == ',' and next());
             }
 
             // closing bracket
@@ -1881,15 +1881,15 @@ json json::parser::parse()
         case ('9'):
         {
             // remember position of number's first character
-            const auto _first_pos = _pos - 1;
+            const auto _firstpos_ = pos_ - 1;
 
-            while (next() and (std::isdigit(_current) || _current == '.'
-                               || _current == 'e' || _current == 'E'
-                               || _current == '+' || _current == '-'));
+            while (next() and (std::isdigit(current_) || current_ == '.'
+                               || current_ == 'e' || current_ == 'E'
+                               || current_ == '+' || current_ == '-'));
 
             try
             {
-                const auto float_val = std::stod(_buffer.substr(_first_pos, _pos - _first_pos));
+                const auto float_val = std::stod(buffer_.substr(_firstpos_, pos_ - _firstpos_));
                 const auto int_val = static_cast<int>(float_val);
 
                 // check if conversion loses precision
@@ -1907,7 +1907,7 @@ json json::parser::parse()
             catch (...)
             {
                 error("error translating " +
-                      _buffer.substr(_first_pos, _pos - _first_pos) + " to number");
+                      buffer_.substr(_firstpos_, pos_ - _firstpos_) + " to number");
             }
         }
 
@@ -1925,26 +1925,26 @@ true. If the end of the buffer is reached, false is returned.
 
 @return whether another non-whitespace character could be read
 
-@post _current holds the next character
+@post current_ holds the next character
 */
 bool json::parser::next()
 {
-    if (_pos == _buffer.size())
+    if (pos_ == buffer_.size())
     {
         return false;
     }
 
-    _current = _buffer[_pos++];
+    current_ = buffer_[pos_++];
 
     // skip trailing whitespace
-    while (std::isspace(_current))
+    while (std::isspace(current_))
     {
-        if (_pos == _buffer.size())
+        if (pos_ == buffer_.size())
         {
             return false;
         }
 
-        _current = _buffer[_pos++];
+        current_ = buffer_[pos_++];
     }
 
     return true;
@@ -1964,8 +1964,8 @@ the error message \p msg), and the last read token.
 void json::parser::error(const std::string& msg)
 {
     throw std::invalid_argument("parse error at position " +
-                                std::to_string(_pos) + ": " + msg +
-                                ", last read: '" + _current + "'");
+                                std::to_string(pos_) + ": " + msg +
+                                ", last read: '" + current_ + "'");
 }
 
 /*!
@@ -1974,41 +1974,41 @@ Parses a string after opening quotes (\p ") where read.
 @return the parsed string
 
 @pre  An opening quote \p " was read in the main parse function @ref parse.
-      _pos is the position after the opening quote.
+      pos_ is the position after the opening quote.
 
 @post The character after the closing quote \p " is the current character @ref
-      _current. Whitespace is skipped.
+      current_. Whitespace is skipped.
 */
 std::string json::parser::parseString()
 {
     // get position of closing quotes
-    auto quote_pos = _buffer.find_first_of("\"", _pos);
+    auto quotepos_ = buffer_.find_first_of("\"", pos_);
 
     // if the closing quotes are escaped (character before the quotes is a
     // backslash), we continue looking for the final quotes
-    while (quote_pos != std::string::npos and _buffer[quote_pos - 1] == '\\')
+    while (quotepos_ != std::string::npos and buffer_[quotepos_ - 1] == '\\')
     {
-        quote_pos = _buffer.find_first_of("\"", quote_pos + 1);
+        quotepos_ = buffer_.find_first_of("\"", quotepos_ + 1);
     }
 
     // check if closing quotes were found
-    if (quote_pos == std::string::npos)
+    if (quotepos_ == std::string::npos)
     {
         error("expected '\"'");
     }
 
     // store the coordinates of the string for the later return value
-    const auto stringBegin = _pos;
-    const auto stringLength = quote_pos - _pos;
+    const auto stringBegin = pos_;
+    const auto stringLength = quotepos_ - pos_;
 
     // set buffer position to the position behind (+1) the closing quote
-    _pos = quote_pos + 1;
+    pos_ = quotepos_ + 1;
 
     // read next character
     next();
 
     // return the string value
-    return _buffer.substr(stringBegin, stringLength);
+    return buffer_.substr(stringBegin, stringLength);
 }
 
 /*!
@@ -2023,12 +2023,12 @@ error is raised via @ref error.
 */
 void json::parser::parseTrue()
 {
-    if (_buffer.substr(_pos, 3) != "rue")
+    if (buffer_.substr(pos_, 3) != "rue")
     {
         error("expected true");
     }
 
-    _pos += 3;
+    pos_ += 3;
 
     // read next character
     next();
@@ -2046,12 +2046,12 @@ error is raised via @ref error.
 */
 void json::parser::parseFalse()
 {
-    if (_buffer.substr(_pos, 4) != "alse")
+    if (buffer_.substr(pos_, 4) != "alse")
     {
         error("expected false");
     }
 
-    _pos += 4;
+    pos_ += 4;
 
     // read next character
     next();
@@ -2069,12 +2069,12 @@ error is raised via @ref error.
 */
 void json::parser::parseNull()
 {
-    if (_buffer.substr(_pos, 3) != "ull")
+    if (buffer_.substr(pos_, 3) != "ull")
     {
         error("expected null");
     }
 
-    _pos += 3;
+    pos_ += 3;
 
     // read next character
     next();
@@ -2082,8 +2082,8 @@ void json::parser::parseNull()
 
 /*!
 This function wraps functionality to check whether the current character @ref
-_current matches a given character \p c. In case of a match, the next character
-of the buffer @ref _buffer is read. In case of a mismatch, an error is raised
+current_ matches a given character \p c. In case of a match, the next character
+of the buffer @ref buffer_ is read. In case of a mismatch, an error is raised
 via @ref error.
 
 @param c  character that is expected
@@ -2092,7 +2092,7 @@ via @ref error.
 */
 void json::parser::expect(const char c)
 {
-    if (_current != c)
+    if (current_ != c)
     {
         std::string msg = "expected '";
         msg.append(1, c);
diff --git a/src/json.h b/src/json.h
index fc46813d..688d805b 100644
--- a/src/json.h
+++ b/src/json.h
@@ -112,17 +112,17 @@ class json
 
   public:
     /// create an object according to given type
-    json(const value_type) noexcept;
+    json(const value_type);
     /// create a null object
     json() = default;
     /// create a null object
     json(std::nullptr_t) noexcept;
     /// create a string object from a C++ string
-    json(const std::string&) noexcept;
+    json(const std::string&);
     /// create a string object from a C++ string (move)
-    json(std::string&&) noexcept;
+    json(std::string&&);
     /// create a string object from a C string
-    json(const char*) noexcept;
+    json(const char*);
     /// create a Boolean object
     json(const bool) noexcept;
     /// create a number object
@@ -130,18 +130,18 @@ class json
     /// create a number object
     json(const double) noexcept;
     /// create an array
-    json(const array_t&) noexcept;
+    json(const array_t&);
     /// create an array (move)
-    json(array_t&&) noexcept;
+    json(array_t&&);
     /// create an object
-    json(const object_t&) noexcept;
+    json(const object_t&);
     /// create an object (move)
-    json(object_t&&) noexcept;
+    json(object_t&&);
     /// create from an initializer list (to an array or object)
-    json(list_init_t) noexcept;
+    json(list_init_t);
 
     /// copy constructor
-    json(const json&) noexcept;
+    json(const json&);
     /// move constructor
     json(json&&) noexcept;
 
@@ -158,7 +158,7 @@ class json
 
   private:
     /// return the type as string
-    const std::string _typename() const noexcept;
+    const std::string type_name() const noexcept;
 
   public:
     /// explicit value conversion
@@ -312,14 +312,14 @@ class json
 
   private:
     /// the type of this object
-    value_type _type = value_type::null;
+    value_type type_ = value_type::null;
 
     /// the payload
-    value _value {};
+    value value_ {};
 
   private:
     /// mutex to guard payload
-    static std::mutex _token;
+    static std::mutex token_;
 
   public:
     /// an iterator
@@ -347,11 +347,11 @@ class json
 
       private:
         /// a JSON value
-        json* _object = nullptr;
+        json* object_ = nullptr;
         /// an iterator for JSON arrays
-        array_t::iterator* _vi = nullptr;
+        array_t::iterator* vi_ = nullptr;
         /// an iterator for JSON objects
-        object_t::iterator* _oi = nullptr;
+        object_t::iterator* oi_ = nullptr;
     };
 
     /// a const iterator
@@ -380,11 +380,11 @@ class json
 
       private:
         /// a JSON value
-        const json* _object = nullptr;
+        const json* object_ = nullptr;
         /// an iterator for JSON arrays
-        array_t::const_iterator* _vi = nullptr;
+        array_t::const_iterator* vi_ = nullptr;
         /// an iterator for JSON objects
-        object_t::const_iterator* _oi = nullptr;
+        object_t::const_iterator* oi_ = nullptr;
     };
 
   private:
@@ -427,11 +427,11 @@ class json
 
       private:
         /// a buffer of the input
-        std::string _buffer {};
+        std::string buffer_ {};
         /// the current character
-        char _current {};
+        char current_ {};
         /// the position inside the input buffer
-        size_t _pos = 0;
+        size_t pos_ = 0;
     };
 };