diff --git a/src/stored-object.cpp b/src/stored-object.cpp
index a549d06..e6fcad1 100644
--- a/src/stored-object.cpp
+++ b/src/stored-object.cpp
@@ -17,17 +17,16 @@ template<typename StoredType>
 class PrimitiveHolder : public BaseHolder {
 public:
     PrimitiveHolder(const sol::stack_object& luaObject) noexcept
-            : BaseHolder(luaObject.get_type()), data_(luaObject.as<StoredType>()) {}
+            : data_(luaObject.as<StoredType>()) {}
 
     PrimitiveHolder(const sol::object& luaObject) noexcept
-            : BaseHolder(luaObject.get_type()), data_(luaObject.as<StoredType>()) {}
+            : data_(luaObject.as<StoredType>()) {}
 
-    PrimitiveHolder(sol::type type, const StoredType& init) noexcept
-            : BaseHolder(type), data_(init) {}
+    PrimitiveHolder(const StoredType& init) noexcept
+            : data_(init) {}
 
-    bool rawCompare(const BaseHolder* other) const noexcept final {
-        ASSERT(type_ == other->type());
-        return static_cast<const PrimitiveHolder<StoredType>*>(other)->data_ == data_;
+    bool compare(const BaseHolder* other) const noexcept final {
+        return BaseHolder::compare(other) && static_cast<const PrimitiveHolder<StoredType>*>(other)->data_ == data_;
     }
 
     std::size_t hash() const noexcept final {
@@ -45,17 +44,15 @@ private:
 class FunctionHolder : public BaseHolder {
 public:
     template<typename SolObject>
-    FunctionHolder(SolObject luaObject) noexcept
-            : BaseHolder(sol::type::function) {
+    FunctionHolder(SolObject luaObject) noexcept {
         sol::state_view lua(luaObject.lua_state());
         sol::function dumper = lua["string"]["dump"];
-
         ASSERT(dumper.valid());
         function_ = dumper(luaObject);
     }
 
-    bool rawCompare(const BaseHolder* other) const noexcept final {
-        return function_ == static_cast<const FunctionHolder*>(other)->function_;
+    bool compare(const BaseHolder* other) const noexcept final {
+        return BaseHolder::compare(other) && static_cast<const FunctionHolder*>(other)->function_ == function_;
     }
 
     std::size_t hash() const noexcept final {
@@ -66,10 +63,8 @@ public:
         sol::state_view lua((lua_State*)state);
         sol::function loader = lua["loadstring"];
         ASSERT(loader.valid());
-
         sol::function result = loader(function_);
-        ASSERT(result.valid()) << "Unable to restore function!\n"
-            << "Content:\n" << function_;
+        ASSERT(result.valid()) << "Unable to restore function!\n" << "Content:\n" << function_;
         return sol::make_object(state, result);
     }
 
@@ -138,7 +133,7 @@ std::unique_ptr<BaseHolder> fromSolObject(const SolObject& luaObject) {
             // SolTableToShared is used to prevent from infinity recursion
             // in recursive tables
             dumpTable(table, luaTable, visited);
-            return std::make_unique<PrimitiveHolder<SharedTable*>>(sol::type::userdata, table);
+            return std::make_unique<PrimitiveHolder<SharedTable*>>(table);
         }
         default:
             ERROR << "Unable to store object of that type: " << (int)luaObject.get_type() << "\n";
@@ -152,7 +147,7 @@ StoredObject::StoredObject(StoredObject&& init) noexcept
         : data_(std::move(init.data_)) {}
 
 StoredObject::StoredObject(SharedTable* table) noexcept
-        : data_(new PrimitiveHolder<SharedTable*>(sol::type::userdata, table)) {
+        : data_(new PrimitiveHolder<SharedTable*>(table)) {
 }
 
 StoredObject::StoredObject(const sol::object& object) noexcept
@@ -187,7 +182,7 @@ StoredObject& StoredObject::operator=(StoredObject&& o) noexcept {
 }
 
 bool StoredObject::operator==(const StoredObject& o) const noexcept {
-    if (data_)
+    if (data_ && o.data_)
         return data_->compare(o.data_.get());
     else
         return data_.get() == o.data_.get();
diff --git a/src/stored-object.h b/src/stored-object.h
index d5addc3..32ce2f6 100644
--- a/src/stored-object.h
+++ b/src/stored-object.h
@@ -9,25 +9,16 @@ namespace effil {
 
 class BaseHolder {
 public:
-    BaseHolder(sol::type t) noexcept : type_(t) {}
+    BaseHolder() = default;
     virtual ~BaseHolder() = default;
 
-    sol::type type() const noexcept {
-        return type_;
+    virtual bool compare(const BaseHolder* other) const noexcept {
+        return typeid(*this) == typeid(*other);
     }
 
-    bool compare(const BaseHolder* other) const noexcept {
-        ASSERT(other != nullptr);
-        return type_ == other->type_ && rawCompare(other);
-    }
-
-    virtual bool rawCompare(const BaseHolder* other) const noexcept = 0;
     virtual std::size_t hash() const noexcept = 0;
     virtual sol::object unpack(sol::this_state state) const noexcept = 0;
 
-protected:
-    sol::type type_;
-
 private:
     BaseHolder(const BaseHolder&) = delete;
     BaseHolder(BaseHolder&) = delete;