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.

```
tuple& operator=(const tuple& u);
```

Remarks: This operator shall be defined as deleted unless is_copy_assignable_v<Ti> is true for all i.

```
tuple& operator=(tuple&& u) noexcept(see below);
```

Remarks: This operator shall be defined as deleted unless is_move_assignable_v<Ti> is true for all i.

Remarks: The expression inside noexcept is equivalent to the logical and of the following expressions:

`is_nothrow_move_assignable_v<Ti>`

where Ti is the ith type in Types.

```
template <class... UTypes> tuple& operator=(const tuple<UTypes...>& u);
```

Remarks: This operator shall not participate in overload resolution unless sizeof...(Types) == sizeof...(UTypes) and is_assignable_v<Ti&, const Ui&> is true for all i.

```
template <class... UTypes> tuple& operator=(tuple<UTypes...>&& u);
```

Remarks: This operator shall not participate in overload resolution unless is_assignable_v<Ti&, Ui&&> == true for all i and sizeof...(Types) == sizeof...(UTypes).

```
template <class U1, class U2> tuple& operator=(const pair<U1, U2>& u);
```

Effects: Assigns u.first to the first element of *this and u.second to the second element of *this.

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.

```
template <class U1, class U2> tuple& operator=(pair<U1, U2>&& u);
```

Effects: Assigns std::forward<U1>(u.first) to the first
element of *this and

std::forward<U2>(u.second) to the
second element of *this.

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.