From 838c4b9a45a50f252c7b20d14570b0b7463709ab Mon Sep 17 00:00:00 2001
From: Steven Le Rouzic <steven.lerouzic@gmail.com>
Date: Wed, 8 Jan 2025 23:40:52 +0100
Subject: Finish work on hashing probably

---
 asl/box.hpp                   |   8 +++
 asl/buffer.hpp                |   2 +
 asl/hash.hpp                  |   6 ++
 asl/meta.hpp                  |   2 +-
 asl/option.hpp                |  16 ++++++
 asl/span.hpp                  |   6 --
 asl/status.hpp                |  13 ++++-
 asl/status_or.hpp             |  15 ++++-
 asl/tests/hash_tests.cpp      | 124 +++++++++++++++++++++++++++++++++++++++++-
 asl/tests/status_or_tests.cpp |   4 --
 asl/tests/status_tests.cpp    |   7 ---
 11 files changed, 176 insertions(+), 27 deletions(-)

(limited to 'asl')

diff --git a/asl/box.hpp b/asl/box.hpp
index d018c03..340a37c 100644
--- a/asl/box.hpp
+++ b/asl/box.hpp
@@ -5,6 +5,7 @@
 #include "asl/annotations.hpp"
 #include "asl/memory.hpp"
 #include "asl/utility.hpp"
+#include "asl/hash.hpp"
 
 namespace asl
 {
@@ -82,6 +83,13 @@ public:
     {
         return m_ptr == nullptr;
     }
+
+    template<typename H>
+    requires hashable<T>
+    friend H AslHashValue(H h, const box& b)
+    {
+        return H::combine(ASL_MOVE(h), *b);
+    }
 };
 
 template<is_object T, allocator Allocator = DefaultAllocator, typename... Args>
diff --git a/asl/buffer.hpp b/asl/buffer.hpp
index 7d33c73..93f811b 100644
--- a/asl/buffer.hpp
+++ b/asl/buffer.hpp
@@ -6,6 +6,7 @@
 #include "asl/memory.hpp"
 #include "asl/assert.hpp"
 #include "asl/span.hpp"
+#include "asl/hash.hpp"
 
 namespace asl
 {
@@ -391,6 +392,7 @@ public:
     }
 
     template<typename H>
+    requires hashable<T>
     friend H AslHashValue(H h, const buffer& b)
     {
         return H::combine_contiguous(ASL_MOVE(h), b.as_span());
diff --git a/asl/hash.hpp b/asl/hash.hpp
index 5f81e92..d3a12bd 100644
--- a/asl/hash.hpp
+++ b/asl/hash.hpp
@@ -120,6 +120,12 @@ constexpr H AslHashValue(H h, bool value)
 template<typename H, typename T>
 constexpr void AslHashValue(H h, T*); // Don't hash pointers
 
+template<typename H, hashable T>
+constexpr H AslHashValue(H h, const span<T>& s)
+{
+    return H::combine_contiguous(ASL_MOVE(h), span<const T>{s.data(), s.size()});
+}
+
 template<hashable T>
 constexpr uint64_t hash_value(const T& value)
 {
diff --git a/asl/meta.hpp b/asl/meta.hpp
index 8940ec6..e77f4a7 100644
--- a/asl/meta.hpp
+++ b/asl/meta.hpp
@@ -197,7 +197,7 @@ template<is_enum T> struct is_uniquely_represented<T> : true_type {};
 template<> struct is_uniquely_represented<uint128_t> : true_type {};
 template<> struct is_uniquely_represented<byte> : true_type {};
 
-template<typename T> concept uniquely_represented = is_uniquely_represented<T>::value;
+template<typename T> concept uniquely_represented = is_uniquely_represented<un_cv_t<T>>::value;
 
 template<typename T, typename U>
 concept equality_comparable_with = requires (const un_cvref_t<T>& a, const un_cvref_t<U>& b)
diff --git a/asl/option.hpp b/asl/option.hpp
index eb6a91c..f7a3eab 100644
--- a/asl/option.hpp
+++ b/asl/option.hpp
@@ -5,6 +5,7 @@
 #include "asl/maybe_uninit.hpp"
 #include "asl/functional.hpp"
 #include "asl/annotations.hpp"
+#include "asl/hash.hpp"
 
 namespace asl
 {
@@ -485,8 +486,23 @@ public:
     {
         return has_value() ? ASL_MOVE(*this) : invoke(ASL_FWD(f));
     }
+
+    template<typename H>
+    requires (!uniquely_represented<option>) && hashable<T>
+    friend H AslHashValue(H h, const option& opt)
+    {
+        if (!opt.has_value())
+        {
+            return H::combine(ASL_MOVE(h), 0);
+        }
+        return H::combine(ASL_MOVE(h), 1, opt.value());
+    }
 };
 
+template<typename T>
+requires has_niche<T> && uniquely_represented<T>
+struct is_uniquely_represented<option<T>> : true_type {};
+
 template<typename T>
 option(T) -> option<T>;
 
diff --git a/asl/span.hpp b/asl/span.hpp
index bb36291..8f6fb4a 100644
--- a/asl/span.hpp
+++ b/asl/span.hpp
@@ -171,12 +171,6 @@ public:
         ASL_ASSERT(sub_size >= 0 && sub_size <= size());
         return span<T>{ data() + size() - sub_size, sub_size };
     }
-
-    template<typename H>
-    friend H AslHashValue(H h, const span& s)
-    {
-        return H::combine_contiguous(ASL_MOVE(h), span<const T>{s.data(), s.size()});
-    }
 };
 
 template<is_object T, isize_t kSize>
diff --git a/asl/status.hpp b/asl/status.hpp
index aa64e4e..9645f96 100644
--- a/asl/status.hpp
+++ b/asl/status.hpp
@@ -104,9 +104,6 @@ public:
         return m_payload == nullptr;
     }
 
-    // NOLINTNEXTLINE(*-explicit-conversions)
-    constexpr operator bool() const { return ok(); }
-
     constexpr status_code code() const
     {
         return is_inline() ? code_inline() : code_internal();
@@ -122,6 +119,16 @@ public:
     }
 
     friend void AslFormat(Formatter& f, const status&);
+
+    template<typename H>
+    friend H AslHashValue(H h, const status& s)
+    {
+        if (s.is_inline())
+        {
+            return H::combine(ASL_MOVE(h), s.code());
+        }
+        return H::combine(ASL_MOVE(h), s.code(), s.message());
+    }
 };
 
 static constexpr status ok() { return status{status_code::ok}; }
diff --git a/asl/status_or.hpp b/asl/status_or.hpp
index 04fcc4a..b8b2881 100644
--- a/asl/status_or.hpp
+++ b/asl/status_or.hpp
@@ -2,6 +2,7 @@
 
 #include "asl/status.hpp"
 #include "asl/maybe_uninit.hpp"
+#include "asl/hash.hpp"
 
 namespace asl
 {
@@ -122,9 +123,6 @@ public:
 
     constexpr bool ok() const { return m_status.ok(); }
 
-    // NOLINTNEXTLINE(*-explicit-conversions)
-    constexpr operator bool() const { return m_status; }
-
     constexpr status_code code() const { return m_status.code(); }
     
     constexpr string_view message() const { return m_status.message(); }
@@ -161,6 +159,17 @@ public:
     {
         return ok() ? ASL_MOVE(value()) : static_cast<T>(ASL_FWD(other_value));
     }
+
+    template<typename H>
+    requires hashable<T>
+    friend H AslHashValue(H h, const status_or& s)
+    {
+        if (s.ok())
+        {
+            return H::combine(ASL_MOVE(h), s.m_status, s.value());
+        }
+        return H::combine(ASL_MOVE(h), s.m_status);
+    }
 };
 
 template<typename T>
diff --git a/asl/tests/hash_tests.cpp b/asl/tests/hash_tests.cpp
index 1ef051e..6098102 100644
--- a/asl/tests/hash_tests.cpp
+++ b/asl/tests/hash_tests.cpp
@@ -3,6 +3,10 @@
 #include "asl/string_view.hpp"
 #include "asl/string.hpp"
 #include "asl/buffer.hpp"
+#include "asl/box.hpp"
+#include "asl/option.hpp"
+#include "asl/status.hpp"
+#include "asl/status_or.hpp"
 
 static_assert(!asl::hashable<int*>);
 static_assert(!asl::hashable<int[]>);
@@ -57,6 +61,7 @@ ASL_TEST(strings)
 }
 
 static_assert(asl::hashable<asl::span<const int>>);
+static_assert(!asl::hashable<asl::span<const int*>>);
 static_assert(asl::hashable<asl::span<asl::string_view>>);
 
 ASL_TEST(span)
@@ -81,6 +86,7 @@ ASL_TEST(span)
 }
 
 static_assert(asl::hashable<asl::buffer<int>>);
+static_assert(!asl::hashable<asl::buffer<int*>>);
 
 ASL_TEST(buffer)
 {
@@ -137,6 +143,118 @@ enum class Enum2 {};
 static_assert(asl::hashable<Enum1>);
 static_assert(asl::hashable<Enum2>);
 
-// @Todo option (optimize uniquely_represented + has_niche)
-// @Todo status, status_or
-// @Todo box
+static_assert(!asl::hashable<asl::box<int*>>);
+static_assert(asl::hashable<asl::box<asl::string_view>>);
+
+ASL_TEST(box)
+{
+    auto b1 = asl::make_box<asl::string_view>("Hello, world!");
+    auto b2 = asl::make_box<asl::string_view>("Hello, world!");
+    auto b3 = asl::make_box<asl::string_view>("Hello, world! 2");
+
+    ASL_TEST_EXPECT(asl::hash_value(b1) == asl::hash_value(b2));
+    ASL_TEST_EXPECT(asl::hash_value(b1) != asl::hash_value(b3));
+    ASL_TEST_EXPECT(asl::hash_value(b1) == asl::hash_value("Hello, world!"_sv));
+}
+
+struct NonZero
+{
+    int value;
+
+    constexpr explicit NonZero(int x) : value(x)
+    {
+        ASL_ASSERT(x != 0);
+    }
+
+    constexpr explicit NonZero(asl::niche_t) : value(0) {}
+
+    constexpr bool operator==(asl::niche_t) const { return value == 0; }
+};
+
+namespace asl { template<> struct is_uniquely_represented<NonZero> : true_type {}; }
+static_assert(asl::has_niche<NonZero>);
+static_assert(asl::uniquely_represented<NonZero>);
+
+static_assert(asl::hashable<asl::option<int>>);
+static_assert(!asl::hashable<asl::option<int*>>);
+static_assert(asl::hashable<asl::option<asl::string_view>>);
+static_assert(asl::hashable<asl::option<NonZero>>);
+static_assert(asl::uniquely_represented<asl::option<NonZero>>);
+
+ASL_TEST(option)
+{
+    asl::option<int> int1 = 0;
+    asl::option<int> int2 = 0;
+    asl::option<int> int3 = 1;
+    asl::option<int> int4 = asl::nullopt;
+
+    ASL_TEST_EXPECT(asl::hash_value(int1) == asl::hash_value(int2));
+    ASL_TEST_EXPECT(asl::hash_value(int1) != asl::hash_value(int3));
+    ASL_TEST_EXPECT(asl::hash_value(int1) != asl::hash_value(int4));
+
+    asl::option<NonZero> noz1{8};
+    asl::option<NonZero> noz2{8};
+    asl::option<NonZero> noz3{9};
+    asl::option<NonZero> noz4 = asl::nullopt;
+
+    ASL_TEST_EXPECT(asl::hash_value(noz1) == asl::hash_value(noz2));
+    ASL_TEST_EXPECT(asl::hash_value(noz1) != asl::hash_value(noz3));
+    ASL_TEST_EXPECT(asl::hash_value(noz1) != asl::hash_value(noz4));
+}
+
+static_assert(asl::hashable<asl::status>);
+
+ASL_TEST(status)
+{
+    asl::status s1 = asl::ok();
+    asl::status s2 = asl::ok();
+    asl::status s3 = asl::internal_error();
+    asl::status s4 = asl::internal_error();
+    asl::status s5 = asl::runtime_error();
+    asl::status s6 = asl::internal_error("Oh, no!");
+    asl::status s7 = asl::internal_error("Oh, no!");
+    asl::status s8 = asl::internal_error("Oh, no");
+    asl::status s9 = asl::runtime_error("Oh, no!");
+
+    ASL_TEST_EXPECT(asl::hash_value(s1) == asl::hash_value(s2));
+    ASL_TEST_EXPECT(asl::hash_value(s3) == asl::hash_value(s4));
+    ASL_TEST_EXPECT(asl::hash_value(s6) == asl::hash_value(s7));
+    
+    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s3));
+    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s5));
+    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s6));
+    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s9));
+    
+    ASL_TEST_EXPECT(asl::hash_value(s3) != asl::hash_value(s5));
+    ASL_TEST_EXPECT(asl::hash_value(s3) != asl::hash_value(s6));
+    ASL_TEST_EXPECT(asl::hash_value(s3) != asl::hash_value(s8));
+    ASL_TEST_EXPECT(asl::hash_value(s3) != asl::hash_value(s9));
+    
+    ASL_TEST_EXPECT(asl::hash_value(s6) != asl::hash_value(s8));
+    ASL_TEST_EXPECT(asl::hash_value(s6) != asl::hash_value(s9));
+}
+
+static_assert(asl::hashable<asl::status_or<int>>);
+static_assert(asl::hashable<asl::status_or<asl::string_view>>);
+static_assert(!asl::hashable<asl::status_or<int*>>);
+
+ASL_TEST(status_or)
+{
+    asl::status_or<int> s1 = 42;
+    asl::status_or<int> s2 = 42;
+    asl::status_or<int> s3 = 43;
+    asl::status_or<int> s4 = asl::runtime_error();
+    asl::status_or<int> s5 = asl::runtime_error();
+    asl::status_or<int> s6 = asl::runtime_error("Hello");
+    asl::status_or<int> s7 = asl::runtime_error("Hello");
+
+    ASL_TEST_EXPECT(asl::hash_value(s1) == asl::hash_value(s2));
+    ASL_TEST_EXPECT(asl::hash_value(s4) == asl::hash_value(s5));
+    ASL_TEST_EXPECT(asl::hash_value(s6) == asl::hash_value(s7));
+    
+    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s3));
+    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s4));
+    ASL_TEST_EXPECT(asl::hash_value(s1) != asl::hash_value(s6));
+    
+    ASL_TEST_EXPECT(asl::hash_value(s4) != asl::hash_value(s6));
+}
diff --git a/asl/tests/status_or_tests.cpp b/asl/tests/status_or_tests.cpp
index 5038e7e..e792270 100644
--- a/asl/tests/status_or_tests.cpp
+++ b/asl/tests/status_or_tests.cpp
@@ -18,7 +18,6 @@ ASL_TEST(ok)
 {
     asl::status_or<int> s = 6;
     ASL_TEST_EXPECT(s.ok());
-    ASL_TEST_EXPECT(s);
     ASL_TEST_EXPECT(s.code() == asl::status_code::ok);
 }
 
@@ -26,19 +25,16 @@ ASL_TEST(from_status)
 {
     asl::status_or<char> s = asl::internal_error();
     ASL_TEST_EXPECT(!s.ok());
-    ASL_TEST_EXPECT(!s);
     ASL_TEST_EXPECT(s.code() == asl::status_code::internal);
     ASL_TEST_EXPECT(s.message() == ""_sv);
     
     asl::status_or<int> s2 = asl::internal_error("oh no");
     ASL_TEST_EXPECT(!s2.ok());
-    ASL_TEST_EXPECT(!s2);
     ASL_TEST_EXPECT(s2.code() == asl::status_code::internal);
     ASL_TEST_EXPECT(s2.message() == "oh no"_sv);
     
     asl::status_or<int> s3 = asl::internal_error("{} {}", 1, 2);
     ASL_TEST_EXPECT(!s3.ok());
-    ASL_TEST_EXPECT(!s3);
     ASL_TEST_EXPECT(s3.code() == asl::status_code::internal);
     ASL_TEST_EXPECT(s3.message() == "1 2"_sv);
 }
diff --git a/asl/tests/status_tests.cpp b/asl/tests/status_tests.cpp
index 8ac6373..b598389 100644
--- a/asl/tests/status_tests.cpp
+++ b/asl/tests/status_tests.cpp
@@ -6,7 +6,6 @@
 ASL_TEST(simple_ok)
 {
     asl::status s = asl::ok();
-    ASL_TEST_ASSERT(s);
     ASL_TEST_ASSERT(s.ok());
     ASL_TEST_ASSERT(s.code() == asl::status_code::ok);
 }
@@ -14,7 +13,6 @@ ASL_TEST(simple_ok)
 ASL_TEST(simple_code)
 {
     asl::status s = asl::runtime_error();
-    ASL_TEST_ASSERT(!s);
     ASL_TEST_ASSERT(!s.ok());
     ASL_TEST_ASSERT(s.code() == asl::status_code::runtime);
     ASL_TEST_ASSERT(s.message() == ""_sv);
@@ -23,7 +21,6 @@ ASL_TEST(simple_code)
 ASL_TEST(with_message)
 {
     asl::status s = asl::internal_error("We done goofed");
-    ASL_TEST_ASSERT(!s);
     ASL_TEST_ASSERT(!s.ok());
     ASL_TEST_ASSERT(s.code() == asl::status_code::internal);
     ASL_TEST_ASSERT(s.message() == "We done goofed"_sv);
@@ -47,25 +44,21 @@ ASL_TEST(copy_message)
 
     {
         asl::status s = asl::internal_error("Oh no!");
-        ASL_TEST_ASSERT(!s);
         ASL_TEST_ASSERT(!s.ok());
         ASL_TEST_ASSERT(s.code() == asl::status_code::internal);
         ASL_TEST_ASSERT(s.message() == "Oh no!"_sv);
 
         const asl::status s3{s}; // NOLINT
-        ASL_TEST_ASSERT(!s3);
         ASL_TEST_ASSERT(!s3.ok());
         ASL_TEST_ASSERT(s3.code() == asl::status_code::internal);
         ASL_TEST_ASSERT(s3.message() == "Oh no!"_sv);
 
         s2 = s;
-        ASL_TEST_ASSERT(!s2);
         ASL_TEST_ASSERT(!s2.ok());
         ASL_TEST_ASSERT(s2.code() == asl::status_code::internal);
         ASL_TEST_ASSERT(s2.message() == "Oh no!"_sv);
     }
 
-    ASL_TEST_ASSERT(!s2);
     ASL_TEST_ASSERT(!s2.ok());
     ASL_TEST_ASSERT(s2.code() == asl::status_code::internal);
     ASL_TEST_ASSERT(s2.message() == "Oh no!"_sv);
-- 
cgit