From f40d2f773ab828b11db54815726142fe08b53144 Mon Sep 17 00:00:00 2001
From: Antony Polukhin <antoshkka@gmail.com>
Date: Sun, 11 Oct 2020 21:09:14 +0300
Subject: [PATCH] cleanup quck examples

---
 doc/pfr.qbk                            |  48 +++---
 example/quick_examples.cpp             | 195 ++++++++++++++++---------
 include/boost/pfr/detail/detectors.hpp |  36 +++--
 include/boost/pfr/functors.hpp         |  25 ++--
 include/boost/pfr/ops.hpp              | 105 +++++++------
 5 files changed, 238 insertions(+), 171 deletions(-)

diff --git a/doc/pfr.qbk b/doc/pfr.qbk
index 27eef30..2bf0b0d 100644
--- a/doc/pfr.qbk
+++ b/doc/pfr.qbk
@@ -136,50 +136,46 @@ PFR is a header only library that does not depend on Boost. You can just copy th
 
 [section Short Examples for the Impatient]
 
-Examples in the table use the following definition:
-
 [import ../example/quick_examples.cpp]
 
-[pfr_quick_examples_structures]
-
 
 [table:quick_examples
-[[ Code snippet ] [ `var` content or output ] [ Function description: ]]
+[[ Code snippet ] [ Functions reference: ]]
 [
-    [ [pfr_quick_examples_get_1] ]
-    [ `var == {A {1, 2.0}}` ]
-    [ [funcref boost::pfr::get get] ]
-][
-    [ [pfr_quick_examples_get_2] ]
-    [ `var == {A, {777, 42.01}}` ]
-    [ [funcref boost::pfr::get get] ]
+    [ [pfr_quick_examples_get] ]
+    [ [funcref boost::pfr::get] ]
 ][
     [ [pfr_quick_examples_ops] ]
-    [ assert succeeds ]
-    [ [headerref boost/pfr/ops.hpp using\u00A0namespace\u00A0ops;] ]
+    [
+        [headerref boost/pfr/ops.hpp Header boost/pfr/ops.hpp]
+    ]
 ][
     [ [pfr_quick_examples_for_each] ]
-    [ `var == {B, {787, 103.142}}` ]
-    [ [funcref boost::pfr::for_each_field for_each_field] ]
+    [
+        [funcref boost::pfr::for_each_field]
+
+        [funcref boost::pfr::io]
+    ]
+][
+    [ [pfr_quick_examples_functions_for] ]
+    [ [macroref BOOST_PFR_FUNCTIONS_FOR] ]
+][
+    [ [pfr_quick_examples_eq_fields] ]
+    [ [headerref boost/pfr/ops.hpp Header boost/pfr/ops_fields.hpp ]
 ][
     [ [pfr_quick_examples_for_each_idx] ]
-    [ ```0: char
-1: quick_examples_ns::foo
-``` ]
-    [ [funcref boost::pfr::for_each_field for_each_field] ]
+    [ [funcref boost::pfr::for_each_field] ]
 ][
     [ [pfr_quick_examples_tuple_size] ]
-    [ `tuple_size: 2` ]
-    [ [classref boost::pfr::tuple_size tuple_size] ]
+    [ [classref boost::pfr::tuple_size] ]
 ][
     [ [pfr_quick_examples_structure_to_tuple] ]
-    [ `var == {A, {777, 3.14159}}` ]
-    [ [funcref boost::pfr::structure_to_tuple structure_to_tuple] ]
+    [ [funcref boost::pfr::structure_to_tuple] ]
 ][
     [ [pfr_quick_examples_structure_tie] ]
-    [ `var == {A, {1, 2.0}}` ]
-    [ [funcref boost::pfr::structure_tie structure_tie] ]
+    [ [funcref boost::pfr::structure_tie] ]
 ]]
+]
 
 
 [endsect]
diff --git a/example/quick_examples.cpp b/example/quick_examples.cpp
index fa945b0..8c3fc71 100644
--- a/example/quick_examples.cpp
+++ b/example/quick_examples.cpp
@@ -12,61 +12,65 @@
 #include <boost/pfr.hpp>
 #include <boost/type_index.hpp>
 
-
-//[pfr_quick_examples_structures
-struct foo {
-    int integer;
-    double real;
-    
-    void operator +=(int v) {
-        integer += v * 10;
-        real += v * 100;
-    }
-};
-
-struct bar {
-    char character;
-    foo f;
-};
-
-bar var{'A', {777, 3.141593}};
-//]
-    
-inline std::ostream& operator<<(std::ostream& os, const bar& b) {
-    return os << '{' << b.character << ", {" << b.f.integer << ", " << b.f.real << "}}";
-}
-
 void test_examples() {
 
 #if BOOST_PFR_USE_CPP17
   {
 //[pfr_quick_examples_ops
-    struct test { std::string f1; std::string_view f2; };
-    assert(boost::pfr::gt(test{"abc", ""}, test{"aaa", "zomg"}));
+    // Assert equality.
+    // Note that the equality operator for structure is not defined.
+
+    struct test {
+        std::string f1;
+        std::string_view f2;
+    };
+
+    assert(
+        boost::pfr::eq(test{"aaa", "zomg"}, test{"aaa", "zomg"})
+    );
 //]
   }
 #endif
-    
-  {  
-    bar var{'A', {777, 3.141593}};
-    
-//[pfr_quick_examples_for_each    
-    // increments first field on 1, calls foo::operator+= for second field
+
+  {
+//[pfr_quick_examples_for_each
+    // Increment each field of the variable on 1 and
+    // output the content of the variable.
+
+    struct test {
+        int f1;
+        long f2;
+    };
+
+    test var{42, 43};
+
     boost::pfr::for_each_field(var, [](auto& field) {
         field += 1;
     });
-//]
-    
-    std::cout << "flat_for_each_field outputs:\n" << var << '\n';
-  }
-    
-  {
-    bar var{'A', {777, 3.141593}};
 
-//[pfr_quick_examples_for_each_idx  
-    boost::pfr::for_each_field(var, [](auto& field, std::size_t idx) {
-        std::cout << idx << ": "
-            << boost::typeindex::type_id_runtime(field) << '\n';
+    // Outputs: {43, 44}
+    std::cout << boost::pfr::io(var);
+//]
+  }
+
+  {
+//[pfr_quick_examples_for_each_idx
+    // Iterate over fields of a varible and output index and
+    // type of a variable.
+
+    struct tag0{};
+    struct tag1{};
+    struct sample {
+        tag0 a;
+        tag1 b;
+    };
+
+    // Outputs:
+    //  0: tag0
+    //  1: tag1
+    boost::pfr::for_each_field(sample{}, [](const auto& field, std::size_t idx) {
+        std::cout << '\n' << idx << ": "
+            << boost::typeindex::type_id_runtime(field);
     });
 //]
   }
@@ -74,55 +78,104 @@ void test_examples() {
 
   {
 //[pfr_quick_examples_tuple_size
-    std::cout << "tuple_size: "
-        << boost::pfr::tuple_size<bar>::value << '\n';
+    struct some { int a,b,c,d,e; };
+
+    std::cout << "Fields count in structure: "
+        << boost::pfr::tuple_size<some>::value  // Outputs: 5
+        << '\n';
+//]
+  }
+
+  {
+//[pfr_quick_examples_get
+    // Get field by index and assign new value to that field
+
+    struct sample {
+        char c;
+        float f;
+    };
+
+    sample var{};
+    boost::pfr::get<1>(var) = 42.01;
+
+    std::cout << var.f; // Outputs: 42.01
 //]
   }
 
 #if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
   {
-    bar var{'A', {777, 3.141593}};
-//[pfr_quick_examples_get_1
-    boost::pfr::get<1>(var) = foo{1, 2}; // C++17 or Loophole is required
-//]
-    std::cout << "boost::pfr::get<1>(var) outputs:\n" << var << '\n';
-  }
-#endif
-  
-  {
-    bar var{'A', {777, 3.141593}};
-//[pfr_quick_examples_get_2
-    boost::pfr::get<1>(var.f) = 42.01;
-//]
-    std::cout << "boost::pfr::get<1>(var.f) outputs:\n" << var << '\n';
-  }
-
-#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
-  {
-    bar var{'A', {777, 3.141593}};
 //[pfr_quick_examples_structure_to_tuple
-    // C++17 or Loophole is required
+    struct foo { int a, b; };
+    struct other {
+        char c;
+        foo nested;
+    };
+
+    other var{'A', {3, 4}};
     std::tuple<char, foo> t = boost::pfr::structure_to_tuple(var);
-    std::get<1>(t) = foo{1, 2};
+    assert(std::get<0>(t) == 'A');
+    assert(
+        boost::pfr::eq(std::get<1>(t), foo{3, 4})
+    );
 //]
-    std::cout << "boost::pfr::structure_to_tuple(var) :\n" << var << '\n';
   }
 #endif
 
 #if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
   {
-    bar var{'A', {777, 3.141593}};
 //[pfr_quick_examples_structure_tie
-    // C++17 or Loophole is required
+    struct foo { int a, b; };
+    struct other {
+        char c;
+        foo f;
+    };
+
+    other var{'A', {14, 15}};
     std::tuple<char&, foo&> t = boost::pfr::structure_tie(var);
     std::get<1>(t) = foo{1, 2};
+
+    std::cout << boost::pfr::io(var.f); // Outputs: {1, 2}
 //]
-    std::cout << "boost::pfr::structure_tie(var) :\n" << var << '\n';
   }
 #endif
 
-} // void test_examples() {
+} // void test_examples()
 
+//[pfr_quick_examples_functions_for
+// Define all the comparison and IO operators for my_structure type along
+// with hash_value function.
+
+#include <boost/pfr/functions_for.hpp>
+
+namespace my_namespace {
+    struct my_structure {
+        int a,b,c,d,e,f,g;
+        // ...
+    };
+    BOOST_PFR_FUNCTIONS_FOR(my_structure)
+}
+//]
+
+//[pfr_quick_examples_eq_fields
+// Define only the equality and inequality operators for my_eq_ne_structure.
+
+#include <boost/pfr/functions_for.hpp>
+
+namespace my_namespace {
+    struct my_eq_ne_structure {
+        float a,b,c,d,e,f,g;
+        // ...
+    };
+
+    inline bool operator==(const my_eq_ne_structure& x, const my_eq_ne_structure& y) {
+        return boost::pfr::eq_fields(x, y);
+    }
+
+    inline bool operator!=(const my_eq_ne_structure& x, const my_eq_ne_structure& y) {
+        return boost::pfr::ne_fields(x, y);
+    }
+}
+//]
 
 int main() {
     test_examples();
diff --git a/include/boost/pfr/detail/detectors.hpp b/include/boost/pfr/detail/detectors.hpp
index 061b4b7..2ee04e3 100644
--- a/include/boost/pfr/detail/detectors.hpp
+++ b/include/boost/pfr/detail/detectors.hpp
@@ -9,52 +9,58 @@
 
 #include <boost/pfr/detail/config.hpp>
 
+#include <functional>
 #include <type_traits>
 
 namespace boost { namespace pfr { namespace detail {
 ///////////////////// `value` is true if Detector<Tleft, Tright> does not compile (SFINAE)
-    struct success{};
+    struct can_not_apply{};
 
     template <template <class, class> class Detector, class Tleft, class Tright>
     struct not_appliable {
         static constexpr bool value = std::is_same<
             Detector<Tleft, Tright>,
-            success
+            can_not_apply
         >::value;
     };
 
 ///////////////////// Detectors for different operators
     template <class S, class T> auto comp_eq_detector_msvc_helper(long) -> decltype(std::declval<S>() == std::declval<T>());
-    template <class S, class T> success comp_eq_detector_msvc_helper(int);
+    template <class S, class T> can_not_apply comp_eq_detector_msvc_helper(int);
     template <class T1, class T2> using comp_eq_detector = decltype(comp_eq_detector_msvc_helper<T1,T2>(1L));
 
     template <class S, class T> auto comp_ne_detector_msvc_helper(long) -> decltype(std::declval<S>() != std::declval<T>());
-    template <class S, class T> success comp_ne_detector_msvc_helper(int);
-    template <class T1, class T2> using comp_ne_detector =  decltype(comp_ne_detector_msvc_helper<T1,T2>(1L));
+    template <class S, class T> can_not_apply comp_ne_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_ne_detector = decltype(comp_ne_detector_msvc_helper<T1,T2>(1L));
 
     template <class S, class T> auto comp_lt_detector_msvc_helper(long) -> decltype(std::declval<S>() < std::declval<T>());
-    template <class S, class T> success comp_lt_detector_msvc_helper(int);
-    template <class T1, class T2> using comp_lt_detector =  decltype(comp_lt_detector_msvc_helper<T1,T2>(1L));
+    template <class S, class T> can_not_apply comp_lt_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_lt_detector = decltype(comp_lt_detector_msvc_helper<T1,T2>(1L));
 
     template <class S, class T> auto comp_le_detector_msvc_helper(long) -> decltype(std::declval<S>() <= std::declval<T>());
-    template <class S, class T> success comp_le_detector_msvc_helper(int);
-    template <class T1, class T2> using comp_le_detector =  decltype(comp_le_detector_msvc_helper<T1,T2>(1L));
+    template <class S, class T> can_not_apply comp_le_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_le_detector = decltype(comp_le_detector_msvc_helper<T1,T2>(1L));
 
     template <class S, class T> auto comp_gt_detector_msvc_helper(long) -> decltype(std::declval<S>() > std::declval<T>());
-    template <class S, class T> success comp_gt_detector_msvc_helper(int);
-    template <class T1, class T2> using comp_gt_detector =   decltype(comp_gt_detector_msvc_helper<T1,T2>(1L));
+    template <class S, class T> can_not_apply comp_gt_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_gt_detector = decltype(comp_gt_detector_msvc_helper<T1,T2>(1L));
 
     template <class S, class T> auto comp_ge_detector_msvc_helper(long) -> decltype(std::declval<S>() >= std::declval<T>());
-    template <class S, class T> success comp_ge_detector_msvc_helper(int);
-    template <class T1, class T2> using comp_ge_detector =   decltype(comp_ge_detector_msvc_helper<T1,T2>(1L));
+    template <class S, class T> can_not_apply comp_ge_detector_msvc_helper(int);
+    template <class T1, class T2> using comp_ge_detector = decltype(comp_ge_detector_msvc_helper<T1,T2>(1L));
+
+
+    template <class S> auto hash_detector_msvc_helper(long) -> decltype(std::hash<S>{}(std::declval<S>()));
+    template <class S> can_not_apply hash_detector_msvc_helper(int);
+    template <class T1, class T2> using hash_detector = decltype(hash_detector_msvc_helper<T1,T2>(1L));
 
 
     template <class S, class T> auto ostreamable_detector_msvc_helper(long) -> decltype(std::declval<S>() << std::declval<T>());
-    template <class S, class T> success ostreamable_detector_msvc_helper(int);
+    template <class S, class T> can_not_apply ostreamable_detector_msvc_helper(int);
     template <class S, class T> using ostreamable_detector = decltype(ostreamable_detector_msvc_helper<S,T>(1L));
 
     template <class S, class T> auto istreamable_detector_msvc_helper(long) -> decltype(std::declval<S>() >> std::declval<T>());
-    template <class S, class T> success istreamable_detector_msvc_helper(int);
+    template <class S, class T> can_not_apply istreamable_detector_msvc_helper(int);
     template <class S, class T> using istreamable_detector = decltype(istreamable_detector_msvc_helper<S,T>(1L));
 
 }}} // namespace boost::pfr::detail
diff --git a/include/boost/pfr/functors.hpp b/include/boost/pfr/functors.hpp
index 5a6a4f4..9c882ce 100644
--- a/include/boost/pfr/functors.hpp
+++ b/include/boost/pfr/functors.hpp
@@ -12,7 +12,6 @@
 #include <boost/pfr/ops.hpp>
 
 #include <boost/pfr/detail/functional.hpp>
-#include <boost/pfr/detail/make_integer_sequence.hpp>
 
 /// \file boost/pfr/functors.hpp
 /// Contains functors that are close to the Standard Library ones.
@@ -27,7 +26,7 @@ namespace boost { namespace pfr {
 template <class T = void> struct equal_to {
     /// \return \b true if each field of \b x equals the field with same index of \b y.
     bool operator()(const T& x, const T& y) const {
-        return detail::binary_visit<detail::equal_impl>(x, y);
+        return boost::pfr::eq(x, y);
     }
 
 #ifdef BOOST_PFR_DOXYGEN_INVOKED
@@ -44,7 +43,7 @@ template <class T = void> struct equal_to {
 template <> struct equal_to<void> {
     template <class T, class U>
     bool operator()(const T& x, const U& y) const {
-        return detail::binary_visit<detail::equal_impl>(x, y);
+        return boost::pfr::eq(x, y);
     }
 
     typedef std::true_type is_transparent;
@@ -55,7 +54,7 @@ template <> struct equal_to<void> {
 template <class T = void> struct not_equal {
     /// \return \b true if at least one field \b x not equals the field with same index of \b y.
     bool operator()(const T& x, const T& y) const {
-        return detail::binary_visit<detail::not_equal_impl>(x, y);
+        return boost::pfr::ne(x, y);
     }
 
 #ifdef BOOST_PFR_DOXYGEN_INVOKED
@@ -72,7 +71,7 @@ template <class T = void> struct not_equal {
 template <> struct not_equal<void> {
     template <class T, class U>
     bool operator()(const T& x, const U& y) const {
-        return detail::binary_visit<detail::not_equal_impl>(x, y);
+        return boost::pfr::ne(x, y);
     }
 
     typedef std::true_type is_transparent;
@@ -83,7 +82,7 @@ template <> struct not_equal<void> {
 template <class T = void> struct greater {
     /// \return \b true if field of \b x greater than the field with same index of \b y and all previous fields of \b x equal to the same fields of \b y.
     bool operator()(const T& x, const T& y) const {
-        return detail::binary_visit<detail::greater_impl>(x, y);
+        return boost::pfr::gt(x, y);
     }
 
 #ifdef BOOST_PFR_DOXYGEN_INVOKED
@@ -100,7 +99,7 @@ template <class T = void> struct greater {
 template <> struct greater<void> {
     template <class T, class U>
     bool operator()(const T& x, const U& y) const {
-        return detail::binary_visit<detail::greater_impl>(x, y);
+        return boost::pfr::gt(x, y);
     }
 
     typedef std::true_type is_transparent;
@@ -111,7 +110,7 @@ template <> struct greater<void> {
 template <class T = void> struct less {
     /// \return \b true if field of \b x less than the field with same index of \b y and all previous fields of \b x equal to the same fields of \b y.
     bool operator()(const T& x, const T& y) const {
-        return detail::binary_visit<detail::less_impl>(x, y);
+        return boost::pfr::lt(x, y);
     }
 
 #ifdef BOOST_PFR_DOXYGEN_INVOKED
@@ -128,7 +127,7 @@ template <class T = void> struct less {
 template <> struct less<void> {
     template <class T, class U>
     bool operator()(const T& x, const U& y) const {
-        return detail::binary_visit<detail::less_impl>(x, y);
+        return boost::pfr::lt(x, y);
     }
 
     typedef std::true_type is_transparent;
@@ -140,7 +139,7 @@ template <class T = void> struct greater_equal {
     /// \return \b true if field of \b x greater than the field with same index of \b y and all previous fields of \b x equal to the same fields of \b y;
     /// or if each field of \b x equals the field with same index of \b y.
     bool operator()(const T& x, const T& y) const {
-        return detail::binary_visit<detail::greater_equal_impl>(x, y);
+        return boost::pfr::ge(x, y);
     }
 
 #ifdef BOOST_PFR_DOXYGEN_INVOKED
@@ -157,7 +156,7 @@ template <class T = void> struct greater_equal {
 template <> struct greater_equal<void> {
     template <class T, class U>
     bool operator()(const T& x, const U& y) const {
-        return detail::binary_visit<detail::greater_equal_impl>(x, y);
+        return boost::pfr::ge(x, y);
     }
 
     typedef std::true_type is_transparent;
@@ -169,7 +168,7 @@ template <class T = void> struct less_equal {
     /// \return \b true if field of \b x less than the field with same index of \b y and all previous fields of \b x equal to the same fields of \b y;
     /// or if each field of \b x equals the field with same index of \b y.
     bool operator()(const T& x, const T& y) const {
-        return detail::binary_visit<detail::less_equal_impl>(x, y);
+        return boost::pfr::le(x, y);
     }
 
 #ifdef BOOST_PFR_DOXYGEN_INVOKED
@@ -186,7 +185,7 @@ template <class T = void> struct less_equal {
 template <> struct less_equal<void> {
     template <class T, class U>
     bool operator()(const T& x, const U& y) const {
-        return detail::binary_visit<detail::less_equal_impl>(x, y);
+        return boost::pfr::le(x, y);
     }
 
     typedef std::true_type is_transparent;
diff --git a/include/boost/pfr/ops.hpp b/include/boost/pfr/ops.hpp
index e13db98..78e22a3 100644
--- a/include/boost/pfr/ops.hpp
+++ b/include/boost/pfr/ops.hpp
@@ -42,102 +42,115 @@ namespace boost { namespace pfr {
 namespace detail {
 
 ///////////////////// Helper typedefs that are used by all the ops
-    template <template <class, class> class Detector, class T>
-    using enable_not_comp_base_t = typename std::enable_if<
-        not_appliable<Detector, T const&, T const&>::value,
+    template <template <class, class> class Detector, class T, class U>
+    using enable_not_comp_base_t = std::enable_if_t<
+        not_appliable<Detector, T const&, U const&>::value,
         bool
-    >::type;
+    >;
 
-    template <template <class, class> class Detector, class T>
-    using enable_comp_base_t = typename std::enable_if<
-        !not_appliable<Detector, T const&, T const&>::value,
+    template <template <class, class> class Detector, class T, class U>
+    using enable_comp_base_t = std::enable_if_t<
+        !not_appliable<Detector, T const&, U const&>::value,
         bool
-    >::type;
+    >;
 ///////////////////// std::enable_if_t like functions that enable only if types do not support operation
 
-    template <class T> using enable_not_eq_comp_t = enable_not_comp_base_t<comp_eq_detector, T>;
-    template <class T> using enable_not_ne_comp_t = enable_not_comp_base_t<comp_ne_detector, T>;
-    template <class T> using enable_not_lt_comp_t = enable_not_comp_base_t<comp_lt_detector, T>;
-    template <class T> using enable_not_le_comp_t = enable_not_comp_base_t<comp_le_detector, T>;
-    template <class T> using enable_not_gt_comp_t = enable_not_comp_base_t<comp_gt_detector, T>;
-    template <class T> using enable_not_ge_comp_t = enable_not_comp_base_t<comp_ge_detector, T>;
+    template <class T, class U> using enable_not_eq_comp_t = enable_not_comp_base_t<comp_eq_detector, T, U>;
+    template <class T, class U> using enable_not_ne_comp_t = enable_not_comp_base_t<comp_ne_detector, T, U>;
+    template <class T, class U> using enable_not_lt_comp_t = enable_not_comp_base_t<comp_lt_detector, T, U>;
+    template <class T, class U> using enable_not_le_comp_t = enable_not_comp_base_t<comp_le_detector, T, U>;
+    template <class T, class U> using enable_not_gt_comp_t = enable_not_comp_base_t<comp_gt_detector, T, U>;
+    template <class T, class U> using enable_not_ge_comp_t = enable_not_comp_base_t<comp_ge_detector, T, U>;
 
+    template <class T> using enable_not_hashable_t = std::enable_if_t<
+        not_appliable<hash_detector, const T&, const T&>::value,
+        std::size_t
+    >;
 ///////////////////// std::enable_if_t like functions that enable only if types do support operation
 
-    template <class T> using enable_eq_comp_t = enable_comp_base_t<comp_eq_detector, T>;
-    template <class T> using enable_ne_comp_t = enable_comp_base_t<comp_ne_detector, T>;
-    template <class T> using enable_lt_comp_t = enable_comp_base_t<comp_lt_detector, T>;
-    template <class T> using enable_le_comp_t = enable_comp_base_t<comp_le_detector, T>;
-    template <class T> using enable_gt_comp_t = enable_comp_base_t<comp_gt_detector, T>;
-    template <class T> using enable_ge_comp_t = enable_comp_base_t<comp_ge_detector, T>;
+    template <class T, class U> using enable_eq_comp_t = enable_comp_base_t<comp_eq_detector, T, U>;
+    template <class T, class U> using enable_ne_comp_t = enable_comp_base_t<comp_ne_detector, T, U>;
+    template <class T, class U> using enable_lt_comp_t = enable_comp_base_t<comp_lt_detector, T, U>;
+    template <class T, class U> using enable_le_comp_t = enable_comp_base_t<comp_le_detector, T, U>;
+    template <class T, class U> using enable_gt_comp_t = enable_comp_base_t<comp_gt_detector, T, U>;
+    template <class T, class U> using enable_ge_comp_t = enable_comp_base_t<comp_ge_detector, T, U>;
+
+    template <class T> using enable_hashable_t = std::enable_if_t<
+        !not_appliable<hash_detector, const T&, const T&>::value,
+        std::size_t
+    >;
 } // namespace detail
 
-template <class T>
-detail::enable_not_eq_comp_t<T> eq(const T& lhs, const T& rhs) noexcept {
+template <class T, class U>
+detail::enable_not_eq_comp_t<T, U> eq(const T& lhs, const U& rhs) noexcept {
     return boost::pfr::eq_fields(lhs, rhs);
 }
 
-template <class T>
-detail::enable_eq_comp_t<T> eq(const T& lhs, const T& rhs) noexcept {
+template <class T, class U>
+detail::enable_eq_comp_t<T, U> eq(const T& lhs, const U& rhs) {
     return lhs == rhs;
 }
 
-template <class T>
-detail::enable_not_ne_comp_t<T> ne(const T& lhs, const T& rhs) noexcept {
+template <class T, class U>
+detail::enable_not_ne_comp_t<T, U> ne(const T& lhs, const U& rhs) noexcept {
     return boost::pfr::ne_fields(lhs, rhs);
 }
 
-template <class T>
-detail::enable_ne_comp_t<T> ne(const T& lhs, const T& rhs) noexcept {
+template <class T, class U>
+detail::enable_ne_comp_t<T, U> ne(const T& lhs, const U& rhs) {
     return lhs != rhs;
 }
 
-template <class T>
-detail::enable_not_lt_comp_t<T> lt(const T& lhs, const T& rhs) noexcept {
+template <class T, class U>
+detail::enable_not_lt_comp_t<T, U> lt(const T& lhs, const U& rhs) noexcept {
     return boost::pfr::lt_fields(lhs, rhs);
 }
 
-template <class T>
-detail::enable_lt_comp_t<T> lt(const T& lhs, const T& rhs) noexcept {
+template <class T, class U>
+detail::enable_lt_comp_t<T, U> lt(const T& lhs, const U& rhs) {
     return lhs < rhs;
 }
 
-template <class T>
-detail::enable_not_gt_comp_t<T> gt(const T& lhs, const T& rhs) noexcept {
+template <class T, class U>
+detail::enable_not_gt_comp_t<T, U> gt(const T& lhs, const U& rhs) noexcept {
     return boost::pfr::gt_fields(lhs, rhs);
 }
 
-template <class T>
-detail::enable_gt_comp_t<T> gt(const T& lhs, const T& rhs) noexcept {
+template <class T, class U>
+detail::enable_gt_comp_t<T, U> gt(const T& lhs, const U& rhs) {
     return lhs > rhs;
 }
 
-template <class T>
-detail::enable_not_le_comp_t<T> le(const T& lhs, const T& rhs) noexcept {
+template <class T, class U>
+detail::enable_not_le_comp_t<T, U> le(const T& lhs, const U& rhs) noexcept {
     return boost::pfr::le_fields(lhs, rhs);
 }
 
-template <class T>
-detail::enable_le_comp_t<T> le(const T& lhs, const T& rhs) noexcept {
+template <class T, class U>
+detail::enable_le_comp_t<T, U> le(const T& lhs, const U& rhs) {
     return lhs <= rhs;
 }
 
-template <class T>
-detail::enable_not_ge_comp_t<T> ge(const T& lhs, const T& rhs) noexcept {
+template <class T, class U>
+detail::enable_not_ge_comp_t<T, U> ge(const T& lhs, const U& rhs) noexcept {
     return boost::pfr::ge_fields(lhs, rhs);
 }
 
-template <class T>
-detail::enable_ge_comp_t<T> ge(const T& lhs, const T& rhs) noexcept {
+template <class T, class U>
+detail::enable_ge_comp_t<T, U> ge(const T& lhs, const U& rhs) {
     return lhs >= rhs;
 }
 
-/// \brief helper function for Boost
 template <class T>
-static std::enable_if_t<std::is_trivial<T>::value, std::size_t> hash_value(const T& value) noexcept {
+detail::enable_not_hashable_t<T> hash_value(const T& value) noexcept {
     return boost::pfr::hash_fields(value);
 }
 
+template <class T>
+detail::enable_hashable_t<T> hash_value(const T& value) {
+    return std::hash<T>{}(value);
+}
+
 }} // namespace boost::pfr
 
 #endif // BOOST_PFR_OPS_HPP