Improving pair and tuple, revision 3

Addressed issues:

• LWG 2051.

• LWG 2397.

• LWG 2312 is partially addressed: The currently proposed wording still intends to make an implementation conforming that would accept a smaller number of elements values compared to the actual tuple-size (and to value-initialize the remaining ones), therefore the size-related requirements are currently not part of the SFINAE constraints. If LWG 2312 would be accepted the corresponding constraints would be similarly adjusted as described by the issue and the corresponding requirement could be removed.

Revision History

Changes since N4064 (revision 2):

• Improve and simplify definition of EXPLICIT as well as the individual member specifications by separating out the number of constructor declarations from the decision to add explicit or not.

• After the Cologne meeting the authors recognized that three of the existing tuple allocator constructors haven been incorrectly marked with EXPLICIT. The constructors

  template <class Alloc>
    tuple(allocator_arg_t, const Alloc& a);
  template <class Alloc>
    tuple(allocator_arg_t, const Alloc& a, const tuple&);
  template <class Alloc>
    tuple(allocator_arg_t, const Alloc& a, tuple&&);
  

  correspond to the three non-allocator constructors

  constexpr tuple();
  tuple(const tuple&) = default;
  tuple(tuple&&) = default;
  

  and none of these can be explicit as declared (The core language does not propagate explicit for special members when declared in that form). The whole idea of propagating EXPLICIT to the allocator constructors was to reflect the explicit-nature of the corresponding non-tuple constructors. To realize this, EXPLICIT need to be removed from the three aforementioned constructors.

Changes since N3739 (revision 1):

• Improved the current rationale (Thanks to Mike Spertus!)

• During the Rapperswil LEWG discussion a new vote lead to a revised result on the preferred representation form:

  Do we prefer the EXPLICIT(see below) constexpr tuple(UTypes&&...); editorial representation?

  SF-F-N-A-SA

  0-8-3-2-0

  Therefore this revision now uses the annotation EXPLICIT for the affected constructor pairs and defines the meaning of that in Clause 17.

Changes since N3680:

• During a straw-pool vote there was a small majority (4:3) in favour for keeping the two-signatures approach, so this presentation form was used in this revision.

• The original example has been improved.

• The missing application of the declaration pattern to the allocator_arg_t constructors has been fixed.

• Consequent usage of the more precise is_convertible trait instead of the somewhat vague is implicitly convertible description.

Introduction

For many programmers it is a surprise to find out, that the following code is rejected by their compiler:

std::tuple<int, int> pixel_coordinates() 
{
  return {10, -15};  // Oops: Error
}

struct NonCopyable { NonCopyable(int); NonCopyable(const NonCopyable&) = delete; };

std::pair<NonCopyable, double> pmd{42, 3.14};  // Oops: Error

What is wrong with this? Why doesn't this just work?

This paper explains the reason for the current specification of pair and tuple and suggests changes to the working paper to fix these and some other bothersome constraints of these general type wrappers.

Looking backwards

At the time when N3240 was proposed, several driving forces defined the constraints of resolving a bunch of library issues and NB comments.

One notable intention was to prevent that the type wrappers tuple and pair should allow implicit conversions for wrapped types that are not implicitly convertible, as expressed by LWG 1324 and DE 15.

Another relevant requirement was to keep backward-compatibility to C++03 in regard to null pointer literals expressed as integral null constants as described by LWG 811.

At that time there was a strong resistance to add further constructors especially to std::pair. At some point in time there did exist a very large number of such constructors due to allocator support. One important consequence of this pair simplification was the acceptance of N3059.

Thus with the previous acceptance of proposal N3240 the specification provides the following advantages for pair and tuple:

1. Heterogenous template constructors are constrained upon the criterion that the element-wise source types are implicitly convertible to the element-wise destination types.

   struct B { explicit B(bool); };
   
   std::tuple<B> tb = std::tuple<bool>(); // Error
   

2. The non-template constructor tuple(const Types&...) and the corresponding template-constructor are explicit. This prevents that a single-element tuple from being copy-initialized by an argument object and has only an explicit constructor for this construction.

   struct X { X(); explicit X(const X&); } x;
   
   std::tuple<X> tx = x; // Error
   
   struct E { explicit E(int); };
   
   std::tuple<E> te = 42; // Error
   

3. Non-template constructors accepting a sequence of elements, such as explicit tuple(const Types&...) and pair(const T1& x, const T2& y), are still kept to support the special conversion scenario where a pointer(-to-member) element type is initialized with the null pointer constant 0 instead of nullptr.

   class C;
   
   std::tuple<int*> tpi(0); // OK
   std::tuple<int C::*> tpmi(0); // OK
   

Discussion

We propose that pair/tuple obey the same initialization rules as their underlying element types. Unless we have such "perfect initialization", pair and tuple exhibit confusing and unintuitive behavior as illustrated by the examples below.

1. It means that tuple objects cannot be returned from a function as simple as this:

   std::tuple<int, int> foo_tuple() 
   {
     return {1, -1};  // Error
   }
   
   std::pair<int, int> foo_pair() 
   {
     return {1, -1};  // OK
   }
   

2. It means that tuple or pair objects cannot be constructed for element types that cannot be copied:

   struct D { D(int); D(const D&) = delete; };
   
   std::tuple<D> td(12); // Error
   

3. It even means that tuple or pair objects cannot be direct-constructed for element types via an explicit conversion:

   struct Y { explicit Y(int); };
   
   std::tuple<Y> ty(12); // Error
   

4. It has been observed by Johannes Schaub that there exists a defect with tuple in regard to the non-template constructor explicit tuple(const Types&...): The current specification has the effect that the instantiation of tuple<> would be required to be ill-formed because it has two conflicting default constructors.

Starting with the last point: This is indeed a simple oversight that slipped in during the tuple standardization. The TR1 document did have the following specification:

template <class T1 = unspecified ,
          class T2 = unspecified ,
          ...,
          class TM = unspecified >
class tuple
{
public:
  tuple();
  explicit tuple(P1, P2, ..., PN); // iff N > 0
  […]
};

When the variadic form of tuples was proposed via N2151 and its successors, the highlighted size constraint inadvertently got lost.

The other three problems are all caused by (A) constructors that are always explicit and (B) by constrained constructor templates that impose implicit convertible constraints on the element types.

So, notwithstanding the good motivation behind the current specification of pair and tuple, it turns out to have some unfortunate consequences.

This proposal is intending to solve all these problems by a simple procedure that still ensures that all positive aspects of the current specification are conserved.

"Perfect initialization"

Before explaining the general outline of this proposal it is more helpful to start with a simple, but useful programming idiom.

Consider the following class template A that is intended to be used as a wrapper for some other type T:

#include <type_traits>
#include <utility>

template<class T>
struct A {
  template<class U,
    typename std::enable_if<
      std::is_constructible<T, U>::value &&
      std::is_convertible<U, T>::value
    , bool>::type = false
  >
  A(U&& u) : t(std::forward<U>(u)) {}

 template<class U,
    typename std::enable_if<
      std::is_constructible<T, U>::value &&
      !std::is_convertible<U, T>::value
    , bool>::type = false
  >
  explicit A(U&& u) : t(std::forward<U>(u)) {}
  
  T t;
};

The shown constructors both use perfect forwarding and they have essentially the same signatures except for one being explicit, the other one not. Furthermore, they are mutually exclusively constrained. In other words: This combination behaves for any destination type T and any argument type U like a single constructor that is either explicit or non-explicit (or no constructor at all). Attempts to construct a A<T> from some value of type U will reflect the allowed initialization forms of the wrapped type T:

struct Im{ Im(int){} };
struct Ex{ explicit Ex(int){} };

A<Im> ai1(1); // OK
A<Im> ai2{2}; // OK

A<Im> ai3 = 3;   // OK
A<Im> ai4 = {4}; // OK

A<Ex> ae1(1); // OK
A<Ex> ae2{2}; // OK

A<Ex> ae3 = 3;   // Error
A<Ex> ae4 = {4}; // Error

This technique can easily be extended to the variadic template case, and when doing so can be considered as a key to solving the problems of tuple and pair.

It should be noted here, that for the general case the std::is_constructible<T, U>::value requirement for the non-explicit constructor which is constrained on std::is_convertible<U, T>::value is not redundant, because it is possible to create types that can be copy-initialized but not direct-initialized:

struct Odd {
  explicit Odd(int) = delete;
  Odd(long){}
};

Odd o2 = 1; // OK
Odd o1(1);  // Error

Technically it would be possible to apply the same technique of creating element-dependent explicit or non-explicit default constructors. This application was shortly considered during the write-up of this proposal, but rejected because for the current C++ rules there is no longer any observable difference for an explicit default constructor that cannot be invoked with more than zero arguments and one that is not explicit.

The technique cannot be applied to copy/move operators in the same way as for the other constructors (because these special member functions cannot be templates) and given the very rare request for such a support the idea was no further investigated by the author. A second argument against providing this support is based on the consistency with the core language rules that the explicit-character of these constructors is not conserved for the implicitly declared versions in classes that contain corresponding sub-objects with such explicit constructors.

Outline

As shown above, the current over-constraining restrictions of the pair and tuple constructors are due to unconditional usage of explicit and implicitly convertible requirements.

The general approach of this proposal is to require "perfect initialization" semantics for pair and tuple constructors extended to the variadic case. Albeit this seemingly doubles the number of constructor declarations in the draft, it does not change the effective number of these for a particular combination of element type and source type of some initialization due to their mutual exclusion property.

In theory the same technique could be applied to the piecewise_construct_t of pair. This proposal does not propose this, because this constructor is specifically asked for by the corresponding tag and there are no further constraint except the is_constructible requirements.

In addition, this proposal fixes the specification problem of tuple<>'s default constructors.

The wording is intentionally chosen, so that an implementation is not required (but allowed) to use the "perfect initialization" idiom.

This is done by taking advantage of the already existing nomenclature "This function does not participate in overload resolution unless […]". Its worth emphasizing that even though this phrase is usually used to describe constrained templates in the Library specification, the actual wording of this doesn't necessarily imply to "sfinae out" template functions. Many library implementations solve this problem by providing a specialization for the empty tuple case that does not provide the additional default constructor, for example. This is also a valid way to ensure that functions don't participate in overload resolution.

Why not explicit for single argument constructors only?

In C++03 explicit constructors had no behavioural difference, unless they had been single-argument constructors, so one might suggest to restrict adding the explicit keyword to constructors that take exactly one argument.

I think this is idea is flawed (unless I'm using specifically tagged constructors like the piecewise-one of pair). Consider the following example:

#include <tuple>
#include <chrono>
#include <iostream>

using hms_t = std::tuple<std::chrono::hours, std::chrono::minutes, std::chrono::seconds>;

void launch_rocket_at(std::chrono::seconds s)
{
  std::cout << "launching rocket in " << s.count() << " seconds!\n";
}

void launch_rocket_at(hms_t times)
{
  using namespace std;
  launch_rocket_at(get<0>(times) + get<1>(times) + get<2>(times));
}

int main()
{
  using namespace std;
  launch_rocket_at(make_tuple(1, 2, 3)); // #1: very scary
  launch_rocket_at({1, 2, 3});           // #2: even scarier
  using namespace std::chrono;
  launch_rocket_at(make_tuple(hours(1), minutes(2), seconds(3))); // #3: Perfectly clear!
  launch_rocket_at({hours(1), minutes(2), seconds(3)});           // #4: Also clear!
  launch_rocket_at(hms_t{1, 2, 3});                               // #5: And this, too
}

which should output:

launching rocket in 3723 seconds!
launching rocket in 3723 seconds!
launching rocket in 3723 seconds!

If the former two calls to function launch_rocket_at where possible, this would directly subvert the intended explicitness of the std::duration constructor and would make using the time-utility types much more unsafe. Why? Consider the following scenario:

If the client believed that the order of the units was seconds, minutes, hours, and input 3, 2, 1, — intending 3 seconds, 2 minutes, and 1 hour — the rocket would launch in 10,921 seconds instead of the intended 3,723 seconds. This mistake can indeed easily happen, if you look again at the lines marked with #1 and #2.

Due to our intentionally conserved constraints to be explicit here we catch that mistake at compile-time, instead of having to shoot the rocket down...

Editorial Representation

During the write-up of this proposal I had the idea of replacing the prototype declaration pairs by a single one expressed by some pseudo-macro that looks like a single declaration. For example

template <class... UTypes>
constexpr tuple(UTypes&&...);
template <class... UTypes>
explicit constexpr tuple(UTypes&&...);

could instead be declared as follows:

template <class... UTypes>
EXPLICIT constexpr tuple(UTypes&&...);

This form of representation still means that EXPLICIT needs to be defined somewhere and somehow, but only once.

There was a strong preference during the Rapperswil 2014 LEWG discussion to use the "macro" instead of the individual declarations.

This paper does not use a previously suggested form of EXPLICIT(see below) instead of EXPLICIT, because there is nothing specific to explain below again (The different SFINAE conditions are not relevant at that point, because they appear as usual with the normal, detailed prototype specifications).

In any way, the final editorial decision is being handed over to the project editor.

Proposed resolution

The proposed wording changes refer to N4296.

1. Add an additional new paragraph at the end of 17.5.2.2 [functions.within.classes] and move the current second paragraph to the end of the first paragraph:

   -1- For the sake of exposition, Clauses 18 through 30 and Annex D do not describe copy/move constructors, assignment operators, or (non-virtual) destructors with the same apparent semantics as those that can be generated by default (12.1, 12.4, 12.8). It is unspecified whether the implementation provides explicit definitions for such member function signatures, or for virtual destructors that can be generated by default.

   -2- It is unspecified whether the implementation provides explicit definitions for such member function signatures, or for virtual destructors that can be generated by default.

   -?- For the sake of exposition, the library clauses sometimes annotate constructors with EXPLICIT. Such a constructor is conditionally declared as either explicit or non-explicit (12.3.1 [class.conv.ctor]). [Note: This is typically implemented by declaring two such constructors, of which at most one participates in overload resolution — end note]

2. Change 20.3.2 [pairs.pair], class template pair synopsis, as indicated:

   namespace std {
     template <class T1, class T2>
     struct pair {
       typedef T1 first_type;
       typedef T2 second_type;
   
       T1 first;
       T2 second;
       pair(const pair&) = default;
       pair(pair&&) = default;
       constexpr pair();
       EXPLICIT constexpr pair(const T1& x, const T2& y);
       template<class U, class V> EXPLICIT constexpr pair(U&& x, V&& y);
       template<class U, class V> EXPLICIT constexpr pair(const pair<U, V>& p);
       template<class U, class V> EXPLICIT constexpr pair(pair<U, V>&& p);
       template <class... Args1, class... Args2>
       pair(piecewise_construct_t,
         tuple<Args1...> first_args, tuple<Args2...> second_args);
   
       pair& operator=(const pair& p);
       template<class U, class V> pair& operator=(const pair<U, V>& p);
       pair& operator=(pair&& p) noexcept(see below);
       template<class U, class V> pair& operator=(pair<U, V>&& p);
   
       void swap(pair& p) noexcept(see below);
     };
   }
   

3. Change 20.3.2 [pairs.pair] around p5 as indicated:

   EXPLICIT constexpr pair(const T1& x, const T2& y);
   

   -5- Requires: is_copy_constructible<first_type>::value is true and is_copy_constructible<second_type>::value is true.

   -6- Effects: The constructor initializes first with x and second with y.

   -?- Remarks: This constructor shall not participate in overload resolution unless is_copy_constructible<first_type>::value is true and is_copy_constructible<second_type>::value is true. The constructor is explicit if and only if is_convertible<const first_type&, first_type>::value is false or is_convertible<const second_type&, second_type>::value is false.

4. Change 20.3.2 [pairs.pair] around p7 as indicated:

   template<class U, class V> EXPLICIT constexpr pair(U&& x, V&& y);
   

   -7- Requires: is_constructible<first_type, U&&>::value is true and is_constructible<second_type, V&&>::value is true.

   -8- Effects: The constructor initializes first with std::forward<U>(x) and second with std::forward<V>(y).

   -9- Remarks: If U is not implicitly convertible to first_type or V is not implicitly convertible to second_type this constructor shall not participate in overload resolution. This constructor shall not participate in overload resolution unless is_constructible<first_type, U&&>::value is true and is_constructible<second_type, V&&>::value is true. The constructor is explicit if and only if is_convertible<U&&, first_type>::value is false or is_convertible<V&&, second_type>::value is false.

5. Change 20.3.2 [pairs.pair] around p10 as indicated:

   template<class U, class V> EXPLICIT constexpr pair(const pair<U, V>& p);
   

   -10- Requires: is_constructible<first_type, const U&>::value is true and is_constructible<second_type, const V&>::value is true.

   -11- Effects: The constructor initializesInitializes members from the corresponding members of the argument.

   -12- Remarks: This constructor shall not participate in overload resolution unless const U& is implicitly convertible to first_type and const V& is implicitly convertible to second_type is_constructible<first_type, const U&>::value is true and is_constructible<second_type, const V&>::value is true. The constructor is explicit if and only if is_convertible<const U&, first_type>::value is false or is_convertible<const V&, second_type>::value is false.

6. Change 20.3.2 [pairs.pair] around p13 as indicated:

   template<class U, class V> EXPLICIT constexpr pair(pair<U, V>&& p);
   

   -13- Requires: is_constructible<first_type, U&&>::value is true and is_constructible<second_type, V&&>::value is true.

   -14- Effects: The constructor initializes first with std::forward<U>(p.first) and second with std::forward<V>(p.second).

   -15- Remarks: This constructor shall not participate in overload resolution unless U is implicitly convertible to first_type and V is implicitly convertible to second_type is_constructible<first_type, U&&>::value is true and is_constructible<second_type, V&&>::value is true. The constructor is explicit if and only if is_convertible<U&&, first_type>::value is false or is_convertible<V&&, second_type>::value is false.

7. Change 20.4.2 [tuple.tuple], class template tuple synopsis, as indicated. The intent is to declare the set of "conditionally explicit" constructors and to fix the multiple default constructor problem for empty tuples.

   namespace std {
     template <class... Types>
     class tuple {
     public:
       // 20.4.2.1, tuple construction
       constexpr tuple();
       EXPLICIT constexpr explicit tuple(const Types&...); // only if sizeof...(Types) >= 1
       template <class... UTypes>
         EXPLICIT constexpr explicit tuple(UTypes&&...);   // only if sizeof...(Types) >= 1
       
       tuple(const tuple&) = default;
       tuple(tuple&&) = default;
     
       template <class... UTypes>
         EXPLICIT constexpr tuple(const tuple<UTypes...>&);
       template <class... UTypes>
         EXPLICIT constexpr tuple(tuple<UTypes...>&&);
   
       template <class U1, class U2>
         EXPLICIT constexpr tuple(const pair<U1, U2>&);          // only if sizeof...(Types) == 2
       template <class U1, class U2>
         EXPLICIT constexpr tuple(pair<U1, U2>&&);               // only if sizeof...(Types) == 2
   
       // allocator-extended constructors
       template <class Alloc>
         tuple(allocator_arg_t, const Alloc& a);
       template <class Alloc>
         EXPLICIT tuple(allocator_arg_t, const Alloc& a, const Types&...);
       template <class Alloc, class... UTypes>
         EXPLICIT tuple(allocator_arg_t, const Alloc& a, UTypes&&...);
       template <class Alloc>
         tuple(allocator_arg_t, const Alloc& a, const tuple&);
       template <class Alloc>
         tuple(allocator_arg_t, const Alloc& a, tuple&&);
       template <class Alloc, class... UTypes>
         EXPLICIT tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
       template <class Alloc, class... UTypes>
         EXPLICIT tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
       template <class Alloc, class U1, class U2>
         EXPLICIT tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
       template <class Alloc, class U1, class U2>
         EXPLICIT tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
   
       [..]
     };
   }
   

8. Change 20.4.2.1 [tuple.cnstr] around p6 as indicated:

   EXPLICIT constexpr explicit tuple(const Types&...);
   

   -6- Requires: is_copy_constructible<Ti>::value is true for all i.

   -7- Effects: The constructor initializesInitializes each element with the value of the corresponding parameter.

   -?- Remarks: This constructor shall not participate in overload resolution unless sizeof...(Types) >= 1 and is_copy_constructible<T_i>::value is true for all i. The constructor is explicit if and only if is_convertible<const T_i&, T_i>::value is false for at least one i.

9. Change 20.4.2.1 [tuple.cnstr] around p8 as indicated:

   template <class... UTypes>
     EXPLICIT constexpr explicit tuple(UTypes&&... u);
   

   -8- Requires: sizeof...(Types) == sizeof...(UTypes). is_constructible<T_i, U_i&&>::value is true for all i.

   -9- Effects: The constructor initializesInitializes the elements in the tuple with the corresponding value in std::forward<UTypes>(u).

   -10- Remarks: This constructor shall not participate in overload resolution unless each type in UTypes is implicitly convertible to its corresponding type in Types sizeof...(Types) >= 1 and is_constructible<T_i, U_i&&>::value is true for all i. The constructor is explicit if and only if is_convertible<U_i&&, T_i>::value is false for at least one i.

10. Change 20.4.2.1 [tuple.cnstr] around p15 as indicated:

    template <class... UTypes> EXPLICIT constexpr tuple(const tuple<UTypes...>& u);
    

    -15- Requires: sizeof...(Types) == sizeof...(UTypes). is_constructible<T_i, const U_i&>::value is true for all i.

    -16- Effects: The constructor initializesConstructs each element of *this with the corresponding element of u.

    -17- Remarks: This constructor shall not participate in overload resolution unless const U_i& is implicitly convertible to T_i for all i is_constructible<T_i, const U_i&>::value is true for all i. The constructor is explicit if and only if is_convertible<const U_i&, T_i>::value is false for at least one i.

11. Change 20.4.2.1 [tuple.cnstr] around p18 as indicated:

    template <class... UTypes> EXPLICIT constexpr tuple(tuple<UTypes...>&& u);
    

    -18- Requires: sizeof...(Types) == sizeof...(UTypes). is_constructible<T_i, U_i&&>::value is true for all i.

    -19- Effects: For all i, the constructor initializes the i^th element of *this with std::forward<U_i>(get<i>(u)).

    -20- Remarks: This constructor shall not participate in overload resolution unless each type in UTypes is implicitly convertible to its corresponding type in Types is_constructible<T_i, U_i&&>::value is true for all i. The constructor is explicit if and only if is_convertible<U_i&&, T_i>::value is false for at least one i.

12. Change 20.4.2.1 [tuple.cnstr] around p21 as indicated:

    template <class U1, class U2> EXPLICIT constexpr tuple(const pair<U1, U2>& u);
    

    -21- Requires: sizeof...(Types) == 2. is_constructible<T₀, const U1&>::value is true for the first type T₀ in Types and is_constructible<T₁, const U2&>::value is true for the second type T₁ in Types.

    -22- Effects: The constructor initializesConstructs the first element with u.first and the second element with u.second.

    -23- Remarks: This constructor shall not participate in overload resolution unless const U1& is implicitly convertible to T₀ and const U2& is implicitly convertible to T₁ is_constructible<T₀, const U1&>::value is true and is_constructible<T₁, const U2&>::value is true. The constructor is explicit if and only if is_convertible<const U1&, T₀>::value is false or is_convertible<const U2&, T₁>::value is false.

13. Change 20.4.2.1 [tuple.cnstr] around p24 as indicated:

    template <class U1, class U2> EXPLICIT constexpr tuple(pair<U1, U2>&& u);
    

    -24- Requires: sizeof...(Types) == 2. is_constructible<T₀, U1&&>::value is true for the first type T₀ in Types and is_constructible<T₁, U2&&>::value is true for the second type T₁ in Types.

    -25- Effects: The constructor iInitializes the first element with std::forward<U1>(u.first) and the second element with std::forward<U2>(u.second).

    -26- Remarks: This constructor shall not participate in overload resolution unless U1 is implicitly convertible to T₀ and U2 is implicitly convertible to T₁ is_constructible<T₀, U1&&>::value is true and is_constructible<T₁, U2&&>::value is true. The constructor is explicit if and only if is_convertible<U1&&, T₀>::value is false or is_convertible<U2&&, T₁>::value is false.

14. Change 20.4.2.1 [tuple.cnstr] around p27 as indicated:

    template <class Alloc>
      tuple(allocator_arg_t, const Alloc& a);
    template <class Alloc>
      EXPLICIT tuple(allocator_arg_t, const Alloc& a, const Types&...);
    template <class Alloc, class... UTypes>
      EXPLICIT tuple(allocator_arg_t, const Alloc& a, UTypes&&...);
    template <class Alloc>
      tuple(allocator_arg_t, const Alloc& a, const tuple&);
    template <class Alloc>
      tuple(allocator_arg_t, const Alloc& a, tuple&&);
    template <class Alloc, class... UTypes>
      EXPLICIT tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
    template <class Alloc, class... UTypes>
      EXPLICIT tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
    template <class Alloc, class U1, class U2>
      EXPLICIT tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
    template <class Alloc, class U1, class U2>
      EXPLICIT tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
    

    -27- Requires: Alloc shall meet the requirements for an Allocator (17.6.3.5).

    -28- Effects: Equivalent to the preceding constructors except that each element is constructed with uses-allocator construction (20.7.7.2).

Implementation Hint

The following example presents how to constrain even non-template functions such as the constructors that directly take the element types.

template<class T1, class T2>
struct pair {

  […]

  template<class U1 = T1, class U2 = T2,
    typename enable_if<
      is_copy_constructible<U1>::value && is_copy_constructible<U2>::value &&
      is_convertible<const U1&, U1>::value && is_convertible<const U2&, U2>::value
    , bool>::type = false
  >
  constexpr pair(const T1&, const T2&);

  template<class U1 = T1, class U2 = T2,
    typename enable_if<
      is_copy_constructible<U1>::value && is_copy_constructible<U2>::value &&
      !(is_convertible<const U1&, U1>::value && is_convertible<const U2&, U2>::value)
    , bool>::type = false
  >
  explicit constexpr pair(const T1&, const T2&);
};

Acknowledgements

I would like to thank Howard Hinnant for his very helpful discussions and comments during reviews of this paper and for his motivating example. Thanks also to Jonathan Wakely for his review that improved this proposal to a large extend. Thanks as well go to Mike Spertus for helping to improve the rationale.