In the descriptions that follow, let i be in the range [0, sizeof...(Types)),
and T be the type in Types....

```
constexpr variant() noexcept(see below);
```

```
variant(const variant& w);
```

```
variant(variant&& w) noexcept(see below);
```

```
template<class T> constexpr variant(T&& t) noexcept(see below);
```

Remarks:
This function shall not participate in overload resolution unless

- sizeof...(Types) is nonzero,
- is_same_v<remove_cvref_t<T>, variant> is false,
- remove_cvref_t<T> is neither a specialization of in_place_type_t nor a specialization of in_place_index_t,
- is_constructible_v<T, T> is true, and
- the expression FUN(std::forward<T>(t)) (with FUN being the above-mentioned set of imaginary functions) is well-formed.

```
template<class T, class... Args> constexpr explicit variant(in_place_type_t<T>, Args&&... args);
```

```
template<class T, class U, class... Args>
constexpr explicit variant(in_place_type_t<T>, initializer_list<U> il, Args&&... args);
```

```
template<size_t I, class... Args> constexpr explicit variant(in_place_index_t<I>, Args&&... args);
```

```
template<size_t I, class U, class... Args>
constexpr explicit variant(in_place_index_t<I>, initializer_list<U> il, Args&&... args);
```