Alias fn<A, T>(...) to impl<A, T>::fn(...)

Author: patrickroberts

README.md

@@ -24,7 +24,7 @@ struct insertable : simply::member_affordance_base {
 template <typename Self>
 struct simply::iface<insertable, Self> {
   friend auto operator<<(std::ostream &out, const Self &self) -> std::ostream & {
-    return simply::impl<insertable, Self>::fn(self, out);
+    return simply::fn<insertable, Self>(self, out);
   }
 };
 

include/simply/dyn.hpp

@@ -83,7 +83,7 @@ class dyn
     requires simply::destroy_affordance<Affordance>
   {
     using destroy = simply::destroy_affordance_t<Affordance>;
-    simply::impl<destroy, dyn>::fn(*this);
+    simply::fn<destroy, dyn>(*this);
   }
 };
 
@@ -116,7 +116,8 @@ concept _allocator_storage_dyn =
                               simply::allocator_storage>;
 
 template <typename T, typename Dyn>
-using _storage_impl_t = simply::impl<typename Dyn::storage_type, T>;
+inline constexpr const auto &_storage_fn =
+    simply::fn<typename Dyn::storage_type, T>;
 
 template <simply::member_affordance Affordance, typename T,
           simply::_allocator_storage_dyn Dyn, typename R, typename Self,
@@ -126,9 +127,9 @@ struct impl<simply::impl<Affordance, T>, Dyn,
   static constexpr auto fn(Self dyn, Args... args) noexcept(NoExcept) -> R {
     using self_type = simply::apply_cvref_t<Self, T>;
 
-    const auto pointer = simply::_storage_impl_t<T, Dyn>::fn(dyn.get());
-    return simply::impl<Affordance, T>::fn(std::forward<self_type>(*pointer),
-                                           std::forward<Args>(args)...);
+    const auto pointer = simply::_storage_fn<T, Dyn>(dyn.get());
+    return simply::fn<Affordance, T>(std::forward<self_type>(*pointer),
+                                     std::forward<Args>(args)...);
   }
 };
 
@@ -146,9 +147,9 @@ struct impl<simply::impl<Affordance, T>, Dyn,
         dyn.get_allocator(),
         std::in_place_type<T>,
         simply::elide([&] -> T {
-          const auto pointer = simply::_storage_impl_t<T, Dyn>::fn(dyn.get());
-          return simply::impl<Affordance, T>::fn(
-              std::forward<self_type>(*pointer), std::forward<Args>(args)...);
+          const auto pointer = simply::_storage_fn<T, Dyn>(dyn.get());
+          return simply::fn<Affordance, T>(std::forward<self_type>(*pointer),
+                                           std::forward<Args>(args)...);
         }),
     };
   }
@@ -167,7 +168,7 @@ struct impl<simply::impl<Affordance, T>, Dyn,
     }
 
     auto alloc = simply::_rebind_alloc<T>(dyn.get_allocator());
-    const auto pointer = simply::_storage_impl_t<T, Dyn>::fn(dyn.get());
+    const auto pointer = simply::_storage_fn<T, Dyn>(dyn.get());
 
     using traits = std::allocator_traits<decltype(alloc)>;
 

include/simply/extractable.hpp

@@ -22,7 +22,7 @@ struct extractable : simply::member_affordance_base {
 template <typename In, typename Self>
 struct iface<simply::extractable<In>, Self> {
   friend constexpr auto operator>>(In &out, const Self &self) -> In & {
-    return simply::impl<simply::extractable<In>, Self>::fn(self, out);
+    return simply::fn<simply::extractable<In>, Self>(self, out);
   }
 };
 

include/simply/impl.hpp

@@ -13,6 +13,9 @@ 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;
+
 template <simply::member_affordance Affordance, typename T>
 struct affordance_traits<Affordance, T> {
   using function_type = decltype(Affordance::template fn<T>);

include/simply/insertable.hpp

@@ -22,7 +22,7 @@ struct insertable : simply::member_affordance_base {
 template <typename Out, typename Self>
 struct iface<simply::insertable<Out>, Self> {
   friend constexpr auto operator<<(Out &out, const Self &self) -> Out & {
-    return simply::impl<simply::insertable<Out>, Self>::fn(self, out);
+    return simply::fn<simply::insertable<Out>, Self>(self, out);
   }
 };
 

include/simply/storage.hpp

@@ -79,9 +79,9 @@ struct iface<Storage, Self> {
         object_ptr(
             other.valueless_after_move()
                 ? nullptr
-                : simply::impl<
+                : simply::fn<
                       simply::copy_affordance_t<typename Self::affordance_type>,
-                      Self>::fn(static_cast<const Self &>(other))
+                      Self>(static_cast<const Self &>(other))
                       ._release()) {}
 
   constexpr iface(iface &&other) noexcept

include/simply/vtable.hpp

@@ -42,7 +42,7 @@ inline constexpr simply::vtable<Affordance, Self>
 template <simply::member_affordance Affordance, typename Self, typename T>
 inline constexpr simply::vtable<Affordance, Self>
     vtable_for<Affordance, Self, T> = {
-        .fn = &simply::impl<simply::impl<Affordance, T>, Self>::fn,
+        .fn = &simply::fn<simply::impl<Affordance, T>, Self>,
 };
 
 } // namespace simply

tests/counters.cpp

@@ -46,14 +46,14 @@ struct labeled : simply::member_affordance_base {
 template <typename CountT, typename Self>
 struct simply::iface<copy_countable<CountT>, Self> {
   constexpr auto copy_count(this const Self &self) -> CountT {
-    return simply::impl<copy_countable<CountT>, Self>::fn(self);
+    return simply::fn<copy_countable<CountT>, Self>(self);
   }
 };
 
 template <typename LabelT, typename Self>
 struct simply::iface<labeled<LabelT>, Self> {
   constexpr auto label(this const Self &self) -> LabelT {
-    return simply::impl<labeled<LabelT>, Self>::fn(self);
+    return simply::fn<labeled<LabelT>, Self>(self);
   }
 };