behaves like builtin

Author: ConorWilliams

include/libfork/ev.hpp

@@ -1,10 +1,12 @@
 #pragma once
 
+#include <concepts>
 #include <memory>
 #include <optional>
 #include <type_traits>
 #include <utility>
 
+#include "libfork/macros/assert.hpp"
 #include "libfork/macros/utility.hpp"
 #include "libfork/utility.hpp"
 
@@ -22,8 +24,7 @@ namespace lf {
  * @tparam T The type to test.
  */
 template <typename T>
-concept trivial_return =
-    std::is_trivially_default_constructible_v<T> && std::is_trivially_destructible_v<T>;
+concept trivial_return = std::default_initializable<T> && std::is_trivially_destructible_v<T>;
 
 /**
  * @brief A wrapper for return values from libfork's coroutines.
@@ -43,14 +44,14 @@ class ev : detail::immovable<ev<T>> {
   template <typename Self>
   [[nodiscard]] constexpr auto operator->(this Self &self) LF_HOF_RETURNS(self.m_value.operator->())
 
- private:
   template <typename... Args>
     requires std::constructible_from<T, Args...>
   constexpr void emplace(Args &&...args) & {
     LF_ASSERT(!m_value.has_value());
     m_value.emplace(std::forward<Args>(args)...);
   }
 
+ private:
   std::optional<T> m_value;
 };
 
@@ -76,9 +77,9 @@ class ev<T> : detail::immovable<ev<T>> {
   //   return std::addressof(m_value);
   // }
 
- private:
   constexpr auto get() & -> T * { return std::addressof(m_value); }
 
+ private:
   T m_value;
 };
 

test/src/test_ev.cpp

@@ -1,4 +1,5 @@
 
+#include <memory>
 #include <type_traits>
 
 #include <catch2/catch_template_test_macros.hpp>
@@ -8,56 +9,68 @@
 
 namespace {
 
-template <typename T>
-concept good_deref = requires (lf::ev<T> val, T ref) {
+template <typename T, typename Ref>
+concept deref_like = requires (T val, Ref ref) {
   { *val } -> std::same_as<decltype((ref))>;
+  { *std::move(val) } -> std::same_as<decltype(std::move(ref))>;
 };
 
-template <typename T>
-struct add_const : std::type_identity<T const> {};
+struct non_trivial {
+  constexpr ~non_trivial() {}
+};
 
-template <typename T>
-struct add_const<T &> : std::type_identity<T const &> {};
+static_assert(!lf::trivial_return<non_trivial>);
 
-template <typename T>
-struct add_const<T &&> : std::type_identity<T const &&> {};
+consteval auto const_test() -> bool {
 
-template <typename T>
-concept good_decref = requires (lf::ev<T> const val, typename add_const<T>::type ref) {
-  { *val } -> std::same_as<decltype((ref))>;
-};
+  {
+    lf::ev<non_trivial const> x;
+    x.emplace();
+  }
 
-struct nt {
-  nt() {}
-};
+  {
+    lf::ev<int> x;
+    int const *p = x.get();
+    std::construct_at(p, 3);
+  }
 
-static_assert(!lf::trivial_return<nt>);
+  return true;
+}
 
 } // namespace
 
-TEMPLATE_TEST_CASE("Ev operator *", "[ev]", nt, int, int &, int &&, int const &, int const &&) {
+TEST_CASE("Ev constexpr tests", "[ev]") { REQUIRE(const_test()); }
 
-  using U = std::remove_reference_t<TestType>;
+TEMPLATE_TEST_CASE("Ev operator *", "[ev]", non_trivial, int) {
 
-  static_assert(good_deref<TestType>);
-  static_assert(good_decref<TestType>);
+  using lf::ev;
 
-  lf::ev<TestType> val{};
-  static_assert(std::same_as<decltype(*val), U &>);
-  static_assert(std::same_as<decltype(*std::move(val)), U &&>);
+  static_assert(deref_like<ev<TestType>, TestType>);
+  static_assert(deref_like<ev<TestType> const, TestType const>);
 
-  lf::ev<TestType> const cval{};
-  static_assert(std::same_as<decltype(*cval), U const &>);
-  static_assert(std::same_as<decltype(*std::move(cval)), U const &&>);
+  static_assert(deref_like<ev<TestType const>, TestType const>);
+  static_assert(deref_like<ev<TestType const> const, TestType const>);
+
+  static_assert(deref_like<ev<TestType &>, TestType &>);
+  static_assert(deref_like<ev<TestType &> const, TestType const &>);
+
+  static_assert(deref_like<ev<TestType const &>, TestType const &>);
+  static_assert(deref_like<ev<TestType const &> const, TestType const &>);
+
+  static_assert(deref_like<ev<TestType &&>, TestType &&>);
+  static_assert(deref_like<ev<TestType &&> const, TestType const &&>);
+
+  static_assert(deref_like<ev<TestType const &&>, TestType const &&>);
+  static_assert(deref_like<ev<TestType const &&> const, TestType const &&>);
 }
 
-TEMPLATE_TEST_CASE("Eventually operator ->", "[ev]", nt, int, int &) {
+TEMPLATE_TEST_CASE("Eventually operator ->", "[ev]", non_trivial, non_trivial &, int, int &) {
 
-  using U = std::remove_reference_t<TestType>;
+  using deref = std::remove_reference_t<TestType>;
 
   lf::ev<TestType> val{};
-  static_assert(std::same_as<decltype(val.operator->()), U *>);
+  static_assert(std::same_as<decltype(val.operator->()), deref *>);
 
   lf::ev<TestType> const cval{};
-  static_assert(std::same_as<decltype(cval.operator->()), U const *>);
+  static_assert(std::same_as<decltype(cval.operator->()), deref const *>);
 }