🎨 Make shrinking transparent to equality comparison

Problem:
- Shrinking as much as possible should be "invisible", i.e. a shrunk value
  should be usable like a regular value. As much as possible, regularity
  operations should be able to treat them the same.

Solution:
- Make shrunk objects equality comparable with their non-shrunk counterparts.

Author: elbeno

include/stdx/type_traits.hpp

@@ -221,11 +221,18 @@ namespace detail {
 template <typename T> struct shrinkwrap {
     using is_shrinkwrapped = void;
     using type = T;
+    friend constexpr auto operator==(shrinkwrap const &, shrinkwrap const &)
+        -> bool = default;
 };
 
 template <auto V> struct shrinkwrap_value {
     using is_shrinkwrapped_value = void;
+    using type = std::remove_cvref_t<decltype(V)>;
     constexpr static auto value = V;
+
+    friend constexpr auto operator==(shrinkwrap_value const &,
+                                     shrinkwrap_value const &)
+        -> bool = default;
 };
 
 template <typename T>
@@ -268,9 +275,7 @@ template <auto V,
 consteval auto shrink_impl() {
     return F;
 }
-} // namespace stdx
 
-namespace stdx {
 inline namespace v1 {
 namespace detail {
 template <typename T> consteval auto maybe_expand() -> T;
@@ -323,6 +328,13 @@ template <typename T> constexpr auto expand(T &&t) -> decltype(auto) {
 template <typename T> using shrink_t = decltype(shrink<T>());
 template <typename T> using expand_t = decltype(expand<T>());
 
+template <detail::is_shrunk_value T, typename U>
+constexpr auto operator==(T const &t, U const &u) -> bool
+    requires requires { expand(t) == u; }
+{
+    return expand(t) == u;
+}
+
 STDX_PRAGMA(diagnostic push)
 #ifdef __clang__
 STDX_PRAGMA(diagnostic ignored "-Wunknown-warning-option")

test/ct_string.cpp

@@ -226,6 +226,14 @@ TEST_CASE("named object with shrunk name", "[ct_string]") {
     STATIC_CHECK(stdx::matching_name_q<"test">::template fn<T>::value);
 }
 
+TEST_CASE("shrunk ct_string compares equal to ct_string", "[ct_string]") {
+    using namespace stdx::ct_string_literals;
+    constexpr auto s = stdx::shrink<"test">();
+    STATIC_CHECK(s == "test"_cts);
+    STATIC_CHECK("test"_cts == s);
+    STATIC_CHECK(s == s);
+}
+
 TEST_CASE("name or type fallback", "[ct_string]") {
     using namespace stdx::ct_string_literals;
     using T = stdx::with_name<"test">;