在编译时对类型的置换P(N，R）

基本思想是将最初的类型列表处理为(type, count)对的列表，然后从那里开始工作。首先，一些基元：

template<class, size_t> struct counted_type {};
template<class...> struct pack {};

我们的表示将是counted_type s的pack。要构建它，我们需要能够向它添加一个类型：

template<class T, class CT> struct do_push;
template<class T, class...Ts, size_t... Is>
struct do_push<T, pack<counted_type<Ts, Is>...>>{
   using type = std::conditional_t<std::disjunction_v<std::is_same<Ts, T>...>,
        pack<counted_type<Ts, Is + (std::is_same_v<Ts, T>? 1 : 0)>...>,
        pack<counted_type<Ts, Is>..., counted_type<T, 1>>
        >;
};
template<class T, class CT> using push = typename do_push<T, CT>::type;

如果类型已经存在，我们将计数加1；否则我们附加一个CCD_ 4。

为了以后使用它，我们需要能够从中删除一种类型：

template<class T, class CT> struct do_pop;
template<class T, class...Ts, std::size_t... Is>
struct do_pop<T, pack<counted_type<Ts, Is>...>>{
   using type = remove<counted_type<T, 0>,
                       pack<counted_type<Ts, Is - (std::is_same_v<Ts, T>? 1 : 0)>...>>;
};
template<class T, class CT> using pop = typename do_pop<T, CT>::type;

remove<T, pack<Ts...>>从Ts...中删除T的第一个实例（如果它存在），并返回生成的包（如果T不存在，则返回的包不变）。（相当无聊的）实现留给读者练习。

使用push，我们可以很容易地从以下类型的pack构建counted_types的pack：

template<class P, class CT = pack<> >
struct count_types_imp { using type = CT; };
template<class CT, class T, class... Ts>
struct count_types_imp<pack<T, Ts...>, CT>
        : count_types_imp<pack<Ts...>, push<T, CT>> {};
template<class P>
using count_types = typename count_types_imp<P>::type;

现在，实际实现是

template<class T> struct identity { using type = T; };
template <std::size_t N, typename CT, typename = pack<> > struct PermutationNHelper;
// Workaround for GCC's partial ordering failure
template <std::size_t N, class CT, class> struct PermutationNHelper1;
template <std::size_t N, class... Types, std::size_t... Counts, class... Current >
struct PermutationNHelper1<N, pack<counted_type<Types, Counts>...>, pack<Current...>> {
    // The next item can be anything in Types...
    // We append it to Current... and pop it from the list of types, then
    // recursively generate the remaining items
    // Do this for every type in Types..., and concatenate the result.
    using type = concat<
        typename PermutationNHelper<N-1, pop<Types, pack<counted_type<Types, Counts>...>>,
                                    pack<Current..., Types>>::type...
        >;
};

template <std::size_t N, class... Types, std::size_t... Counts, class... Current >
struct PermutationNHelper<N, pack<counted_type<Types, Counts>...>, pack<Current...>> {
    using type = typename std::conditional_t<
                     N == 0,
                     identity<pack<pack<Current...>>>,
                     PermutationNHelper1<N, pack<counted_type<Types, Counts>...>, 
                                            pack<Current...>>
                  >::type; 
     // Note that we don't attempt to evaluate PermutationNHelper1<...>::type 
     // until we are sure that N > 0
};

template <std::size_t N, typename Pack>
using PermutationN = typename PermutationNHelper<N, count_types<Pack>>::type;

通常情况下，这可以在一个具有两个部分专门化的模板中完成（一个用于N>0，一个用于N==0），但GCC的部分排序有缺陷，所以我使用conditional显式调度。事实上，在N等于0的情况下评估PermutationNHelper1中的包扩展会发生可怕的爆炸，因此引入了缺乏想象力的PermutationNHelper1，以提供额外的间接性水平并防止爆炸。

concat只是您的Merge（好吧，typename Merge<...>::type）的可变版本。实现留给读者练习。