```
template<class T> struct tuple_size;
```

All specializations of tuple_size meet the
*Cpp17UnaryTypeTrait* requirements ([meta.rqmts]) with a
base characteristic of integral_constant<size_t, N>
for some N.

```
template<class... Types>
struct tuple_size<tuple<Types...>> : public integral_constant<size_t, sizeof...(Types)> { };
```

```
template<size_t I, class... Types>
struct tuple_element<I, tuple<Types...>> {
using type = TI;
};
```

```
template<class T> struct tuple_size<const T>;
```

If the expression TS::value is well-formed
when treated as an unevaluated operand ([term.unevaluated.operand]), then
each specialization of the template meets the *Cpp17UnaryTypeTrait* requirements ([meta.rqmts])
with a base characteristic of
integral_constant<size_t, TS::value>

Otherwise, it has no member value.

Only the validity of the immediate context of the expression is considered.

[*Note 1*: *end note*]

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.

โ ```
template<size_t I, class T> struct tuple_element<I, const T>;
```

Then
each specialization of the template meets the *Cpp17TransformationTrait* requirements ([meta.rqmts])
with a member typedef type that names the type add_const_t<TE>.