Exclude destruction from construction contraints

Author: patrickroberts

include/simply/concepts.hpp

@@ -81,6 +81,33 @@ concept fundamental_destroy_mixin =
 template <typename T, typename U>
 concept different_from = not std::same_as<T, U>;
 
+// std::is_constructible requires destruction to be well-formed
+template <typename T, typename... Args>
+concept constructible_from =
+    requires(void *location) { ::new (location) T(std::declval<Args>()...); };
+
+// std::is_nothrow_constructible requires destruction to be well-formed
+template <typename T, typename... Args>
+concept nothrow_constructible_from = requires(void *location) {
+  { ::new (location) T(std::declval<Args>()...) } noexcept;
+};
+
+template <typename T>
+concept default_constructible = simply::constructible_from<T>;
+
+template <typename T>
+concept copy_constructible = simply::constructible_from<T, const T &>;
+
+template <typename T>
+concept nothrow_copy_constructible =
+    simply::nothrow_constructible_from<T, const T &>;
+
+template <typename T>
+concept move_constructible = simply::constructible_from<T, T>;
+
+template <typename T>
+concept nothrow_move_constructible = simply::nothrow_constructible_from<T, T>;
+
 template <simply::composition Composition, typename T>
 inline constexpr bool enable_mixin_for<Composition, T> =
     simply::enable_mixin_for<simply::unique_fundamental_t<Composition>, T>;

include/simply/copyable.hpp

@@ -1,15 +1,14 @@
 #ifndef SIMPLY_COPYABLE_HPP
 #define SIMPLY_COPYABLE_HPP
 
-#include <simply/type_traits.hpp>
+#include <simply/concepts.hpp>
 
 namespace simply {
 
 struct copyable : simply::copy_base {
-  template <typename T>
-    requires std::is_copy_constructible_v<T>
+  template <simply::copy_constructible T>
   static constexpr auto fn(const std::type_identity_t<T> &self) noexcept(
-      std::is_nothrow_copy_constructible_v<T>) -> T {
+      simply::nothrow_copy_constructible<T>) -> T {
     return self;
   }
 };

include/simply/destructible.hpp

@@ -8,8 +8,10 @@
 namespace simply {
 
 struct destructible : simply::destroy_base {
-  template <std::destructible T>
-  static constexpr void fn(std::type_identity_t<T> &self) noexcept {
+  template <typename T>
+    requires std::is_destructible_v<T>
+  static constexpr void fn(std::type_identity_t<T> &self) noexcept(
+      std::is_nothrow_destructible_v<T>) {
     if constexpr (not std::is_trivially_destructible_v<T>) {
       std::destroy_at(std::addressof(self));
     }

include/simply/dyn.hpp

@@ -32,36 +32,42 @@ class dyn
   // TODO add default constructor for nullable mixin
 
   // TODO generalize member constraints based on storage
+  dyn(const dyn &other) = delete;
   constexpr dyn(const dyn &other)
     requires simply::copy_mixin<Mixin>
   = default;
 
-  constexpr dyn(dyn &&other) noexcept = default;
+  dyn(dyn &&other) = delete;
+  constexpr dyn(dyn &&other) noexcept
+    requires simply::move_mixin<Mixin>
+  = default;
 
   template <typename Alloc, simply::has_mixin<Mixin> T, typename... Args>
-    requires std::constructible_from<T, Args...>
+    requires simply::constructible_from<T, Args...>
   constexpr explicit dyn(std::allocator_arg_t alloc_tag, const Alloc &alloc,
                          std::in_place_type_t<T> obj_tag, Args &&...args)
       : storage_base(alloc_tag, alloc, obj_tag, std::forward<Args>(args)...),
         dispatch_base(obj_tag) {}
 
   template <simply::has_mixin<Mixin> T, typename... Args>
-    requires std::constructible_from<T, Args...>
+    requires simply::constructible_from<T, Args...>
   constexpr explicit dyn(std::in_place_type_t<T> tag, Args &&...args)
       : storage_base(tag, std::forward<Args>(args)...), dispatch_base(tag) {}
 
   template <typename T>
     requires(not std::same_as<std::remove_cvref_t<T>, dyn>) and
                 (not simply::specialization_of<std::remove_cvref_t<T>,
                                                std::in_place_type_t>) and
-                simply::has_mixin<std::decay_t<T>, Mixin>
+                simply::has_mixin<std::decay_t<T>, Mixin> and
+                simply::constructible_from<std::decay_t<T>, T>
   constexpr explicit dyn(T &&value)
       : storage_base(std::in_place_type<std::decay_t<T>>,
                      std::forward<T>(value)),
         dispatch_base(std::in_place_type<std::decay_t<T>>) {}
 
+  auto operator=(const dyn &other) -> dyn & = delete;
   constexpr auto operator=(const dyn &other) -> dyn &
-    requires simply::copy_mixin<Mixin>
+    requires simply::destroy_mixin<Mixin> and simply::copy_mixin<Mixin>
   {
     // prevent self-assignment
     if (this == std::addressof(other)) {
@@ -73,14 +79,18 @@ class dyn
     return *this;
   }
 
-  constexpr auto operator=(dyn &&other) noexcept -> dyn & {
+  auto operator=(dyn &&other) -> dyn & = delete;
+  constexpr auto operator=(dyn &&other) noexcept -> dyn &
+    requires simply::destroy_mixin<Mixin> and simply::move_mixin<Mixin>
+  {
     std::destroy_at(this);
     std::construct_at(this, std::move(other));
     return *this;
   }
 
   // TODO expose overloads for assignment mixins
 
+  ~dyn() = delete;
   constexpr ~dyn()
     requires simply::destroy_mixin<Mixin>
   {

include/simply/impl.hpp

@@ -34,6 +34,7 @@ template <typename Mixin>
 inline constexpr simply::_deduce_t<Mixin> fn<Mixin, simply::_deduce_tag_t>{};
 
 template <simply::member Mixin, typename T>
+  requires requires { Mixin::template fn<T>; }
 struct mixin_traits<Mixin, T> {
   using function_type = decltype(Mixin::template fn<T>);
 };

include/simply/movable.hpp

@@ -1,16 +1,16 @@
 #ifndef SIMPLY_MOVABLE_HPP
 #define SIMPLY_MOVABLE_HPP
 
-#include <simply/type_traits.hpp>
+#include <simply/concepts.hpp>
 
 #include <utility>
 
 namespace simply {
 
 struct movable : simply::move_base {
-  template <std::move_constructible T>
+  template <simply::move_constructible T>
   static constexpr auto fn(std::type_identity_t<T> &&self) noexcept(
-      std::is_nothrow_move_constructible_v<T>) -> T {
+      simply::nothrow_move_constructible<T>) -> T {
     return std::move(self);
   }
 };

tests/CMakeLists.txt

@@ -8,6 +8,9 @@ FetchContent_Declare(
 
 FetchContent_MakeAvailable(googletest)
 
+add_library(concepts concepts.cpp)
+target_link_libraries(concepts simply)
+
 add_library(counters counters.cpp)
 target_link_libraries(counters simply)
 

tests/concepts.cpp

@@ -0,0 +1,101 @@
+#include <simply/copyable.hpp>
+#include <simply/destructible.hpp>
+#include <simply/dyn.hpp>
+#include <simply/movable.hpp>
+
+struct semiregular {
+  semiregular();
+  semiregular(const semiregular &);
+  semiregular(semiregular &&) noexcept;
+
+  auto operator=(const semiregular &) -> semiregular &;
+  auto operator=(semiregular &&) noexcept -> semiregular &;
+
+  ~semiregular();
+};
+
+struct uncopyable {
+  uncopyable();
+  uncopyable(const uncopyable &) = delete;
+  uncopyable(uncopyable &&) noexcept;
+
+  auto operator=(const uncopyable &) -> uncopyable &;
+  auto operator=(uncopyable &&) noexcept -> uncopyable &;
+
+  ~uncopyable();
+};
+
+struct immovable {
+  immovable();
+  immovable(const immovable &);
+  immovable(immovable &&) = delete;
+
+  auto operator=(const immovable &) -> immovable &;
+  auto operator=(immovable &&) noexcept -> immovable &;
+
+  ~immovable();
+};
+
+struct indestructible {
+  indestructible();
+  indestructible(const indestructible &);
+  indestructible(indestructible &&) noexcept;
+
+  auto operator=(const indestructible &) -> indestructible &;
+  auto operator=(indestructible &&) noexcept -> indestructible &;
+
+  ~indestructible() = delete;
+};
+
+using unusable = simply::dyn<simply::composes<>>;
+using copyable = simply::dyn<simply::copyable>;
+using movable = simply::dyn<simply::movable>;
+using destructible = simply::dyn<simply::destructible>;
+
+template <typename T, typename U>
+concept constructible_from_in_place =
+    simply::constructible_from<T, std::in_place_type_t<U>>;
+
+static_assert(constructible_from_in_place<unusable, semiregular>);
+static_assert(constructible_from_in_place<unusable, uncopyable>);
+static_assert(constructible_from_in_place<unusable, immovable>);
+static_assert(constructible_from_in_place<unusable, indestructible>);
+
+static_assert(not simply::copy_constructible<unusable>);
+static_assert(not simply::move_constructible<unusable>);
+static_assert(not std::is_destructible_v<unusable>);
+
+static_assert(constructible_from_in_place<copyable, semiregular>);
+static_assert(not constructible_from_in_place<copyable, uncopyable>);
+static_assert(constructible_from_in_place<copyable, immovable>);
+// TODO reimplement copyable not to depend on destruction
+// clang is the only compiler that thinks it doesn't
+#if defined(__clang__)
+static_assert(constructible_from_in_place<copyable, indestructible>);
+#endif
+
+static_assert(simply::copy_constructible<copyable>);
+static_assert(not simply::move_constructible<copyable>);
+static_assert(not std::is_destructible_v<copyable>);
+
+static_assert(constructible_from_in_place<movable, semiregular>);
+static_assert(constructible_from_in_place<movable, uncopyable>);
+static_assert(not constructible_from_in_place<movable, immovable>);
+// TODO reimplement movable not to depend on destruction
+// clang is the only compiler that thinks it doesn't
+#if defined(__clang__)
+static_assert(constructible_from_in_place<movable, indestructible>);
+#endif
+
+static_assert(not simply::copy_constructible<movable>);
+static_assert(simply::move_constructible<movable>);
+static_assert(not std::is_destructible_v<movable>);
+
+static_assert(constructible_from_in_place<destructible, semiregular>);
+static_assert(constructible_from_in_place<destructible, uncopyable>);
+static_assert(constructible_from_in_place<destructible, immovable>);
+static_assert(not constructible_from_in_place<destructible, indestructible>);
+
+static_assert(not simply::copy_constructible<destructible>);
+static_assert(not simply::move_constructible<destructible>);
+static_assert(std::is_destructible_v<destructible>);