Support C++23 monadic operators in OptionalRef

.bazelrc

@@ -50,3 +50,5 @@ build:clang --copt -Wno-used-but-marked-unused
 build:clang --copt -Wno-switch-default
 #
 build:clang --copt -Wno-poison-system-directories
+build:clang --copt -Wno-unknown-warning-option
+build:clang --copt -Wno-nrvo

include/fixed_containers/optional_reference.hpp

@@ -5,6 +5,7 @@
 #include "fixed_containers/source_location.hpp"
 
 #include <compare>
+#include <functional>
 #include <memory>
 #include <optional>
 #include <type_traits>
@@ -27,6 +28,9 @@ class OptionalReference
     using pointer = T*;
     using const_pointer = T*;
     using BackingType = pointer;
+    template <class F, class Ref>
+    using TransformResultType =
+        OptionalReference<std::remove_reference_t<std::invoke_result_t<F, Ref>>>;
 
 public:
     // Needed for structural type
@@ -144,6 +148,124 @@ class OptionalReference
         return val;
     }
 
+    template <class F>
+    constexpr std::invoke_result_t<F, reference> and_then(F&& func) &
+    {
+        if (has_value())
+        {
+            return std::invoke(std::forward<F>(func), *val());
+        }
+        return std::invoke_result_t<F, reference>{};
+    }
+
+    template <class F>
+    constexpr std::invoke_result_t<F, const_reference> and_then(F&& func) const&
+    {
+        if (has_value())
+        {
+            return std::invoke(std::forward<F>(func), *val());
+        }
+        return std::invoke_result_t<F, const_reference>{};
+    }
+
+    template <class F>
+    constexpr std::invoke_result_t<F, reference> and_then(F&& func) &&
+    {
+        if (has_value())
+        {
+            return std::invoke(std::forward<F>(func), *val());
+        }
+        return std::invoke_result_t<F, reference>{};
+    }
+
+    template <class F>
+    constexpr std::invoke_result_t<F, const_reference> and_then(F&& func) const&&
+    {
+        if (has_value())
+        {
+            return std::invoke(std::forward<F>(func), *val());
+        }
+        return std::invoke_result_t<F, const_reference>{};
+    }
+
+    template <class F>
+    constexpr TransformResultType<F, reference> transform(F&& func) &
+    {
+        using InvokeResult = std::invoke_result_t<F, reference>;
+        static_assert(std::is_reference_v<InvokeResult>,
+                      "transform() function must return a reference for OptionalReference");
+        using ResultValueType = std::remove_reference_t<InvokeResult>;
+        if (has_value())
+        {
+            return OptionalReference<ResultValueType>(std::invoke(std::forward<F>(func), *val()));
+        }
+        return OptionalReference<ResultValueType>{};
+    }
+
+    template <class F>
+    constexpr TransformResultType<F, const_reference> transform(F&& func) const&
+    {
+        using InvokeResult = std::invoke_result_t<F, const_reference>;
+        static_assert(std::is_reference_v<InvokeResult>,
+                      "transform() function must return a reference for OptionalReference");
+        using ResultValueType = std::remove_reference_t<InvokeResult>;
+        if (has_value())
+        {
+            return OptionalReference<ResultValueType>(std::invoke(std::forward<F>(func), *val()));
+        }
+        return OptionalReference<ResultValueType>{};
+    }
+
+    template <class F>
+    constexpr TransformResultType<F, reference> transform(F&& func) &&
+    {
+        using InvokeResult = std::invoke_result_t<F, reference>;
+        static_assert(std::is_reference_v<InvokeResult>,
+                      "transform() function must return a reference for OptionalReference");
+        using ResultValueType = std::remove_reference_t<InvokeResult>;
+        if (has_value())
+        {
+            return OptionalReference<ResultValueType>(std::invoke(std::forward<F>(func), *val()));
+        }
+        return OptionalReference<ResultValueType>{};
+    }
+
+    template <class F>
+    constexpr TransformResultType<F, const_reference> transform(F&& func) const&&
+    {
+        using InvokeResult = std::invoke_result_t<F, const_reference>;
+        static_assert(std::is_reference_v<InvokeResult>,
+                      "transform() function must return a reference for OptionalReference");
+        using ResultValueType = std::remove_reference_t<InvokeResult>;
+        if (has_value())
+        {
+            return OptionalReference<ResultValueType>(std::invoke(std::forward<F>(func), *val()));
+        }
+        return OptionalReference<ResultValueType>{};
+    }
+
+    template <class F>
+    constexpr Self or_else(F&& func) const&
+        requires std::is_same_v<std::invoke_result_t<F>, Self>
+    {
+        if (has_value())
+        {
+            return *this;
+        }
+        return std::invoke(std::forward<F>(func));
+    }
+
+    template <class F>
+    constexpr Self or_else(F&& func) &&
+        requires std::is_same_v<std::invoke_result_t<F>, Self>
+    {
+        if (has_value())
+        {
+            return std::move(*this);
+        }
+        return std::invoke(std::forward<F>(func));
+    }
+
 private:
     [[nodiscard]] constexpr const BackingType& val() const
     {

test/fixed_deque_test.cpp

@@ -13,6 +13,7 @@
 
 #include <algorithm>
 #include <array>
+#include <concepts>
 #include <cstddef>
 #include <deque>
 #include <initializer_list>

test/fixed_map_test.cpp

@@ -16,6 +16,7 @@
 #include <algorithm>
 #include <array>
 #include <cmath>
+#include <concepts>
 #include <cstddef>
 #include <functional>
 #include <iterator>

test/fixed_string_test.cpp

@@ -10,6 +10,7 @@
 
 #include <algorithm>
 #include <array>
+#include <concepts>
 #include <cstddef>
 #include <iterator>
 #include <span>
@@ -1910,7 +1911,7 @@ TEST(FixedString, AppendTruncating)
     constexpr auto VAL1 = []()
     {
         FixedString<4> out{"1"};
-        std::string_view view{"2345678"};
+        const std::string_view view{"2345678"};
         append_truncating(out, view);
         return out;
     }();

test/fixed_unordered_map_test.cpp

@@ -17,6 +17,7 @@
 #include <algorithm>
 #include <array>
 #include <cmath>
+#include <concepts>
 #include <cstddef>
 #include <iterator>
 #include <memory>

test/fixed_vector_test.cpp

@@ -13,6 +13,7 @@
 
 #include <algorithm>
 #include <array>
+#include <concepts>
 #include <cstddef>
 #include <iterator>
 #include <memory>