ref partial

Author: ConorWilliams

include/libfork/ev.hpp

@@ -75,4 +75,20 @@ class ev<T> : detail::immovable<ev<T>> {
   T m_value;
 };
 
+/**
+ * @brief A specialisation of `ev` for reference types.
+ */
+template <typename T>
+  requires std::is_reference_v<T>
+class ev<T> {
+ public:
+  template <typename Self>
+  [[nodiscard]] constexpr auto operator*(this Self &&self) noexcept -> auto && {
+    return std::forward_like<Self>(*self.m_ptr);
+  }
+
+ private:
+  std::add_pointer_t<std::remove_reference_t<T>> m_ptr;
+};
+
 } // namespace lf

test/src/test_ev.cpp

@@ -1,23 +1,57 @@
 
-#include <string>
+#include <type_traits>
 
 #include <catch2/catch_template_test_macros.hpp>
 #include <catch2/catch_test_macros.hpp>
 
 #include "libfork/ev.hpp"
 
-TEMPLATE_TEST_CASE("Eventually operator *", "[ev]", int, std::string) {
+namespace {
+
+template <typename T>
+concept good_deref = requires (lf::ev<T> val, T ref) {
+  { *val } -> std::same_as<decltype((ref))>;
+};
+
+template <typename T>
+struct add_const : std::type_identity<T const> {};
+
+template <typename T>
+struct add_const<T &> : std::type_identity<T const &> {};
+
+template <typename T>
+struct add_const<T &&> : std::type_identity<T const &&> {};
+
+template <typename T>
+concept good_decref = requires (lf::ev<T> const val, typename add_const<T>::type ref) {
+  { *val } -> std::same_as<decltype((ref))>;
+};
+
+struct nt {
+  nt() {}
+};
+
+static_assert(!lf::trivial_return<nt>);
+
+} // namespace
+
+TEMPLATE_TEST_CASE("Ev operator *", "[ev]", nt, int, int &, int &&, int const &, int const &&) {
+
+  using U = std::remove_reference_t<TestType>;
+
+  static_assert(good_deref<TestType>);
+  static_assert(good_decref<TestType>);
 
   lf::ev<TestType> val{};
-  static_assert(std::same_as<decltype(*val), TestType &>);
-  static_assert(std::same_as<decltype(*std::move(val)), TestType &&>);
+  static_assert(std::same_as<decltype(*val), U &>);
+  static_assert(std::same_as<decltype(*std::move(val)), U &&>);
 
   lf::ev<TestType> const cval{};
-  static_assert(std::same_as<decltype(*cval), TestType const &>);
-  static_assert(std::same_as<decltype(*std::move(cval)), TestType const &&>);
+  static_assert(std::same_as<decltype(*cval), U const &>);
+  static_assert(std::same_as<decltype(*std::move(cval)), U const &&>);
 }
 
-TEMPLATE_TEST_CASE("Eventually operator ->", "[ev]", int, std::string) {
+TEMPLATE_TEST_CASE("Eventually operator ->", "[ev]", nt, int) {
 
   lf::ev<TestType> val{};
   static_assert(std::same_as<decltype(val.operator->()), TestType *>);