Proposed resolution:

Note: This alternate proposed resolution works only if 1191 has been accepted.

1. Change [tuple.general] p. 2, header <tuple> synopsis, as indicated:

   namespace std {
   
   ...
   
   // 20.4.2.4, tuple creation functions:
   const unspecified ignore;
   
   template <class... Types>
     tuple<VTypes...> make_tuple(Types&&...);
     template <class... Types>
     tuple<ATypes...> forward_as_tuple(Types&&...);
     
   template<class... Types>
     tuple<Types&...> tie(Types&...);
     
   template <class... TTypes, class... UTypes>
     tuple<TTypes..., UTypes...> tuple_cat(const tuple<TTypes...>&, const tuple<UTypes...>&);
   template <class... TTypes, class... UTypes>
     tuple<TTypes..., UTypes...> tuple_cat(tuple<TTypes...>&&, const tuple<UTypes...>&);
   template <class... TTypes, class... UTypes>
     tuple<TTypes..., UTypes...> tuple_cat(const tuple<TTypes...>&, tuple<UTypes...>&&);
   template <class... TTypes, class... UTypes>
     tuple<TTypes..., UTypes...> tuple_cat(tuple<TTypes...>&&, tuple<UTypes...>&&);
   template <class... Tuples>
     tuple<CTypes...> tuple_cat(Tuples&&...);
   
   ...
   
   

2. Change [tuple.creation] as indicated:

   template <class... TTypes, class... UTypes>
     tuple<TTypes..., UTypes...> tuple_cat(const tuple<TTypes...>& t, const tuple<UTypes...>& u);

   8 Requires: All the types in TTypes shall be CopyConstructible (Table 35). All the types in UTypes shall be CopyConstructible (Table 35).

   9 Returns: A tuple object constructed by copy constructing its first sizeof...(TTypes) elements from the corresponding elements of t and copy constructing its last sizeof...(UTypes) elements from the corresponding elements of u.

   template <class... TTypes, class... UTypes>
     tuple<TTypes..., UTypes...> tuple_cat(tuple<TTypes...>&& t, const tuple<UTypes...>& u);

   10 Requires: All the types in TTypes shall be MoveConstructible (Table 34). All the types in UTypes shall be CopyConstructible (Table 35).

   11 Returns: A tuple object constructed by move constructing its first sizeof...(TTypes) elements from the corresponding elements of t and copy constructing its last sizeof...(UTypes) elements from the corresponding elements of u.

   template <class... TTypes, class... UTypes>
     tuple<TTypes..., UTypes...> tuple_cat(const tuple<TTypes...>& t, tuple<UTypes...>&& u);

   12 Requires: All the types in TTypes shall be CopyConstructible (Table 35). All the types in UTypes shall be MoveConstructible (Table 34).

   13 Returns: A tuple object constructed by copy constructing its first sizeof...(TTypes) elements from the corresponding elements of t and move constructing its last sizeof...(UTypes) elements from the corresponding elements of u.

   template <class... TTypes, class... UTypes>
     tuple<TTypes..., UTypes...> tuple_cat(tuple<TTypes...>&& t, tuple<UTypes...>&& u);

   14 Requires: All the types in TTypes shall be MoveConstructible (Table 34). All the types in UTypes shall be MoveConstructible (Table 34).

   15 Returns: A tuple object constructed by move constructing its first sizeof...(TTypes) elements from the corresponding elements of t and move constructing its last sizeof...(UTypes) elements from the corresponding elements of u.

   template <class... Tuples>
     tuple<CTypes...> tuple_cat(Tuples&&... tpls);
   

   8 Let Ti be the i^th type in Tuples, Ui be remove_reference<Ti>::type, and tp_i be the i^th parameter in the function parameter pack tpls, where all indexing is zero-based in the following paragraphs of this sub-clause [tuple.creation].

   9 Requires: For all i, Ui shall be the type cv_i tuple<Args_i...>, where cv_i is the (possibly empty) i^th cv-qualifier-seq, and Args_i is the parameter pack representing the element types in Ui. Let Aik be the k_i^th type in Args_i, then for all Aik the following requirements shall be satisfied: If Ti is deduced as an lvalue reference type, then is_constructible<Aik, cv_i Aik&>::value == true, otherwise is_constructible<Aik, cv_i Aik&&>::value == true.

   10 Remarks: The types in CTypes shall be equal to the ordered sequence of the expanded types Args₀..., Args₁..., Args_n-1..., where n equals sizeof...(Tuples). Let e_i... be the i^th ordered sequence of tuple elements of the result tuple object corresponding to the type sequence Args_i.

   11 Returns: A tuple object constructed by initializing the k_i^th type element eik in e_i... with get<k_i>(std::forward<Ti>(tp_i)) for each valid k_i and each element group e_i in order.

   12 [Note: An implementation may support additional types in the parameter pack Tuples, such as pair and array that support the tuple-like protocol. — end note]

[ 2010 Batavia ]

Moved to Ready with Daniel's improved wording.

[ 2010-11-06: Daniel comments and proposes some alternative wording: ]

There are some problems in the wording: First, even though the result type tuple<see below> implies it, the specification of the contained tuple element types is missing. Second, the term "tuple protocol" is not defined anywhere and I see no reason why this normative wording should not be a non-normative note. We could at least give a better approximation, maybe "tuple-like protocol" as indicated from header <utility> synopsis. Further, it seems to me that the effects need to contain a combination of std::forward with the call of get. Finally I suggest to replace the requirements Move/CopyConstructible by proper usage of is_constructible, as indicated by n3140.

[ 2010 Rapperswil: Alisdair to provide wording. ]

[ Resolution proposed by ballot comment: ]

Adopt a simplified form of the proposal in n2975, restricted to tuples and neither requiring nor outlawing support for other tuple-like types.

Addresses GB-88

The tuple_cat template consists of four overloads and that can concatenate only two tuples. A single variadic signature that can concatenate an arbitrary number of tuples would be preferred.