Fixes operator== with std::optional

    - Prevents comparable operators from considering the tag types like tuple_tag
    - Allows Struct classes to implement their own comparable operators so it can
      be used with types like std::optional

Author: ricejasonf

include/boost/hana/core/tag_of.hpp

@@ -15,6 +15,8 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/config.hpp>
 #include <boost/hana/core/when.hpp>
 
+#include <type_traits>
+
 
 BOOST_HANA_NAMESPACE_BEGIN
     //! @cond
@@ -44,6 +46,14 @@ BOOST_HANA_NAMESPACE_BEGIN
     template <typename T> struct tag_of<T const volatile> : tag_of<T> { };
     template <typename T> struct tag_of<T&> : tag_of<T> { };
     template <typename T> struct tag_of<T&&> : tag_of<T> { };
+
+    namespace detail {
+        template <typename T>
+        struct has_idempotent_tag
+            : std::is_same<hana::tag_of_t<T>,
+                           std::remove_const_t<std::remove_reference_t<T>>>
+        { };
+    }
 BOOST_HANA_NAMESPACE_END
 
 #endif // !BOOST_HANA_CORE_TAG_OF_HPP

include/boost/hana/detail/operators/comparable.hpp

@@ -26,15 +26,23 @@ BOOST_HANA_NAMESPACE_BEGIN namespace detail {
 
     namespace operators {
         template <typename X, typename Y, typename = typename std::enable_if<
-            detail::comparable_operators<typename hana::tag_of<X>::type>::value ||
-            detail::comparable_operators<typename hana::tag_of<Y>::type>::value
+            !detail::has_idempotent_tag<X>::value &&
+            !detail::has_idempotent_tag<Y>::value &&
+            (detail::comparable_operators<
+                typename hana::tag_of<X>::type>::value ||
+             detail::comparable_operators<
+                typename hana::tag_of<Y>::type>::value)
         >::type>
         constexpr auto operator==(X&& x, Y&& y)
         { return hana::equal(static_cast<X&&>(x), static_cast<Y&&>(y)); }
 
         template <typename X, typename Y, typename = typename std::enable_if<
-            detail::comparable_operators<typename hana::tag_of<X>::type>::value ||
-            detail::comparable_operators<typename hana::tag_of<Y>::type>::value
+            !detail::has_idempotent_tag<X>::value &&
+            !detail::has_idempotent_tag<Y>::value &&
+            (detail::comparable_operators<
+                typename hana::tag_of<X>::type>::value ||
+             detail::comparable_operators<
+                typename hana::tag_of<Y>::type>::value)
         >::type>
         constexpr auto operator!=(X&& x, Y&& y)
         { return hana::not_equal(static_cast<X&&>(x), static_cast<Y&&>(y)); }

include/boost/hana/equal.hpp

@@ -191,7 +191,10 @@ BOOST_HANA_NAMESPACE_BEGIN
     }
 
     template <typename S>
-    struct equal_impl<S, S, when<hana::Struct<S>::value>> {
+    struct equal_impl<S, S, when<
+        hana::Struct<S>::value &&
+        !detail::EqualityComparable<S, S>::value
+    >> {
         template <typename X, typename Y>
         static constexpr auto apply(X const& x, Y const& y) {
             return hana::all_of(hana::accessors<S>(),

test/issues/github_460.cpp

@@ -0,0 +1,27 @@
+// Copyright Jason Rice 2020
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#include <boost/hana/define_struct.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/members.hpp>
+#include <boost/hana/not_equal.hpp>
+namespace hana = boost::hana;
+
+
+struct SomeStruct {
+    BOOST_HANA_DEFINE_STRUCT(SomeStruct, (int, x));
+
+    constexpr bool operator==(SomeStruct const& other) {
+        return hana::equal(hana::members(*this), hana::members(other));
+    }
+
+    constexpr bool operator!=(SomeStruct const& other) {
+        return hana::not_equal(hana::members(*this), hana::members(other));
+    }
+};
+
+int main() {
+    static_assert(SomeStruct{5} == SomeStruct{5}, "");
+    static_assert(hana::equal(SomeStruct{5}, SomeStruct{5}), "");
+}

test/issues/github_470.cpp

@@ -0,0 +1,39 @@
+// Copyright Jason Rice 2020
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#include <boost/hana/equal.hpp>
+#include <boost/hana/not_equal.hpp>
+#include <boost/hana/tuple.hpp>
+#include <cassert>
+namespace hana = boost::hana;
+
+namespace {
+    template <typename T>
+    struct optional {
+        T t;
+    };
+
+    template <typename T>
+    constexpr bool operator==(optional<T> const& o, T const& t) {
+        return o.t == t;
+    }
+    template <typename T>
+    constexpr bool operator==(T const& t, optional<T> const& o) {
+        return o.t == t;
+    }
+    template <typename T>
+    constexpr bool operator!=(optional<T> const& o, T const& t) {
+        return o.t != t;
+    }
+    template <typename T>
+    constexpr bool operator!=(T const& t, optional<T> const& o) {
+        return o.t != t;
+    }
+}
+
+int main() {
+    boost::hana::tuple<int> x{};
+    optional<boost::hana::tuple<int>> attr{x};
+    assert(attr == x);  // <-- Kablooey!
+}