Refactored primary template enable_affordance_for

Author: patrickroberts

include/simply/dyn.hpp

@@ -12,6 +12,9 @@
 
 namespace simply {
 
+// TODO reconsider template parameters to avoid requiring user to explicitly
+// categorize affordances, or provide a type alias template to categorize them
+// and inject defaults. Rename to `basic_dyn`?
 template <simply::affordance Affordance,
           simply::storage_affordance Storage = simply::allocator_storage<>,
           simply::dispatch_affordance Dispatch = simply::indirect_dispatch>

include/simply/impl.hpp

@@ -7,15 +7,18 @@
 
 namespace simply {
 
-template <typename Affordance, typename T,
-          typename Fn = affordance_traits<Affordance, T>::function_type>
+template <typename Affordance, typename T, typename Fn>
 struct impl {
   static constexpr auto fn = Affordance::template fn<T>;
 };
 
 template <typename Affordance, typename T>
 inline constexpr const auto &fn = simply::impl<Affordance, T>::fn;
 
+// TODO consider `bind<Affordance>(self)(rest...)` as an alternative to
+// `fn<Affordance, remove_cvref_t<decltype(self)>>(self, rest...)` that exposes
+// operator() as an overload set with non-deduced parameter types
+
 template <simply::member_affordance Affordance, typename T>
 struct affordance_traits<Affordance, T> {
   using function_type = decltype(Affordance::template fn<T>);

include/simply/storage.hpp

@@ -73,7 +73,7 @@ struct iface<Storage, Self> {
   using void_pointer = traits::void_pointer;
   using const_void_pointer = traits::const_void_pointer;
 
-  // TODO use this->alloc instead of other.alloc to copy other->object_ptr
+  // BUG use this->alloc instead of other.alloc to copy other->object_ptr
   constexpr iface(const iface &other)
       : alloc(traits::select_on_container_copy_construction(other.alloc)),
         object_ptr(

include/simply/type_traits.hpp

@@ -27,6 +27,10 @@ struct dispatch_affordance_base : simply::affordance_base {};
 template <typename Affordance, typename T>
 struct affordance_traits;
 
+template <typename Affordance, typename T,
+          typename Fn = affordance_traits<Affordance, T>::function_type>
+struct impl;
+
 template <typename Affordance, typename Tag>
 struct fundamental_affordance_type {};
 
@@ -76,10 +80,9 @@ template <typename T>
 inline constexpr bool enable_affordance =
     std::derived_from<T, simply::affordance_base>;
 
-// TODO integrate this customization point with impl and/or affordance_traits
 template <typename Affordance, typename T>
 inline constexpr bool enable_affordance_for =
-    requires { &Affordance::template fn<T>; };
+    requires { simply::impl<Affordance, T>::fn; };
 
 template <typename T, typename Tag>
 inline constexpr bool enable_affordance_tag = std::derived_from<T, Tag>;

tests/counters.cpp

@@ -63,12 +63,8 @@ static_assert([] {
       : simply::composes<copy_countable<int>, labeled<char>,
                          simply::copy_constructible, simply::destructible> {};
 
-  using dyn = simply::dyn<countable>;
-  static_assert(requires {
-    typename simply::affordance_traits<copy_countable<int>, dyn>::function_type;
-  });
   // initialize a vector of dyn<countable> with three different counter types
-  std::vector<dyn> v;
+  std::vector<simply::dyn<countable>> v;
   v.emplace_back(std::in_place_type<counter<'A'>>);
   v.emplace_back(std::in_place_type<counter<'B'>>);
   v.emplace_back(std::in_place_type<counter<'C'>>);