The defaulted move and copy constructor, respectively, of
tuple shall be a constexpr function if and only if all
required element-wise initializations for copy and move, respectively,
would satisfy the requirements for a constexpr function.

The
defaulted move and copy constructor of tuple<> shall be
constexpr functions.

In the constructor descriptions that follow, let i be in the range
[0, sizeof...(Types)) in order, Ti
be the ith type in Types, and
Ui be the ith type in a template parameter pack named UTypes, where indexing
is zero-based.

For each tuple assignment operator, an exception is thrown only if the
assignment of one of the types in Types throws an exception.

In the function descriptions that follow, let i be in the range [0, sizeof...​(Types))
in order, Ti be the ith type in Types,
and Ui be the ith type in a
template parameter pack named UTypes, where indexing is zero-based.

Remarks: This operator shall not participate in overload resolution unless
sizeof...(Types) == 2 and
is_­assignable_­v<T0&, const U1&> is true for the first type T0 in
Types and is_­assignable_­v<T1&, const U2&> is true for the
second type T1 in Types.

Remarks:
This operator shall not participate in overload resolution unless
sizeof...(Types) == 2 and
is_­assignable_­v<T0&, U1&&> is true for the first type T0 in
Types and is_­assignable_­v<T1&, U2&&> is true for the second
type T1 in Types.

Effects: Constructs a tuple of references to the arguments in t suitable
for forwarding as arguments to a function.

Because the result may contain references
to temporary variables, a program shall ensure that the return value of this
function does not outlive any of its arguments (e.g., the program should typically
not store the result in a named variable).

If the expression TS​::​value is well-formed
when treated as an unevaluated operand, then each
of the three templates shall satisfy the UnaryTypeTrait requirements ([meta.rqmts])
with a base characteristic of

The compilation of the expression can result in side effects
such as the instantiation of class template specializations and
function template specializations, the generation of implicitly-defined functions, and so on.

Such side effects are not in the “immediate context” and
can result in the program being ill-formed.

The reason get is a
non-member function is that if this functionality had been
provided as a member function, code where the type
depended on a template parameter would have required using
the template keyword.