From 5314f47b33d3bdfa0bf095fc51a8073b57173000 Mon Sep 17 00:00:00 2001
From: Arthur O'Dwyer <arthur.j.odwyer@gmail.com>
Date: Sun, 2 Jan 2022 15:13:50 -0500
Subject: [PATCH] Hidden-friend tl::unexpected's comparison operators.

These comparison operators were added in afa1b9dd.
It would perhaps be better to simply remove them,
at least `< <= > >=`, especially since `tl::expected`
itself does not provide `< <= > >=`.
---
 include/tl/expected.hpp | 74 ++++++++++++++++++-----------------------
 1 file changed, 32 insertions(+), 42 deletions(-)

diff --git a/include/tl/expected.hpp b/include/tl/expected.hpp
index 31b130a..3b8240b 100644
--- a/include/tl/expected.hpp
+++ b/include/tl/expected.hpp
@@ -143,35 +143,29 @@ template <class E> class unexpected {
   TL_EXPECTED_11_CONSTEXPR E &&value() && { return std::move(m_val); }
   constexpr const E &&value() const && { return std::move(m_val); }
 
+  friend constexpr bool operator==(const unexpected &lhs, const unexpected &rhs) {
+    return lhs.value() == rhs.value();
+  }
+  friend constexpr bool operator!=(const unexpected &lhs, const unexpected &rhs) {
+    return lhs.value() != rhs.value();
+  }
+  friend constexpr bool operator<(const unexpected &lhs, const unexpected &rhs) {
+    return lhs.value() < rhs.value();
+  }
+  friend constexpr bool operator<=(const unexpected &lhs, const unexpected &rhs) {
+    return lhs.value() <= rhs.value();
+  }
+  friend constexpr bool operator>(const unexpected &lhs, const unexpected &rhs) {
+    return lhs.value() > rhs.value();
+  }
+  friend constexpr bool operator>=(const unexpected &lhs, const unexpected &rhs) {
+    return lhs.value() >= rhs.value();
+  }
+
 private:
   E m_val;
 };
 
-template <class E>
-constexpr bool operator==(const unexpected<E> &lhs, const unexpected<E> &rhs) {
-  return lhs.value() == rhs.value();
-}
-template <class E>
-constexpr bool operator!=(const unexpected<E> &lhs, const unexpected<E> &rhs) {
-  return lhs.value() != rhs.value();
-}
-template <class E>
-constexpr bool operator<(const unexpected<E> &lhs, const unexpected<E> &rhs) {
-  return lhs.value() < rhs.value();
-}
-template <class E>
-constexpr bool operator<=(const unexpected<E> &lhs, const unexpected<E> &rhs) {
-  return lhs.value() <= rhs.value();
-}
-template <class E>
-constexpr bool operator>(const unexpected<E> &lhs, const unexpected<E> &rhs) {
-  return lhs.value() > rhs.value();
-}
-template <class E>
-constexpr bool operator>=(const unexpected<E> &lhs, const unexpected<E> &rhs) {
-  return lhs.value() >= rhs.value();
-}
-
 template <class E>
 unexpected<typename std::decay<E>::type> make_unexpected(E &&e) {
   return unexpected<typename std::decay<E>::type>(std::forward<E>(e));
@@ -1935,6 +1929,19 @@ class expected : private detail::expected_move_assign_base<T, E>,
                   "T must be move-constructible and convertible to from U&&");
     return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v));
   }
+
+  friend constexpr bool operator==(const expected &x, const unexpected<E> &e) {
+    return x.has_value() ? false : x.error() == e.value();
+  }
+  friend constexpr bool operator==(const unexpected<E> &e, const expected &x) {
+    return x.has_value() ? false : x.error() == e.value();
+  }
+  friend constexpr bool operator!=(const expected &x, const unexpected<E> &e) {
+    return x.has_value() ? true : x.error() != e.value();
+  }
+  friend constexpr bool operator!=(const unexpected<E> &e, const expected &x) {
+    return x.has_value() ? true : x.error() != e.value();
+  }
 };
 
 namespace detail {
@@ -2294,23 +2301,6 @@ constexpr bool operator!=(const U &v, const expected<T, E> &x) {
   return x.has_value() ? *x != v : true;
 }
 
-template <class T, class E>
-constexpr bool operator==(const expected<T, E> &x, const unexpected<E> &e) {
-  return x.has_value() ? false : x.error() == e.value();
-}
-template <class T, class E>
-constexpr bool operator==(const unexpected<E> &e, const expected<T, E> &x) {
-  return x.has_value() ? false : x.error() == e.value();
-}
-template <class T, class E>
-constexpr bool operator!=(const expected<T, E> &x, const unexpected<E> &e) {
-  return x.has_value() ? true : x.error() != e.value();
-}
-template <class T, class E>
-constexpr bool operator!=(const unexpected<E> &e, const expected<T, E> &x) {
-  return x.has_value() ? true : x.error() != e.value();
-}
-
 template <class T, class E,
           detail::enable_if_t<(std::is_void<T>::value ||
                                std::is_move_constructible<T>::value) &&