```
template<class VT>
static constexpr bool
```*is-callable-from* = *see below*;

If *noex* is true,
*is-callable-from*<VT> is equal to:
is_nothrow_invocable_r_v<R, VT cv *ref*, ArgTypes...> &&
is_nothrow_invocable_r_v<R, VT *inv-quals*, ArgTypes...>

Otherwise, *is-callable-from*<VT> is equal to:
is_invocable_r_v<R, VT cv *ref*, ArgTypes...> &&
is_invocable_r_v<R, VT *inv-quals*, ArgTypes...>

```
copyable_function() noexcept;
copyable_function(nullptr_t) noexcept;
```

```
copyable_function(const copyable_function& f);
```

```
copyable_function(copyable_function&& f) noexcept;
```

```
template<class F> copyable_function(F&& f);
```

- f is a null function pointer value, or
- f is a null member pointer value, or
- remove_cvref_t<F> is a specialization of the copyable_function class template, and f has no target object.

Otherwise, *this has a target object of type VT
direct-non-list-initialized with std::forward<F>(f).

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

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

```
copyable_function& operator=(const copyable_function& f);
```

```
copyable_function& operator=(copyable_function&& f);
```

```
copyable_function& operator=(nullptr_t) noexcept;
```

```
template<class F> copyable_function& operator=(F&& f);
```

```
~copyable_function();
```