Simplified dispatch iface

Author: patrickroberts

README.md

@@ -63,8 +63,8 @@ int main() {
   - `composes<Affordances...>`
   - `chooses<Affordances...>`
   - `destructible`
-  - `move_constructible`
-  - `copy_constructible`
+  - `movable`
+  - `copyable`
   - `extractable<In>`
   - `insertable<Out>`
   - `allocator_storage<Allocator>`

include/simply/copyable.hpp

@@ -1,11 +1,11 @@
 #ifndef SIMPLY_COPYABLE_HPP
 #define SIMPLY_COPYABLE_HPP
 
-#include <simply/movable.hpp>
+#include <simply/type_traits.hpp>
 
 namespace simply {
 
-struct copy_constructible : simply::copy_affordance_base {
+struct copyable : simply::copy_affordance_base {
   template <typename T>
     requires std::is_copy_constructible_v<T>
   static constexpr auto fn(const std::type_identity_t<T> &self) noexcept(
@@ -14,9 +14,6 @@ struct copy_constructible : simply::copy_affordance_base {
   }
 };
 
-struct copyable
-    : simply::composes<simply::copy_constructible, simply::movable> {};
-
 } // namespace simply
 
 #endif // SIMPLY_COPYABLE_HPP

include/simply/dispatch.hpp

@@ -8,24 +8,12 @@
 
 namespace simply {
 
-struct indirect_dispatch : simply::dispatch_affordance_base {
-  template <simply::affordance Affordance>
-  struct type : simply::affordance_base {
-    using affordance_type = Affordance;
-  };
-};
+struct indirect_dispatch : simply::dispatch_affordance_base {};
 
-struct inplace_dispatch : simply::dispatch_affordance_base {
-  template <simply::affordance Affordance>
-  struct type : simply::affordance_base {
-    using affordance_type = Affordance;
-  };
-};
+struct inplace_dispatch : simply::dispatch_affordance_base {};
 
-template <simply::specialization_of<simply::indirect_dispatch::type> Dispatch,
-          typename Self>
-  requires simply::affordance<Dispatch>
-struct iface<Dispatch, Self> {
+template <typename Self>
+struct iface<simply::indirect_dispatch, Self> {
   template <typename T>
   constexpr iface([[maybe_unused]] std::in_place_type_t<T> tag)
       : vtable_ptr(
@@ -44,16 +32,14 @@ struct iface<Dispatch, Self> {
     return static_cast<const base_type &>(*vtable_ptr).fn;
   }
 
-  using affordance_type = Dispatch::affordance_type;
+  using affordance_type = simply::affordance_type_t<Self>;
   using vtable_type = simply::vtable<affordance_type, Self>;
 
   const vtable_type *vtable_ptr;
 };
 
-template <simply::specialization_of<simply::inplace_dispatch::type> Dispatch,
-          typename Self>
-  requires simply::affordance<Dispatch>
-struct iface<Dispatch, Self> {
+template <typename Self>
+struct iface<simply::inplace_dispatch, Self> {
   template <typename T>
   constexpr iface([[maybe_unused]] std::in_place_type_t<T> tag)
       : vtable(simply::vtable_for<affordance_type, Self, T>) {}
@@ -71,7 +57,7 @@ struct iface<Dispatch, Self> {
     return static_cast<const base_type &>(vtable).fn;
   }
 
-  using affordance_type = Dispatch::affordance_type;
+  using affordance_type = simply::affordance_type_t<Self>;
   using vtable_type = simply::vtable<affordance_type, Self>;
 
   vtable_type vtable;

include/simply/dyn.hpp

@@ -22,11 +22,10 @@ class dyn
     : public simply::iface<Affordance,
                            simply::dyn<Affordance, Storage, Dispatch>>,
       public simply::iface<Storage, simply::dyn<Affordance, Storage, Dispatch>>,
-      public simply::iface<typename Dispatch::template type<Affordance>,
+      public simply::iface<Dispatch,
                            simply::dyn<Affordance, Storage, Dispatch>> {
   using storage_base = simply::iface<Storage, dyn>;
-  using dispatch_base =
-      simply::iface<typename Dispatch::template type<Affordance>, dyn>;
+  using dispatch_base = simply::iface<Dispatch, dyn>;
 
 public:
   using affordance_type = Affordance;
@@ -102,6 +101,11 @@ using dyn = simply::dyn<Affordance, simply::pmr::polymorphic_allocator_storage,
 
 } // namespace pmr
 
+template <typename Affordance, typename Storage, typename Dispatch>
+struct affordance_type<simply::dyn<Affordance, Storage, Dispatch>> {
+  using type = Affordance;
+};
+
 template <simply::member_affordance Affordance,
           simply::specialization_of<simply::dyn> Dyn, typename R, typename Self,
           typename... Args, bool NoExcept>

include/simply/elide.hpp

@@ -39,7 +39,7 @@ class elide {
   template <typename U>
   void operator,(U &&) = delete;
 
-  constexpr ~elide() = default;
+  ~elide() = default;
 };
 
 template <typename F>

include/simply/movable.hpp

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

include/simply/storage.hpp

@@ -21,6 +21,7 @@ struct allocator_storage : simply::storage_affordance_base {
   using void_pointer = traits::void_pointer;
   using const_void_pointer = traits::const_void_pointer;
 
+  // TODO express this by dispatching directly from iface to reduce boilerplate
   template <typename T>
   struct fn_t {
     using rebound = traits::template rebind_traits<T>;
@@ -103,10 +104,10 @@ struct iface<Storage, Self> {
       : alloc(), object_ptr(_construct_with(simply::_rebind_alloc<T>(alloc),
                                             std::forward<Args>(args)...)) {}
 
-  constexpr auto operator=(const iface &other) -> iface & = delete;
-  constexpr auto operator=(iface &&other) noexcept -> iface & = delete;
+  auto operator=(const iface &other) -> iface & = default;
+  auto operator=(iface &&other) noexcept -> iface & = default;
 
-  constexpr ~iface() noexcept = default;
+  ~iface() = default;
 
   [[nodiscard]] constexpr auto get_allocator() const noexcept
       -> allocator_type {

include/simply/type_traits.hpp

@@ -27,6 +27,12 @@ struct dispatch_affordance_base : simply::affordance_base {};
 template <typename Affordance, typename T>
 struct affordance_traits;
 
+template <typename T>
+struct affordance_type;
+
+template <typename T>
+using affordance_type_t = affordance_type<T>::type;
+
 template <typename Affordance, typename T,
           typename Fn = affordance_traits<Affordance, T>::function_type>
 struct impl;

tests/counters.cpp

@@ -1,4 +1,5 @@
 #include <simply/copyable.hpp>
+#include <simply/destructible.hpp>
 #include <simply/dyn.hpp>
 
 #include <algorithm>
@@ -8,14 +9,14 @@
 // example of a class with a label that counts how many times it is copied
 template <char Label>
 struct counter {
-  constexpr counter() = default;
+  counter() = default;
   constexpr counter(const counter &other) : copied(other.copied + 1) {}
   counter(counter &&other) = delete;
 
   auto operator=(const counter &) -> counter & = delete;
   auto operator=(counter &&) -> counter & = delete;
 
-  constexpr ~counter() = default;
+  ~counter() = default;
 
   [[nodiscard]] constexpr auto copy_count() const { return copied; }
   [[nodiscard]] constexpr auto label() const { return Label; }
@@ -59,9 +60,9 @@ struct simply::iface<labeled<LabelT>, Self> {
 
 // test dyn<countable> at compile-time
 static_assert([] {
-  struct countable
-      : simply::composes<copy_countable<int>, labeled<char>,
-                         simply::copy_constructible, simply::destructible> {};
+  struct countable : simply::composes<copy_countable<int>, labeled<char>,
+                                      simply::copyable, simply::destructible> {
+  };
 
   // initialize a vector of dyn<countable> with three different counter types
   std::vector<simply::dyn<countable>> v;