#include <type_traits>

namespace details
{

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

    template <typename T, typename First, typename... Rest>
    struct occurance_count<T, First, Rest...>
    {
        constexpr static int const value {
            (std::is_same_v<T, First> ? 1 : 0) + occurance_count<T, Rest...>::value
        };
    };

    template <typename T>
    struct occurance_count<T>
    {
        constexpr static int const value { 0 };
    };
    
}

template <typename... Ts>
struct most_common;

template <typename T, typename... Ts>
struct most_common<T, Ts...>
{
private:

    constexpr static int const current { details::occurance_count<T, T, Ts...>::value };
    constexpr static int const rest    { most_common<Ts...>::value };
    
public:
    
    constexpr static int const value { (current >= rest ? current : rest) };
    using type = std::conditional_t< (current >= rest), T, typename most_common<Ts...>::type >;
    
};

template <typename T>
struct most_common<T>
{
    constexpr static int const value { 1 };
    using type = T;
};

template <typename Ts...>
using most_common_t = typename most_common<Ts...>::type;

int main()
{
    static_assert( std::is_same_v<most_common_t<int, float, double>::type, int> );
    static_assert( most_common<int, float, double>::value == 1 );
    
    static_assert( std::is_same_v<most_common_t<int, float, double, int>::type, int> );
    static_assert( most_common<int, float, double, int>::value == 2 );
    
    static_assert( std::is_same_v<most_common_t<float, int, double, int>::type, int> );
    static_assert( most_common<float, int, double, int>::value == 2 );
    
    static_assert( std::is_same_v<most_common_t<float, int, float, double, int>::type, float> );
    static_assert( most_common<float, int, float, double, int>::value == 2 );

    static_assert( std::is_same_v<most_common_t<int, float, int, double, int>::type, int> );
    static_assert( most_common<int, float, int, double, int>::value == 3 );
}