diff --git a/include/loki/details/pddl/action.hpp b/include/loki/details/pddl/action.hpp
index a6b81ca..0b86695 100644
--- a/include/loki/details/pddl/action.hpp
+++ b/include/loki/details/pddl/action.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_ACTION_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <optional>
 #include <string>
@@ -62,6 +64,18 @@ class ActionImpl
     const std::optional<Effect>& get_effect() const;
 };
 
+template<>
+struct UniquePDDLHasher<const ActionImpl*>
+{
+    size_t operator()(const ActionImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const ActionImpl*>
+{
+    bool operator()(const ActionImpl* l, const ActionImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const ActionImpl& element);
 
 }
diff --git a/include/loki/details/pddl/atom.hpp b/include/loki/details/pddl/atom.hpp
index 3226dcb..9f4259b 100644
--- a/include/loki/details/pddl/atom.hpp
+++ b/include/loki/details/pddl/atom.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_ATOM_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 
@@ -49,6 +51,18 @@ class AtomImpl
     const TermList& get_terms() const;
 };
 
+template<>
+struct UniquePDDLHasher<const AtomImpl*>
+{
+    size_t operator()(const AtomImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const AtomImpl*>
+{
+    bool operator()(const AtomImpl* l, const AtomImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const AtomImpl& element);
 
 }
diff --git a/include/loki/details/pddl/axiom.hpp b/include/loki/details/pddl/axiom.hpp
index e8e5748..57cf390 100644
--- a/include/loki/details/pddl/axiom.hpp
+++ b/include/loki/details/pddl/axiom.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_DERIVED_PREDICATE_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 
@@ -53,6 +55,18 @@ class AxiomImpl
     size_t get_num_parameters_to_ground_head() const;
 };
 
+template<>
+struct UniquePDDLHasher<const AxiomImpl*>
+{
+    size_t operator()(const AxiomImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const AxiomImpl*>
+{
+    bool operator()(const AxiomImpl* l, const AxiomImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const AxiomImpl& element);
 
 }
diff --git a/include/loki/details/pddl/conditions.hpp b/include/loki/details/pddl/conditions.hpp
index 72bca4e..c2b1690 100644
--- a/include/loki/details/pddl/conditions.hpp
+++ b/include/loki/details/pddl/conditions.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_CONDITIONS_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 
@@ -199,6 +201,102 @@ class ConditionForallImpl
     const Condition& get_condition() const;
 };
 
+template<>
+struct UniquePDDLHasher<const ConditionLiteralImpl&>
+{
+    size_t operator()(const ConditionLiteralImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const ConditionAndImpl&>
+{
+    size_t operator()(const ConditionAndImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const ConditionOrImpl&>
+{
+    size_t operator()(const ConditionOrImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const ConditionNotImpl&>
+{
+    size_t operator()(const ConditionNotImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const ConditionImplyImpl&>
+{
+    size_t operator()(const ConditionImplyImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const ConditionExistsImpl&>
+{
+    size_t operator()(const ConditionExistsImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const ConditionForallImpl&>
+{
+    size_t operator()(const ConditionForallImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const ConditionImpl*>
+{
+    size_t operator()(const ConditionImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const ConditionLiteralImpl&>
+{
+    bool operator()(const ConditionLiteralImpl& l, const ConditionLiteralImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const ConditionAndImpl&>
+{
+    bool operator()(const ConditionAndImpl& l, const ConditionAndImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const ConditionOrImpl&>
+{
+    bool operator()(const ConditionOrImpl& l, const ConditionOrImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const ConditionNotImpl&>
+{
+    bool operator()(const ConditionNotImpl& l, const ConditionNotImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const ConditionImplyImpl&>
+{
+    bool operator()(const ConditionImplyImpl& l, const ConditionImplyImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const ConditionExistsImpl&>
+{
+    bool operator()(const ConditionExistsImpl& l, const ConditionExistsImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const ConditionForallImpl&>
+{
+    bool operator()(const ConditionForallImpl& l, const ConditionForallImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const ConditionImpl*>
+{
+    bool operator()(const ConditionImpl* l, const ConditionImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const ConditionLiteralImpl& element);
 extern std::ostream& operator<<(std::ostream& out, const ConditionAndImpl& element);
 extern std::ostream& operator<<(std::ostream& out, const ConditionOrImpl& element);
diff --git a/include/loki/details/pddl/domain.hpp b/include/loki/details/pddl/domain.hpp
index b9bad81..c16c6ea 100644
--- a/include/loki/details/pddl/domain.hpp
+++ b/include/loki/details/pddl/domain.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_DOMAIN_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 #include "loki/details/utils/filesystem.hpp"
 
 #include <optional>
@@ -75,6 +77,18 @@ class DomainImpl
     const AxiomList& get_axioms() const;
 };
 
+template<>
+struct UniquePDDLHasher<const DomainImpl*>
+{
+    size_t operator()(const DomainImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const DomainImpl*>
+{
+    bool operator()(const DomainImpl* l, const DomainImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const DomainImpl& element);
 
 }
diff --git a/include/loki/details/pddl/effects.hpp b/include/loki/details/pddl/effects.hpp
index d019a7e..dd3515a 100644
--- a/include/loki/details/pddl/effects.hpp
+++ b/include/loki/details/pddl/effects.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_EFFECTS_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 
@@ -164,6 +166,78 @@ class EffectConditionalWhenImpl
     const Effect& get_effect() const;
 };
 
+template<>
+struct UniquePDDLHasher<const EffectLiteralImpl&>
+{
+    size_t operator()(const EffectLiteralImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const EffectAndImpl&>
+{
+    size_t operator()(const EffectAndImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const EffectNumericImpl&>
+{
+    size_t operator()(const EffectNumericImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const EffectConditionalForallImpl&>
+{
+    size_t operator()(const EffectConditionalForallImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const EffectConditionalWhenImpl&>
+{
+    size_t operator()(const EffectConditionalWhenImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const EffectImpl*>
+{
+    size_t operator()(const EffectImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const EffectLiteralImpl&>
+{
+    bool operator()(const EffectLiteralImpl& l, const EffectLiteralImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const EffectAndImpl&>
+{
+    bool operator()(const EffectAndImpl& l, const EffectAndImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const EffectNumericImpl&>
+{
+    bool operator()(const EffectNumericImpl& l, const EffectNumericImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const EffectConditionalForallImpl&>
+{
+    bool operator()(const EffectConditionalForallImpl& l, const EffectConditionalForallImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const EffectConditionalWhenImpl&>
+{
+    bool operator()(const EffectConditionalWhenImpl& l, const EffectConditionalWhenImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const EffectImpl*>
+{
+    bool operator()(const EffectImpl* l, const EffectImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const EffectLiteralImpl& element);
 extern std::ostream& operator<<(std::ostream& out, const EffectAndImpl& element);
 extern std::ostream& operator<<(std::ostream& out, const EffectNumericImpl& element);
diff --git a/include/loki/details/pddl/equal_to.hpp b/include/loki/details/pddl/equal_to.hpp
new file mode 100644
index 0000000..fd82788
--- /dev/null
+++ b/include/loki/details/pddl/equal_to.hpp
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2023 Dominik Drexler and Simon Stahlberg
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *<
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef LOKI_INCLUDE_LOKI_PDDL_EQUAL_TO_HPP_
+#define LOKI_INCLUDE_LOKI_PDDL_EQUAL_TO_HPP_
+
+#include "loki/details/pddl/declarations.hpp"
+#include "loki/details/utils/concepts.hpp"
+
+#include <functional>
+#include <variant>
+
+namespace loki
+{
+
+/// @brief `UniquePDDLEqualTo` is a comparator that should be implemented to work in the context where
+/// all objects of a custom type `T` are uniquely created and uncopieable.
+/// This ensures that pointers can simply be compared and do not need to be dereferenced.
+/// @tparam T the type of the object to compare.
+template<typename T>
+struct UniquePDDLEqualTo
+{
+    bool operator()(const T& l, const T& r) const { return std::equal_to<T>()(l, r); }
+};
+
+/// Spezialization for std::variant.
+template<typename... Ts>
+struct UniquePDDLEqualTo<std::variant<Ts...>>
+{
+    bool operator()(const std::variant<Ts...>& l, const std::variant<Ts...>& r) const
+    {
+        if (l.index() != r.index())
+        {
+            return false;  // Different types held
+        }
+        // Compare the held values, but only if they are of the same type
+        return std::visit(
+            [](const auto& lhs, const auto& rhs) -> bool
+            {
+                if constexpr (std::is_same_v<decltype(lhs), decltype(rhs)>)
+                {
+                    return UniquePDDLEqualTo<decltype(lhs)>()(lhs, rhs);
+                }
+                else
+                {
+                    return false;  // Different types can't be equal
+                }
+            },
+            l,
+            r);
+    }
+};
+
+}
+
+#endif
diff --git a/include/loki/details/pddl/factories.hpp b/include/loki/details/pddl/factories.hpp
index 1b6c46e..23fa4b3 100644
--- a/include/loki/details/pddl/factories.hpp
+++ b/include/loki/details/pddl/factories.hpp
@@ -25,9 +25,11 @@
 #include "loki/details/pddl/declarations.hpp"
 #include "loki/details/pddl/domain.hpp"
 #include "loki/details/pddl/effects.hpp"
+#include "loki/details/pddl/equal_to.hpp"
 #include "loki/details/pddl/function.hpp"
 #include "loki/details/pddl/function_expressions.hpp"
 #include "loki/details/pddl/function_skeleton.hpp"
+#include "loki/details/pddl/hash.hpp"
 #include "loki/details/pddl/literal.hpp"
 #include "loki/details/pddl/metric.hpp"
 #include "loki/details/pddl/numeric_fluent.hpp"
@@ -46,26 +48,29 @@
 namespace loki
 {
 
-using RequirementsFactory = UniqueFactory<RequirementsImpl, Hasher<const RequirementsImpl*>, EqualTo<const RequirementsImpl*>>;
-using TypeFactory = UniqueFactory<TypeImpl, Hasher<const TypeImpl*>, EqualTo<const TypeImpl*>>;
-using VariableFactory = UniqueFactory<VariableImpl, Hasher<const VariableImpl*>, EqualTo<const VariableImpl*>>;
-using TermFactory = UniqueFactory<TermImpl, Hasher<const TermImpl*>, EqualTo<const TermImpl*>>;
-using ObjectFactory = UniqueFactory<ObjectImpl, Hasher<const ObjectImpl*>, EqualTo<const ObjectImpl*>>;
-using AtomFactory = UniqueFactory<AtomImpl, Hasher<const AtomImpl*>, EqualTo<const AtomImpl*>>;
-using LiteralFactory = UniqueFactory<LiteralImpl, Hasher<const LiteralImpl*>, EqualTo<const LiteralImpl*>>;
-using ParameterFactory = UniqueFactory<ParameterImpl, Hasher<const ParameterImpl*>, EqualTo<const ParameterImpl*>>;
-using PredicateFactory = UniqueFactory<PredicateImpl, Hasher<const PredicateImpl*>, EqualTo<const PredicateImpl*>>;
-using FunctionExpressionFactory = UniqueFactory<FunctionExpressionImpl, Hasher<const FunctionExpressionImpl*>, EqualTo<const FunctionExpressionImpl*>>;
-using FunctionFactory = UniqueFactory<FunctionImpl, Hasher<const FunctionImpl*>, EqualTo<const FunctionImpl*>>;
-using FunctionSkeletonFactory = UniqueFactory<FunctionSkeletonImpl, Hasher<const FunctionSkeletonImpl*>, EqualTo<const FunctionSkeletonImpl*>>;
-using ConditionFactory = UniqueFactory<ConditionImpl, Hasher<const ConditionImpl*>, EqualTo<const ConditionImpl*>>;
-using EffectFactory = UniqueFactory<EffectImpl, Hasher<const EffectImpl*>, EqualTo<const EffectImpl*>>;
-using ActionFactory = UniqueFactory<ActionImpl, Hasher<const ActionImpl*>, EqualTo<const ActionImpl*>>;
-using AxiomFactory = UniqueFactory<AxiomImpl, Hasher<const AxiomImpl*>, EqualTo<const AxiomImpl*>>;
-using OptimizationMetricFactory = UniqueFactory<OptimizationMetricImpl, Hasher<const OptimizationMetricImpl*>, EqualTo<const OptimizationMetricImpl*>>;
-using NumericFluentFactory = UniqueFactory<NumericFluentImpl, Hasher<const NumericFluentImpl*>, EqualTo<const NumericFluentImpl*>>;
-using DomainFactory = UniqueFactory<DomainImpl, Hasher<const DomainImpl*>, EqualTo<const DomainImpl*>>;
-using ProblemFactory = UniqueFactory<ProblemImpl, Hasher<const ProblemImpl*>, EqualTo<const ProblemImpl*>>;
+using RequirementsFactory = UniqueFactory<RequirementsImpl, UniquePDDLHasher<const RequirementsImpl*>, UniquePDDLEqualTo<const RequirementsImpl*>>;
+using TypeFactory = UniqueFactory<TypeImpl, UniquePDDLHasher<const TypeImpl*>, UniquePDDLEqualTo<const TypeImpl*>>;
+using VariableFactory = UniqueFactory<VariableImpl, UniquePDDLHasher<const VariableImpl*>, UniquePDDLEqualTo<const VariableImpl*>>;
+using TermFactory = UniqueFactory<TermImpl, UniquePDDLHasher<const TermImpl*>, UniquePDDLEqualTo<const TermImpl*>>;
+using ObjectFactory = UniqueFactory<ObjectImpl, UniquePDDLHasher<const ObjectImpl*>, UniquePDDLEqualTo<const ObjectImpl*>>;
+using AtomFactory = UniqueFactory<AtomImpl, UniquePDDLHasher<const AtomImpl*>, UniquePDDLEqualTo<const AtomImpl*>>;
+using LiteralFactory = UniqueFactory<LiteralImpl, UniquePDDLHasher<const LiteralImpl*>, UniquePDDLEqualTo<const LiteralImpl*>>;
+using ParameterFactory = UniqueFactory<ParameterImpl, UniquePDDLHasher<const ParameterImpl*>, UniquePDDLEqualTo<const ParameterImpl*>>;
+using PredicateFactory = UniqueFactory<PredicateImpl, UniquePDDLHasher<const PredicateImpl*>, UniquePDDLEqualTo<const PredicateImpl*>>;
+using FunctionExpressionFactory =
+    UniqueFactory<FunctionExpressionImpl, UniquePDDLHasher<const FunctionExpressionImpl*>, UniquePDDLEqualTo<const FunctionExpressionImpl*>>;
+using FunctionFactory = UniqueFactory<FunctionImpl, UniquePDDLHasher<const FunctionImpl*>, UniquePDDLEqualTo<const FunctionImpl*>>;
+using FunctionSkeletonFactory =
+    UniqueFactory<FunctionSkeletonImpl, UniquePDDLHasher<const FunctionSkeletonImpl*>, UniquePDDLEqualTo<const FunctionSkeletonImpl*>>;
+using ConditionFactory = UniqueFactory<ConditionImpl, UniquePDDLHasher<const ConditionImpl*>, UniquePDDLEqualTo<const ConditionImpl*>>;
+using EffectFactory = UniqueFactory<EffectImpl, UniquePDDLHasher<const EffectImpl*>, UniquePDDLEqualTo<const EffectImpl*>>;
+using ActionFactory = UniqueFactory<ActionImpl, UniquePDDLHasher<const ActionImpl*>, UniquePDDLEqualTo<const ActionImpl*>>;
+using AxiomFactory = UniqueFactory<AxiomImpl, UniquePDDLHasher<const AxiomImpl*>, UniquePDDLEqualTo<const AxiomImpl*>>;
+using OptimizationMetricFactory =
+    UniqueFactory<OptimizationMetricImpl, UniquePDDLHasher<const OptimizationMetricImpl*>, UniquePDDLEqualTo<const OptimizationMetricImpl*>>;
+using NumericFluentFactory = UniqueFactory<NumericFluentImpl, UniquePDDLHasher<const NumericFluentImpl*>, UniquePDDLEqualTo<const NumericFluentImpl*>>;
+using DomainFactory = UniqueFactory<DomainImpl, UniquePDDLHasher<const DomainImpl*>, UniquePDDLEqualTo<const DomainImpl*>>;
+using ProblemFactory = UniqueFactory<ProblemImpl, UniquePDDLHasher<const ProblemImpl*>, UniquePDDLEqualTo<const ProblemImpl*>>;
 
 using VariadicPDDLConstructorFactory = VariadicContainer<RequirementsFactory,
                                                          TypeFactory,
diff --git a/include/loki/details/pddl/function.hpp b/include/loki/details/pddl/function.hpp
index 8ed6ab7..b353d5f 100644
--- a/include/loki/details/pddl/function.hpp
+++ b/include/loki/details/pddl/function.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_FUNCTION_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 
@@ -49,6 +51,18 @@ class FunctionImpl
     const TermList& get_terms() const;
 };
 
+template<>
+struct UniquePDDLHasher<const FunctionImpl*>
+{
+    size_t operator()(const FunctionImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const FunctionImpl*>
+{
+    bool operator()(const FunctionImpl* l, const FunctionImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const FunctionImpl& element);
 
 }
diff --git a/include/loki/details/pddl/function_expressions.hpp b/include/loki/details/pddl/function_expressions.hpp
index fdc28ea..a110b07 100644
--- a/include/loki/details/pddl/function_expressions.hpp
+++ b/include/loki/details/pddl/function_expressions.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_FUNCTION_EXPRESSIONS_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 #include <unordered_map>
@@ -174,6 +176,78 @@ class FunctionExpressionFunctionImpl
     const Function& get_function() const;
 };
 
+template<>
+struct UniquePDDLHasher<const FunctionExpressionNumberImpl&>
+{
+    size_t operator()(const FunctionExpressionNumberImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const FunctionExpressionBinaryOperatorImpl&>
+{
+    size_t operator()(const FunctionExpressionBinaryOperatorImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const FunctionExpressionMultiOperatorImpl&>
+{
+    size_t operator()(const FunctionExpressionMultiOperatorImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const FunctionExpressionMinusImpl&>
+{
+    size_t operator()(const FunctionExpressionMinusImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const FunctionExpressionFunctionImpl&>
+{
+    size_t operator()(const FunctionExpressionFunctionImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const FunctionExpressionImpl*>
+{
+    size_t operator()(const FunctionExpressionImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const FunctionExpressionNumberImpl&>
+{
+    bool operator()(const FunctionExpressionNumberImpl& l, const FunctionExpressionNumberImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const FunctionExpressionBinaryOperatorImpl&>
+{
+    bool operator()(const FunctionExpressionBinaryOperatorImpl& l, const FunctionExpressionBinaryOperatorImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const FunctionExpressionMultiOperatorImpl&>
+{
+    bool operator()(const FunctionExpressionMultiOperatorImpl& l, const FunctionExpressionMultiOperatorImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const FunctionExpressionMinusImpl&>
+{
+    bool operator()(const FunctionExpressionMinusImpl& l, const FunctionExpressionMinusImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const FunctionExpressionFunctionImpl&>
+{
+    bool operator()(const FunctionExpressionFunctionImpl& l, const FunctionExpressionFunctionImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const FunctionExpressionImpl*>
+{
+    bool operator()(const FunctionExpressionImpl* l, const FunctionExpressionImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const FunctionExpressionNumberImpl& element);
 extern std::ostream& operator<<(std::ostream& out, const FunctionExpressionBinaryOperatorImpl& element);
 extern std::ostream& operator<<(std::ostream& out, const FunctionExpressionMultiOperatorImpl& element);
diff --git a/include/loki/details/pddl/function_skeleton.hpp b/include/loki/details/pddl/function_skeleton.hpp
index 36cb382..f07dc37 100644
--- a/include/loki/details/pddl/function_skeleton.hpp
+++ b/include/loki/details/pddl/function_skeleton.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_FUNCTION_SKELETON_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 
@@ -51,6 +53,18 @@ class FunctionSkeletonImpl
     const Type& get_type() const;
 };
 
+template<>
+struct UniquePDDLHasher<const FunctionSkeletonImpl*>
+{
+    size_t operator()(const FunctionSkeletonImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const FunctionSkeletonImpl*>
+{
+    bool operator()(const FunctionSkeletonImpl* l, const FunctionSkeletonImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const FunctionSkeletonImpl& element);
 
 }
diff --git a/include/loki/details/pddl/hash.hpp b/include/loki/details/pddl/hash.hpp
new file mode 100644
index 0000000..a73a76a
--- /dev/null
+++ b/include/loki/details/pddl/hash.hpp
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2023 Dominik Drexler and Simon Stahlberg
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *<
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef LOKI_INCLUDE_LOKI_PDDL_HASH_HPP_
+#define LOKI_INCLUDE_LOKI_PDDL_HASH_HPP_
+
+#include "loki/details/pddl/declarations.hpp"
+#include "loki/details/utils/concepts.hpp"
+#include "loki/details/utils/unique_factory.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <ranges>
+#include <utility>
+#include <variant>
+
+namespace loki
+{
+
+/// @brief `UniquePDDLHasher` is a hasher that should be implemented to work in the context where
+/// all objects of a custom type `T` are uniquely created and uncopieable.
+/// This ensures that pointers can simply be hashed and do not need to be dereferenced.
+/// @tparam T the type of the object to hash.
+template<typename T>
+struct UniquePDDLHasher
+{
+    size_t operator()(const T& element) const { return std::hash<T>()(element); }
+};
+
+struct UniquePDDLHashCombiner
+{
+public:
+    template<typename T>
+    void operator()(size_t& seed, const T& value) const
+    {
+        seed ^= UniquePDDLHasher<T>()(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+    }
+
+    void operator()(size_t& seed, const std::size_t& value) const { seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2); }
+
+    template<typename... Types>
+    size_t operator()(const Types&... args) const
+    {
+        size_t seed = 0;
+        ((*this)(seed, args), ...);
+        return seed;
+    }
+};
+
+/// Spezialization for std::ranges::forward_range.
+template<typename ForwardRange>
+requires std::ranges::forward_range<ForwardRange>
+struct UniquePDDLHasher<ForwardRange>
+{
+    size_t operator()(const ForwardRange& range) const
+    {
+        std::size_t aggregated_hash = 0;
+        for (const auto& item : range)
+        {
+            UniquePDDLHashCombiner()(aggregated_hash, item);
+        }
+        return aggregated_hash;
+    }
+};
+
+/// Spezialization for std::variant.
+template<typename Variant>
+requires IsVariant<Variant>
+struct UniquePDDLHasher<Variant>
+{
+    size_t operator()(const Variant& variant) const
+    {
+        return std::visit([](const auto& arg) { return UniquePDDLHasher<decltype(arg)>()(arg); }, variant);
+    }
+};
+
+}
+
+#endif
diff --git a/include/loki/details/pddl/literal.hpp b/include/loki/details/pddl/literal.hpp
index 3bdd64f..2beb5d2 100644
--- a/include/loki/details/pddl/literal.hpp
+++ b/include/loki/details/pddl/literal.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_LITERAL_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 
@@ -49,6 +51,18 @@ class LiteralImpl
     const Atom& get_atom() const;
 };
 
+template<>
+struct UniquePDDLHasher<const LiteralImpl*>
+{
+    size_t operator()(const LiteralImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const LiteralImpl*>
+{
+    bool operator()(const LiteralImpl* l, const LiteralImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const LiteralImpl& element);
 }
 
diff --git a/include/loki/details/pddl/metric.hpp b/include/loki/details/pddl/metric.hpp
index 57d613f..f71a2ec 100644
--- a/include/loki/details/pddl/metric.hpp
+++ b/include/loki/details/pddl/metric.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_METRIC_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 
@@ -58,6 +60,18 @@ class OptimizationMetricImpl
     const FunctionExpression& get_function_expression() const;
 };
 
+template<>
+struct UniquePDDLHasher<const OptimizationMetricImpl*>
+{
+    size_t operator()(const OptimizationMetricImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const OptimizationMetricImpl*>
+{
+    bool operator()(const OptimizationMetricImpl* l, const OptimizationMetricImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const OptimizationMetricImpl& element);
 }
 
diff --git a/include/loki/details/pddl/numeric_fluent.hpp b/include/loki/details/pddl/numeric_fluent.hpp
index 6a13437..3445fac 100644
--- a/include/loki/details/pddl/numeric_fluent.hpp
+++ b/include/loki/details/pddl/numeric_fluent.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_NUMERIC_FLUENT_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 
@@ -49,6 +51,18 @@ class NumericFluentImpl
     double get_number() const;
 };
 
+template<>
+struct UniquePDDLHasher<const NumericFluentImpl*>
+{
+    size_t operator()(const NumericFluentImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const NumericFluentImpl*>
+{
+    bool operator()(const NumericFluentImpl* l, const NumericFluentImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const NumericFluentImpl& element);
 
 }
diff --git a/include/loki/details/pddl/object.hpp b/include/loki/details/pddl/object.hpp
index 10ff1bd..97365a8 100644
--- a/include/loki/details/pddl/object.hpp
+++ b/include/loki/details/pddl/object.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_OBJECT_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 
@@ -49,6 +51,20 @@ class ObjectImpl
     const TypeList& get_bases() const;
 };
 
+template<>
+struct UniquePDDLHasher<const ObjectImpl*>
+{
+    size_t operator()(const ObjectImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const ObjectImpl*>
+{
+    bool operator()(const ObjectImpl* l, const ObjectImpl* r) const;
+};
+
+extern std::ostream& operator<<(std::ostream& out, const ObjectImpl& element);
+
 }
 
 #endif
diff --git a/include/loki/details/pddl/parameter.hpp b/include/loki/details/pddl/parameter.hpp
index e8af150..c66e62d 100644
--- a/include/loki/details/pddl/parameter.hpp
+++ b/include/loki/details/pddl/parameter.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_PARAMETER_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 
@@ -54,6 +56,18 @@ class ParameterImpl
 /// by checking whether the types are compatible
 extern bool is_specialized_parameter(const Parameter& specialized_parameter, const Parameter& generalized_parameter);
 
+template<>
+struct UniquePDDLHasher<const ParameterImpl*>
+{
+    size_t operator()(const ParameterImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const ParameterImpl*>
+{
+    bool operator()(const ParameterImpl* l, const ParameterImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const ParameterImpl& element);
 }
 
diff --git a/include/loki/details/pddl/predicate.hpp b/include/loki/details/pddl/predicate.hpp
index 6bc7546..33a3459 100644
--- a/include/loki/details/pddl/predicate.hpp
+++ b/include/loki/details/pddl/predicate.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_PREDICATE_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 
@@ -51,6 +53,18 @@ class PredicateImpl
     const ParameterList& get_parameters() const;
 };
 
+template<>
+struct UniquePDDLHasher<const PredicateImpl*>
+{
+    size_t operator()(const PredicateImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const PredicateImpl*>
+{
+    bool operator()(const PredicateImpl* l, const PredicateImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const PredicateImpl& element);
 
 }
diff --git a/include/loki/details/pddl/problem.hpp b/include/loki/details/pddl/problem.hpp
index 861ab0c..5b4538d 100644
--- a/include/loki/details/pddl/problem.hpp
+++ b/include/loki/details/pddl/problem.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_PROBLEM_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 #include "loki/details/utils/filesystem.hpp"
 
 #include <optional>
@@ -80,6 +82,18 @@ class ProblemImpl
     const AxiomList& get_axioms() const;
 };
 
+template<>
+struct UniquePDDLHasher<const ProblemImpl*>
+{
+    size_t operator()(const ProblemImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const ProblemImpl*>
+{
+    bool operator()(const ProblemImpl* l, const ProblemImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const ProblemImpl& element);
 
 }
diff --git a/include/loki/details/pddl/requirements.hpp b/include/loki/details/pddl/requirements.hpp
index 6dbd89b..4759271 100644
--- a/include/loki/details/pddl/requirements.hpp
+++ b/include/loki/details/pddl/requirements.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_REQUIREMENTS_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <set>
 #include <string>
@@ -80,6 +82,18 @@ class RequirementsImpl
     const RequirementEnumSet& get_requirements() const;
 };
 
+template<>
+struct UniquePDDLHasher<const RequirementsImpl*>
+{
+    size_t operator()(const RequirementsImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const RequirementsImpl*>
+{
+    bool operator()(const RequirementsImpl* l, const RequirementsImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const RequirementsImpl& element);
 
 }
diff --git a/include/loki/details/pddl/term.hpp b/include/loki/details/pddl/term.hpp
index 3237a1c..2c1827f 100644
--- a/include/loki/details/pddl/term.hpp
+++ b/include/loki/details/pddl/term.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_TERM_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 
@@ -75,6 +77,42 @@ class TermVariableImpl
     const Variable& get_variable() const;
 };
 
+template<>
+struct UniquePDDLHasher<const TermObjectImpl&>
+{
+    size_t operator()(const TermObjectImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const TermVariableImpl&>
+{
+    size_t operator()(const TermVariableImpl& e) const;
+};
+
+template<>
+struct UniquePDDLHasher<const TermImpl*>
+{
+    size_t operator()(const TermImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const TermObjectImpl&>
+{
+    bool operator()(const TermObjectImpl& l, const TermObjectImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const TermVariableImpl&>
+{
+    bool operator()(const TermVariableImpl& l, const TermVariableImpl& r) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const TermImpl*>
+{
+    bool operator()(const TermImpl* l, const TermImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const TermObjectImpl& element);
 extern std::ostream& operator<<(std::ostream& out, const TermVariableImpl& element);
 extern std::ostream& operator<<(std::ostream& out, const TermImpl& element);
diff --git a/include/loki/details/pddl/type.hpp b/include/loki/details/pddl/type.hpp
index a6cf295..275d7fd 100644
--- a/include/loki/details/pddl/type.hpp
+++ b/include/loki/details/pddl/type.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_TYPE_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 
@@ -55,6 +57,18 @@ extern TypeSet collect_types_from_hierarchy(const TypeList& types);
 /// @brief Return true iff type is a subtype of or equal to one of the types in parent_types
 extern bool is_subtype_or_equal(const Type& type, const TypeList& parent_types);
 
+template<>
+struct UniquePDDLHasher<const TypeImpl*>
+{
+    size_t operator()(const TypeImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const TypeImpl*>
+{
+    bool operator()(const TypeImpl* l, const TypeImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const TypeImpl& element);
 
 }
diff --git a/include/loki/details/pddl/variable.hpp b/include/loki/details/pddl/variable.hpp
index 1386490..8788ca8 100644
--- a/include/loki/details/pddl/variable.hpp
+++ b/include/loki/details/pddl/variable.hpp
@@ -19,6 +19,8 @@
 #define LOKI_INCLUDE_LOKI_PDDL_VARIABLE_HPP_
 
 #include "loki/details/pddl/declarations.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <string>
 
@@ -49,6 +51,18 @@ class VariableImpl
 
 extern VariableSet collect_free_variables(const loki::ConditionImpl& condition);
 
+template<>
+struct UniquePDDLHasher<const VariableImpl*>
+{
+    size_t operator()(const VariableImpl* e) const;
+};
+
+template<>
+struct UniquePDDLEqualTo<const VariableImpl*>
+{
+    bool operator()(const VariableImpl* l, const VariableImpl* r) const;
+};
+
 extern std::ostream& operator<<(std::ostream& out, const VariableImpl& element);
 
 }
diff --git a/include/loki/details/utils/equal_to.hpp b/include/loki/details/utils/equal_to.hpp
deleted file mode 100644
index ec07538..0000000
--- a/include/loki/details/utils/equal_to.hpp
+++ /dev/null
@@ -1,300 +0,0 @@
-/*
- * Copyright (C) 2023 Dominik Drexler and Simon Stahlberg
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *<
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */
-
-#ifndef LOKI_INCLUDE_LOKI_UTILS_EQUAL_TO_HPP_
-#define LOKI_INCLUDE_LOKI_UTILS_EQUAL_TO_HPP_
-
-#include "loki/details/pddl/declarations.hpp"
-#include "loki/details/utils/concepts.hpp"
-
-#include <functional>
-
-namespace loki
-{
-
-/// @brief `EqualTo` is a comparator that should be implemented to work in the context where
-/// all objects of a custom type `T` are uniquely created and uncopieable.
-/// This ensures that pointers can simply be compared and do not need to be dereferenced.
-/// @tparam T the type of the object to compare.
-template<typename T>
-struct EqualTo
-{
-    bool operator()(const T& l, const T& r) const { return std::equal_to<T>()(l, r); }
-};
-
-/// Spezialization for std::variant.
-template<typename... Ts>
-struct EqualTo<std::variant<Ts...>>
-{
-    bool operator()(const std::variant<Ts...>& l, const std::variant<Ts...>& r) const
-    {
-        if (l.index() != r.index())
-        {
-            return false;  // Different types held
-        }
-        // Compare the held values, but only if they are of the same type
-        return std::visit(
-            [](const auto& lhs, const auto& rhs) -> bool
-            {
-                if constexpr (std::is_same_v<decltype(lhs), decltype(rhs)>)
-                {
-                    return EqualTo<decltype(lhs)>()(lhs, rhs);
-                }
-                else
-                {
-                    return false;  // Different types can't be equal
-                }
-            },
-            l,
-            r);
-    }
-};
-
-/**
- * Specializations for PDDL
- */
-
-template<>
-struct EqualTo<const ActionImpl*>
-{
-    bool operator()(const ActionImpl* l, const ActionImpl* r) const;
-};
-
-template<>
-struct EqualTo<const AtomImpl*>
-{
-    bool operator()(const AtomImpl* l, const AtomImpl* r) const;
-};
-
-template<>
-struct EqualTo<const AxiomImpl*>
-{
-    bool operator()(const AxiomImpl* l, const AxiomImpl* r) const;
-};
-
-template<>
-struct EqualTo<const ConditionLiteralImpl&>
-{
-    bool operator()(const ConditionLiteralImpl& l, const ConditionLiteralImpl& r) const;
-};
-
-template<>
-struct EqualTo<const ConditionAndImpl&>
-{
-    bool operator()(const ConditionAndImpl& l, const ConditionAndImpl& r) const;
-};
-
-template<>
-struct EqualTo<const ConditionOrImpl&>
-{
-    bool operator()(const ConditionOrImpl& l, const ConditionOrImpl& r) const;
-};
-
-template<>
-struct EqualTo<const ConditionNotImpl&>
-{
-    bool operator()(const ConditionNotImpl& l, const ConditionNotImpl& r) const;
-};
-
-template<>
-struct EqualTo<const ConditionImplyImpl&>
-{
-    bool operator()(const ConditionImplyImpl& l, const ConditionImplyImpl& r) const;
-};
-
-template<>
-struct EqualTo<const ConditionExistsImpl&>
-{
-    bool operator()(const ConditionExistsImpl& l, const ConditionExistsImpl& r) const;
-};
-
-template<>
-struct EqualTo<const ConditionForallImpl&>
-{
-    bool operator()(const ConditionForallImpl& l, const ConditionForallImpl& r) const;
-};
-
-template<>
-struct EqualTo<const ConditionImpl*>
-{
-    bool operator()(const ConditionImpl* l, const ConditionImpl* r) const;
-};
-
-template<>
-struct EqualTo<const DomainImpl*>
-{
-    bool operator()(const DomainImpl* l, const DomainImpl* r) const;
-};
-
-template<>
-struct EqualTo<const EffectLiteralImpl&>
-{
-    bool operator()(const EffectLiteralImpl& l, const EffectLiteralImpl& r) const;
-};
-
-template<>
-struct EqualTo<const EffectAndImpl&>
-{
-    bool operator()(const EffectAndImpl& l, const EffectAndImpl& r) const;
-};
-
-template<>
-struct EqualTo<const EffectNumericImpl&>
-{
-    bool operator()(const EffectNumericImpl& l, const EffectNumericImpl& r) const;
-};
-
-template<>
-struct EqualTo<const EffectConditionalForallImpl&>
-{
-    bool operator()(const EffectConditionalForallImpl& l, const EffectConditionalForallImpl& r) const;
-};
-
-template<>
-struct EqualTo<const EffectConditionalWhenImpl&>
-{
-    bool operator()(const EffectConditionalWhenImpl& l, const EffectConditionalWhenImpl& r) const;
-};
-
-template<>
-struct EqualTo<const EffectImpl*>
-{
-    bool operator()(const EffectImpl* l, const EffectImpl* r) const;
-};
-
-template<>
-struct EqualTo<const FunctionExpressionNumberImpl&>
-{
-    bool operator()(const FunctionExpressionNumberImpl& l, const FunctionExpressionNumberImpl& r) const;
-};
-
-template<>
-struct EqualTo<const FunctionExpressionBinaryOperatorImpl&>
-{
-    bool operator()(const FunctionExpressionBinaryOperatorImpl& l, const FunctionExpressionBinaryOperatorImpl& r) const;
-};
-
-template<>
-struct EqualTo<const FunctionExpressionMultiOperatorImpl&>
-{
-    bool operator()(const FunctionExpressionMultiOperatorImpl& l, const FunctionExpressionMultiOperatorImpl& r) const;
-};
-
-template<>
-struct EqualTo<const FunctionExpressionMinusImpl&>
-{
-    bool operator()(const FunctionExpressionMinusImpl& l, const FunctionExpressionMinusImpl& r) const;
-};
-
-template<>
-struct EqualTo<const FunctionExpressionFunctionImpl&>
-{
-    bool operator()(const FunctionExpressionFunctionImpl& l, const FunctionExpressionFunctionImpl& r) const;
-};
-
-template<>
-struct EqualTo<const FunctionExpressionImpl*>
-{
-    bool operator()(const FunctionExpressionImpl* l, const FunctionExpressionImpl* r) const;
-};
-
-template<>
-struct EqualTo<const FunctionImpl*>
-{
-    bool operator()(const FunctionImpl* l, const FunctionImpl* r) const;
-};
-
-template<>
-struct EqualTo<const LiteralImpl*>
-{
-    bool operator()(const LiteralImpl* l, const LiteralImpl* r) const;
-};
-
-template<>
-struct EqualTo<const OptimizationMetricImpl*>
-{
-    bool operator()(const OptimizationMetricImpl* l, const OptimizationMetricImpl* r) const;
-};
-
-template<>
-struct EqualTo<const NumericFluentImpl*>
-{
-    bool operator()(const NumericFluentImpl* l, const NumericFluentImpl* r) const;
-};
-
-template<>
-struct EqualTo<const ObjectImpl*>
-{
-    bool operator()(const ObjectImpl* l, const ObjectImpl* r) const;
-};
-
-template<>
-struct EqualTo<const ParameterImpl*>
-{
-    bool operator()(const ParameterImpl* l, const ParameterImpl* r) const;
-};
-
-template<>
-struct EqualTo<const PredicateImpl*>
-{
-    bool operator()(const PredicateImpl* l, const PredicateImpl* r) const;
-};
-
-template<>
-struct EqualTo<const ProblemImpl*>
-{
-    bool operator()(const ProblemImpl* l, const ProblemImpl* r) const;
-};
-
-template<>
-struct EqualTo<const RequirementsImpl*>
-{
-    bool operator()(const RequirementsImpl* l, const RequirementsImpl* r) const;
-};
-
-template<>
-struct EqualTo<const TermObjectImpl&>
-{
-    bool operator()(const TermObjectImpl& l, const TermObjectImpl& r) const;
-};
-
-template<>
-struct EqualTo<const TermVariableImpl&>
-{
-    bool operator()(const TermVariableImpl& l, const TermVariableImpl& r) const;
-};
-
-template<>
-struct EqualTo<const TermImpl*>
-{
-    bool operator()(const TermImpl* l, const TermImpl* r) const;
-};
-
-template<>
-struct EqualTo<const TypeImpl*>
-{
-    bool operator()(const TypeImpl* l, const TypeImpl* r) const;
-};
-
-template<>
-struct EqualTo<const VariableImpl*>
-{
-    bool operator()(const VariableImpl* l, const VariableImpl* r) const;
-};
-}
-
-#endif
diff --git a/include/loki/details/utils/hash.hpp b/include/loki/details/utils/hash.hpp
deleted file mode 100644
index d9ec29c..0000000
--- a/include/loki/details/utils/hash.hpp
+++ /dev/null
@@ -1,331 +0,0 @@
-/*
- * Copyright (C) 2023 Dominik Drexler and Simon Stahlberg
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *<
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */
-
-#ifndef LOKI_INCLUDE_LOKI_UTILS_HASH_HPP_
-#define LOKI_INCLUDE_LOKI_UTILS_HASH_HPP_
-
-#include "loki/details/pddl/declarations.hpp"
-#include "loki/details/utils/concepts.hpp"
-
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <ranges>
-#include <utility>
-#include <variant>
-
-namespace loki
-{
-
-/// @brief `Hasher` is a hasher that should be implemented to work in the context where
-/// all objects of a custom type `T` are uniquely created and uncopieable.
-/// This ensures that pointers can simply be hashed and do not need to be dereferenced.
-/// @tparam T the type of the object to hash.
-template<typename T>
-struct Hasher
-{
-    size_t operator()(const T& element) const { return std::hash<T>()(element); }
-};
-
-struct HashCombiner
-{
-public:
-    template<typename T>
-    void operator()(size_t& seed, const T& value) const
-    {
-        seed ^= Hasher<T>()(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
-    }
-
-    void operator()(size_t& seed, const std::size_t& value) const { seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2); }
-
-    template<typename... Types>
-    size_t operator()(const Types&... args) const
-    {
-        size_t seed = 0;
-        ((*this)(seed, args), ...);
-        return seed;
-    }
-};
-
-/// Spezialization for std::ranges::forward_range.
-template<typename ForwardRange>
-requires std::ranges::forward_range<ForwardRange>
-struct Hasher<ForwardRange>
-{
-    size_t operator()(const ForwardRange& range) const
-    {
-        std::size_t aggregated_hash = 0;
-        for (const auto& item : range)
-        {
-            HashCombiner()(aggregated_hash, item);
-        }
-        return aggregated_hash;
-    }
-};
-
-/// Spezialization for std::variant.
-template<typename Variant>
-requires IsVariant<Variant>
-struct Hasher<Variant>
-{
-    size_t operator()(const Variant& variant) const
-    {
-        return std::visit([](const auto& arg) { return Hasher<decltype(arg)>()(arg); }, variant);
-    }
-};
-
-/**
- * Specializations for PDDL
- */
-
-template<>
-struct Hasher<const ActionImpl*>
-{
-    size_t operator()(const ActionImpl* e) const;
-};
-
-template<>
-struct Hasher<const AtomImpl*>
-{
-    size_t operator()(const AtomImpl* e) const;
-};
-
-template<>
-struct Hasher<const AxiomImpl*>
-{
-    size_t operator()(const AxiomImpl* e) const;
-};
-
-template<>
-struct Hasher<const ConditionLiteralImpl&>
-{
-    size_t operator()(const ConditionLiteralImpl& e) const;
-};
-
-template<>
-struct Hasher<const ConditionAndImpl&>
-{
-    size_t operator()(const ConditionAndImpl& e) const;
-};
-
-template<>
-struct Hasher<const ConditionOrImpl&>
-{
-    size_t operator()(const ConditionOrImpl& e) const;
-};
-
-template<>
-struct Hasher<const ConditionNotImpl&>
-{
-    size_t operator()(const ConditionNotImpl& e) const;
-};
-
-template<>
-struct Hasher<const ConditionImplyImpl&>
-{
-    size_t operator()(const ConditionImplyImpl& e) const;
-};
-
-template<>
-struct Hasher<const ConditionExistsImpl&>
-{
-    size_t operator()(const ConditionExistsImpl& e) const;
-};
-
-template<>
-struct Hasher<const ConditionForallImpl&>
-{
-    size_t operator()(const ConditionForallImpl& e) const;
-};
-
-template<>
-struct Hasher<const ConditionImpl*>
-{
-    size_t operator()(const ConditionImpl* e) const;
-};
-
-template<>
-struct Hasher<const DomainImpl*>
-{
-    size_t operator()(const DomainImpl* e) const;
-};
-
-template<>
-struct Hasher<const EffectLiteralImpl&>
-{
-    size_t operator()(const EffectLiteralImpl& e) const;
-};
-
-template<>
-struct Hasher<const EffectAndImpl&>
-{
-    size_t operator()(const EffectAndImpl& e) const;
-};
-
-template<>
-struct Hasher<const EffectNumericImpl&>
-{
-    size_t operator()(const EffectNumericImpl& e) const;
-};
-
-template<>
-struct Hasher<const EffectConditionalForallImpl&>
-{
-    size_t operator()(const EffectConditionalForallImpl& e) const;
-};
-
-template<>
-struct Hasher<const EffectConditionalWhenImpl&>
-{
-    size_t operator()(const EffectConditionalWhenImpl& e) const;
-};
-
-template<>
-struct Hasher<const EffectImpl*>
-{
-    size_t operator()(const EffectImpl* e) const;
-};
-
-template<>
-struct Hasher<const FunctionExpressionNumberImpl&>
-{
-    size_t operator()(const FunctionExpressionNumberImpl& e) const;
-};
-
-template<>
-struct Hasher<const FunctionExpressionBinaryOperatorImpl&>
-{
-    size_t operator()(const FunctionExpressionBinaryOperatorImpl& e) const;
-};
-
-template<>
-struct Hasher<const FunctionExpressionMultiOperatorImpl&>
-{
-    size_t operator()(const FunctionExpressionMultiOperatorImpl& e) const;
-};
-
-template<>
-struct Hasher<const FunctionExpressionMinusImpl&>
-{
-    size_t operator()(const FunctionExpressionMinusImpl& e) const;
-};
-
-template<>
-struct Hasher<const FunctionExpressionFunctionImpl&>
-{
-    size_t operator()(const FunctionExpressionFunctionImpl& e) const;
-};
-
-template<>
-struct Hasher<const FunctionExpressionImpl*>
-{
-    size_t operator()(const FunctionExpressionImpl* e) const;
-};
-
-template<>
-struct Hasher<const FunctionSkeletonImpl*>
-{
-    size_t operator()(const FunctionSkeletonImpl* e) const;
-};
-
-template<>
-struct Hasher<const FunctionImpl*>
-{
-    size_t operator()(const FunctionImpl* e) const;
-};
-
-template<>
-struct Hasher<const LiteralImpl*>
-{
-    size_t operator()(const LiteralImpl* e) const;
-};
-
-template<>
-struct Hasher<const OptimizationMetricImpl*>
-{
-    size_t operator()(const OptimizationMetricImpl* e) const;
-};
-
-template<>
-struct Hasher<const NumericFluentImpl*>
-{
-    size_t operator()(const NumericFluentImpl* e) const;
-};
-
-template<>
-struct Hasher<const ObjectImpl*>
-{
-    size_t operator()(const ObjectImpl* e) const;
-};
-
-template<>
-struct Hasher<const ParameterImpl*>
-{
-    size_t operator()(const ParameterImpl* e) const;
-};
-
-template<>
-struct Hasher<const PredicateImpl*>
-{
-    size_t operator()(const PredicateImpl* e) const;
-};
-
-template<>
-struct Hasher<const ProblemImpl*>
-{
-    size_t operator()(const ProblemImpl* e) const;
-};
-
-template<>
-struct Hasher<const RequirementsImpl*>
-{
-    size_t operator()(const RequirementsImpl* e) const;
-};
-
-template<>
-struct Hasher<const TermObjectImpl&>
-{
-    size_t operator()(const TermObjectImpl& e) const;
-};
-
-template<>
-struct Hasher<const TermVariableImpl&>
-{
-    size_t operator()(const TermVariableImpl& e) const;
-};
-
-template<>
-struct Hasher<const TermImpl*>
-{
-    size_t operator()(const TermImpl* e) const;
-};
-
-template<>
-struct Hasher<const TypeImpl*>
-{
-    size_t operator()(const TypeImpl* e) const;
-};
-
-template<>
-struct Hasher<const VariableImpl*>
-{
-    size_t operator()(const VariableImpl* e) const;
-};
-
-}
-
-#endif
diff --git a/include/loki/details/utils/unique_factory.hpp b/include/loki/details/utils/unique_factory.hpp
index efec3c8..0c1bc57 100644
--- a/include/loki/details/utils/unique_factory.hpp
+++ b/include/loki/details/utils/unique_factory.hpp
@@ -18,8 +18,6 @@
 #ifndef LOKI_INCLUDE_LOKI_UTILS_UNIQUE_VALUE_FACTORY_HPP_
 #define LOKI_INCLUDE_LOKI_UTILS_UNIQUE_VALUE_FACTORY_HPP_
 
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 #include "loki/details/utils/segmented_vector.hpp"
 
 #include <memory>
@@ -36,9 +34,9 @@ namespace loki
 /// uniqueness checks and SegmentedVector for continuous and cache-efficient storage of value types.
 /// @tparam HolderType is the holder value type which can be an std::variant.
 /// Note that using a base class value type will result in object slicing.
-/// @tparam Hash the hash function, default uses `Hasher` hasher.
-/// @tparam KeyEqual the comparison function, default uses `EqualTo` comparator.
-template<typename HolderType, typename Hash = Hasher<const HolderType*>, typename KeyEqual = EqualTo<const HolderType*>>
+/// @tparam Hash the hash function.
+/// @tparam KeyEqual the comparison function.
+template<typename HolderType, typename Hash, typename KeyEqual>
 class UniqueFactory
 {
 private:
@@ -68,12 +66,6 @@ class UniqueFactory
     UniqueFactory& operator=(UniqueFactory&& other) = default;
 
     /// @brief Returns a pointer to an existing object or creates it before if it does not exist.
-    /// The `SubType` is not allowed to be copieable because `Hasher` and `EqualTo`
-    /// is implemented to hash and compare simply the pointers.
-    /// The `HolderType` is allowed to be copieable but `Hasher` and `EqualTo`
-    /// will have to take this into account by hashing and comparing the nested `SubType`.
-    /// For example, if `HolderType` is a std::variant, then `Hasher` and `ShallowEqual`
-    /// will hash or compare the nested `SubType` object.
     template<typename SubType, typename... Args>
     requires(!std::is_copy_constructible_v<SubType>) HolderType const* get_or_create(Args&&... args)
     {
diff --git a/include/loki/loki.hpp b/include/loki/loki.hpp
index 6a68e8d..b52f1c7 100644
--- a/include/loki/loki.hpp
+++ b/include/loki/loki.hpp
@@ -57,9 +57,7 @@
  */
 
 #include "loki/details/utils/collections.hpp"
-#include "loki/details/utils/equal_to.hpp"
 #include "loki/details/utils/filesystem.hpp"
-#include "loki/details/utils/hash.hpp"
 #include "loki/details/utils/memory.hpp"
 #include "loki/details/utils/segmented_vector.hpp"
 #include "loki/details/utils/unique_factory.hpp"
diff --git a/src/pddl/action.cpp b/src/pddl/action.cpp
index a0a0a62..f4ce641 100644
--- a/src/pddl/action.cpp
+++ b/src/pddl/action.cpp
@@ -21,6 +21,7 @@
 #include "loki/details/pddl/conditions.hpp"
 #include "loki/details/pddl/effects.hpp"
 #include "loki/details/pddl/parameter.hpp"
+#include "loki/details/utils/collections.hpp"
 
 namespace loki
 {
@@ -51,6 +52,21 @@ const std::optional<Condition>& ActionImpl::get_condition() const { return m_con
 
 const std::optional<Effect>& ActionImpl::get_effect() const { return m_effect; }
 
+size_t UniquePDDLHasher<const ActionImpl*>::operator()(const ActionImpl* e) const
+{
+    return UniquePDDLHashCombiner()(e->get_name(), get_sorted_vector(e->get_parameters()), e->get_condition(), e->get_effect());
+}
+
+bool UniquePDDLEqualTo<const ActionImpl*>::operator()(const ActionImpl* l, const ActionImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->get_name() == r->get_name()) && (get_sorted_vector(l->get_parameters()) == get_sorted_vector(r->get_parameters()))
+               && (l->get_condition() == r->get_condition()) && (l->get_effect() == r->get_effect());
+    }
+    return true;
+}
+
 std::ostream& operator<<(std::ostream& out, const ActionImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/atom.cpp b/src/pddl/atom.cpp
index 8d0b835..cfca0aa 100644
--- a/src/pddl/atom.cpp
+++ b/src/pddl/atom.cpp
@@ -31,6 +31,17 @@ const Predicate& AtomImpl::get_predicate() const { return m_predicate; }
 
 const TermList& AtomImpl::get_terms() const { return m_terms; }
 
+size_t UniquePDDLHasher<const AtomImpl*>::operator()(const AtomImpl* e) const { return UniquePDDLHashCombiner()(e->get_predicate(), e->get_terms()); }
+
+bool UniquePDDLEqualTo<const AtomImpl*>::operator()(const AtomImpl* l, const AtomImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->get_predicate() == r->get_predicate()) && (l->get_terms() == r->get_terms());
+    }
+    return true;
+}
+
 std::ostream& operator<<(std::ostream& out, const AtomImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/axiom.cpp b/src/pddl/axiom.cpp
index 4a1ce61..178ed34 100644
--- a/src/pddl/axiom.cpp
+++ b/src/pddl/axiom.cpp
@@ -23,6 +23,7 @@
 #include "loki/details/pddl/literal.hpp"
 #include "loki/details/pddl/parameter.hpp"
 #include "loki/details/pddl/predicate.hpp"
+#include "loki/details/utils/collections.hpp"
 
 namespace loki
 {
@@ -45,6 +46,21 @@ const ParameterList& AxiomImpl::get_parameters() const { return m_parameters; }
 
 size_t AxiomImpl::get_num_parameters_to_ground_head() const { return m_num_parameters_to_ground_head; }
 
+size_t UniquePDDLHasher<const AxiomImpl*>::operator()(const AxiomImpl* e) const
+{
+    return UniquePDDLHashCombiner()(e->get_derived_predicate_name(), get_sorted_vector(e->get_parameters()), e->get_condition());
+}
+
+bool UniquePDDLEqualTo<const AxiomImpl*>::operator()(const AxiomImpl* l, const AxiomImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->get_derived_predicate_name() == r->get_derived_predicate_name())
+               && (get_sorted_vector(l->get_parameters()) == get_sorted_vector(r->get_parameters())) && (l->get_condition() == r->get_condition());
+    }
+    return true;
+}
+
 std::ostream& operator<<(std::ostream& out, const AxiomImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/conditions.cpp b/src/pddl/conditions.cpp
index 2489b9b..a269345 100644
--- a/src/pddl/conditions.cpp
+++ b/src/pddl/conditions.cpp
@@ -20,6 +20,7 @@
 #include "formatter.hpp"
 #include "loki/details/pddl/literal.hpp"
 #include "loki/details/pddl/parameter.hpp"
+#include "loki/details/utils/collections.hpp"
 
 namespace loki
 {
@@ -94,6 +95,108 @@ const ParameterList& ConditionForallImpl::get_parameters() const { return m_para
 
 const Condition& ConditionForallImpl::get_condition() const { return m_condition; }
 
+size_t UniquePDDLHasher<const ConditionLiteralImpl&>::operator()(const ConditionLiteralImpl& e) const { return UniquePDDLHashCombiner()(e.get_literal()); }
+
+size_t UniquePDDLHasher<const ConditionAndImpl&>::operator()(const ConditionAndImpl& e) const
+{
+    return UniquePDDLHashCombiner()(get_sorted_vector(e.get_conditions()));
+}
+
+size_t UniquePDDLHasher<const ConditionOrImpl&>::operator()(const ConditionOrImpl& e) const
+{
+    return UniquePDDLHashCombiner()(get_sorted_vector(e.get_conditions()));
+}
+
+size_t UniquePDDLHasher<const ConditionNotImpl&>::operator()(const ConditionNotImpl& e) const { return UniquePDDLHashCombiner()(e.get_condition()); }
+
+size_t UniquePDDLHasher<const ConditionImplyImpl&>::operator()(const ConditionImplyImpl& e) const
+{
+    return UniquePDDLHashCombiner()(e.get_condition_left(), e.get_condition_right());
+}
+
+size_t UniquePDDLHasher<const ConditionExistsImpl&>::operator()(const ConditionExistsImpl& e) const
+{
+    return UniquePDDLHashCombiner()(get_sorted_vector(e.get_parameters()), e.get_condition());
+}
+
+size_t UniquePDDLHasher<const ConditionForallImpl&>::operator()(const ConditionForallImpl& e) const
+{
+    return UniquePDDLHashCombiner()(get_sorted_vector(e.get_parameters()), e.get_condition());
+}
+
+size_t UniquePDDLHasher<const ConditionImpl*>::operator()(const ConditionImpl* e) const
+{
+    return std::visit([](const auto& arg) { return UniquePDDLHasher<decltype(arg)>()(arg); }, *e);
+}
+
+bool UniquePDDLEqualTo<const ConditionLiteralImpl&>::operator()(const ConditionLiteralImpl& l, const ConditionLiteralImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_literal() == r.get_literal());
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const ConditionAndImpl&>::operator()(const ConditionAndImpl& l, const ConditionAndImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (get_sorted_vector(l.get_conditions()) == get_sorted_vector(r.get_conditions()));
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const ConditionOrImpl&>::operator()(const ConditionOrImpl& l, const ConditionOrImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (get_sorted_vector(l.get_conditions()) == get_sorted_vector(r.get_conditions()));
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const ConditionNotImpl&>::operator()(const ConditionNotImpl& l, const ConditionNotImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_condition() == r.get_condition());
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const ConditionImplyImpl&>::operator()(const ConditionImplyImpl& l, const ConditionImplyImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_condition_left() == r.get_condition_left()) && (l.get_condition_left() == r.get_condition_left());
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const ConditionExistsImpl&>::operator()(const ConditionExistsImpl& l, const ConditionExistsImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_condition() == r.get_condition()) && (get_sorted_vector(l.get_parameters()) == get_sorted_vector(r.get_parameters()));
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const ConditionForallImpl&>::operator()(const ConditionForallImpl& l, const ConditionForallImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_condition() == r.get_condition()) && (get_sorted_vector(l.get_parameters()) == get_sorted_vector(r.get_parameters()));
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const ConditionImpl*>::operator()(const ConditionImpl* l, const ConditionImpl* r) const
+{
+    return UniquePDDLEqualTo<ConditionImpl>()(*l, *r);
+}
+
 std::ostream& operator<<(std::ostream& out, const ConditionLiteralImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/domain.cpp b/src/pddl/domain.cpp
index dfb66cf..5467561 100644
--- a/src/pddl/domain.cpp
+++ b/src/pddl/domain.cpp
@@ -20,13 +20,14 @@
 #include "formatter.hpp"
 #include "loki/details/pddl/action.hpp"
 #include "loki/details/pddl/axiom.hpp"
+#include "loki/details/pddl/equal_to.hpp"
 #include "loki/details/pddl/function_skeleton.hpp"
+#include "loki/details/pddl/hash.hpp"
 #include "loki/details/pddl/object.hpp"
 #include "loki/details/pddl/predicate.hpp"
 #include "loki/details/pddl/requirements.hpp"
 #include "loki/details/pddl/type.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
+#include "loki/details/utils/collections.hpp"
 
 #include <iostream>
 
@@ -77,6 +78,33 @@ const ActionList& DomainImpl::get_actions() const { return m_actions; }
 
 const AxiomList& DomainImpl::get_axioms() const { return m_axioms; }
 
+size_t UniquePDDLHasher<const DomainImpl*>::operator()(const DomainImpl* e) const
+{
+    return UniquePDDLHashCombiner()(e->get_name(),
+                                    e->get_requirements(),
+                                    get_sorted_vector(e->get_types()),
+                                    get_sorted_vector(e->get_constants()),
+                                    get_sorted_vector(e->get_predicates()),
+                                    get_sorted_vector(e->get_functions()),
+                                    get_sorted_vector(e->get_actions()),
+                                    get_sorted_vector(e->get_axioms()));
+}
+
+bool UniquePDDLEqualTo<const DomainImpl*>::operator()(const DomainImpl* l, const DomainImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->get_name() == r->get_name()) && (l->get_requirements() == r->get_requirements())
+               && (get_sorted_vector(l->get_types()) == get_sorted_vector(r->get_types()))
+               && (get_sorted_vector(l->get_constants()) == get_sorted_vector(r->get_constants()))
+               && (get_sorted_vector(l->get_predicates()) == get_sorted_vector(r->get_predicates()))
+               && (get_sorted_vector(l->get_functions()) == get_sorted_vector(r->get_functions()))
+               && (get_sorted_vector(l->get_actions()) == get_sorted_vector(r->get_actions()))
+               && (get_sorted_vector(l->get_axioms()) == get_sorted_vector(r->get_axioms()));
+    }
+    return true;
+}
+
 std::ostream& operator<<(std::ostream& out, const DomainImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/effects.cpp b/src/pddl/effects.cpp
index a9d8397..9ad029b 100644
--- a/src/pddl/effects.cpp
+++ b/src/pddl/effects.cpp
@@ -23,6 +23,7 @@
 #include "loki/details/pddl/function_expressions.hpp"
 #include "loki/details/pddl/literal.hpp"
 #include "loki/details/pddl/parameter.hpp"
+#include "loki/details/utils/collections.hpp"
 
 #include <cassert>
 
@@ -99,6 +100,78 @@ const Condition& EffectConditionalWhenImpl::get_condition() const { return m_con
 
 const Effect& EffectConditionalWhenImpl::get_effect() const { return m_effect; }
 
+size_t UniquePDDLHasher<const EffectLiteralImpl&>::operator()(const EffectLiteralImpl& e) const { return UniquePDDLHashCombiner()(e.get_literal()); }
+
+size_t UniquePDDLHasher<const EffectAndImpl&>::operator()(const EffectAndImpl& e) const { return UniquePDDLHashCombiner()(get_sorted_vector(e.get_effects())); }
+
+size_t UniquePDDLHasher<const EffectNumericImpl&>::operator()(const EffectNumericImpl& e) const
+{
+    return UniquePDDLHashCombiner()(e.get_assign_operator(), e.get_function(), e.get_function_expression());
+}
+
+size_t UniquePDDLHasher<const EffectConditionalForallImpl&>::operator()(const EffectConditionalForallImpl& e) const
+{
+    return UniquePDDLHashCombiner()(e.get_effect(), get_sorted_vector(e.get_parameters()));
+}
+
+size_t UniquePDDLHasher<const EffectConditionalWhenImpl&>::operator()(const EffectConditionalWhenImpl& e) const
+{
+    return UniquePDDLHashCombiner()(e.get_condition(), e.get_effect());
+}
+
+size_t UniquePDDLHasher<const EffectImpl*>::operator()(const EffectImpl* e) const
+{
+    return std::visit([](const auto& arg) { return UniquePDDLHasher<decltype(arg)>()(arg); }, *e);
+}
+
+bool UniquePDDLEqualTo<const EffectLiteralImpl&>::operator()(const EffectLiteralImpl& l, const EffectLiteralImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_literal() == r.get_literal());
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const EffectAndImpl&>::operator()(const EffectAndImpl& l, const EffectAndImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (get_sorted_vector(l.get_effects()) == get_sorted_vector(r.get_effects()));
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const EffectNumericImpl&>::operator()(const EffectNumericImpl& l, const EffectNumericImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_assign_operator() == r.get_assign_operator()) && (l.get_function() == r.get_function())
+               && (l.get_function_expression() == r.get_function_expression());
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const EffectConditionalForallImpl&>::operator()(const EffectConditionalForallImpl& l, const EffectConditionalForallImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_effect() == r.get_effect()) && (get_sorted_vector(l.get_parameters()) == get_sorted_vector(r.get_parameters()));
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const EffectConditionalWhenImpl&>::operator()(const EffectConditionalWhenImpl& l, const EffectConditionalWhenImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_condition() == r.get_condition()) && (l.get_effect() == r.get_effect());
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const EffectImpl*>::operator()(const EffectImpl* l, const EffectImpl* r) const { return UniquePDDLEqualTo<EffectImpl>()(*l, *r); }
+
 std::ostream& operator<<(std::ostream& out, const EffectLiteralImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/formatter.cpp b/src/pddl/formatter.cpp
index e3b4e56..e514ead 100644
--- a/src/pddl/formatter.cpp
+++ b/src/pddl/formatter.cpp
@@ -17,8 +17,8 @@
 
 #include "formatter.hpp"
 
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 
 #include <cassert>
 #include <sstream>
@@ -180,7 +180,7 @@ void PDDLFormatter::write(const DomainImpl& element, std::ostream& out)
     if (!element.get_types().empty())
     {
         out << std::string(m_indent, ' ') << "(:types ";
-        std::unordered_map<TypeList, TypeList, Hasher<TypeList>> subtypes_by_parent_types;
+        std::unordered_map<TypeList, TypeList, UniquePDDLHasher<TypeList>> subtypes_by_parent_types;
         for (const auto& type : element.get_types())
         {
             // We do not want to print root type "object"
@@ -223,7 +223,7 @@ void PDDLFormatter::write(const DomainImpl& element, std::ostream& out)
     if (!element.get_constants().empty())
     {
         out << std::string(m_indent, ' ') << "(:constants ";
-        std::unordered_map<TypeList, ObjectList, Hasher<TypeList>> constants_by_types;
+        std::unordered_map<TypeList, ObjectList, UniquePDDLHasher<TypeList>> constants_by_types;
         for (const auto& constant : element.get_constants())
         {
             constants_by_types[constant->get_bases()].push_back(constant);
@@ -514,7 +514,7 @@ void PDDLFormatter::write(const ProblemImpl& element, std::ostream& out)
     if (!element.get_objects().empty())
     {
         out << std::string(m_indent, ' ') << "(:objects ";
-        std::unordered_map<TypeList, ObjectList, Hasher<TypeList>> objects_by_types;
+        std::unordered_map<TypeList, ObjectList, UniquePDDLHasher<TypeList>> objects_by_types;
         for (const auto& object : element.get_objects())
         {
             objects_by_types[object->get_bases()].push_back(object);
diff --git a/src/pddl/formatter.hpp b/src/pddl/formatter.hpp
index 56d1e55..9d65313 100644
--- a/src/pddl/formatter.hpp
+++ b/src/pddl/formatter.hpp
@@ -15,8 +15,8 @@
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  */
 
-#ifndef LOKI_INCLUDE_LOKI_PDDL_FORMATTER_HPP_
-#define LOKI_INCLUDE_LOKI_PDDL_FORMATTER_HPP_
+#ifndef LOKI_SRC_LOKI_PDDL_FORMATTER_HPP_
+#define LOKI_SRC_LOKI_PDDL_FORMATTER_HPP_
 
 #include "loki/details/pddl/action.hpp"
 #include "loki/details/pddl/atom.hpp"
diff --git a/src/pddl/function.cpp b/src/pddl/function.cpp
index 16b4c0e..1152519 100644
--- a/src/pddl/function.cpp
+++ b/src/pddl/function.cpp
@@ -36,6 +36,20 @@ const FunctionSkeleton& FunctionImpl::get_function_skeleton() const { return m_f
 
 const TermList& FunctionImpl::get_terms() const { return m_terms; }
 
+size_t UniquePDDLHasher<const FunctionImpl*>::operator()(const FunctionImpl* e) const
+{
+    return UniquePDDLHashCombiner()(e->get_function_skeleton(), e->get_terms());
+}
+
+bool UniquePDDLEqualTo<const FunctionImpl*>::operator()(const FunctionImpl* l, const FunctionImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->get_function_skeleton() == r->get_function_skeleton()) && (l->get_terms() == r->get_terms());
+    }
+    return true;
+}
+
 std::ostream& operator<<(std::ostream& out, const FunctionImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/function_expressions.cpp b/src/pddl/function_expressions.cpp
index 62eab3e..ce069ad 100644
--- a/src/pddl/function_expressions.cpp
+++ b/src/pddl/function_expressions.cpp
@@ -19,6 +19,7 @@
 
 #include "formatter.hpp"
 #include "loki/details/pddl/function.hpp"
+#include "loki/details/utils/collections.hpp"
 
 #include <cassert>
 
@@ -110,6 +111,91 @@ size_t FunctionExpressionFunctionImpl::get_index() const { return m_index; }
 
 const Function& FunctionExpressionFunctionImpl::get_function() const { return m_function; }
 
+size_t UniquePDDLHasher<const FunctionExpressionNumberImpl&>::operator()(const FunctionExpressionNumberImpl& e) const
+{
+    return UniquePDDLHashCombiner()(e.get_number());
+}
+
+size_t UniquePDDLHasher<const FunctionExpressionBinaryOperatorImpl&>::operator()(const FunctionExpressionBinaryOperatorImpl& e) const
+{
+    return UniquePDDLHashCombiner()(e.get_binary_operator(), e.get_left_function_expression(), e.get_right_function_expression());
+}
+
+size_t UniquePDDLHasher<const FunctionExpressionMultiOperatorImpl&>::operator()(const FunctionExpressionMultiOperatorImpl& e) const
+{
+    return UniquePDDLHashCombiner()(e.get_multi_operator(), get_sorted_vector(e.get_function_expressions()));
+}
+
+size_t UniquePDDLHasher<const FunctionExpressionMinusImpl&>::operator()(const FunctionExpressionMinusImpl& e) const
+{
+    return UniquePDDLHashCombiner()(e.get_function_expression());
+}
+
+size_t UniquePDDLHasher<const FunctionExpressionFunctionImpl&>::operator()(const FunctionExpressionFunctionImpl& e) const
+{
+    return UniquePDDLHashCombiner()(e.get_function());
+}
+
+size_t UniquePDDLHasher<const FunctionExpressionImpl*>::operator()(const FunctionExpressionImpl* e) const
+{
+    return std::visit([](const auto& arg) { return UniquePDDLHasher<decltype(arg)>()(arg); }, *e);
+}
+
+bool UniquePDDLEqualTo<const FunctionExpressionNumberImpl&>::operator()(const FunctionExpressionNumberImpl& l, const FunctionExpressionNumberImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_number() == r.get_number());
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const FunctionExpressionBinaryOperatorImpl&>::operator()(const FunctionExpressionBinaryOperatorImpl& l,
+                                                                                const FunctionExpressionBinaryOperatorImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_binary_operator() == r.get_binary_operator()) && (l.get_left_function_expression() == r.get_left_function_expression())
+               && (l.get_right_function_expression() == r.get_right_function_expression());
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const FunctionExpressionMultiOperatorImpl&>::operator()(const FunctionExpressionMultiOperatorImpl& l,
+                                                                               const FunctionExpressionMultiOperatorImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_multi_operator() == r.get_multi_operator())
+               && (get_sorted_vector(l.get_function_expressions()) == get_sorted_vector(r.get_function_expressions()));
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const FunctionExpressionMinusImpl&>::operator()(const FunctionExpressionMinusImpl& l, const FunctionExpressionMinusImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_function_expression() == r.get_function_expression());
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const FunctionExpressionFunctionImpl&>::operator()(const FunctionExpressionFunctionImpl& l,
+                                                                          const FunctionExpressionFunctionImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_function() == r.get_function());
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const FunctionExpressionImpl*>::operator()(const FunctionExpressionImpl* l, const FunctionExpressionImpl* r) const
+{
+    return UniquePDDLEqualTo<FunctionExpressionImpl>()(*l, *r);
+}
+
 std::ostream& operator<<(std::ostream& out, const FunctionExpressionNumberImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/function_skeleton.cpp b/src/pddl/function_skeleton.cpp
index b662d58..73f4768 100644
--- a/src/pddl/function_skeleton.cpp
+++ b/src/pddl/function_skeleton.cpp
@@ -19,6 +19,7 @@
 
 #include "formatter.hpp"
 #include "loki/details/pddl/parameter.hpp"
+#include "loki/details/utils/collections.hpp"
 
 namespace loki
 {
@@ -38,6 +39,21 @@ const ParameterList& FunctionSkeletonImpl::get_parameters() const { return m_par
 
 const Type& FunctionSkeletonImpl::get_type() const { return m_type; }
 
+size_t UniquePDDLHasher<const FunctionSkeletonImpl*>::operator()(const FunctionSkeletonImpl* e) const
+{
+    return UniquePDDLHashCombiner()(e->get_name(), e->get_type(), get_sorted_vector(e->get_parameters()));
+}
+
+bool UniquePDDLEqualTo<const FunctionSkeletonImpl*>::operator()(const FunctionSkeletonImpl* l, const FunctionSkeletonImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->get_name() == r->get_name()) && (l->get_type() == r->get_type())
+               && (get_sorted_vector(l->get_parameters()) == get_sorted_vector(r->get_parameters()));
+    }
+    return true;
+}
+
 std::ostream& operator<<(std::ostream& out, const FunctionSkeletonImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/literal.cpp b/src/pddl/literal.cpp
index b536e91..46d3968 100644
--- a/src/pddl/literal.cpp
+++ b/src/pddl/literal.cpp
@@ -30,6 +30,17 @@ bool LiteralImpl::is_negated() const { return m_is_negated; }
 
 const Atom& LiteralImpl::get_atom() const { return m_atom; }
 
+size_t UniquePDDLHasher<const LiteralImpl*>::operator()(const LiteralImpl* e) const { return UniquePDDLHashCombiner()(e->is_negated(), e->get_atom()); }
+
+bool UniquePDDLEqualTo<const LiteralImpl*>::operator()(const LiteralImpl* l, const LiteralImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->is_negated() == r->is_negated()) && (l->get_atom() == r->get_atom());
+    }
+    return true;
+}
+
 std::ostream& operator<<(std::ostream& out, const LiteralImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/metric.cpp b/src/pddl/metric.cpp
index e4f0d8b..61944a3 100644
--- a/src/pddl/metric.cpp
+++ b/src/pddl/metric.cpp
@@ -50,6 +50,20 @@ OptimizationMetricEnum OptimizationMetricImpl::get_optimization_metric() const {
 
 const FunctionExpression& OptimizationMetricImpl::get_function_expression() const { return m_function_expression; }
 
+size_t UniquePDDLHasher<const OptimizationMetricImpl*>::operator()(const OptimizationMetricImpl* e) const
+{
+    return UniquePDDLHashCombiner()(e->get_optimization_metric(), e->get_function_expression());
+}
+
+bool UniquePDDLEqualTo<const OptimizationMetricImpl*>::operator()(const OptimizationMetricImpl* l, const OptimizationMetricImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->get_optimization_metric() == r->get_optimization_metric()) && (l->get_function_expression() == r->get_function_expression());
+    }
+    return true;
+}
+
 std::ostream& operator<<(std::ostream& out, const OptimizationMetricImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/numeric_fluent.cpp b/src/pddl/numeric_fluent.cpp
index 89d9e58..e1ea651 100644
--- a/src/pddl/numeric_fluent.cpp
+++ b/src/pddl/numeric_fluent.cpp
@@ -30,6 +30,20 @@ const Function& NumericFluentImpl::get_function() const { return m_function; }
 
 double NumericFluentImpl::get_number() const { return m_number; }
 
+size_t UniquePDDLHasher<const NumericFluentImpl*>::operator()(const NumericFluentImpl* e) const
+{
+    return UniquePDDLHashCombiner()(e->get_number(), e->get_function());
+}
+
+bool UniquePDDLEqualTo<const NumericFluentImpl*>::operator()(const NumericFluentImpl* l, const NumericFluentImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->get_number() == r->get_number()) && (l->get_function() == r->get_function());
+    }
+    return true;
+}
+
 std::ostream& operator<<(std::ostream& out, const NumericFluentImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/object.cpp b/src/pddl/object.cpp
index 8e61fb5..f5eb651 100644
--- a/src/pddl/object.cpp
+++ b/src/pddl/object.cpp
@@ -19,6 +19,7 @@
 
 #include "formatter.hpp"
 #include "loki/details/pddl/type.hpp"
+#include "loki/details/utils/collections.hpp"
 
 namespace loki
 {
@@ -30,4 +31,25 @@ const std::string& ObjectImpl::get_name() const { return m_name; }
 
 const TypeList& ObjectImpl::get_bases() const { return m_types; }
 
+size_t UniquePDDLHasher<const ObjectImpl*>::operator()(const ObjectImpl* e) const
+{
+    return UniquePDDLHashCombiner()(e->get_name(), get_sorted_vector(e->get_bases()));
+}
+
+bool UniquePDDLEqualTo<const ObjectImpl*>::operator()(const ObjectImpl* l, const ObjectImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->get_name() == r->get_name()) && (get_sorted_vector(l->get_bases()) == get_sorted_vector(r->get_bases()));
+    }
+    return true;
+}
+
+std::ostream& operator<<(std::ostream& out, const ObjectImpl& element)
+{
+    auto formatter = PDDLFormatter();
+    formatter.write(element, out);
+    return out;
+}
+
 }
diff --git a/src/pddl/parameter.cpp b/src/pddl/parameter.cpp
index 7ef63de..856b541 100644
--- a/src/pddl/parameter.cpp
+++ b/src/pddl/parameter.cpp
@@ -20,6 +20,7 @@
 #include "formatter.hpp"
 #include "loki/details/pddl/type.hpp"
 #include "loki/details/pddl/variable.hpp"
+#include "loki/details/utils/collections.hpp"
 
 #include <cassert>
 
@@ -45,6 +46,20 @@ bool is_specialized_parameter(const Parameter& specialized_parameter, const Para
     return false;
 }
 
+size_t UniquePDDLHasher<const ParameterImpl*>::operator()(const ParameterImpl* e) const
+{
+    return UniquePDDLHashCombiner()(e->get_variable(), get_sorted_vector(e->get_bases()));
+}
+
+bool UniquePDDLEqualTo<const ParameterImpl*>::operator()(const ParameterImpl* l, const ParameterImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->get_variable() == r->get_variable()) && (get_sorted_vector(l->get_bases()) == get_sorted_vector(r->get_bases()));
+    }
+    return true;
+}
+
 std::ostream& operator<<(std::ostream& out, const ParameterImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/predicate.cpp b/src/pddl/predicate.cpp
index bf02f4d..187da6a 100644
--- a/src/pddl/predicate.cpp
+++ b/src/pddl/predicate.cpp
@@ -21,6 +21,7 @@
 #include "loki/details/pddl/parameter.hpp"
 #include "loki/details/pddl/type.hpp"
 #include "loki/details/pddl/variable.hpp"
+#include "loki/details/utils/collections.hpp"
 
 #include <memory>
 
@@ -39,6 +40,20 @@ const std::string& PredicateImpl::get_name() const { return m_name; }
 
 const ParameterList& PredicateImpl::get_parameters() const { return m_parameters; }
 
+size_t UniquePDDLHasher<const PredicateImpl*>::operator()(const PredicateImpl* e) const
+{
+    return UniquePDDLHashCombiner()(e->get_name(), get_sorted_vector(e->get_parameters()));
+}
+
+bool UniquePDDLEqualTo<const PredicateImpl*>::operator()(const PredicateImpl* l, const PredicateImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->get_name() == r->get_name()) && (get_sorted_vector(l->get_parameters()) == get_sorted_vector(r->get_parameters()));
+    }
+    return true;
+}
+
 std::ostream& operator<<(std::ostream& out, const PredicateImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/problem.cpp b/src/pddl/problem.cpp
index 7b8a459..6f27994 100644
--- a/src/pddl/problem.cpp
+++ b/src/pddl/problem.cpp
@@ -21,6 +21,8 @@
 #include "loki/details/pddl/axiom.hpp"
 #include "loki/details/pddl/conditions.hpp"
 #include "loki/details/pddl/domain.hpp"
+#include "loki/details/pddl/equal_to.hpp"
+#include "loki/details/pddl/hash.hpp"
 #include "loki/details/pddl/literal.hpp"
 #include "loki/details/pddl/metric.hpp"
 #include "loki/details/pddl/numeric_fluent.hpp"
@@ -28,8 +30,7 @@
 #include "loki/details/pddl/predicate.hpp"
 #include "loki/details/pddl/requirements.hpp"
 #include "loki/details/pddl/type.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
+#include "loki/details/utils/collections.hpp"
 
 #include <iostream>
 
@@ -88,6 +89,32 @@ const std::optional<OptimizationMetric>& ProblemImpl::get_optimization_metric()
 
 const AxiomList& ProblemImpl::get_axioms() const { return m_axioms; }
 
+size_t UniquePDDLHasher<const ProblemImpl*>::operator()(const ProblemImpl* e) const
+{
+    return UniquePDDLHashCombiner()(e->get_name(),
+                                    e->get_domain(),
+                                    get_sorted_vector(e->get_objects()),
+                                    get_sorted_vector(e->get_derived_predicates()),
+                                    get_sorted_vector(e->get_initial_literals()),
+                                    get_sorted_vector(e->get_numeric_fluents()),
+                                    e->get_goal_condition(),
+                                    e->get_optimization_metric());
+}
+
+bool UniquePDDLEqualTo<const ProblemImpl*>::operator()(const ProblemImpl* l, const ProblemImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->get_name() == r->get_name()) && (l->get_domain() == r->get_domain())
+               && (get_sorted_vector(l->get_objects()) == get_sorted_vector(r->get_objects()))
+               && (get_sorted_vector(l->get_derived_predicates()) == get_sorted_vector(r->get_derived_predicates()))
+               && (get_sorted_vector(l->get_initial_literals()) == get_sorted_vector(r->get_initial_literals()))
+               && (get_sorted_vector(l->get_numeric_fluents()) == get_sorted_vector(r->get_numeric_fluents()))
+               && (l->get_goal_condition() == r->get_goal_condition()) && (l->get_optimization_metric() == r->get_optimization_metric());
+    }
+    return true;
+}
+
 std::ostream& operator<<(std::ostream& out, const ProblemImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/requirements.cpp b/src/pddl/requirements.cpp
index 9513cb2..c181c0b 100644
--- a/src/pddl/requirements.cpp
+++ b/src/pddl/requirements.cpp
@@ -58,6 +58,17 @@ bool RequirementsImpl::test(RequirementEnum requirement) const { return m_requir
 
 const RequirementEnumSet& RequirementsImpl::get_requirements() const { return m_requirements; }
 
+size_t UniquePDDLHasher<const RequirementsImpl*>::operator()(const RequirementsImpl* e) const { return UniquePDDLHashCombiner()(e->get_requirements()); }
+
+bool UniquePDDLEqualTo<const RequirementsImpl*>::operator()(const RequirementsImpl* l, const RequirementsImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->get_requirements() == r->get_requirements());
+    }
+    return true;
+}
+
 std::ostream& operator<<(std::ostream& out, const RequirementsImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/term.cpp b/src/pddl/term.cpp
index ef35be7..fd89e4d 100644
--- a/src/pddl/term.cpp
+++ b/src/pddl/term.cpp
@@ -38,6 +38,35 @@ size_t TermVariableImpl::get_index() const { return m_index; }
 
 const Variable& TermVariableImpl::get_variable() const { return m_variable; }
 
+size_t UniquePDDLHasher<const TermObjectImpl&>::operator()(const TermObjectImpl& e) const { return UniquePDDLHashCombiner()(e.get_object()); }
+
+size_t UniquePDDLHasher<const TermVariableImpl&>::operator()(const TermVariableImpl& e) const { return UniquePDDLHashCombiner()(e.get_variable()); }
+
+size_t UniquePDDLHasher<const TermImpl*>::operator()(const TermImpl* e) const
+{
+    return std::visit([](const auto& arg) { return UniquePDDLHasher<decltype(arg)>()(arg); }, *e);
+}
+
+bool UniquePDDLEqualTo<const TermObjectImpl&>::operator()(const TermObjectImpl& l, const TermObjectImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_object() == r.get_object());
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const TermVariableImpl&>::operator()(const TermVariableImpl& l, const TermVariableImpl& r) const
+{
+    if (&l != &r)
+    {
+        return (l.get_variable() == r.get_variable());
+    }
+    return true;
+}
+
+bool UniquePDDLEqualTo<const TermImpl*>::operator()(const TermImpl* l, const TermImpl* r) const { return UniquePDDLEqualTo<TermImpl>()(*l, *r); }
+
 std::ostream& operator<<(std::ostream& out, const TermObjectImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/type.cpp b/src/pddl/type.cpp
index cd28b73..fb46158 100644
--- a/src/pddl/type.cpp
+++ b/src/pddl/type.cpp
@@ -17,6 +17,7 @@
 #include "loki/details/pddl/type.hpp"
 
 #include "formatter.hpp"
+#include "loki/details/utils/collections.hpp"
 
 namespace loki
 {
@@ -58,6 +59,20 @@ bool is_subtype_or_equal(const Type& type, const TypeList& parent_types)
     return false;
 }
 
+size_t UniquePDDLHasher<const TypeImpl*>::operator()(const TypeImpl* e) const
+{
+    return UniquePDDLHashCombiner()(e->get_name(), get_sorted_vector(e->get_bases()));
+}
+
+bool UniquePDDLEqualTo<const TypeImpl*>::operator()(const TypeImpl* l, const TypeImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->get_name() == r->get_name()) && (get_sorted_vector(l->get_bases()) == get_sorted_vector(r->get_bases()));
+    }
+    return true;
+}
+
 std::ostream& operator<<(std::ostream& out, const TypeImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/pddl/variable.cpp b/src/pddl/variable.cpp
index 0cc0b03..69a3aff 100644
--- a/src/pddl/variable.cpp
+++ b/src/pddl/variable.cpp
@@ -98,6 +98,17 @@ VariableSet collect_free_variables(const ConditionImpl& condition)
     return free_variables;
 }
 
+size_t UniquePDDLHasher<const VariableImpl*>::operator()(const VariableImpl* e) const { return UniquePDDLHashCombiner()(e->get_name()); }
+
+bool UniquePDDLEqualTo<const VariableImpl*>::operator()(const VariableImpl* l, const VariableImpl* r) const
+{
+    if (&l != &r)
+    {
+        return (l->get_name() == r->get_name());
+    }
+    return true;
+}
+
 std::ostream& operator<<(std::ostream& out, const VariableImpl& element)
 {
     auto formatter = PDDLFormatter();
diff --git a/src/utils/equal_to.cpp b/src/utils/equal_to.cpp
deleted file mode 100644
index cf536ba..0000000
--- a/src/utils/equal_to.cpp
+++ /dev/null
@@ -1,396 +0,0 @@
-/*
- * Copyright (C) 2023 Dominik Drexler and Simon Stahlberg
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */
-
-#include "loki/details/utils/equal_to.hpp"
-
-#include "loki/details/pddl/action.hpp"
-#include "loki/details/pddl/atom.hpp"
-#include "loki/details/pddl/axiom.hpp"
-#include "loki/details/pddl/conditions.hpp"
-#include "loki/details/pddl/declarations.hpp"
-#include "loki/details/pddl/domain.hpp"
-#include "loki/details/pddl/effects.hpp"
-#include "loki/details/pddl/function.hpp"
-#include "loki/details/pddl/function_expressions.hpp"
-#include "loki/details/pddl/function_skeleton.hpp"
-#include "loki/details/pddl/literal.hpp"
-#include "loki/details/pddl/metric.hpp"
-#include "loki/details/pddl/numeric_fluent.hpp"
-#include "loki/details/pddl/object.hpp"
-#include "loki/details/pddl/parameter.hpp"
-#include "loki/details/pddl/position.hpp"
-#include "loki/details/pddl/predicate.hpp"
-#include "loki/details/pddl/problem.hpp"
-#include "loki/details/pddl/requirements.hpp"
-#include "loki/details/pddl/term.hpp"
-#include "loki/details/pddl/type.hpp"
-#include "loki/details/pddl/variable.hpp"
-#include "loki/details/utils/collections.hpp"
-
-namespace loki
-{
-bool EqualTo<const ActionImpl*>::operator()(const ActionImpl* l, const ActionImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_name() == r->get_name()) && (get_sorted_vector(l->get_parameters()) == get_sorted_vector(r->get_parameters()))
-               && (l->get_condition() == r->get_condition()) && (l->get_effect() == r->get_effect());
-    }
-    return true;
-}
-
-bool EqualTo<const AtomImpl*>::operator()(const AtomImpl* l, const AtomImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_predicate() == r->get_predicate()) && (l->get_terms() == r->get_terms());
-    }
-    return true;
-}
-
-bool EqualTo<const AxiomImpl*>::operator()(const AxiomImpl* l, const AxiomImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_derived_predicate_name() == r->get_derived_predicate_name())
-               && (get_sorted_vector(l->get_parameters()) == get_sorted_vector(r->get_parameters())) && (l->get_condition() == r->get_condition());
-    }
-    return true;
-}
-
-bool EqualTo<const ConditionLiteralImpl&>::operator()(const ConditionLiteralImpl& l, const ConditionLiteralImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_literal() == r.get_literal());
-    }
-    return true;
-}
-
-bool EqualTo<const ConditionAndImpl&>::operator()(const ConditionAndImpl& l, const ConditionAndImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (get_sorted_vector(l.get_conditions()) == get_sorted_vector(r.get_conditions()));
-    }
-    return true;
-}
-
-bool EqualTo<const ConditionOrImpl&>::operator()(const ConditionOrImpl& l, const ConditionOrImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (get_sorted_vector(l.get_conditions()) == get_sorted_vector(r.get_conditions()));
-    }
-    return true;
-}
-
-bool EqualTo<const ConditionNotImpl&>::operator()(const ConditionNotImpl& l, const ConditionNotImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_condition() == r.get_condition());
-    }
-    return true;
-}
-
-bool EqualTo<const ConditionImplyImpl&>::operator()(const ConditionImplyImpl& l, const ConditionImplyImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_condition_left() == r.get_condition_left()) && (l.get_condition_left() == r.get_condition_left());
-    }
-    return true;
-}
-
-bool EqualTo<const ConditionExistsImpl&>::operator()(const ConditionExistsImpl& l, const ConditionExistsImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_condition() == r.get_condition()) && (get_sorted_vector(l.get_parameters()) == get_sorted_vector(r.get_parameters()));
-    }
-    return true;
-}
-
-bool EqualTo<const ConditionForallImpl&>::operator()(const ConditionForallImpl& l, const ConditionForallImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_condition() == r.get_condition()) && (get_sorted_vector(l.get_parameters()) == get_sorted_vector(r.get_parameters()));
-    }
-    return true;
-}
-
-bool EqualTo<const ConditionImpl*>::operator()(const ConditionImpl* l, const ConditionImpl* r) const { return EqualTo<ConditionImpl>()(*l, *r); }
-
-bool EqualTo<const DomainImpl*>::operator()(const DomainImpl* l, const DomainImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_name() == r->get_name()) && (l->get_requirements() == r->get_requirements())
-               && (get_sorted_vector(l->get_types()) == get_sorted_vector(r->get_types()))
-               && (get_sorted_vector(l->get_constants()) == get_sorted_vector(r->get_constants()))
-               && (get_sorted_vector(l->get_predicates()) == get_sorted_vector(r->get_predicates()))
-               && (get_sorted_vector(l->get_functions()) == get_sorted_vector(r->get_functions()))
-               && (get_sorted_vector(l->get_actions()) == get_sorted_vector(r->get_actions()))
-               && (get_sorted_vector(l->get_axioms()) == get_sorted_vector(r->get_axioms()));
-    }
-    return true;
-}
-
-bool EqualTo<const EffectLiteralImpl&>::operator()(const EffectLiteralImpl& l, const EffectLiteralImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_literal() == r.get_literal());
-    }
-    return true;
-}
-
-bool EqualTo<const EffectAndImpl&>::operator()(const EffectAndImpl& l, const EffectAndImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (get_sorted_vector(l.get_effects()) == get_sorted_vector(r.get_effects()));
-    }
-    return true;
-}
-
-bool EqualTo<const EffectNumericImpl&>::operator()(const EffectNumericImpl& l, const EffectNumericImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_assign_operator() == r.get_assign_operator()) && (l.get_function() == r.get_function())
-               && (l.get_function_expression() == r.get_function_expression());
-    }
-    return true;
-}
-
-bool EqualTo<const EffectConditionalForallImpl&>::operator()(const EffectConditionalForallImpl& l, const EffectConditionalForallImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_effect() == r.get_effect()) && (get_sorted_vector(l.get_parameters()) == get_sorted_vector(r.get_parameters()));
-    }
-    return true;
-}
-
-bool EqualTo<const EffectConditionalWhenImpl&>::operator()(const EffectConditionalWhenImpl& l, const EffectConditionalWhenImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_condition() == r.get_condition()) && (l.get_effect() == r.get_effect());
-    }
-    return true;
-}
-
-bool EqualTo<const EffectImpl*>::operator()(const EffectImpl* l, const EffectImpl* r) const { return EqualTo<EffectImpl>()(*l, *r); }
-
-bool EqualTo<const FunctionExpressionNumberImpl&>::operator()(const FunctionExpressionNumberImpl& l, const FunctionExpressionNumberImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_number() == r.get_number());
-    }
-    return true;
-}
-
-bool EqualTo<const FunctionExpressionBinaryOperatorImpl&>::operator()(const FunctionExpressionBinaryOperatorImpl& l,
-                                                                      const FunctionExpressionBinaryOperatorImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_binary_operator() == r.get_binary_operator()) && (l.get_left_function_expression() == r.get_left_function_expression())
-               && (l.get_right_function_expression() == r.get_right_function_expression());
-    }
-    return true;
-}
-
-bool EqualTo<const FunctionExpressionMultiOperatorImpl&>::operator()(const FunctionExpressionMultiOperatorImpl& l,
-                                                                     const FunctionExpressionMultiOperatorImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_multi_operator() == r.get_multi_operator())
-               && (get_sorted_vector(l.get_function_expressions()) == get_sorted_vector(r.get_function_expressions()));
-    }
-    return true;
-}
-
-bool EqualTo<const FunctionExpressionMinusImpl&>::operator()(const FunctionExpressionMinusImpl& l, const FunctionExpressionMinusImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_function_expression() == r.get_function_expression());
-    }
-    return true;
-}
-
-bool EqualTo<const FunctionExpressionFunctionImpl&>::operator()(const FunctionExpressionFunctionImpl& l, const FunctionExpressionFunctionImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_function() == r.get_function());
-    }
-    return true;
-}
-
-bool EqualTo<const FunctionExpressionImpl*>::operator()(const FunctionExpressionImpl* l, const FunctionExpressionImpl* r) const
-{
-    return EqualTo<FunctionExpressionImpl>()(*l, *r);
-}
-
-template<>
-struct EqualTo<const FunctionSkeletonImpl*>
-{
-    bool operator()(const FunctionSkeletonImpl* l, const FunctionSkeletonImpl* r) const;
-};
-
-bool EqualTo<const FunctionSkeletonImpl*>::operator()(const FunctionSkeletonImpl* l, const FunctionSkeletonImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_name() == r->get_name()) && (l->get_type() == r->get_type())
-               && (get_sorted_vector(l->get_parameters()) == get_sorted_vector(r->get_parameters()));
-    }
-    return true;
-}
-
-bool EqualTo<const FunctionImpl*>::operator()(const FunctionImpl* l, const FunctionImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_function_skeleton() == r->get_function_skeleton()) && (l->get_terms() == r->get_terms());
-    }
-    return true;
-}
-
-bool EqualTo<const LiteralImpl*>::operator()(const LiteralImpl* l, const LiteralImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->is_negated() == r->is_negated()) && (l->get_atom() == r->get_atom());
-    }
-    return true;
-}
-
-bool EqualTo<const OptimizationMetricImpl*>::operator()(const OptimizationMetricImpl* l, const OptimizationMetricImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_optimization_metric() == r->get_optimization_metric()) && (l->get_function_expression() == r->get_function_expression());
-    }
-    return true;
-}
-
-bool EqualTo<const NumericFluentImpl*>::operator()(const NumericFluentImpl* l, const NumericFluentImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_number() == r->get_number()) && (l->get_function() == r->get_function());
-    }
-    return true;
-}
-
-bool EqualTo<const ObjectImpl*>::operator()(const ObjectImpl* l, const ObjectImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_name() == r->get_name()) && (get_sorted_vector(l->get_bases()) == get_sorted_vector(r->get_bases()));
-    }
-    return true;
-}
-
-bool EqualTo<const ParameterImpl*>::operator()(const ParameterImpl* l, const ParameterImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_variable() == r->get_variable()) && (get_sorted_vector(l->get_bases()) == get_sorted_vector(r->get_bases()));
-    }
-    return true;
-}
-
-bool EqualTo<const PredicateImpl*>::operator()(const PredicateImpl* l, const PredicateImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_name() == r->get_name()) && (get_sorted_vector(l->get_parameters()) == get_sorted_vector(r->get_parameters()));
-    }
-    return true;
-}
-
-bool EqualTo<const ProblemImpl*>::operator()(const ProblemImpl* l, const ProblemImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_name() == r->get_name()) && (l->get_domain() == r->get_domain())
-               && (get_sorted_vector(l->get_objects()) == get_sorted_vector(r->get_objects()))
-               && (get_sorted_vector(l->get_derived_predicates()) == get_sorted_vector(r->get_derived_predicates()))
-               && (get_sorted_vector(l->get_initial_literals()) == get_sorted_vector(r->get_initial_literals()))
-               && (get_sorted_vector(l->get_numeric_fluents()) == get_sorted_vector(r->get_numeric_fluents()))
-               && (l->get_goal_condition() == r->get_goal_condition()) && (l->get_optimization_metric() == r->get_optimization_metric());
-    }
-    return true;
-}
-
-bool EqualTo<const RequirementsImpl*>::operator()(const RequirementsImpl* l, const RequirementsImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_requirements() == r->get_requirements());
-    }
-    return true;
-}
-
-bool EqualTo<const TermObjectImpl&>::operator()(const TermObjectImpl& l, const TermObjectImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_object() == r.get_object());
-    }
-    return true;
-}
-
-bool EqualTo<const TermVariableImpl&>::operator()(const TermVariableImpl& l, const TermVariableImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_variable() == r.get_variable());
-    }
-    return true;
-}
-
-bool EqualTo<const TermImpl*>::operator()(const TermImpl* l, const TermImpl* r) const { return EqualTo<TermImpl>()(*l, *r); }
-
-bool EqualTo<const TypeImpl*>::operator()(const TypeImpl* l, const TypeImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_name() == r->get_name()) && (get_sorted_vector(l->get_bases()) == get_sorted_vector(r->get_bases()));
-    }
-    return true;
-}
-
-bool EqualTo<const VariableImpl*>::operator()(const VariableImpl* l, const VariableImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_name() == r->get_name());
-    }
-    return true;
-}
-}
diff --git a/src/utils/hash.cpp b/src/utils/hash.cpp
deleted file mode 100644
index 638e134..0000000
--- a/src/utils/hash.cpp
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright (C) 2023 Dominik Drexler and Simon Stahlberg
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */
-
-#include "loki/details/utils/hash.hpp"
-
-#include "loki/details/pddl/action.hpp"
-#include "loki/details/pddl/atom.hpp"
-#include "loki/details/pddl/axiom.hpp"
-#include "loki/details/pddl/conditions.hpp"
-#include "loki/details/pddl/declarations.hpp"
-#include "loki/details/pddl/domain.hpp"
-#include "loki/details/pddl/effects.hpp"
-#include "loki/details/pddl/function.hpp"
-#include "loki/details/pddl/function_expressions.hpp"
-#include "loki/details/pddl/function_skeleton.hpp"
-#include "loki/details/pddl/literal.hpp"
-#include "loki/details/pddl/metric.hpp"
-#include "loki/details/pddl/numeric_fluent.hpp"
-#include "loki/details/pddl/object.hpp"
-#include "loki/details/pddl/parameter.hpp"
-#include "loki/details/pddl/position.hpp"
-#include "loki/details/pddl/predicate.hpp"
-#include "loki/details/pddl/problem.hpp"
-#include "loki/details/pddl/requirements.hpp"
-#include "loki/details/pddl/term.hpp"
-#include "loki/details/pddl/type.hpp"
-#include "loki/details/pddl/variable.hpp"
-#include "loki/details/utils/collections.hpp"
-
-namespace loki
-{
-size_t Hasher<const ActionImpl*>::operator()(const ActionImpl* e) const
-{
-    return HashCombiner()(e->get_name(), get_sorted_vector(e->get_parameters()), e->get_condition(), e->get_effect());
-}
-
-size_t Hasher<const AtomImpl*>::operator()(const AtomImpl* e) const { return HashCombiner()(e->get_predicate(), e->get_terms()); }
-
-size_t Hasher<const AxiomImpl*>::operator()(const AxiomImpl* e) const
-{
-    return HashCombiner()(e->get_derived_predicate_name(), get_sorted_vector(e->get_parameters()), e->get_condition());
-}
-
-size_t Hasher<const ConditionLiteralImpl&>::operator()(const ConditionLiteralImpl& e) const { return HashCombiner()(e.get_literal()); }
-
-size_t Hasher<const ConditionAndImpl&>::operator()(const ConditionAndImpl& e) const { return HashCombiner()(get_sorted_vector(e.get_conditions())); }
-
-size_t Hasher<const ConditionOrImpl&>::operator()(const ConditionOrImpl& e) const { return HashCombiner()(get_sorted_vector(e.get_conditions())); }
-
-size_t Hasher<const ConditionNotImpl&>::operator()(const ConditionNotImpl& e) const { return HashCombiner()(e.get_condition()); }
-
-size_t Hasher<const ConditionImplyImpl&>::operator()(const ConditionImplyImpl& e) const
-{
-    return HashCombiner()(e.get_condition_left(), e.get_condition_right());
-}
-
-size_t Hasher<const ConditionExistsImpl&>::operator()(const ConditionExistsImpl& e) const
-{
-    return HashCombiner()(get_sorted_vector(e.get_parameters()), e.get_condition());
-}
-
-size_t Hasher<const ConditionForallImpl&>::operator()(const ConditionForallImpl& e) const
-{
-    return HashCombiner()(get_sorted_vector(e.get_parameters()), e.get_condition());
-}
-
-size_t Hasher<const ConditionImpl*>::operator()(const ConditionImpl* e) const
-{
-    return std::visit([](const auto& arg) { return Hasher<decltype(arg)>()(arg); }, *e);
-}
-
-size_t Hasher<const DomainImpl*>::operator()(const DomainImpl* e) const
-{
-    return HashCombiner()(e->get_name(),
-                          e->get_requirements(),
-                          get_sorted_vector(e->get_types()),
-                          get_sorted_vector(e->get_constants()),
-                          get_sorted_vector(e->get_predicates()),
-                          get_sorted_vector(e->get_functions()),
-                          get_sorted_vector(e->get_actions()),
-                          get_sorted_vector(e->get_axioms()));
-}
-
-size_t Hasher<const EffectLiteralImpl&>::operator()(const EffectLiteralImpl& e) const { return HashCombiner()(e.get_literal()); }
-
-size_t Hasher<const EffectAndImpl&>::operator()(const EffectAndImpl& e) const { return HashCombiner()(get_sorted_vector(e.get_effects())); }
-
-size_t Hasher<const EffectNumericImpl&>::operator()(const EffectNumericImpl& e) const
-{
-    return HashCombiner()(e.get_assign_operator(), e.get_function(), e.get_function_expression());
-}
-
-size_t Hasher<const EffectConditionalForallImpl&>::operator()(const EffectConditionalForallImpl& e) const
-{
-    return HashCombiner()(e.get_effect(), get_sorted_vector(e.get_parameters()));
-}
-
-size_t Hasher<const EffectConditionalWhenImpl&>::operator()(const EffectConditionalWhenImpl& e) const
-{
-    return HashCombiner()(e.get_condition(), e.get_effect());
-}
-
-size_t Hasher<const EffectImpl*>::operator()(const EffectImpl* e) const
-{
-    return std::visit([](const auto& arg) { return Hasher<decltype(arg)>()(arg); }, *e);
-}
-
-size_t Hasher<const FunctionExpressionNumberImpl&>::operator()(const FunctionExpressionNumberImpl& e) const { return HashCombiner()(e.get_number()); }
-
-size_t Hasher<const FunctionExpressionBinaryOperatorImpl&>::operator()(const FunctionExpressionBinaryOperatorImpl& e) const
-{
-    return HashCombiner()(e.get_binary_operator(), e.get_left_function_expression(), e.get_right_function_expression());
-}
-
-size_t Hasher<const FunctionExpressionMultiOperatorImpl&>::operator()(const FunctionExpressionMultiOperatorImpl& e) const
-{
-    return HashCombiner()(e.get_multi_operator(), get_sorted_vector(e.get_function_expressions()));
-}
-
-size_t Hasher<const FunctionExpressionMinusImpl&>::operator()(const FunctionExpressionMinusImpl& e) const
-{
-    return HashCombiner()(e.get_function_expression());
-}
-
-size_t Hasher<const FunctionExpressionFunctionImpl&>::operator()(const FunctionExpressionFunctionImpl& e) const { return HashCombiner()(e.get_function()); }
-
-size_t Hasher<const FunctionExpressionImpl*>::operator()(const FunctionExpressionImpl* e) const
-{
-    return std::visit([](const auto& arg) { return Hasher<decltype(arg)>()(arg); }, *e);
-}
-
-size_t Hasher<const FunctionSkeletonImpl*>::operator()(const FunctionSkeletonImpl* e) const
-{
-    return HashCombiner()(e->get_name(), e->get_type(), get_sorted_vector(e->get_parameters()));
-}
-
-size_t Hasher<const FunctionImpl*>::operator()(const FunctionImpl* e) const { return HashCombiner()(e->get_function_skeleton(), e->get_terms()); }
-
-size_t Hasher<const LiteralImpl*>::operator()(const LiteralImpl* e) const { return HashCombiner()(e->is_negated(), e->get_atom()); }
-
-size_t Hasher<const OptimizationMetricImpl*>::operator()(const OptimizationMetricImpl* e) const
-{
-    return HashCombiner()(e->get_optimization_metric(), e->get_function_expression());
-}
-
-size_t Hasher<const NumericFluentImpl*>::operator()(const NumericFluentImpl* e) const { return HashCombiner()(e->get_number(), e->get_function()); }
-
-size_t Hasher<const ObjectImpl*>::operator()(const ObjectImpl* e) const { return HashCombiner()(e->get_name(), get_sorted_vector(e->get_bases())); }
-
-size_t Hasher<const ParameterImpl*>::operator()(const ParameterImpl* e) const { return HashCombiner()(e->get_variable(), get_sorted_vector(e->get_bases())); }
-
-size_t Hasher<const PredicateImpl*>::operator()(const PredicateImpl* e) const { return HashCombiner()(e->get_name(), get_sorted_vector(e->get_parameters())); }
-
-size_t Hasher<const ProblemImpl*>::operator()(const ProblemImpl* e) const
-{
-    return HashCombiner()(e->get_name(),
-                          e->get_domain(),
-                          get_sorted_vector(e->get_objects()),
-                          get_sorted_vector(e->get_derived_predicates()),
-                          get_sorted_vector(e->get_initial_literals()),
-                          get_sorted_vector(e->get_numeric_fluents()),
-                          e->get_goal_condition(),
-                          e->get_optimization_metric());
-}
-
-size_t Hasher<const RequirementsImpl*>::operator()(const RequirementsImpl* e) const { return HashCombiner()(e->get_requirements()); }
-
-size_t Hasher<const TermObjectImpl&>::operator()(const TermObjectImpl& e) const { return HashCombiner()(e.get_object()); }
-
-size_t Hasher<const TermVariableImpl&>::operator()(const TermVariableImpl& e) const { return HashCombiner()(e.get_variable()); }
-
-size_t Hasher<const TermImpl*>::operator()(const TermImpl* e) const
-{
-    return std::visit([](const auto& arg) { return Hasher<decltype(arg)>()(arg); }, *e);
-}
-
-size_t Hasher<const TypeImpl*>::operator()(const TypeImpl* e) const { return HashCombiner()(e->get_name(), get_sorted_vector(e->get_bases())); }
-
-size_t Hasher<const VariableImpl*>::operator()(const VariableImpl* e) const { return HashCombiner()(e->get_name()); }
-}
diff --git a/tests/unit/pddl/reference.cpp b/tests/unit/pddl/reference.cpp
index 084f2e4..d2a01b6 100644
--- a/tests/unit/pddl/reference.cpp
+++ b/tests/unit/pddl/reference.cpp
@@ -16,6 +16,8 @@
  */
 
 #include <gtest/gtest.h>
+#include <loki/details/pddl/equal_to.hpp>
+#include <loki/details/pddl/hash.hpp>
 #include <loki/details/pddl/object.hpp>
 #include <loki/details/pddl/reference.hpp>
 #include <loki/details/utils/unique_factory.hpp>
@@ -25,7 +27,7 @@ namespace loki::domain::tests
 
 TEST(LokiTests, PddlReferenceTest)
 {
-    UniqueFactory<ObjectImpl> factory(2);
+    UniqueFactory<ObjectImpl, UniquePDDLHasher<const ObjectImpl*>, UniquePDDLEqualTo<const ObjectImpl*>> factory(2);
     const auto object_0 = factory.get_or_create<ObjectImpl>("object_0", TypeList());
     const auto object_1 = factory.get_or_create<ObjectImpl>("object_1", TypeList());
 
diff --git a/tests/unit/utils/value_type_factory.cpp b/tests/unit/utils/value_type_factory.cpp
index 4bab0fb..db655bd 100644
--- a/tests/unit/utils/value_type_factory.cpp
+++ b/tests/unit/utils/value_type_factory.cpp
@@ -16,6 +16,8 @@
  */
 
 #include <gtest/gtest.h>
+#include <loki/details/pddl/equal_to.hpp>
+#include <loki/details/pddl/hash.hpp>
 #include <loki/details/pddl/object.hpp>
 #include <loki/details/pddl/term.hpp>
 #include <loki/details/pddl/type.hpp>
@@ -27,7 +29,7 @@ namespace loki::domain::tests
 
 TEST(LokiTests, UtilsUniqueFactoryIteratorTest)
 {
-    UniqueFactory<ObjectImpl> factory(2);
+    UniqueFactory<ObjectImpl, UniquePDDLHasher<const ObjectImpl*>, UniquePDDLEqualTo<const ObjectImpl*>> factory(2);
     const auto object_0 = factory.get_or_create<ObjectImpl>("object_0", TypeList());
     const auto object_1 = factory.get_or_create<ObjectImpl>("object_1", TypeList());
     const auto object_2 = factory.get_or_create<ObjectImpl>("object_2", TypeList());
@@ -46,7 +48,7 @@ TEST(LokiTests, UtilsUniqueFactoryIteratorTest)
 
 TEST(LokiTests, UtilsUniqueFactoryIteratorEmptyTest)
 {
-    UniqueFactory<ObjectImpl> factory(4);
+    UniqueFactory<ObjectImpl, UniquePDDLHasher<const ObjectImpl*>, UniquePDDLEqualTo<const ObjectImpl*>> factory(4);
 
     auto objects = ObjectList {};
     for (const auto& object : factory)
@@ -59,8 +61,8 @@ TEST(LokiTests, UtilsUniqueFactoryIteratorEmptyTest)
 
 TEST(LokiTests, UtilsUniqueFactoryVariantTest)
 {
-    UniqueFactory<ObjectImpl> objects(2);
-    UniqueFactory<TermImpl> terms(2);
+    UniqueFactory<ObjectImpl, UniquePDDLHasher<const ObjectImpl*>, UniquePDDLEqualTo<const ObjectImpl*>> objects(2);
+    UniqueFactory<TermImpl, UniquePDDLHasher<const TermImpl*>, UniquePDDLEqualTo<const TermImpl*>> terms(2);
     const auto object_0 = objects.get_or_create<ObjectImpl>("object_0", TypeList());
     const auto object_1 = objects.get_or_create<ObjectImpl>("object_1", TypeList());
 
@@ -74,7 +76,7 @@ TEST(LokiTests, UtilsUniqueFactoryVariantTest)
 
 TEST(LokiTests, UtilsUniqueFactoryTest)
 {
-    UniqueFactory<ObjectImpl> factory(2);
+    UniqueFactory<ObjectImpl, UniquePDDLHasher<const ObjectImpl*>, UniquePDDLEqualTo<const ObjectImpl*>> factory(2);
     EXPECT_EQ(factory.size(), 0);
 
     // Test uniqueness: insert the same element twice
@@ -86,16 +88,16 @@ TEST(LokiTests, UtilsUniqueFactoryTest)
     const auto object_0_1 = factory.get_or_create<ObjectImpl>("object_0", TypeList());
     EXPECT_EQ(factory.size(), 1);
     EXPECT_EQ(object_0_0, object_0_1);
-    EXPECT_EQ(Hasher<const ObjectImpl*>()(object_0_0), Hasher<const ObjectImpl*>()(object_0_1));
-    EXPECT_TRUE(EqualTo<const ObjectImpl*>()(object_0_0, object_0_1));
+    EXPECT_EQ(UniquePDDLHasher<const ObjectImpl*>()(object_0_0), UniquePDDLHasher<const ObjectImpl*>()(object_0_1));
+    EXPECT_TRUE(UniquePDDLEqualTo<const ObjectImpl*>()(object_0_0, object_0_1));
 
     const auto object_1 = factory.get_or_create<ObjectImpl>("object_1", TypeList());
     EXPECT_EQ(factory.size(), 2);
     EXPECT_NE(object_0_0, object_1);
     EXPECT_EQ(object_1->get_index(), 1);
     EXPECT_EQ(object_1->get_name(), "object_1");
-    EXPECT_NE(Hasher<const ObjectImpl*>()(object_0_0), Hasher<const ObjectImpl*>()(object_1));
-    EXPECT_FALSE(EqualTo<const ObjectImpl*>()(object_0_0, object_1));
+    EXPECT_NE(UniquePDDLHasher<const ObjectImpl*>()(object_0_0), UniquePDDLHasher<const ObjectImpl*>()(object_1));
+    EXPECT_FALSE(UniquePDDLEqualTo<const ObjectImpl*>()(object_0_0, object_1));
 }
 
 }