This is more of an assumption than a quote from the standard, but I think it makes sense.
The problem is that a list enclosed in braces can mean many things. It can be a list of initializers, but according to uniform initialization, there can also be any number of other things, such as aggregate initializers or just constructor arguments.
Consider the following situation:
struct Bar { Bar(int, int, int){} }; void foo(const std::vector<int> & v); void zoo(const Bar & v);
I can name both foo({1,2,3}) and zoo({1,2,3}) . Since the argument type of both functions is known, there is no ambiguity. However, the foo argument is displayed as a list of initializers, and the zoo argument is a constructor call with uniform initialization.
In a tuple situation, the problem is that all the types involved are templates. The constructor argument type must be inferred; It is not known at the time of the function call. This true role is manifested only in the body of the function.
Since there are many ways to build a member of a collection, this conclusion may be ambiguous or simply incorrect, so the compiler warns you that it makes an assumption.
In fact, you can build the failure of this assumption very simply:
std::tuple<Bar, std::vector<int>> s{{1,2,3}, {1,2,3}};
This will not be able to create the first member of the tuple, because the list of commands is displayed incorrectly. The only “good” way of writing tuples is explicitly:
std::tuple<Bar, std::vector<int>> s{Bar{1,2,3}, std::vector<int>{1,2,3}};