namespace std { class any { public: // [any.cons], construction and destruction constexpr any() noexcept; any(const any& other); any(any&& other) noexcept; template<class T> any(T&& value); template<class T, class... Args> explicit any(in_place_type_t<T>, Args&&...); template<class T, class U, class... Args> explicit any(in_place_type_t<T>, initializer_list<U>, Args&&...); ~any(); // [any.assign], assignments any& operator=(const any& rhs); any& operator=(any&& rhs) noexcept; template<class T> any& operator=(T&& rhs); // [any.modifiers], modifiers template<class T, class... Args> decay_t<T>& emplace(Args&& ...); template<class T, class U, class... Args> decay_t<T>& emplace(initializer_list<U>, Args&&...); void reset() noexcept; void swap(any& rhs) noexcept; // [any.observers], observers bool has_value() const noexcept; const type_info& type() const noexcept; }; }

An object of class any stores an instance of any type that meets the constructor requirements or it has no value,
and this is referred to as the *state* of the class any object.

The stored instance is called the *contained value*.

Two states are equivalent if either they both have no value, or they both have a value and the contained values are equivalent.

Implementations should avoid the use of dynamically allocated memory for a small contained value.

However, any such small-object optimization shall only be applied to types T for which
is_nothrow_move_constructible_v<T> is true.

```
constexpr any() noexcept;
```

```
any(const any& other);
```

```
any(any&& other) noexcept;
```

Otherwise, constructs an object of type any that
contains either the contained value of other, or
contains an object of the same type constructed from
the contained value of other considering that contained value as an rvalue.

```
template<class T>
any(T&& value);
```

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

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

```
~any();
```

```
any& operator=(const any& rhs);
```

```
any& operator=(any&& rhs) noexcept;
```

```
template<class T>
any& operator=(T&& rhs);
```

```
template<class T, class... Args>
decay_t<T>& emplace(Args&&... args);
```

Remarks:
If an exception is thrown during the call to VT's constructor,
*this does not contain a value, and any previously contained value
has been destroyed.

This function shall not participate in overload resolution unless
is_copy_constructible_v<VT> is true and
is_constructible_v<VT, Args...> is true.

```
template<class T, class U, class... Args>
decay_t<T>& emplace(initializer_list<U> il, Args&&... args);
```

Remarks:
If an exception is thrown during the call to VT's constructor,
*this does not contain a value, and any previously contained value
has been destroyed.

The function shall not participate in overload resolution unless
is_copy_constructible_v<VT> is true and
is_constructible_v<VT, initializer_list<U>&, Args...> is true.

```
void reset() noexcept;
```

```
void swap(any& rhs) noexcept;
```

```
bool has_value() const noexcept;
```

```
const type_info& type() const noexcept;
```