Сортировка аргументов шаблона C++

Используя Boost.Mp11 вы можете

#include <boost/mp11.hpp>

using namespace boost::mp11;

template<class LHS, class RHS>
struct Less : std::bool_constant<LHS::getType() < RHS::getType()> {};

template <typename... Ts>
struct Sort {
  using type = mp_sort<mp_list<Ts...>, Less>;
};

который создает mp_list с отсортированными типами.

Демо

Хорошо, я сделал это — быстрая сортировка во время компиляции!

#include <iostream>
#include <typeinfo>

template <typename T1, typename T2>
struct compare {
    static constexpr bool less = T1::value < T2::value;
};

template <typename... Seq>
struct Sequence {
};

template <typename S1, typename S2>
struct SequenceExtend;

template <typename... Seq1, typename... Seq2>
struct SequenceExtend<Sequence<Seq1...>, Sequence<Seq2...>> {
    using type = Sequence<Seq1..., Seq2...>;
};

template <typename S, typename T>
struct SequenceAppend;

template <typename... Seq, typename T>
struct SequenceAppend<Sequence<Seq...>, T> {
    using type = Sequence<Seq..., T>;
};

template <typename Pivot, typename Seq>
struct SequencePartition;

template <typename Pivot, typename First>
struct SequencePartition<Pivot, Sequence<First>> {
    using less = std::conditional_t<compare<First, Pivot>::less, Sequence<First>, Sequence<>>;
    using greater = std::conditional_t<!compare<First, Pivot>::less, Sequence<First>, Sequence<>>;
};

template <typename Pivot, typename First, typename...Rest>
struct SequencePartition<Pivot, Sequence<First, Rest...>> {
    using less = std::conditional_t<
        compare<First, Pivot>::less,
        typename SequenceAppend<typename SequencePartition<Pivot, Sequence<Rest...>>::less, First>::type,
        typename SequencePartition<Pivot, Sequence<Rest...>>::less
    >;

    using greater = std::conditional_t <
        !compare<First, Pivot>::less,
        typename SequenceAppend<typename SequencePartition<Pivot, Sequence<Rest...>>::greater, First>::type,
        typename SequencePartition<Pivot, Sequence<Rest...>>::greater
    >;
};

template <typename... Ts>
struct QuickSort {
private:
    template <typename S>
    struct SortPass;

    template <>
    struct SortPass<Sequence<>> {
        using type = Sequence<>;
    };

    template <typename T>
    struct SortPass<Sequence<T>> {
        using type = Sequence<T>;
    };

    template <typename Pivot, typename... Rest>
    struct SortPass<Sequence<Pivot, Rest...>> {
        using less = typename SequencePartition<Pivot, Sequence<Rest...>>::less;
        using greater = typename SequencePartition<Pivot, Sequence<Rest...>>::greater;
        using type = typename SequenceExtend<
            typename SequenceAppend<typename SortPass<less>::type, Pivot>::type,
            typename SortPass<greater>::type
        >::type;
    };

public:
    using type = typename SortPass<Sequence<Ts...>>::type;
};

struct A {
    static constexpr int value = 1;
};

struct B {
    static constexpr int value = 2;
};

struct C {
    static constexpr int value = 3;
};

int main() {
    using sorted1 = QuickSort<A, B, C>::type;
    using sorted2 = QuickSort<A, C, B>::type;
    using sorted3 = QuickSort<B, A, C>::type;
    using sorted4 = QuickSort<B, C, A>::type;
    using sorted5 = QuickSort<C, A, B>::type;
    using sorted6 = QuickSort<C, B, A>::type;

    return 0;
}