In the descriptions that follow, let i be in the range [0, sizeof...(Types)),
and 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,
unless is_same_v<decay_t<T>, variant> is false,
unless decay_t<T> is neither
a specialization of in_place_type_t
nor a specialization of in_place_index_t,
unless is_constructible_v<, T> is true,
and unless 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);
```