"Manual" signature overload resolution

Question

I want to make a std::function like object that can handle storing more than one overload.

Syntax sort of like this: my_function< int(double, int), double(double, double), char(int, int) >.

Or, more explicitly:

template<typename... Ts>
struct type_list {};

template<typename... Signatures >
struct my_function {
  std::tuple< std::function<Signatures>... > m_functions;
  typedef type_list< Signatures... > sig_list;
  template<typename... Args>
  typename pick_overload_signature< sig_list, type_list<Args...> >::return_value
    operator()( Args&&... args )
  {
    return get<pick_overload_signature< sig_list, type_list<Args...> >::index>(m_functions)(std::forward<Args>(args)...);
  }
};

My question: how should I write pick_overload_signatures?

Here is the work I've done on it:

My inclination would be to write a partial order on function signatures with respect to a given set of arguments, then sort the type list of function signatures, then grab the best (with possibly a compile-time assert that the best one is unique). To pull that off, I'd have to have a solid partial order (with respect to a set of arguments passed in) on function signatures...

13.3.3.1 tells me how to determine if there is a valid conversion. I can cheat for this by using the compiler to do a conversion for me, and use SFINAE to detect if it occurred for a given argument passed in and the signature of one of the "overloads".

13.3.3.2 tells me how to order these conversions. Here I have to detect if a conversion sequence is user defined or a standard sequence. I am not sure how to distinguish between the two.

Maybe I can use traits class to detect the existence of user-defined conversions sequences. Check for the existence of &S::operator D() and &D::D(S const&) and &D::D(S) and &D::D(S&&) or something like that.

has_user_defined_conversion<S,D>::value, has_standard_conversion<S,D>::value, etc?

Will this approach work, has someone already done it, or has someone already done parts of this?

Result of Answers

#include <type_traits>
#include <cstddef>
#include <utility>
#include <functional>
#include <tuple>
#include <string>

// Packaged list of types:
template<typename... Ts>
struct type_list {
   template<template<typename...>class target>
   struct apply {
      typedef target<Ts...> type;
   };
   template<typename T>
   struct append {
      typedef type_list< Ts..., T > type;
   };
   template<typename T>
   struct prepend {
      typedef type_list< T, Ts... > type;
   };
};
template<template<typename>class mapper, typename list>
struct map_types {
   typedef type_list<> type;
};
template<template<typename>class mapper, typename T0, typename... Ts>
struct map_types<mapper, type_list<T0, Ts...>> {
   typedef typename map_types<mapper, type_list<Ts...>>::type tail;
   typedef typename tail::template prepend< typename mapper<T0>::type >::type type;
};
template<template<typename>class mapper, typename list>
using MapTypes = typename map_types<mapper, list>::type;
template<template<typename>class temp>
struct apply_template_to {
   template<typename T>
   struct action {
      typedef temp<T> type;
   };
};
template<template<typename> class temp, typename list>
struct apply_to_each:map_types< apply_template_to<temp>::template action, list > {};
template<template<typename> class temp, typename list>
using ApplyToEach = typename apply_to_each<temp, list>::type;

template<std::size_t n, typename list>
struct nth_type {};
template<std::size_t n, typename first, typename... elements>
struct nth_type<n, type_list<first, elements...>>:nth_type<n-1, type_list<elements...>>
{};
template<typename first, typename... elements>
struct nth_type<0, type_list<first, elements...>>
{
   typedef first type;
};
template<std::size_t n, typename list>
using NthType = typename nth_type<n, list>::type;

// func data
template<typename R, typename... Args>
struct unpacked_func {
   typedef R result_type;
   typedef type_list<Args...> args_type;
   typedef unpacked_func< R, Args... > unpacked_type;
   template<template<typename>class target>
   struct apply {
      typedef target<R(Args...)> type;
   };
};

namespace unpack_details {
   // Extracting basic function properties:
   template<typename Func>
   struct unpack_func {};
   template<typename R, typename... Args>
   struct unpack_func< R(Args...) > {
      typedef unpacked_func< R, Args... > type;
   };
   template<typename R, typename... Args>
   struct unpack_func< unpacked_func<R, Args...> >:
      unpack_func< R(Args...) >
   {};
}

template<typename Func>
using FuncUnpack = typename unpack_details::unpack_func<Func>::type;

template<typename Func>
struct func_props:func_props<FuncUnpack<Func>> {};
template<typename R, typename... Args>
struct func_props<unpacked_func<R, Args...>>:
   unpacked_func<R, Args...>
{};

template<typename Func>
using FuncResult = typename func_props<Func>::result_type;
template<typename Func>
using FuncArgs = typename func_props<Func>::args_type;

template<typename Func>
struct make_func_ptr:make_func_ptr<FuncUnpack<Func>> {};

template<typename R, typename... Args>
struct make_func_ptr< unpacked_func< R, Args... > > {
   typedef R(*type)(Args...);
};
template<typename Func>
using MakeFuncPtr = typename make_func_ptr<Func>::type;

// Marking a type up with an index:
template<typename R, std::size_t i>
struct indexed_type {
   typedef R type;
   enum { value = i };
};

// Sequences of size_t:
template<std::size_t... s>
struct seq {};
template<std::size_t min, std::size_t max, std::size_t... s>
struct make_seq: make_seq< min, max-1, max-1, s...> {};
template<std::size_t min, std::size_t... s>
struct make_seq< min, min, s...> {
     typedef seq<s...> type; 
};
template<std::size_t max, std::size_t min=0>
using MakeSeq = typename make_seq<max, min>::type;

namespace overload_details {
   template<std::size_t n, typename... Overloads>
   struct indexed_linear_signatures {};

   template<typename Overload>
   struct signature_generator {};
   template<typename R, typename... Args>
   struct signature_generator<unpacked_func<R, Args...>> {
      R operator()(Args...); // no impl
   };


   template<typename Func, std::size_t i>
   struct indexed_retval {};

   template<typename R, typename... Args, std::size_t i>
   struct indexed_retval< unpacked_func<R, Args...>, i > {
      typedef unpacked_func<indexed_type<R,i>, Args...> type;
   };

   template<typename Func, std::size_t i>
   using IndexRetval = typename indexed_retval<Func,i>::type;

   void test1() {
      typedef overload_details::IndexRetval< FuncUnpack<void()>, 0 > indexed;
      indexed::apply<std::function>::type test = []()->indexed_type<void,0> {return indexed_type<void,0>();};
   }

   template<std::size_t n, typename Overload, typename... Overloads>
   struct indexed_linear_signatures<n, Overload, Overloads...>:
      signature_generator<IndexRetval<FuncUnpack<Overload>,n>>,
      indexed_linear_signatures<n+1, Overloads...>
   {};

   template<typename T>
   struct extract_index {};
   template<typename T, std::size_t i>
   struct extract_index<indexed_type<T,i>> {
      enum {value = i};
   };

   template<typename T>
   using Decay = typename std::decay<T>::type;

   template<typename indexed_overloads, typename... Args>
   struct get_overload_index {
      enum{ value = extract_index< Decay<decltype( std::declval<indexed_overloads>()(std::declval<Args>()...) )> >::value };
   };

   template<typename Overloads, typename Args>
   struct get_overload {};
   template<typename... Overloads, typename... Args>
   struct get_overload<type_list<Overloads...>, type_list<Args...>> {
      typedef indexed_linear_signatures<0, Overloads...> sig_index;
      enum { index = get_overload_index< sig_index, Args... >::value };
      typedef FuncUnpack< NthType<index, type_list<Overloads...> > > unpacked_sig;
   };

   template<typename Overloads, typename Args>
   using GetOverloadSig = typename get_overload< Overloads, Args >::unpacked_sig;
}

template<typename Overloads, typename Arguments>
struct pick_overload_signature {
   enum{ index = overload_details::get_overload<Overloads, Arguments>::index };
   typedef overload_details::GetOverloadSig<Overloads, Arguments> unpacked_sig;
};
#include <iostream>
void test1() {
   typedef type_list< void(int), void(double) > overloads;
   typedef type_list< int > args;
   typedef pick_overload_signature< overloads, args > result;
   std::cout << result::index << " should be 0\n";
   typedef type_list< double > args2;
   typedef pick_overload_signature< overloads, args2 > result2;
   std::cout << result2::index << " should be 1\n";

//    ;
   typedef ApplyToEach< std::function, overloads >::apply< std::tuple >::type functions;
   typedef std::tuple< std::function<void(int)>, std::function<void(double)> > functions0;
   std::cout << std::is_same<functions, functions0>() << " should be true\n";

   functions funcs{
      [](int) { std::cout << "int!" << "\n"; },
      [](double) { std::cout << "double!" << "\n"; }
   };
   std::get<result::index>(funcs)(0);
}

template< typename... Signatures >
struct my_function {
   typedef type_list<Signatures...> signatures;
   typedef std::tuple< std::function<Signatures>... > func_tuple;
   func_tuple functions;
   template<typename... Funcs>
   explicit my_function(Funcs&&... funcs):
      functions( std::forward<Funcs>(funcs)... )
   {}

   template<typename... Args>
   auto
   operator()(Args&&... args) const ->
      typename overload_details::GetOverloadSig< signatures, type_list<Args...> >::result_type
   {
      return std::get<
         pick_overload_signature< signatures, type_list<Args...> >::index
      >(functions)(std::forward<Args>(args)...);
   }
   // copy/assign boilerplate
   template<typename... OtherSignatures>
   my_function( my_function<OtherSignatures...> const& o ):
      functions( o.functions )
   {}
   template<typename... OtherSignatures>
   my_function( my_function<OtherSignatures...> && o ):
      functions( std::move(o.functions) )
   {}
   template<typename... OtherSignatures>
   my_function& operator=( my_function<OtherSignatures...> const& o )
   {
      functions = o.functions;
      return *this;
   }
   template<typename... OtherSignatures>
   my_function& operator=( my_function<OtherSignatures...> && o ) {
      functions = std::move(o.functions);
      return *this;
   }
};

struct printer {
   template<typename T>
   void operator()( T const& t ) {
      std::cout << t << "\n";
   }
};

void print(int x) {
   std::cout << "int is " << x << "\n";
}
void print(std::string s) {
   std::cout << "string is " << s << "\n";
}
void test2() {
   my_function< void(int), void(std::string) > funcs{
      [](int x){ std::cout << "int is " << x << "\n";},
      [](std::string s){ std::cout << "string is " << s << "\n";}
   };
   std::cout << "test2\n";
   funcs("hello");
   funcs(0);
   my_function< void(int), void(std::string) > funcs2{
      printer(), printer()
   };
   funcs2("hello");
   funcs2(12.7);
   // doesn't work:
   /*
   my_function< void(int), void(std::string) > funcs3{
      print,
      print
   };
   */
}
void test3() {

}
int main() {
   test1();
   test2();
   test3();
}

Isn't done, but is usable.

Thanks all!

Answer 1

i'm sure it is doable your way, but may be you will be satisfied with this one https://gist.github.com/dabrahams/3779345

template<class...Fs> struct overloaded;

template<class F1, class...Fs>
struct overloaded<F1, Fs...> : F1, overloaded<Fs...>::type
{
typedef overloaded type;

overloaded(F1 head, Fs...tail)
: F1(head),
overloaded<Fs...>::type(tail...)
{}
using F1::operator();
using overloaded<Fs...>::type::operator();
};

template<class F>
struct overloaded<F> : F
{
typedef F type;
using F::operator();
};

template<class...Fs>
typename overloaded<Fs...>::type overload(Fs...x)
{ return overloaded<Fs...>(x...); }

auto f = overload(
[](int x) { return x+1; },
[](char const* y) { return y + 1; },
[](int* y) { return y; });

Answer 2

I think you can use something like these traits... But if you want make overloading resolution fully as in standard - you need more code http://en.cppreference.com/w/cpp/language/implicit_cast

#include <type_traits>

template<typename T, typename D>
struct is_constructible
{
   template<typename C, typename F>
   static auto test(C*) -> decltype(C(std::declval<F>()), std::true_type());
   template<typename, typename>
   static std::false_type test(...);
   static const bool value = std::is_class<T>::value && 
      std::is_same<std::true_type, decltype(test<T, D>(0))>::value;
};

template<typename T, typename D>
struct has_conversion_operator
{
   static std::true_type test(D d);
   template<typename C, typename F>
   static auto test(C* c) -> decltype(test(*c));
   template<typename, typename>
   static std::false_type test(...);

   static const bool value = std::is_class<T>::value && 
      !is_constructible<T, D>::value && 
      std::is_same<std::true_type, decltype(test<T, D>(0))>::value;
};

template<typename T, typename D>
struct is_standard_convertible : 
   std::integral_constant<bool, !has_conversion_operator<T, D>::value && 
   !is_constructible<T, D>::value &&
   std::is_convertible<T, D>::value>
{
};

template<typename T, typename D>
struct is_user_convertible :
   std::integral_constant<bool, has_conversion_operator<T, D>::value || 
   is_constructible<T, D>::value>
{
};

and implement what you want like: first check, that signatures are standard_convertible if not check that signature are user_convertible.