Add support for combination of incomplete dispatch (#58)

proxy.h

@@ -614,12 +614,22 @@ struct flattening_traits<std::tuple<T, Ts...>> : flattening_traits_impl<
     typename flattening_traits<T>::type,
     typename flattening_traits<std::tuple<Ts...>>::type> {};
 
+template <class... Ds>
+struct overloads_combination_traits { using type = std::tuple<>; };
+template <class D, class... Ds>
+struct overloads_combination_traits<D, Ds...>
+    : overloads_combination_traits<Ds...> {};
+template <class D, class... Ds>
+    requires(requires { typename D::overload_types; })
+struct overloads_combination_traits<D, Ds...>
+    : flattening_traits<std::tuple<typename D::overload_types,
+        typename overloads_combination_traits<Ds...>::type>> {};
+
 template <class... Os> requires(sizeof...(Os) > 0u)
 struct dispatch_prototype { using overload_types = std::tuple<Os...>; };
 template <class... Ds> requires(sizeof...(Ds) > 0u)
 struct combined_dispatch_prototype : Ds... {
-  using overload_types = typename flattening_traits<
-      std::tuple<typename Ds::overload_types...>>::type;
+  using overload_types = typename overloads_combination_traits<Ds...>::type;
   using Ds::operator()...;
 };
 template <class Ds = std::tuple<>, proxiable_ptr_constraints C =

tests/proxy_invocation_tests.cpp

@@ -169,3 +169,26 @@ TEST(ProxyInvocationTests, TestFunctionPointer) {
   auto ret = p();
   ASSERT_EQ(ret, (GetTypeIndices<int, double>()));
 }
+
+TEST(ProxyInvocationTests, TestCombinationWithIncompleteDispatch) {
+  constexpr auto not_implemented = [](auto&&...) { throw std::runtime_error{ "Not implemented!" }; };
+  PRO_DEF_COMBINED_DISPATCH(WeakCall, poly::Call<void()>, decltype(not_implemented));
+  PRO_DEF_FACADE(WeakCallable, WeakCall);
+  {
+    int side_effect = 0;
+    auto p = pro::make_proxy<WeakCallable>([&] { side_effect = 1; });
+    p();
+    ASSERT_EQ(side_effect, 1);
+  }
+  {
+    bool exception_thrown = false;
+    auto p = pro::make_proxy<WeakCallable>(123);
+    try {
+      p();
+    } catch (const std::runtime_error& e) {
+      exception_thrown = true;
+      ASSERT_EQ(static_cast<std::string>(e.what()), "Not implemented!");
+    }
+    ASSERT_TRUE(exception_thrown);
+  }
+}