As proof of concept, possible implementations (not necessarily the best)
of the various class templates are shown; and Appendix A
contains a listing for a crude test program that displays the results
of instantiation on the standard output.

A class template that just holds a parameter pack:

template <class... Args> struct packer { };

This is inspired by std::tuple, but it has no members,
so it could serve as an empty base class,
and an object of the ultimate type could always be instantiated
(even if the parameter pack contains void
or some type that lacks a default constructor).

Add type(s) to the end of what’s probably, but not necessarily, a parameter pack:

One possible implementation:

Note that T and U are permitted, but not required,
to be packers. It’s not clear that H. sapiens
would need all those possibilities; but they’re allowed for use
in machine-generated code. This applies also to unique_add_to
and to remove_from’s U parameter.

It’s because of the recursion in unique_add_to when T
is itself a packer with a non-empty parameter pack that we specify
that the types be added at the end: if they were added at the front,
their order would be reversed, which would likely be the greater surprise.

Note that, given the above implementation, uniqueify removes the first of two duplicates;
so the order of the types in the resulting parameter pack
might be surprising. For example,
uniqueify_t<packer<one,two,one>>
is packer<two,one>.