Variadic template that determines the best conversion

Question

How can we implement a variadic template that, given a type T and a list of types E₁, E₂, ... E_N, determines the type of that list for which the conversion from T to that type is, according to overload resolution, the best?

void should be the output if no best conversion exists - in other words, when either there is an ambiguity or T cannot be converted to any type in the list.
Note that this implies that our template should be SFINAE-friendly, i.e. not hard-error when no best conversion exists.

The following static_asserts should succeed:

static_assert( std::is_same< best<int, long, short>,       void >{}, "" );
static_assert( std::is_same< best<int, long, std::string>, long >{}, "" );
static_assert( std::is_same< best<int>,                    void >{}, "" );

_{(Assuming, for simplicity, that best is an alias template referring to the actual template)}

This case is left unspecified:

static_assert( std::is_same< best<int, int, int>, ???>{}, "" );

Either void or int should be acceptable here. (If the latter is chosen then we can still check in a wrapper template whether the result type is contained twice in the list, and if it is, output void instead).

Answer 1

My currently best approach:

#include <type_traits>

template <class T> using eval = typename T::type;

template <class T> struct identity {using type = T;};

template <typename T, typename... E>
class best_conversion
{
    template <typename...> struct overloads {};

    template <typename U, typename... Rest>
    struct overloads<U, Rest...> :
        overloads<Rest...>
    {
        using overloads<Rest...>::call;

        static identity<U> call(U);
    };

    template <typename U>
    struct overloads<U>
    {
        static identity<U> call(U);
    };

    template <typename... E_>
    static identity<eval<decltype(overloads<E_...>::call(std::declval<T>()))>>
    best_conv(int);

    template <typename...>
    static identity<void> best_conv(...);

public:

    using type = eval<decltype(best_conv<E...>(0))>;
};

template <typename... T>
using best_conversion_t = eval<best_conversion<T...>>;

Demo. For the "unspecified" case above this template will give you int.

The basic idea is to put a bunch of overloaded functions with one parameter into different scopes that name lookup will look in, with the parameter and return type of each overload corresponding to one of the types in our list.
overloads does this job by recursively introducing one declaration of call at a time and adapting all previously introduced calls from the base specializations via using declarations. That way all calls are in different scopes but are considered equally when it comes to overload resolution.

Then apply SFINAE in a function template best_conv to check whether the call to call (inside overloads) is well-formed: If it is, take the return type (which is by definition the parameter type) of the selected declaration and use it as our result - it will be the type we are looking for.
Also provide a second overload of best_conv that returns void and can be selected as a default (when SFINAE applies in the first overload and kicks it out of the candidate set).

The return types use identity<> to avoid type decays when working with e.g. array or function pointer types.