For example

template
class X
{
using unique_types_ = mp11::mp_unique<mp11::mp_list>;

….
};

wow, I really like you point of view. This solution reduces the number of iterations and removes the limitations of my proposal. Thanks for your dropping your solution

The basic idea is to replace duplicate ExtraFeature base classes with empty dummy classes. This is because it’s easy to map over a parameter pack with just expansions but difficult to filter things out or otherwise change the pack’s size without recursion. Redundant comparisons between packs are avoid in a similar way.

There are several layers of indirection to deal with making index sequences and replacing things with dummy classes, so here’s the sketch of all the layers of a basic example, though certainly ignore this if it’s more confusing than the code itself:

The Pack struct wraps up parameter packs, and FeatureSets are just Packs of types (we instantiate ExtraFeature templates with Derived early for simplicity). Suppose we have extra feature classes F1,F2,F3, and feature sets A=Pack<F1,F2>; B=Pack<F2,F3>; C=Pack<F1,F3>

1) X inherits from UseFeatures, which just passes the buck to MergePacks: eg, UseFeatures<X, A, B, C> = MergePacks<A<X>, B<X>, C<X>>

2) which exists solely to add on an index sequence: MergePacks<A,B,C> = InheritPacks<seq<0,1,2>, A, B, C>

3) then InheritPacks has three base classes, to do the actual work of deduplicating:
– InheritUnique<0, A, seq<0,1,2>, A, B, C>
– InheritUnique<1, B, seq<0,1,2>, A, B, C>
– InheritUnique<2, C, seq<0,1,2>, A, B, C>

4) and each InheritUnique inherits from multiple BlankIfDups, one for each type in its first Pack argument. It also uses the index and index sequence to replace Packs that would be redundant to test against with empty Packs. So,
– InheritUnique<0, A, …> inherits from BlankIfDup<F1, Pack<>, B, C> and BlankIfDup<F2, Pack<>, B, C>
– InheritUnique<1, B, …> inherits from BlankIfDup<F2, Pack<>, Pack<>, C> and BlankIfDup<F3, Pack<>, Pack<>, C>
– InheritUnique<2, C, …> inherits from BlankIfDup<F1, Pack<>, Pack<>, Pack<>> and BlankIfDup<F3, Pack<>, Pack<>, Pack<>>

5) each BlankIfDup is either an alias for the type it is passed if the type in not present in any of the Packs it is passed, or else a Blank tagged with the type. So,
– BlankIfDup<F1, Pack<>, B, C> = Blank<F1> because F1 is in C
– BlankIfDup<F2, Pack<>, B, C> = Blank<F2> because F2 is in B
– BlankIfDup<F2, Pack<>, Pack<>, C> = F2
– BlankIfDup<F3, Pack<>, Pack<>, C> = Blank<F3> because F3 is in C
– BlankIfDup<F1, Pack<>, Pack<>, Pack<>> = F1
– BlankIfDup<F3, Pack<>, Pack<>, Pack<>> = F3

6) thus X inherits from one copy each of F1, F2, and F3, via 3 InheritUniques, via 1 InheritPacks. X also inherits from three dummy Blank<…> classes. See the comments in main() for a complete accounting.

I don’t know if having many empty dummy bases will affect compilation speed in any significant way (and I’d guess it’d be cheaper than heaps of template recursion at any rate) but it shouldn’t have any other costs because of empty base optimization.