#include <algorithm>
#include <type_traits>
#include <string>

template <typename T, typename... Ts>
struct conversion_chain;

template <typename T, typename First, typename... Rest>
struct conversion_chain<T, First, Rest...>
{
    static bool const step { std::is_convertible_v<T, First> };
    using next = std::conditional_t< step, First, T >;
    using chain = conversion_chain<next, Rest...>;

    static std::size_t const length { step + chain::length };
};

template <typename T>
struct conversion_chain<T>
{
    static std::size_t const length { 0 };
};

template <typename... Ts>
struct longest_conversion_chain;

template <typename T, typename... Ts>
struct longest_conversion_chain<T, Ts...>
{
    static std::size_t const current { conversion_chain<T, Ts...>::length + 1 };
    static std::size_t const next { longest_conversion_chain<Ts...>::length };
    static std::size_t const length { std::max(current, next) };
};

template <>
struct longest_conversion_chain<>
{
    static std::size_t const length { 0 };
};

int main()
{
    // empty chain
    static_assert( longest_conversion_chain<>::length == 0 );

    // single type
    static_assert( longest_conversion_chain<int>::length == 1 );

    // same type twice
    static_assert( longest_conversion_chain<int, int>::length == 2 );

    // all types is a chain
    static_assert( longest_conversion_chain<int, float>::length == 2 );
    static_assert( longest_conversion_chain<int, float, double>::length == 3 );

    // two incompatible chains (int and string)
    static_assert( longest_conversion_chain<int, char const*>::length == 1 );

    // can it find the char const* -> std::string chain?
    static_assert( longest_conversion_chain<int, char const*, std::string>::length == 2 );
    static_assert( longest_conversion_chain<char const*, int, std::string>::length == 2 );
    static_assert( longest_conversion_chain<char const*, std::string, int>::length == 2 );

    // can it find the int -> float -> double chain?
    static_assert( longest_conversion_chain<char const*, int, float, std::string, double>::length == 3 );
    static_assert( longest_conversion_chain<char const*, std::string, int, float, double>::length == 3 );

    // three chains of equal length
    static_assert( longest_conversion_chain<int, int, std::string, std::string, int*, int*>::length == 2 );

    // three chains (int, string -> string, int* -> int* -> int*)
    static_assert( longest_conversion_chain<int, int*, std::string, std::string, int*, int*>::length == 3 );
}