Specialized simply::fn<Affordance> to deduce T

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::fn<insertable, Self>(self, out);
+    return simply::fn<insertable>(self, out);
   }
 };
 

include/simply/impl.hpp

@@ -12,12 +12,27 @@ struct impl {
   static constexpr auto fn = Affordance::template fn<T>;
 };
 
-template <typename Affordance, typename T>
+struct _deduce_tag_t {};
+
+template <typename Affordance, typename T = simply::_deduce_tag_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 <typename Affordance>
+struct _deduce_t {
+  template <typename T, typename... Args>
+  static constexpr auto operator()(T &&self, Args &&...args) noexcept(
+      noexcept(simply::fn<Affordance, std::remove_cvref_t<T>>(
+          std::forward<T>(self), std::forward<Args>(args)...)))
+      -> decltype(simply::fn<Affordance, std::remove_cvref_t<T>>(
+          std::forward<T>(self), std::forward<Args>(args)...)) {
+    return simply::fn<Affordance, std::remove_cvref_t<T>>(
+        std::forward<T>(self), std::forward<Args>(args)...);
+  }
+};
+
+template <typename Affordance>
+inline constexpr simply::_deduce_t<Affordance>
+    fn<Affordance, simply::_deduce_tag_t>{};
 
 template <simply::member_affordance Affordance, typename T>
 struct affordance_traits<Affordance, T> {

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::fn<copy_countable<CountT>, Self>(self);
+    return simply::fn<copy_countable<CountT>>(self);
   }
 };
 
 template <typename LabelT, typename Self>
 struct simply::iface<labeled<LabelT>, Self> {
   constexpr auto label(this const Self &self) -> LabelT {
-    return simply::fn<labeled<LabelT>, Self>(self);
+    return simply::fn<labeled<LabelT>>(self);
   }
 };