diff --git a/include/loki/details/pddl/action.hpp b/include/loki/details/pddl/action.hpp
index ebb205c..4458fe5 100644
--- a/include/loki/details/pddl/action.hpp
+++ b/include/loki/details/pddl/action.hpp
@@ -60,18 +60,6 @@ class ActionImpl : public Base<ActionImpl>
     const std::optional<Effect>& get_effect() const;
 };
 
-template<>
-struct ShallowHash<const ActionImpl*>
-{
-    size_t operator()(const ActionImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const ActionImpl*>
-{
-    bool operator()(const ActionImpl* l, const ActionImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/atom.hpp b/include/loki/details/pddl/atom.hpp
index 816eb8a..8aece8a 100644
--- a/include/loki/details/pddl/atom.hpp
+++ b/include/loki/details/pddl/atom.hpp
@@ -47,18 +47,6 @@ class AtomImpl : public Base<AtomImpl>
     const TermList& get_terms() const;
 };
 
-template<>
-struct ShallowHash<const AtomImpl*>
-{
-    size_t operator()(const AtomImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const AtomImpl*>
-{
-    bool operator()(const AtomImpl* l, const AtomImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/axiom.hpp b/include/loki/details/pddl/axiom.hpp
index a598426..bc6c44b 100644
--- a/include/loki/details/pddl/axiom.hpp
+++ b/include/loki/details/pddl/axiom.hpp
@@ -51,18 +51,6 @@ class AxiomImpl : public Base<AxiomImpl>
     size_t get_num_parameters_to_ground_head() const;
 };
 
-template<>
-struct ShallowHash<const AxiomImpl*>
-{
-    size_t operator()(const AxiomImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const AxiomImpl*>
-{
-    bool operator()(const AxiomImpl* l, const AxiomImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/base.hpp b/include/loki/details/pddl/base.hpp
index 44dd62a..858ff70 100644
--- a/include/loki/details/pddl/base.hpp
+++ b/include/loki/details/pddl/base.hpp
@@ -47,10 +47,6 @@ class Base
     Base(Base&& other) = default;
     Base& operator=(Base&& other) = default;
 
-    bool operator<(const Base& other) const { return m_index < other.m_index; }
-
-    bool operator>(const Base& other) const { return m_index > other.m_index; }
-
     /// @brief Overload of the output stream insertion operator (operator<<).
     friend std::ostream& operator<<(std::ostream& os, const Base& element)
     {
diff --git a/include/loki/details/pddl/conditions.hpp b/include/loki/details/pddl/conditions.hpp
index f89e88b..23eb012 100644
--- a/include/loki/details/pddl/conditions.hpp
+++ b/include/loki/details/pddl/conditions.hpp
@@ -47,18 +47,6 @@ class ConditionLiteralImpl : public Base<ConditionLiteralImpl>
     const Literal& get_literal() const;
 };
 
-template<>
-struct ShallowHash<const ConditionLiteralImpl&>
-{
-    size_t operator()(const ConditionLiteralImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const ConditionLiteralImpl&>
-{
-    bool operator()(const ConditionLiteralImpl& l, const ConditionLiteralImpl& r) const;
-};
-
 /* And */
 class ConditionAndImpl : public Base<ConditionAndImpl>
 {
@@ -80,18 +68,6 @@ class ConditionAndImpl : public Base<ConditionAndImpl>
     const ConditionList& get_conditions() const;
 };
 
-template<>
-struct ShallowHash<const ConditionAndImpl&>
-{
-    size_t operator()(const ConditionAndImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const ConditionAndImpl&>
-{
-    bool operator()(const ConditionAndImpl& l, const ConditionAndImpl& r) const;
-};
-
 /* Or */
 class ConditionOrImpl : public Base<ConditionOrImpl>
 {
@@ -115,18 +91,6 @@ class ConditionOrImpl : public Base<ConditionOrImpl>
     const ConditionList& get_conditions() const;
 };
 
-template<>
-struct ShallowHash<const ConditionOrImpl&>
-{
-    size_t operator()(const ConditionOrImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const ConditionOrImpl&>
-{
-    bool operator()(const ConditionOrImpl& l, const ConditionOrImpl& r) const;
-};
-
 /* Not */
 class ConditionNotImpl : public Base<ConditionNotImpl>
 {
@@ -148,18 +112,6 @@ class ConditionNotImpl : public Base<ConditionNotImpl>
     const Condition& get_condition() const;
 };
 
-template<>
-struct ShallowHash<const ConditionNotImpl&>
-{
-    size_t operator()(const ConditionNotImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const ConditionNotImpl&>
-{
-    bool operator()(const ConditionNotImpl& l, const ConditionNotImpl& r) const;
-};
-
 /* Imply */
 class ConditionImplyImpl : public Base<ConditionImplyImpl>
 {
@@ -183,18 +135,6 @@ class ConditionImplyImpl : public Base<ConditionImplyImpl>
     const Condition& get_condition_right() const;
 };
 
-template<>
-struct ShallowHash<const ConditionImplyImpl&>
-{
-    size_t operator()(const ConditionImplyImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const ConditionImplyImpl&>
-{
-    bool operator()(const ConditionImplyImpl& l, const ConditionImplyImpl& r) const;
-};
-
 /* Exists */
 class ConditionExistsImpl : public Base<ConditionExistsImpl>
 {
@@ -218,18 +158,6 @@ class ConditionExistsImpl : public Base<ConditionExistsImpl>
     const Condition& get_condition() const;
 };
 
-template<>
-struct ShallowHash<const ConditionExistsImpl&>
-{
-    size_t operator()(const ConditionExistsImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const ConditionExistsImpl&>
-{
-    bool operator()(const ConditionExistsImpl& l, const ConditionExistsImpl& r) const;
-};
-
 /* Forall */
 class ConditionForallImpl : public Base<ConditionForallImpl>
 {
@@ -253,32 +181,6 @@ class ConditionForallImpl : public Base<ConditionForallImpl>
     const Condition& get_condition() const;
 };
 
-template<>
-struct ShallowHash<const ConditionForallImpl&>
-{
-    size_t operator()(const ConditionForallImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const ConditionForallImpl&>
-{
-    bool operator()(const ConditionForallImpl& l, const ConditionForallImpl& r) const;
-};
-
-/* ConditionImpl */
-
-template<>
-struct ShallowHash<const ConditionImpl*>
-{
-    size_t operator()(const ConditionImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const ConditionImpl*>
-{
-    bool operator()(const ConditionImpl* l, const ConditionImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/declarations.hpp b/include/loki/details/pddl/declarations.hpp
index 6bb0aff..0ab0a1b 100644
--- a/include/loki/details/pddl/declarations.hpp
+++ b/include/loki/details/pddl/declarations.hpp
@@ -38,9 +38,9 @@ using PDDLElement = const T*;
  */
 
 template<typename T>
-struct ShallowHash;
+struct Hasher;
 template<typename T>
-struct ShallowEqualTo;
+struct EqualTo;
 
 template<typename HolderType, typename Hash, typename EqualTo>
 class UniqueFactory;
diff --git a/include/loki/details/pddl/domain.hpp b/include/loki/details/pddl/domain.hpp
index 471a3ea..b031689 100644
--- a/include/loki/details/pddl/domain.hpp
+++ b/include/loki/details/pddl/domain.hpp
@@ -73,18 +73,6 @@ class DomainImpl : public Base<DomainImpl>
     const AxiomList& get_axioms() const;
 };
 
-template<>
-struct ShallowHash<const DomainImpl*>
-{
-    size_t operator()(const DomainImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const DomainImpl*>
-{
-    bool operator()(const DomainImpl* l, const DomainImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/effects.hpp b/include/loki/details/pddl/effects.hpp
index 13e7d78..6726195 100644
--- a/include/loki/details/pddl/effects.hpp
+++ b/include/loki/details/pddl/effects.hpp
@@ -58,18 +58,6 @@ class EffectLiteralImpl : public Base<EffectLiteralImpl>
     const Literal& get_literal() const;
 };
 
-template<>
-struct ShallowHash<const EffectLiteralImpl&>
-{
-    size_t operator()(const EffectLiteralImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const EffectLiteralImpl&>
-{
-    bool operator()(const EffectLiteralImpl& l, const EffectLiteralImpl& r) const;
-};
-
 /* And */
 class EffectAndImpl : public Base<EffectAndImpl>
 {
@@ -91,18 +79,6 @@ class EffectAndImpl : public Base<EffectAndImpl>
     const EffectList& get_effects() const;
 };
 
-template<>
-struct ShallowHash<const EffectAndImpl&>
-{
-    size_t operator()(const EffectAndImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const EffectAndImpl&>
-{
-    bool operator()(const EffectAndImpl& l, const EffectAndImpl& r) const;
-};
-
 /* EffectNumeric */
 class EffectNumericImpl : public Base<EffectNumericImpl>
 {
@@ -128,18 +104,6 @@ class EffectNumericImpl : public Base<EffectNumericImpl>
     const FunctionExpression& get_function_expression() const;
 };
 
-template<>
-struct ShallowHash<const EffectNumericImpl&>
-{
-    size_t operator()(const EffectNumericImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const EffectNumericImpl&>
-{
-    bool operator()(const EffectNumericImpl& l, const EffectNumericImpl& r) const;
-};
-
 /* ConditionalForall */
 class EffectConditionalForallImpl : public Base<EffectConditionalForallImpl>
 {
@@ -163,18 +127,6 @@ class EffectConditionalForallImpl : public Base<EffectConditionalForallImpl>
     const Effect& get_effect() const;
 };
 
-template<>
-struct ShallowHash<const EffectConditionalForallImpl&>
-{
-    size_t operator()(const EffectConditionalForallImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const EffectConditionalForallImpl&>
-{
-    bool operator()(const EffectConditionalForallImpl& l, const EffectConditionalForallImpl& r) const;
-};
-
 /* ConditionalWhen */
 class EffectConditionalWhenImpl : public Base<EffectConditionalWhenImpl>
 {
@@ -198,32 +150,6 @@ class EffectConditionalWhenImpl : public Base<EffectConditionalWhenImpl>
     const Effect& get_effect() const;
 };
 
-template<>
-struct ShallowHash<const EffectConditionalWhenImpl&>
-{
-    size_t operator()(const EffectConditionalWhenImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const EffectConditionalWhenImpl&>
-{
-    bool operator()(const EffectConditionalWhenImpl& l, const EffectConditionalWhenImpl& r) const;
-};
-
-/* EffectImpl */
-
-template<>
-struct ShallowHash<const EffectImpl*>
-{
-    size_t operator()(const EffectImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const EffectImpl*>
-{
-    bool operator()(const EffectImpl* l, const EffectImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/factories.hpp b/include/loki/details/pddl/factories.hpp
index 1b6e120..1b6c46e 100644
--- a/include/loki/details/pddl/factories.hpp
+++ b/include/loki/details/pddl/factories.hpp
@@ -46,28 +46,26 @@
 namespace loki
 {
 
-using RequirementsFactory = UniqueFactory<RequirementsImpl, ShallowHash<const RequirementsImpl*>, ShallowEqualTo<const RequirementsImpl*>>;
-using TypeFactory = UniqueFactory<TypeImpl, ShallowHash<const TypeImpl*>, ShallowEqualTo<const TypeImpl*>>;
-using VariableFactory = UniqueFactory<VariableImpl, ShallowHash<const VariableImpl*>, ShallowEqualTo<const VariableImpl*>>;
-using TermFactory = UniqueFactory<TermImpl, ShallowHash<const TermImpl*>, ShallowEqualTo<const TermImpl*>>;
-using ObjectFactory = UniqueFactory<ObjectImpl, ShallowHash<const ObjectImpl*>, ShallowEqualTo<const ObjectImpl*>>;
-using AtomFactory = UniqueFactory<AtomImpl, ShallowHash<const AtomImpl*>, ShallowEqualTo<const AtomImpl*>>;
-using LiteralFactory = UniqueFactory<LiteralImpl, ShallowHash<const LiteralImpl*>, ShallowEqualTo<const LiteralImpl*>>;
-using ParameterFactory = UniqueFactory<ParameterImpl, ShallowHash<const ParameterImpl*>, ShallowEqualTo<const ParameterImpl*>>;
-using PredicateFactory = UniqueFactory<PredicateImpl, ShallowHash<const PredicateImpl*>, ShallowEqualTo<const PredicateImpl*>>;
-using FunctionExpressionFactory =
-    UniqueFactory<FunctionExpressionImpl, ShallowHash<const FunctionExpressionImpl*>, ShallowEqualTo<const FunctionExpressionImpl*>>;
-using FunctionFactory = UniqueFactory<FunctionImpl, ShallowHash<const FunctionImpl*>, ShallowEqualTo<const FunctionImpl*>>;
-using FunctionSkeletonFactory = UniqueFactory<FunctionSkeletonImpl, ShallowHash<const FunctionSkeletonImpl*>, ShallowEqualTo<const FunctionSkeletonImpl*>>;
-using ConditionFactory = UniqueFactory<ConditionImpl, ShallowHash<const ConditionImpl*>, ShallowEqualTo<const ConditionImpl*>>;
-using EffectFactory = UniqueFactory<EffectImpl, ShallowHash<const EffectImpl*>, ShallowEqualTo<const EffectImpl*>>;
-using ActionFactory = UniqueFactory<ActionImpl, ShallowHash<const ActionImpl*>, ShallowEqualTo<const ActionImpl*>>;
-using AxiomFactory = UniqueFactory<AxiomImpl, ShallowHash<const AxiomImpl*>, ShallowEqualTo<const AxiomImpl*>>;
-using OptimizationMetricFactory =
-    UniqueFactory<OptimizationMetricImpl, ShallowHash<const OptimizationMetricImpl*>, ShallowEqualTo<const OptimizationMetricImpl*>>;
-using NumericFluentFactory = UniqueFactory<NumericFluentImpl, ShallowHash<const NumericFluentImpl*>, ShallowEqualTo<const NumericFluentImpl*>>;
-using DomainFactory = UniqueFactory<DomainImpl, ShallowHash<const DomainImpl*>, ShallowEqualTo<const DomainImpl*>>;
-using ProblemFactory = UniqueFactory<ProblemImpl, ShallowHash<const ProblemImpl*>, ShallowEqualTo<const ProblemImpl*>>;
+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 VariadicPDDLConstructorFactory = VariadicContainer<RequirementsFactory,
                                                          TypeFactory,
diff --git a/include/loki/details/pddl/function.hpp b/include/loki/details/pddl/function.hpp
index b4aba2b..47588e3 100644
--- a/include/loki/details/pddl/function.hpp
+++ b/include/loki/details/pddl/function.hpp
@@ -47,18 +47,6 @@ class FunctionImpl : public Base<FunctionImpl>
     const TermList& get_terms() const;
 };
 
-template<>
-struct ShallowHash<const FunctionImpl*>
-{
-    size_t operator()(const FunctionImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const FunctionImpl*>
-{
-    bool operator()(const FunctionImpl* l, const FunctionImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/function_expressions.hpp b/include/loki/details/pddl/function_expressions.hpp
index dab869b..c786fbe 100644
--- a/include/loki/details/pddl/function_expressions.hpp
+++ b/include/loki/details/pddl/function_expressions.hpp
@@ -67,18 +67,6 @@ class FunctionExpressionNumberImpl : public Base<FunctionExpressionNumberImpl>
     double get_number() const;
 };
 
-template<>
-struct ShallowHash<const FunctionExpressionNumberImpl&>
-{
-    size_t operator()(const FunctionExpressionNumberImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const FunctionExpressionNumberImpl&>
-{
-    bool operator()(const FunctionExpressionNumberImpl& l, const FunctionExpressionNumberImpl& r) const;
-};
-
 /* FunctionExpressionBinaryOperator */
 class FunctionExpressionBinaryOperatorImpl : public Base<FunctionExpressionBinaryOperatorImpl>
 {
@@ -107,18 +95,6 @@ class FunctionExpressionBinaryOperatorImpl : public Base<FunctionExpressionBinar
     const FunctionExpression& get_right_function_expression() const;
 };
 
-template<>
-struct ShallowHash<const FunctionExpressionBinaryOperatorImpl&>
-{
-    size_t operator()(const FunctionExpressionBinaryOperatorImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const FunctionExpressionBinaryOperatorImpl&>
-{
-    bool operator()(const FunctionExpressionBinaryOperatorImpl& l, const FunctionExpressionBinaryOperatorImpl& r) const;
-};
-
 /* FunctionExpressionMultiOperator */
 class FunctionExpressionMultiOperatorImpl : public Base<FunctionExpressionMultiOperatorImpl>
 {
@@ -142,18 +118,6 @@ class FunctionExpressionMultiOperatorImpl : public Base<FunctionExpressionMultiO
     const FunctionExpressionList& get_function_expressions() const;
 };
 
-template<>
-struct ShallowHash<const FunctionExpressionMultiOperatorImpl&>
-{
-    size_t operator()(const FunctionExpressionMultiOperatorImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const FunctionExpressionMultiOperatorImpl&>
-{
-    bool operator()(const FunctionExpressionMultiOperatorImpl& l, const FunctionExpressionMultiOperatorImpl& r) const;
-};
-
 /* FunctionExpressionMinus */
 class FunctionExpressionMinusImpl : public Base<FunctionExpressionMinusImpl>
 {
@@ -175,18 +139,6 @@ class FunctionExpressionMinusImpl : public Base<FunctionExpressionMinusImpl>
     const FunctionExpression& get_function_expression() const;
 };
 
-template<>
-struct ShallowHash<const FunctionExpressionMinusImpl&>
-{
-    size_t operator()(const FunctionExpressionMinusImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const FunctionExpressionMinusImpl&>
-{
-    bool operator()(const FunctionExpressionMinusImpl& l, const FunctionExpressionMinusImpl& r) const;
-};
-
 /* FunctionExpressionFunction */
 class FunctionExpressionFunctionImpl : public Base<FunctionExpressionFunctionImpl>
 {
@@ -208,32 +160,6 @@ class FunctionExpressionFunctionImpl : public Base<FunctionExpressionFunctionImp
     const Function& get_function() const;
 };
 
-template<>
-struct ShallowHash<const FunctionExpressionFunctionImpl&>
-{
-    size_t operator()(const FunctionExpressionFunctionImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const FunctionExpressionFunctionImpl&>
-{
-    bool operator()(const FunctionExpressionFunctionImpl& l, const FunctionExpressionFunctionImpl& r) const;
-};
-
-/* FunctionExpressionImpl */
-
-template<>
-struct ShallowHash<const FunctionExpressionImpl*>
-{
-    size_t operator()(const FunctionExpressionImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const FunctionExpressionImpl*>
-{
-    bool operator()(const FunctionExpressionImpl* l, const FunctionExpressionImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/function_skeleton.hpp b/include/loki/details/pddl/function_skeleton.hpp
index 4eb4730..1a1488b 100644
--- a/include/loki/details/pddl/function_skeleton.hpp
+++ b/include/loki/details/pddl/function_skeleton.hpp
@@ -49,18 +49,6 @@ class FunctionSkeletonImpl : public Base<FunctionSkeletonImpl>
     const Type& get_type() const;
 };
 
-template<>
-struct ShallowHash<const FunctionSkeletonImpl*>
-{
-    size_t operator()(const FunctionSkeletonImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const FunctionSkeletonImpl*>
-{
-    bool operator()(const FunctionSkeletonImpl* l, const FunctionSkeletonImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/literal.hpp b/include/loki/details/pddl/literal.hpp
index 24aa715..9d3bb17 100644
--- a/include/loki/details/pddl/literal.hpp
+++ b/include/loki/details/pddl/literal.hpp
@@ -46,19 +46,6 @@ class LiteralImpl : public Base<LiteralImpl>
     bool is_negated() const;
     const Atom& get_atom() const;
 };
-
-template<>
-struct ShallowHash<const LiteralImpl*>
-{
-    size_t operator()(const LiteralImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const LiteralImpl*>
-{
-    bool operator()(const LiteralImpl* l, const LiteralImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/metric.hpp b/include/loki/details/pddl/metric.hpp
index 20002b0..dabad58 100644
--- a/include/loki/details/pddl/metric.hpp
+++ b/include/loki/details/pddl/metric.hpp
@@ -55,19 +55,6 @@ class OptimizationMetricImpl : public Base<OptimizationMetricImpl>
     OptimizationMetricEnum get_optimization_metric() const;
     const FunctionExpression& get_function_expression() const;
 };
-
-template<>
-struct ShallowHash<const OptimizationMetricImpl*>
-{
-    size_t operator()(const OptimizationMetricImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const OptimizationMetricImpl*>
-{
-    bool operator()(const OptimizationMetricImpl* l, const OptimizationMetricImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/numeric_fluent.hpp b/include/loki/details/pddl/numeric_fluent.hpp
index 9af54f1..0a70529 100644
--- a/include/loki/details/pddl/numeric_fluent.hpp
+++ b/include/loki/details/pddl/numeric_fluent.hpp
@@ -47,18 +47,6 @@ class NumericFluentImpl : public Base<NumericFluentImpl>
     double get_number() const;
 };
 
-template<>
-struct ShallowHash<const NumericFluentImpl*>
-{
-    size_t operator()(const NumericFluentImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const NumericFluentImpl*>
-{
-    bool operator()(const NumericFluentImpl* l, const NumericFluentImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/object.hpp b/include/loki/details/pddl/object.hpp
index d42a4be..7897b67 100644
--- a/include/loki/details/pddl/object.hpp
+++ b/include/loki/details/pddl/object.hpp
@@ -47,18 +47,6 @@ class ObjectImpl : public Base<ObjectImpl>
     const TypeList& get_bases() const;
 };
 
-template<>
-struct ShallowHash<const ObjectImpl*>
-{
-    size_t operator()(const ObjectImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const ObjectImpl*>
-{
-    bool operator()(const ObjectImpl* l, const ObjectImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/parameter.hpp b/include/loki/details/pddl/parameter.hpp
index e35246a..46ae828 100644
--- a/include/loki/details/pddl/parameter.hpp
+++ b/include/loki/details/pddl/parameter.hpp
@@ -48,18 +48,6 @@ class ParameterImpl : public Base<ParameterImpl>
     const TypeList& get_bases() const;
 };
 
-template<>
-struct ShallowHash<const ParameterImpl*>
-{
-    size_t operator()(const ParameterImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const ParameterImpl*>
-{
-    bool operator()(const ParameterImpl* l, const ParameterImpl* r) const;
-};
-
 /// @brief Return true iff specialized_parameter is a specialized version of generalized_parameter
 /// by checking whether the types are compatible
 extern bool is_specialized_parameter(const Parameter& specialized_parameter, const Parameter& generalized_parameter);
diff --git a/include/loki/details/pddl/predicate.hpp b/include/loki/details/pddl/predicate.hpp
index adf25ba..2d46ecc 100644
--- a/include/loki/details/pddl/predicate.hpp
+++ b/include/loki/details/pddl/predicate.hpp
@@ -49,18 +49,6 @@ class PredicateImpl : public Base<PredicateImpl>
     const ParameterList& get_parameters() const;
 };
 
-template<>
-struct ShallowHash<const PredicateImpl*>
-{
-    size_t operator()(const PredicateImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const PredicateImpl*>
-{
-    bool operator()(const PredicateImpl* l, const PredicateImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/problem.hpp b/include/loki/details/pddl/problem.hpp
index a7953f6..c07e09e 100644
--- a/include/loki/details/pddl/problem.hpp
+++ b/include/loki/details/pddl/problem.hpp
@@ -78,18 +78,6 @@ class ProblemImpl : public Base<ProblemImpl>
     const AxiomList& get_axioms() const;
 };
 
-template<>
-struct ShallowHash<const ProblemImpl*>
-{
-    size_t operator()(const ProblemImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const ProblemImpl*>
-{
-    bool operator()(const ProblemImpl* l, const ProblemImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/requirements.hpp b/include/loki/details/pddl/requirements.hpp
index 1b948c1..011c442 100644
--- a/include/loki/details/pddl/requirements.hpp
+++ b/include/loki/details/pddl/requirements.hpp
@@ -78,18 +78,6 @@ class RequirementsImpl : public Base<RequirementsImpl>
     const RequirementEnumSet& get_requirements() const;
 };
 
-template<>
-struct ShallowHash<const RequirementsImpl*>
-{
-    size_t operator()(const RequirementsImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const RequirementsImpl*>
-{
-    bool operator()(const RequirementsImpl* l, const RequirementsImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/term.hpp b/include/loki/details/pddl/term.hpp
index 3110de8..88d3eb1 100644
--- a/include/loki/details/pddl/term.hpp
+++ b/include/loki/details/pddl/term.hpp
@@ -48,18 +48,6 @@ class TermObjectImpl : public Base<TermObjectImpl>
     const Object& get_object() const;
 };
 
-template<>
-struct ShallowHash<const TermObjectImpl&>
-{
-    size_t operator()(const TermObjectImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const TermObjectImpl&>
-{
-    bool operator()(const TermObjectImpl& l, const TermObjectImpl& r) const;
-};
-
 /* TermVariableImpl */
 
 class TermVariableImpl : public Base<TermVariableImpl>
@@ -82,32 +70,6 @@ class TermVariableImpl : public Base<TermVariableImpl>
     const Variable& get_variable() const;
 };
 
-template<>
-struct ShallowHash<const TermVariableImpl&>
-{
-    size_t operator()(const TermVariableImpl& e) const;
-};
-
-template<>
-struct ShallowEqualTo<const TermVariableImpl&>
-{
-    bool operator()(const TermVariableImpl& l, const TermVariableImpl& r) const;
-};
-
-/* TermImpl */
-
-template<>
-struct ShallowHash<const TermImpl*>
-{
-    size_t operator()(const TermImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const TermImpl*>
-{
-    bool operator()(const TermImpl* l, const TermImpl* r) const;
-};
-
 }
 
 #endif
diff --git a/include/loki/details/pddl/type.hpp b/include/loki/details/pddl/type.hpp
index bee48cc..876d479 100644
--- a/include/loki/details/pddl/type.hpp
+++ b/include/loki/details/pddl/type.hpp
@@ -47,18 +47,6 @@ class TypeImpl : public Base<TypeImpl>
     const TypeList& get_bases() const;
 };
 
-template<>
-struct ShallowHash<const TypeImpl*>
-{
-    size_t operator()(const TypeImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const TypeImpl*>
-{
-    bool operator()(const TypeImpl* l, const TypeImpl* r) const;
-};
-
 /// @brief Collects all types from a hierarchy.
 extern TypeSet collect_types_from_hierarchy(const TypeList& types);
 
diff --git a/include/loki/details/pddl/variable.hpp b/include/loki/details/pddl/variable.hpp
index c1feb34..7ea0567 100644
--- a/include/loki/details/pddl/variable.hpp
+++ b/include/loki/details/pddl/variable.hpp
@@ -45,18 +45,6 @@ class VariableImpl : public Base<VariableImpl>
     const std::string& get_name() const;
 };
 
-template<>
-struct ShallowHash<const VariableImpl*>
-{
-    size_t operator()(const VariableImpl* e) const;
-};
-
-template<>
-struct ShallowEqualTo<const VariableImpl*>
-{
-    bool operator()(const VariableImpl* l, const VariableImpl* r) const;
-};
-
 extern VariableSet collect_free_variables(const loki::ConditionImpl& condition);
 
 }
diff --git a/include/loki/details/utils/equal_to.hpp b/include/loki/details/utils/equal_to.hpp
index e036955..ec07538 100644
--- a/include/loki/details/utils/equal_to.hpp
+++ b/include/loki/details/utils/equal_to.hpp
@@ -18,6 +18,7 @@
 #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>
@@ -25,19 +26,19 @@
 namespace loki
 {
 
-/// @brief `ShallowEqualTo` is a comparator that should be implemented to work in the context where
+/// @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 ShallowEqualTo
+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 ShallowEqualTo<std::variant<Ts...>>
+struct EqualTo<std::variant<Ts...>>
 {
     bool operator()(const std::variant<Ts...>& l, const std::variant<Ts...>& r) const
     {
@@ -51,7 +52,7 @@ struct ShallowEqualTo<std::variant<Ts...>>
             {
                 if constexpr (std::is_same_v<decltype(lhs), decltype(rhs)>)
                 {
-                    return ShallowEqualTo<decltype(lhs)>()(lhs, rhs);
+                    return EqualTo<decltype(lhs)>()(lhs, rhs);
                 }
                 else
                 {
@@ -63,6 +64,237 @@ struct ShallowEqualTo<std::variant<Ts...>>
     }
 };
 
+/**
+ * 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
index 55d41ad..7a49569 100644
--- a/include/loki/details/utils/hash.hpp
+++ b/include/loki/details/utils/hash.hpp
@@ -18,6 +18,7 @@
 #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>
@@ -29,23 +30,23 @@
 namespace loki
 {
 
-/// @brief `ShallowHash` is a hasher that should be implemented to work in the context where
+/// @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 ShallowHash
+struct Hasher
 {
     size_t operator()(const T& element) const { return std::hash<T>()(element); }
 };
 
-struct ShallowHashCombiner
+struct HashCombiner
 {
 public:
     template<typename T>
     void operator()(size_t& seed, const T& value) const
     {
-        seed ^= ShallowHash<T>()(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+        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); }
@@ -62,14 +63,14 @@ struct ShallowHashCombiner
 /// Spezialization for std::ranges::forward_range.
 template<typename ForwardRange>
 requires std::ranges::forward_range<ForwardRange>
-struct ShallowHash<ForwardRange>
+struct Hasher<ForwardRange>
 {
     size_t operator()(const ForwardRange& range) const
     {
         std::size_t aggregated_hash = 0;
         for (const auto& item : range)
         {
-            ShallowHashCombiner()(aggregated_hash, item);
+            HashCombiner()(aggregated_hash, item);
         }
         return aggregated_hash;
     }
@@ -78,14 +79,252 @@ struct ShallowHash<ForwardRange>
 /// Spezialization for std::variant.
 template<typename Variant>
 requires IsVariant<Variant>
-struct ShallowHash<Variant>
+struct Hasher<Variant>
 {
     size_t operator()(const Variant& variant) const
     {
-        return std::visit([](const auto& arg) { return ShallowHash<decltype(arg)>()(arg); }, variant);
+        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 744b181..efec3c8 100644
--- a/include/loki/details/utils/unique_factory.hpp
+++ b/include/loki/details/utils/unique_factory.hpp
@@ -36,14 +36,14 @@ 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 `ShallowHash` hasher.
-/// @tparam EqualTo the comparison function, default uses `ShallowEqualTo` comparator.
-template<typename HolderType, typename Hash = ShallowHash<const HolderType*>, typename EqualTo = ShallowEqualTo<const HolderType*>>
+/// @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*>>
 class UniqueFactory
 {
 private:
     // We use an unordered_set to test for uniqueness.
-    std::unordered_set<const HolderType*, Hash, EqualTo> m_uniqueness_set;
+    std::unordered_set<const HolderType*, Hash, KeyEqual> m_uniqueness_set;
 
     // We use pre-allocated memory to store objects persistent.
     SegmentedVector<HolderType> m_persistent_vector;
@@ -68,11 +68,11 @@ 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 `ShallowHash` and `ShallowEqualTo`
+    /// 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 `ShallowHash` and `ShallowEqualTo`
+    /// 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 `ShallowHash` and `ShallowEqual`
+    /// 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/src/pddl/action.cpp b/src/pddl/action.cpp
index e97df23..135bf61 100644
--- a/src/pddl/action.cpp
+++ b/src/pddl/action.cpp
@@ -21,9 +21,6 @@
 #include "loki/details/pddl/effects.hpp"
 #include "loki/details/pddl/parameter.hpp"
 #include "loki/details/pddl/visitors.hpp"
-#include "loki/details/utils/collections.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 namespace loki
 {
@@ -80,18 +77,4 @@ const std::optional<Condition>& ActionImpl::get_condition() const { return m_con
 
 const std::optional<Effect>& ActionImpl::get_effect() const { return m_effect; }
 
-size_t ShallowHash<const ActionImpl*>::operator()(const ActionImpl* e) const
-{
-    return ShallowHashCombiner()(e->get_name(), get_sorted_vector(e->get_parameters()), e->get_condition(), e->get_effect());
-}
-
-bool ShallowEqualTo<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;
-}
 }
diff --git a/src/pddl/atom.cpp b/src/pddl/atom.cpp
index b732669..a83b50e 100644
--- a/src/pddl/atom.cpp
+++ b/src/pddl/atom.cpp
@@ -20,9 +20,6 @@
 #include "loki/details/pddl/predicate.hpp"
 #include "loki/details/pddl/term.hpp"
 #include "loki/details/pddl/visitors.hpp"
-#include "loki/details/utils/collections.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 namespace loki
 {
@@ -43,15 +40,4 @@ const Predicate& AtomImpl::get_predicate() const { return m_predicate; }
 
 const TermList& AtomImpl::get_terms() const { return m_terms; }
 
-size_t ShallowHash<const AtomImpl*>::operator()(const AtomImpl* e) const { return ShallowHashCombiner()(e->get_predicate(), e->get_terms()); }
-
-bool ShallowEqualTo<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;
-}
-
 }
diff --git a/src/pddl/axiom.cpp b/src/pddl/axiom.cpp
index 31dbdcd..d8ff477 100644
--- a/src/pddl/axiom.cpp
+++ b/src/pddl/axiom.cpp
@@ -23,9 +23,6 @@
 #include "loki/details/pddl/parameter.hpp"
 #include "loki/details/pddl/predicate.hpp"
 #include "loki/details/pddl/visitors.hpp"
-#include "loki/details/utils/collections.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 namespace loki
 {
@@ -61,19 +58,4 @@ 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 ShallowHash<const AxiomImpl*>::operator()(const AxiomImpl* e) const
-{
-    return ShallowHashCombiner()(e->get_derived_predicate_name(), get_sorted_vector(e->get_parameters()), e->get_condition());
-}
-
-bool ShallowEqualTo<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;
-}
-
 }
diff --git a/src/pddl/conditions.cpp b/src/pddl/conditions.cpp
index 95a1882..855279a 100644
--- a/src/pddl/conditions.cpp
+++ b/src/pddl/conditions.cpp
@@ -20,9 +20,6 @@
 #include "loki/details/pddl/literal.hpp"
 #include "loki/details/pddl/parameter.hpp"
 #include "loki/details/pddl/visitors.hpp"
-#include "loki/details/utils/collections.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 namespace loki
 {
@@ -34,17 +31,6 @@ void ConditionLiteralImpl::str_impl(std::ostream& out, const FormattingOptions&
 
 const Literal& ConditionLiteralImpl::get_literal() const { return m_literal; }
 
-size_t ShallowHash<const ConditionLiteralImpl&>::operator()(const ConditionLiteralImpl& e) const { return ShallowHashCombiner()(e.get_literal()); }
-
-bool ShallowEqualTo<const ConditionLiteralImpl&>::operator()(const ConditionLiteralImpl& l, const ConditionLiteralImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_literal() == r.get_literal());
-    }
-    return true;
-}
-
 /* And */
 ConditionAndImpl::ConditionAndImpl(size_t index, ConditionList conditions) : Base(index), m_conditions(std::move(conditions)) {}
 
@@ -62,20 +48,6 @@ void ConditionAndImpl::str_impl(std::ostream& out, const FormattingOptions& opti
 
 const ConditionList& ConditionAndImpl::get_conditions() const { return m_conditions; }
 
-size_t ShallowHash<const ConditionAndImpl&>::operator()(const ConditionAndImpl& e) const
-{
-    return ShallowHashCombiner()(get_sorted_vector(e.get_conditions()));
-}
-
-bool ShallowEqualTo<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;
-}
-
 /* Or */
 ConditionOrImpl::ConditionOrImpl(size_t index, ConditionList conditions) : Base(index), m_conditions(std::move(conditions)) {}
 
@@ -93,17 +65,6 @@ void ConditionOrImpl::str_impl(std::ostream& out, const FormattingOptions& optio
 
 const ConditionList& ConditionOrImpl::get_conditions() const { return m_conditions; }
 
-size_t ShallowHash<const ConditionOrImpl&>::operator()(const ConditionOrImpl& e) const { return ShallowHashCombiner()(get_sorted_vector(e.get_conditions())); }
-
-bool ShallowEqualTo<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;
-}
-
 /* Not */
 ConditionNotImpl::ConditionNotImpl(size_t index, Condition condition) : Base(index), m_condition(std::move(condition)) {}
 
@@ -116,17 +77,6 @@ void ConditionNotImpl::str_impl(std::ostream& out, const FormattingOptions& opti
 
 const Condition& ConditionNotImpl::get_condition() const { return m_condition; }
 
-size_t ShallowHash<const ConditionNotImpl&>::operator()(const ConditionNotImpl& e) const { return ShallowHashCombiner()(e.get_condition()); }
-
-bool ShallowEqualTo<const ConditionNotImpl&>::operator()(const ConditionNotImpl& l, const ConditionNotImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_condition() == r.get_condition());
-    }
-    return true;
-}
-
 /* Imply */
 ConditionImplyImpl::ConditionImplyImpl(size_t index, Condition condition_left, Condition condition_right) :
     Base(index),
@@ -148,20 +98,6 @@ const Condition& ConditionImplyImpl::get_condition_left() const { return m_condi
 
 const Condition& ConditionImplyImpl::get_condition_right() const { return m_condition_right; }
 
-size_t ShallowHash<const ConditionImplyImpl&>::operator()(const ConditionImplyImpl& e) const
-{
-    return ShallowHashCombiner()(e.get_condition_left(), e.get_condition_right());
-}
-
-bool ShallowEqualTo<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;
-}
-
 /* Exists */
 ConditionExistsImpl::ConditionExistsImpl(size_t index, ParameterList parameters, Condition condition) :
     Base(index),
@@ -188,20 +124,6 @@ const ParameterList& ConditionExistsImpl::get_parameters() const { return m_para
 
 const Condition& ConditionExistsImpl::get_condition() const { return m_condition; }
 
-size_t ShallowHash<const ConditionExistsImpl&>::operator()(const ConditionExistsImpl& e) const
-{
-    return ShallowHashCombiner()(get_sorted_vector(e.get_parameters()), e.get_condition());
-}
-
-bool ShallowEqualTo<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;
-}
-
 /* Forall */
 ConditionForallImpl::ConditionForallImpl(size_t index, ParameterList parameters, Condition condition) :
     Base(index),
@@ -228,27 +150,4 @@ const ParameterList& ConditionForallImpl::get_parameters() const { return m_para
 
 const Condition& ConditionForallImpl::get_condition() const { return m_condition; }
 
-size_t ShallowHash<const ConditionForallImpl&>::operator()(const ConditionForallImpl& e) const
-{
-    return ShallowHashCombiner()(get_sorted_vector(e.get_parameters()), e.get_condition());
-}
-
-bool ShallowEqualTo<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;
-}
-
-/* ConditionImpl */
-
-size_t ShallowHash<const ConditionImpl*>::operator()(const ConditionImpl* e) const
-{
-    return std::visit([](const auto& arg) { return ShallowHash<decltype(arg)>()(arg); }, *e);
-}
-
-bool ShallowEqualTo<const ConditionImpl*>::operator()(const ConditionImpl* l, const ConditionImpl* r) const { return ShallowEqualTo<ConditionImpl>()(*l, *r); }
-
 }
diff --git a/src/pddl/domain.cpp b/src/pddl/domain.cpp
index 083dffd..225577a 100644
--- a/src/pddl/domain.cpp
+++ b/src/pddl/domain.cpp
@@ -24,7 +24,6 @@
 #include "loki/details/pddl/predicate.hpp"
 #include "loki/details/pddl/requirements.hpp"
 #include "loki/details/pddl/type.hpp"
-#include "loki/details/utils/collections.hpp"
 #include "loki/details/utils/equal_to.hpp"
 #include "loki/details/utils/hash.hpp"
 
@@ -70,7 +69,7 @@ void DomainImpl::str_impl(std::ostream& out, const FormattingOptions& options) c
     if (!m_types.empty())
     {
         out << string(nested_options.indent, ' ') << "(:types ";
-        std::unordered_map<TypeList, TypeList, ShallowHash<TypeList>> subtypes_by_parent_types;
+        std::unordered_map<TypeList, TypeList, Hasher<TypeList>> subtypes_by_parent_types;
         for (const auto& type : m_types)
         {
             // We do not want to print root type "object"
@@ -113,7 +112,7 @@ void DomainImpl::str_impl(std::ostream& out, const FormattingOptions& options) c
     if (!m_constants.empty())
     {
         out << string(nested_options.indent, ' ') << "(:constants ";
-        std::unordered_map<TypeList, ObjectList, ShallowHash<TypeList>> constants_by_types;
+        std::unordered_map<TypeList, ObjectList, Hasher<TypeList>> constants_by_types;
         for (const auto& constant : m_constants)
         {
             constants_by_types[constant->get_bases()].push_back(constant);
@@ -204,31 +203,4 @@ const ActionList& DomainImpl::get_actions() const { return m_actions; }
 
 const AxiomList& DomainImpl::get_axioms() const { return m_axioms; }
 
-size_t ShallowHash<const DomainImpl*>::operator()(const DomainImpl* e) const
-{
-    return ShallowHashCombiner()(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 ShallowEqualTo<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;
-}
-
 }
diff --git a/src/pddl/effects.cpp b/src/pddl/effects.cpp
index bacc1e2..635f3ea 100644
--- a/src/pddl/effects.cpp
+++ b/src/pddl/effects.cpp
@@ -23,9 +23,6 @@
 #include "loki/details/pddl/literal.hpp"
 #include "loki/details/pddl/parameter.hpp"
 #include "loki/details/pddl/visitors.hpp"
-#include "loki/details/utils/collections.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 #include <cassert>
 
@@ -50,17 +47,6 @@ void EffectLiteralImpl::str_impl(std::ostream& out, const FormattingOptions& opt
 
 const Literal& EffectLiteralImpl::get_literal() const { return m_literal; }
 
-size_t ShallowHash<const EffectLiteralImpl&>::operator()(const EffectLiteralImpl& e) const { return ShallowHashCombiner()(e.get_literal()); }
-
-bool ShallowEqualTo<const EffectLiteralImpl&>::operator()(const EffectLiteralImpl& l, const EffectLiteralImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_literal() == r.get_literal());
-    }
-    return true;
-}
-
 /* EffectAnd */
 EffectAndImpl::EffectAndImpl(size_t index, EffectList effects) : Base(index), m_effects(std::move(effects)) {}
 
@@ -78,17 +64,6 @@ void EffectAndImpl::str_impl(std::ostream& out, const FormattingOptions& options
 
 const EffectList& EffectAndImpl::get_effects() const { return m_effects; }
 
-size_t ShallowHash<const EffectAndImpl&>::operator()(const EffectAndImpl& e) const { return ShallowHashCombiner()(get_sorted_vector(e.get_effects())); }
-
-bool ShallowEqualTo<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;
-}
-
 /* EffectNumeric */
 EffectNumericImpl::EffectNumericImpl(size_t index, AssignOperatorEnum assign_operator, Function function, FunctionExpression function_expression) :
     Base(index),
@@ -113,21 +88,6 @@ const Function& EffectNumericImpl::get_function() const { return m_function; }
 
 const FunctionExpression& EffectNumericImpl::get_function_expression() const { return m_function_expression; }
 
-size_t ShallowHash<const EffectNumericImpl&>::operator()(const EffectNumericImpl& e) const
-{
-    return ShallowHashCombiner()(e.get_assign_operator(), e.get_function(), e.get_function_expression());
-}
-
-bool ShallowEqualTo<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;
-}
-
 /* ConditionalConditionalForall */
 EffectConditionalForallImpl::EffectConditionalForallImpl(size_t index, ParameterList parameters, Effect effect) :
     Base(index),
@@ -154,20 +114,6 @@ const ParameterList& EffectConditionalForallImpl::get_parameters() const { retur
 
 const Effect& EffectConditionalForallImpl::get_effect() const { return m_effect; }
 
-size_t ShallowHash<const EffectConditionalForallImpl&>::operator()(const EffectConditionalForallImpl& e) const
-{
-    return ShallowHashCombiner()(e.get_effect(), get_sorted_vector(e.get_parameters()));
-}
-
-bool ShallowEqualTo<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;
-}
-
 /* EffectConditionalWhen */
 EffectConditionalWhenImpl::EffectConditionalWhenImpl(size_t index, Condition condition, Effect effect) :
     Base(index),
@@ -189,27 +135,4 @@ const Condition& EffectConditionalWhenImpl::get_condition() const { return m_con
 
 const Effect& EffectConditionalWhenImpl::get_effect() const { return m_effect; }
 
-size_t ShallowHash<const EffectConditionalWhenImpl&>::operator()(const EffectConditionalWhenImpl& e) const
-{
-    return ShallowHashCombiner()(e.get_condition(), e.get_effect());
-}
-
-bool ShallowEqualTo<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;
-}
-
-/* EffectImpl */
-
-size_t ShallowHash<const EffectImpl*>::operator()(const EffectImpl* e) const
-{
-    return std::visit([](const auto& arg) { return ShallowHash<decltype(arg)>()(arg); }, *e);
-}
-
-bool ShallowEqualTo<const EffectImpl*>::operator()(const EffectImpl* l, const EffectImpl* r) const { return ShallowEqualTo<EffectImpl>()(*l, *r); }
-
 }
diff --git a/src/pddl/function.cpp b/src/pddl/function.cpp
index 728d345..b4815ef 100644
--- a/src/pddl/function.cpp
+++ b/src/pddl/function.cpp
@@ -20,8 +20,6 @@
 #include "loki/details/pddl/function_skeleton.hpp"
 #include "loki/details/pddl/term.hpp"
 #include "loki/details/pddl/visitors.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 namespace loki
 {
@@ -55,15 +53,4 @@ const FunctionSkeleton& FunctionImpl::get_function_skeleton() const { return m_f
 
 const TermList& FunctionImpl::get_terms() const { return m_terms; }
 
-size_t ShallowHash<const FunctionImpl*>::operator()(const FunctionImpl* e) const { return ShallowHashCombiner()(e->get_function_skeleton(), e->get_terms()); }
-
-bool ShallowEqualTo<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;
-}
-
 }
diff --git a/src/pddl/function_expressions.cpp b/src/pddl/function_expressions.cpp
index 5156d8a..65d148c 100644
--- a/src/pddl/function_expressions.cpp
+++ b/src/pddl/function_expressions.cpp
@@ -19,9 +19,6 @@
 
 #include "loki/details/pddl/function.hpp"
 #include "loki/details/pddl/visitors.hpp"
-#include "loki/details/utils/collections.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 #include <cassert>
 
@@ -59,20 +56,6 @@ void FunctionExpressionNumberImpl::str_impl(std::ostream& out, const FormattingO
 
 double FunctionExpressionNumberImpl::get_number() const { return m_number; }
 
-size_t ShallowHash<const FunctionExpressionNumberImpl&>::operator()(const FunctionExpressionNumberImpl& e) const
-{
-    return ShallowHashCombiner()(e.get_number());
-}
-
-bool ShallowEqualTo<const FunctionExpressionNumberImpl&>::operator()(const FunctionExpressionNumberImpl& l, const FunctionExpressionNumberImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_number() == r.get_number());
-    }
-    return true;
-}
-
 /* FunctionExpressionBinaryOperator */
 FunctionExpressionBinaryOperatorImpl::FunctionExpressionBinaryOperatorImpl(size_t index,
                                                                            BinaryOperatorEnum binary_operator,
@@ -100,22 +83,6 @@ const FunctionExpression& FunctionExpressionBinaryOperatorImpl::get_left_functio
 
 const FunctionExpression& FunctionExpressionBinaryOperatorImpl::get_right_function_expression() const { return m_right_function_expression; }
 
-size_t ShallowHash<const FunctionExpressionBinaryOperatorImpl&>::operator()(const FunctionExpressionBinaryOperatorImpl& e) const
-{
-    return ShallowHashCombiner()(e.get_binary_operator(), e.get_left_function_expression(), e.get_right_function_expression());
-}
-
-bool ShallowEqualTo<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;
-}
-
 /* FunctionExpressionMultiOperator */
 FunctionExpressionMultiOperatorImpl::FunctionExpressionMultiOperatorImpl(size_t index,
                                                                          MultiOperatorEnum multi_operator,
@@ -142,22 +109,6 @@ MultiOperatorEnum FunctionExpressionMultiOperatorImpl::get_multi_operator() cons
 
 const FunctionExpressionList& FunctionExpressionMultiOperatorImpl::get_function_expressions() const { return m_function_expressions; }
 
-size_t ShallowHash<const FunctionExpressionMultiOperatorImpl&>::operator()(const FunctionExpressionMultiOperatorImpl& e) const
-{
-    return ShallowHashCombiner()(e.get_multi_operator(), get_sorted_vector(e.get_function_expressions()));
-}
-
-bool ShallowEqualTo<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;
-}
-
 /* FunctionExpressionMinus */
 FunctionExpressionMinusImpl::FunctionExpressionMinusImpl(size_t index, FunctionExpression function_expression) :
     Base(index),
@@ -174,20 +125,6 @@ void FunctionExpressionMinusImpl::str_impl(std::ostream& out, const FormattingOp
 
 const FunctionExpression& FunctionExpressionMinusImpl::get_function_expression() const { return m_function_expression; }
 
-size_t ShallowHash<const FunctionExpressionMinusImpl&>::operator()(const FunctionExpressionMinusImpl& e) const
-{
-    return ShallowHashCombiner()(e.get_function_expression());
-}
-
-bool ShallowEqualTo<const FunctionExpressionMinusImpl&>::operator()(const FunctionExpressionMinusImpl& l, const FunctionExpressionMinusImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_function_expression() == r.get_function_expression());
-    }
-    return true;
-}
-
 /* FunctionExpressionFunction */
 FunctionExpressionFunctionImpl::FunctionExpressionFunctionImpl(size_t index, Function function) : Base(index), m_function(std::move(function)) {}
 
@@ -195,30 +132,4 @@ void FunctionExpressionFunctionImpl::str_impl(std::ostream& out, const Formattin
 
 const Function& FunctionExpressionFunctionImpl::get_function() const { return m_function; }
 
-size_t ShallowHash<const FunctionExpressionFunctionImpl&>::operator()(const FunctionExpressionFunctionImpl& e) const
-{
-    return ShallowHashCombiner()(e.get_function());
-}
-
-bool ShallowEqualTo<const FunctionExpressionFunctionImpl&>::operator()(const FunctionExpressionFunctionImpl& l, const FunctionExpressionFunctionImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_function() == r.get_function());
-    }
-    return true;
-}
-
-/* FunctionExpressionImpl */
-
-size_t ShallowHash<const FunctionExpressionImpl*>::operator()(const FunctionExpressionImpl* e) const
-{
-    return std::visit([](const auto& arg) { return ShallowHash<decltype(arg)>()(arg); }, *e);
-}
-
-bool ShallowEqualTo<const FunctionExpressionImpl*>::operator()(const FunctionExpressionImpl* l, const FunctionExpressionImpl* r) const
-{
-    return ShallowEqualTo<FunctionExpressionImpl>()(*l, *r);
-}
-
 }
diff --git a/src/pddl/function_skeleton.cpp b/src/pddl/function_skeleton.cpp
index 76ddbd9..bd72343 100644
--- a/src/pddl/function_skeleton.cpp
+++ b/src/pddl/function_skeleton.cpp
@@ -18,9 +18,6 @@
 #include "loki/details/pddl/function_skeleton.hpp"
 
 #include "loki/details/pddl/parameter.hpp"
-#include "loki/details/utils/collections.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 namespace loki
 {
@@ -49,19 +46,4 @@ const ParameterList& FunctionSkeletonImpl::get_parameters() const { return m_par
 
 const Type& FunctionSkeletonImpl::get_type() const { return m_type; }
 
-size_t ShallowHash<const FunctionSkeletonImpl*>::operator()(const FunctionSkeletonImpl* e) const
-{
-    return ShallowHashCombiner()(e->get_name(), e->get_type(), get_sorted_vector(e->get_parameters()));
-}
-
-bool ShallowEqualTo<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;
-}
-
 }
diff --git a/src/pddl/literal.cpp b/src/pddl/literal.cpp
index ab4ef08..72c5d75 100644
--- a/src/pddl/literal.cpp
+++ b/src/pddl/literal.cpp
@@ -18,9 +18,6 @@
 #include "loki/details/pddl/literal.hpp"
 
 #include "loki/details/pddl/atom.hpp"
-#include "loki/details/utils/collections.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 namespace loki
 {
@@ -44,15 +41,4 @@ bool LiteralImpl::is_negated() const { return m_is_negated; }
 
 const Atom& LiteralImpl::get_atom() const { return m_atom; }
 
-size_t ShallowHash<const LiteralImpl*>::operator()(const LiteralImpl* e) const { return ShallowHashCombiner()(e->is_negated(), e->get_atom()); }
-
-bool ShallowEqualTo<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;
-}
-
 }
diff --git a/src/pddl/metric.cpp b/src/pddl/metric.cpp
index 7e89ea3..ba6f1cc 100644
--- a/src/pddl/metric.cpp
+++ b/src/pddl/metric.cpp
@@ -19,9 +19,6 @@
 
 #include "loki/details/pddl/function_expressions.hpp"
 #include "loki/details/pddl/visitors.hpp"
-#include "loki/details/utils/collections.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 #include <cassert>
 
@@ -58,18 +55,4 @@ OptimizationMetricEnum OptimizationMetricImpl::get_optimization_metric() const {
 
 const FunctionExpression& OptimizationMetricImpl::get_function_expression() const { return m_function_expression; }
 
-size_t ShallowHash<const OptimizationMetricImpl*>::operator()(const OptimizationMetricImpl* e) const
-{
-    return ShallowHashCombiner()(e->get_optimization_metric(), e->get_function_expression());
-}
-
-bool ShallowEqualTo<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;
-}
-
 }
diff --git a/src/pddl/numeric_fluent.cpp b/src/pddl/numeric_fluent.cpp
index 058f986..3f2756c 100644
--- a/src/pddl/numeric_fluent.cpp
+++ b/src/pddl/numeric_fluent.cpp
@@ -18,8 +18,6 @@
 #include "loki/details/pddl/numeric_fluent.hpp"
 
 #include "loki/details/pddl/function.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 namespace loki
 {
@@ -36,15 +34,4 @@ const Function& NumericFluentImpl::get_function() const { return m_function; }
 
 double NumericFluentImpl::get_number() const { return m_number; }
 
-size_t ShallowHash<const NumericFluentImpl*>::operator()(const NumericFluentImpl* e) const { return ShallowHashCombiner()(e->get_number(), e->get_function()); }
-
-bool ShallowEqualTo<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;
-}
-
 }
diff --git a/src/pddl/object.cpp b/src/pddl/object.cpp
index 2997c7a..5d9f0dd 100644
--- a/src/pddl/object.cpp
+++ b/src/pddl/object.cpp
@@ -18,9 +18,6 @@
 #include "loki/details/pddl/object.hpp"
 
 #include "loki/details/pddl/type.hpp"
-#include "loki/details/utils/collections.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 namespace loki
 {
@@ -54,15 +51,4 @@ const std::string& ObjectImpl::get_name() const { return m_name; }
 
 const TypeList& ObjectImpl::get_bases() const { return m_types; }
 
-size_t ShallowHash<const ObjectImpl*>::operator()(const ObjectImpl* e) const { return ShallowHashCombiner()(e->get_name(), get_sorted_vector(e->get_bases())); }
-
-bool ShallowEqualTo<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;
-}
-
 }
diff --git a/src/pddl/parameter.cpp b/src/pddl/parameter.cpp
index d06c68c..f79e176 100644
--- a/src/pddl/parameter.cpp
+++ b/src/pddl/parameter.cpp
@@ -19,9 +19,6 @@
 
 #include "loki/details/pddl/type.hpp"
 #include "loki/details/pddl/variable.hpp"
-#include "loki/details/utils/collections.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 #include <cassert>
 
@@ -57,20 +54,6 @@ const Variable& ParameterImpl::get_variable() const { return m_variable; }
 
 const TypeList& ParameterImpl::get_bases() const { return m_types; }
 
-size_t ShallowHash<const ParameterImpl*>::operator()(const ParameterImpl* e) const
-{
-    return ShallowHashCombiner()(e->get_variable(), get_sorted_vector(e->get_bases()));
-}
-
-bool ShallowEqualTo<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 is_specialized_parameter(const Parameter& specialized_parameter, const Parameter& generalized_parameter)
 {
     for (const auto& type : specialized_parameter->get_bases())
diff --git a/src/pddl/predicate.cpp b/src/pddl/predicate.cpp
index 22c664c..2f77c45 100644
--- a/src/pddl/predicate.cpp
+++ b/src/pddl/predicate.cpp
@@ -20,9 +20,6 @@
 #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 "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 #include <memory>
 
@@ -50,18 +47,4 @@ const std::string& PredicateImpl::get_name() const { return m_name; }
 
 const ParameterList& PredicateImpl::get_parameters() const { return m_parameters; }
 
-size_t ShallowHash<const PredicateImpl*>::operator()(const PredicateImpl* e) const
-{
-    return ShallowHashCombiner()(e->get_name(), get_sorted_vector(e->get_parameters()));
-}
-
-bool ShallowEqualTo<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;
-}
-
 }
diff --git a/src/pddl/problem.cpp b/src/pddl/problem.cpp
index 72de3e5..d971b1f 100644
--- a/src/pddl/problem.cpp
+++ b/src/pddl/problem.cpp
@@ -28,7 +28,6 @@
 #include "loki/details/pddl/requirements.hpp"
 #include "loki/details/pddl/type.hpp"
 #include "loki/details/pddl/visitors.hpp"
-#include "loki/details/utils/collections.hpp"
 #include "loki/details/utils/equal_to.hpp"
 #include "loki/details/utils/hash.hpp"
 
@@ -80,7 +79,7 @@ void ProblemImpl::str_impl(std::ostream& out, const FormattingOptions& options)
     if (!m_objects.empty())
     {
         out << string(nested_options.indent, ' ') << "(:objects ";
-        std::unordered_map<TypeList, ObjectList, ShallowHash<TypeList>> objects_by_types;
+        std::unordered_map<TypeList, ObjectList, Hasher<TypeList>> objects_by_types;
         for (const auto& object : m_objects)
         {
             objects_by_types[object->get_bases()].push_back(object);
@@ -201,30 +200,4 @@ const std::optional<OptimizationMetric>& ProblemImpl::get_optimization_metric()
 
 const AxiomList& ProblemImpl::get_axioms() const { return m_axioms; }
 
-size_t ShallowHash<const ProblemImpl*>::operator()(const ProblemImpl* e) const
-{
-    return ShallowHashCombiner()(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 ShallowEqualTo<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;
-}
-
 }
diff --git a/src/pddl/requirements.cpp b/src/pddl/requirements.cpp
index 9f94b26..1c3c82f 100644
--- a/src/pddl/requirements.cpp
+++ b/src/pddl/requirements.cpp
@@ -17,9 +17,6 @@
 
 #include "loki/details/pddl/requirements.hpp"
 
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
-
 #include <cassert>
 
 namespace loki
@@ -71,15 +68,4 @@ bool RequirementsImpl::test(RequirementEnum requirement) const { return m_requir
 
 const RequirementEnumSet& RequirementsImpl::get_requirements() const { return m_requirements; }
 
-size_t ShallowHash<const RequirementsImpl*>::operator()(const RequirementsImpl* e) const { return ShallowHashCombiner()(e->get_requirements()); }
-
-bool ShallowEqualTo<const RequirementsImpl*>::operator()(const RequirementsImpl* l, const RequirementsImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_requirements() == r->get_requirements());
-    }
-    return true;
-}
-
 }
diff --git a/src/pddl/term.cpp b/src/pddl/term.cpp
index 577a396..9275f7c 100644
--- a/src/pddl/term.cpp
+++ b/src/pddl/term.cpp
@@ -19,9 +19,6 @@
 
 #include "loki/details/pddl/object.hpp"
 #include "loki/details/pddl/variable.hpp"
-#include "loki/details/utils/collections.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 namespace loki
 {
@@ -33,17 +30,6 @@ void TermObjectImpl::str_impl(std::ostream& out, const FormattingOptions& /*opti
 
 const Object& TermObjectImpl::get_object() const { return m_object; }
 
-size_t ShallowHash<const TermObjectImpl&>::operator()(const TermObjectImpl& e) const { return ShallowHashCombiner()(e.get_object()); }
-
-bool ShallowEqualTo<const TermObjectImpl&>::operator()(const TermObjectImpl& l, const TermObjectImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_object() == r.get_object());
-    }
-    return true;
-}
-
 /* TermVariableImpl */
 TermVariableImpl::TermVariableImpl(size_t index, Variable variable) : Base(index), m_variable(std::move(variable)) {}
 
@@ -51,24 +37,4 @@ void TermVariableImpl::str_impl(std::ostream& out, const FormattingOptions& /*op
 
 const Variable& TermVariableImpl::get_variable() const { return m_variable; }
 
-size_t ShallowHash<const TermVariableImpl&>::operator()(const TermVariableImpl& e) const { return ShallowHashCombiner()(e.get_variable()); }
-
-bool ShallowEqualTo<const TermVariableImpl&>::operator()(const TermVariableImpl& l, const TermVariableImpl& r) const
-{
-    if (&l != &r)
-    {
-        return (l.get_variable() == r.get_variable());
-    }
-    return true;
-}
-
-/* TermImpl */
-
-size_t ShallowHash<const TermImpl*>::operator()(const TermImpl* e) const
-{
-    return std::visit([](const auto& arg) { return ShallowHash<decltype(arg)>()(arg); }, *e);
-}
-
-bool ShallowEqualTo<const TermImpl*>::operator()(const TermImpl* l, const TermImpl* r) const { return ShallowEqualTo<TermImpl>()(*l, *r); }
-
 }
diff --git a/src/pddl/type.cpp b/src/pddl/type.cpp
index d769117..dc5bc83 100644
--- a/src/pddl/type.cpp
+++ b/src/pddl/type.cpp
@@ -17,10 +17,6 @@
 
 #include "loki/details/pddl/type.hpp"
 
-#include "loki/details/utils/collections.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
-
 namespace loki
 {
 TypeImpl::TypeImpl(size_t index, std::string name, TypeList bases) : Base(index), m_name(std::move(name)), m_bases(std::move(bases)) {}
@@ -53,17 +49,6 @@ const std::string& TypeImpl::get_name() const { return m_name; }
 
 const TypeList& TypeImpl::get_bases() const { return m_bases; }
 
-size_t ShallowHash<const TypeImpl*>::operator()(const TypeImpl* e) const { return ShallowHashCombiner()(e->get_name(), get_sorted_vector(e->get_bases())); }
-
-bool ShallowEqualTo<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;
-}
-
 static void collect_types_from_hierarchy_recursively(const TypeList& types, TypeSet& ref_result)
 {
     for (const auto& type : types)
diff --git a/src/pddl/variable.cpp b/src/pddl/variable.cpp
index 88d2977..4bd61a1 100644
--- a/src/pddl/variable.cpp
+++ b/src/pddl/variable.cpp
@@ -22,9 +22,6 @@
 #include "loki/details/pddl/literal.hpp"
 #include "loki/details/pddl/parameter.hpp"
 #include "loki/details/pddl/term.hpp"
-#include "loki/details/utils/collections.hpp"
-#include "loki/details/utils/equal_to.hpp"
-#include "loki/details/utils/hash.hpp"
 
 namespace loki
 {
@@ -34,17 +31,6 @@ void VariableImpl::str_impl(std::ostream& out, const FormattingOptions& /*option
 
 const std::string& VariableImpl::get_name() const { return m_name; }
 
-size_t ShallowHash<const VariableImpl*>::operator()(const VariableImpl* e) const { return ShallowHashCombiner()(e->get_name()); }
-
-bool ShallowEqualTo<const VariableImpl*>::operator()(const VariableImpl* l, const VariableImpl* r) const
-{
-    if (&l != &r)
-    {
-        return (l->get_name() == r->get_name());
-    }
-    return true;
-}
-
 static void collect_free_variables_recursively(const loki::ConditionImpl& condition, VariableSet& ref_quantified_variables, VariableSet& ref_free_variables)
 {
     if (const auto condition_literal = std::get_if<loki::ConditionLiteralImpl>(&condition))
diff --git a/src/utils/equal_to.cpp b/src/utils/equal_to.cpp
new file mode 100644
index 0000000..cf536ba
--- /dev/null
+++ b/src/utils/equal_to.cpp
@@ -0,0 +1,396 @@
+/*
+ * 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
new file mode 100644
index 0000000..638e134
--- /dev/null
+++ b/src/utils/hash.cpp
@@ -0,0 +1,194 @@
+/*
+ * 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/utils/value_type_factory.cpp b/tests/unit/utils/value_type_factory.cpp
index f4cc9ed..4bab0fb 100644
--- a/tests/unit/utils/value_type_factory.cpp
+++ b/tests/unit/utils/value_type_factory.cpp
@@ -86,16 +86,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(ShallowHash<const ObjectImpl*>()(object_0_0), ShallowHash<const ObjectImpl*>()(object_0_1));
-    EXPECT_TRUE(ShallowEqualTo<const ObjectImpl*>()(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));
 
     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(ShallowHash<const ObjectImpl*>()(object_0_0), ShallowHash<const ObjectImpl*>()(object_1));
-    EXPECT_FALSE(ShallowEqualTo<const ObjectImpl*>()(object_0_0, 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));
 }
 
 }