Matching partial specialization to replace tuple element by type

Question

I have searched a lot and could find many similar questions, but none of them solves this particular question AFAIK.

I want to replace a type in a tuple, by type (not by index). I tried something like this:

template <class Tuple, class ToRemove, class ToReplace>
struct ReplaceType {
     using type = Tuple;
};

template <class ToRemove, class ToReplace, class...Args, class...Args2>
struct ReplaceType<std::tuple<Args..., ToRemove, Args2...>, ToRemove, ToReplace> {
    using type = std::tuple<Args..., ToReplace, Args2...>;

};

This won't work but I cannot understand why it should not. It says that parameters are not deducible for Args... and Args2... but to me it should be natural to guess it from the call site:

typename ReplaceType<std::tuple<int, float, char>, float, double>>::type;

From there int should be Args1... in the template specialization and char Args2...

1. Why this won't work?
2. Is there any workaround?

Answer 1

One step at a time.

First, use specialization to map one type to another, leaving all other types unchanged. If T is ToRemove, replace it with `ToReplace, else leave it alone:

template<typename T, typename ToRemove, typename ToReplace>
struct replace_type {

    using type=T;
};

template<typename ToRemove, typename ToReplace>
struct replace_type<ToRemove, ToRemove, ToReplace> {

    using type=ToReplace;
};

Now, once you've gotten that out of the way, use specialization to unpack the tuple types, then repack them after laundering each one using replace_type:

template<class Tuple, typename ToRemove, typename ToReplace>
struct replace_tuple;

template<typename ...Args, typename ToRemove, typename ToReplace>
struct replace_tuple<std::tuple<Args...>, ToRemove, ToReplace> {

    using type=std::tuple<typename
                  replace_type<Args, ToRemove, ToReplace>::type
                  ...>;
};

Tested with gcc 6.3.1:

replace_tuple<std::tuple<int, char, int>, char, unsigned>::type foo;

std::tuple<int, unsigned, int> *bar=&foo;