[func.wrap]

Let t be an object of a type that is a specialization of function, copyable_function, or move_only_function, such that the target object x of t has a type that is a specialization of function, copyable_function, or move_only_function.

Each argument of the invocation of x evaluated as part of the invocation of t may alias an argument in the same position in the invocation of t that has the same type, even if the corresponding parameter is not of reference type.

[Example 1: move_only_function<void(T)> f{copyable_function<void(T)>{[](T) {}; T t; f(t); / it is unspecified how many copies of T are made — end example]

Recommended practice: Implementations should avoid double wrapping when constructing polymorphic wrappers from one another.

22.10.17.2 Class bad_function_call [func.wrap.badcall]

An exception of type bad_function_call is thrown by function::operator() ([func.wrap.func.inv]) when the function wrapper object has no target.

namespace std { class bad_function_call : public exception { public: / see [exception] for the specification of the special member functions const char* what() const noexcept override; }; }

🔗

const char* what() const noexcept override;

Returns: An implementation-defined ntbs.

22.10.17.3 Class template function [func.wrap.func]

22.10.17.3.1 General [func.wrap.func.general]

🔗

namespace std { template<class R, class. ArgTypes> class function<R(ArgTypes..)> { public: using result_type = R; / [func.wrap.func.con], construct/copy/destroy function() noexcept; function(nullptr_t) noexcept; function(const function&); function(function&&) noexcept; template<class F> function(F&&); function& operator=(const function&); function& operator=(function&&); function& operator=(nullptr_t) noexcept; template<class F> function& operator=(F&&); template<class F> function& operator=(reference_wrapper<F>) noexcept; ~function(); / [func.wrap.func.mod], function modifiers void swap(function&) noexcept; / [func.wrap.func.cap], function capacity explicit operator bool() const noexcept; / [func.wrap.func.inv], function invocation R operator()(ArgTypes..) const; / [func.wrap.func.targ], function target access const type_info& target_type() const noexcept; template<class T> T* target() noexcept; template<class T> const T* target() const noexcept; }; template<class R, class. ArgTypes> function(R(*)(ArgTypes..) -> function<R(ArgTypes..)>; template<class F> function(F) -> function<see below>; }

The function class template provides polymorphic wrappers that generalize the notion of a function pointer.

Wrappers can store, copy, and call arbitrary callable objects ([func.def]), given a call signature ([func.def]).

The function class template is a call wrapper ([func.def]) whose call signature ([func.def]) is R(ArgTypes..).

[Note 1:

The types deduced by the deduction guides for function might change in future revisions of C++.

— end note]

22.10.17.3.2 Constructors and destructor [func.wrap.func.con]

🔗

function() noexcept;

Postconditions: !*this.

🔗

function(nullptr_t) noexcept;

Postconditions: !*this.

🔗

function(const function& f);

Postconditions: !*this if !f; otherwise, the target object of *this is a copy of the target object of f.

Throws: Nothing if f's target is a specialization of reference_wrapper or a function pointer.

Otherwise, may throw bad_alloc or any exception thrown by the copy constructor of the stored callable object.

Recommended practice: Implementations should avoid the use of dynamically allocated memory for small callable objects, for example, where f's target is an object holding only a pointer or reference to an object and a member function pointer.

🔗

function(function&& f) noexcept;

Postconditions: If !f, *this has no target; otherwise, the target of *this is equivalent to the target of f before the construction, and f is in a valid state with an unspecified value.

🔗

template<class F> function(F&& f);

Preconditions: FD meets the Cpp17CopyConstructible requirements.

Postconditions: !*this is true if any of the following hold:

(12.1)
f is a null function pointer value.
(12.2)
f is a null member pointer value.
(12.3)
remove_cvref_t<F> is a specialization of the function class template, and !f is true.

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

Throws: Nothing if FD is a specialization of reference_wrapper or a function pointer type.

Otherwise, may throw bad_alloc or any exception thrown by the initialization of the target object.

Recommended practice: Implementations should avoid the use of dynamically allocated memory for small callable objects, for example, where f refers to an object holding only a pointer or reference to an object and a member function pointer.

🔗

template<class F> function(F) -> function<see below>;

Constraints: &F::operator() is well-formed when treated as an unevaluated operand and either

(16.1)
F::operator() is a non-static member function and decltype(&F::operator() is either of the form R(G::*)(A..) cv & ${o p t noexcept {o p t or of the form R (*) (G, A . .) noexcept {o p t for a type G, or}_{o p t for a type G, or}}_{o p t or of the form R (*) (G, A . .) noexcept {o p t for a type G, or}_{o p t for a type G, or}}}_{o p t noexcept {o p t or of the form R (*) (G, A . .) noexcept {o p t for a type G, or}_{o p t for a type G, or}}_{o p t or of the form R (*) (G, A . .) noexcept {o p t for a type G, or}_{o p t for a type G, or}}}$
(16.2)
F::operator() is a static member function and decltype(&F::operator() is of the form R(*)(A..) noexcept ${o p t .}_{o p t .}$

[Example 1: void f() { int i{5}; function g = [&](double) { return i; }; / deduces function<int(double)> } — end example]

🔗

function& operator=(const function& f);

Returns: *this.

🔗

function& operator=(function&& f);

Effects: Replaces the target of *this with the target of f.

Returns: *this.

🔗

function& operator=(nullptr_t) noexcept;

Returns: *this.

🔗

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

Returns: *this.

🔗

template<class F> function& operator=(reference_wrapper<F> f) noexcept;

Returns: *this.

🔗

~function();

Effects: If *this != nullptr, destroys the target of this.

22.10.17.3.3 Modifiers [func.wrap.func.mod]

🔗

void swap(function& other) noexcept;

Effects: Interchanges the target objects of *this and other.

22.10.17.3.4 Capacity [func.wrap.func.cap]

🔗

explicit operator bool() const noexcept;

Returns: true if *this has a target, otherwise false.

22.10.17.3.5 Invocation [func.wrap.func.inv]

🔗

R operator()(ArgTypes.. args) const;

Returns: INVOKE<R>(f, std::forward<ArgTypes>(args).) ([func.require]), where f is the target object ([func.def]) of *this.

Throws: bad_function_call if !*this; otherwise, any exception thrown by the target object.

22.10.17.3.6 Target access [func.wrap.func.targ]

🔗

const type_info& target_type() const noexcept;

Returns: If *this has a target of type T, typeid(T); otherwise, typeid(void).

🔗

template<class T>       T* target() noexcept;
template<class T> const T* target() const noexcept;

Returns: If target_type() == typeid(T) a pointer to the stored function target; otherwise a null pointer.

22.10.17.3.7 Null pointer comparison operator functions [func.wrap.func.nullptr]

🔗

template<class R, class. ArgTypes>
  bool operator=(const function<R(ArgTypes..)>& f, nullptr_t) noexcept;

Returns: !f.

22.10.17.3.8 Specialized algorithms [func.wrap.func.alg]

🔗

template<class R, class. ArgTypes>
  void swap(function<R(ArgTypes..)>& f1, function<R(ArgTypes..)>& f2) noexcept;

The header provides partial specializations of move_only_function for each combination of the possible replacements of the placeholders cv, ref, and noex where

(1.1)
cv is either const or empty,
(1.2)
ref is either &, &&, or empty, and
(1.3)
noex is either true or false.

For each of the possible combinations of the placeholders mentioned above, there is a placeholder inv-quals defined as follows:

(2.1)
If ref is empty, let inv-quals be cv&,
(2.2)
otherwise, let inv-quals be cv ref.

22.10.17.4.2 Class template move_only_function [func.wrap.move.class]

🔗

namespace std { template<class R, class. ArgTypes> class move_only_function<R(ArgTypes..) cv ref noexcept(noex)> { public: using result_type = R; / [func.wrap.move.ctor], constructors, assignments, and destructor move_only_function() noexcept; move_only_function(nullptr_t) noexcept; move_only_function(move_only_function&&) noexcept; template<class F> move_only_function(F&&); template<class T, class. Args> explicit move_only_function(in_place_type_t<T>, Args&&.); template<class T, class U, class. Args> explicit move_only_function(in_place_type_t<T>, initializer_list, Args&&.); move_only_function& operator=(move_only_function&&); move_only_function& operator=(nullptr_t) noexcept; template<class F> move_only_function& operator=(F&&); ~move_only_function(); / [func.wrap.move.inv], invocation explicit operator bool() const noexcept; R operator()(ArgTypes..) cv ref noexcept(noex); / [func.wrap.move.util], utility void swap(move_only_function&) noexcept; friend void swap(move_only_function&, move_only_function&) noexcept; friend bool operator=(const move_only_function&, nullptr_t) noexcept; private: template<class VT> static constexpr bool is-callable-from = see below; / exposition only }; }

The move_only_function class template provides polymorphic wrappers that generalize the notion of a callable object ([func.def]).

These wrappers can store, move, and call arbitrary callable objects, given a call signature.

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

[Note 1:

Such small-object optimization can only be applied to a type T for which is_nothrow_move_constructible_v<T> is true.

— end note]

22.10.17.4.3 Constructors, assignments, and destructor [func.wrap.move.ctor]

🔗

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..>

🔗

move_only_function() noexcept;
move_only_function(nullptr_t) noexcept;

Postconditions: *this has no target object.

🔗

move_only_function(move_only_function&& f) noexcept;

Postconditions: The target object of *this is the target object f had before construction, and f is in a valid state with an unspecified value.

🔗

template<class F> move_only_function(F&& f);

Preconditions: VT meets the Cpp17Destructible requirements, and if is_move_constructible_v<VT> is true, VT meets the Cpp17MoveConstructible requirements.

Postconditions: *this has no target object if any of the following hold:

(8.1)
f is a null function pointer value,
(8.2)
f is a null member pointer value, or
(8.3)
remove_cvref_t<F> is a specialization of the move_only_function or 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).

Throws: Any exception thrown by the initialization of the target object.

May throw bad_alloc unless VT is a function pointer or a specialization of reference_wrapper.

🔗

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

Preconditions: VT meets the Cpp17Destructible requirements, and if is_move_constructible_v<VT> is true, VT meets the Cpp17MoveConstructible requirements.

Postconditions: *this has a target object of type VT direct-non-list-initialized with std::forward<Args>(args)..

Throws: Any exception thrown by the initialization of the target object.

May throw bad_alloc unless VT is a function pointer or a specialization of reference_wrapper.

🔗

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

Constraints:

(17.1)
is_constructible_v<VT, initializer_list&, Args..> is true, and
(17.2)
is-callable-from<VT> is true.

Preconditions: VT meets the Cpp17Destructible requirements, and if is_move_constructible_v<VT> is true, VT meets the Cpp17MoveConstructible requirements.

Postconditions: *this has a target object of type VT direct-non-list-initialized with ilist, std::forward<Args>(args)..

Throws: Any exception thrown by the initialization of the target object.

May throw bad_alloc unless VT is a function pointer or a specialization of reference_wrapper.

🔗

move_only_function& operator=(move_only_function&& f);

Returns: *this.

🔗

move_only_function& operator=(nullptr_t) noexcept;

Returns: *this.

🔗

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

Returns: *this.

🔗

~move_only_function();

Effects: Destroys the target object of *this, if any.

22.10.17.4.4 Invocation [func.wrap.move.inv]

🔗

explicit operator bool() const noexcept;

Returns: true if *this has a target object, otherwise false.

🔗

R operator()(ArgTypes.. args) cv ref noexcept(noex);

Effects: Equivalent to: return INVOKE<R>(static_cast<F inv-quals>(f), std::forward<ArgTypes>(args).); where f is an lvalue designating the target object of *this and F is the type of f.

22.10.17.4.5 Utility [func.wrap.move.util]

🔗

void swap(move_only_function& other) noexcept;

Effects: Exchanges the target objects of *this and other.

🔗

friend void swap(move_only_function& f1, move_only_function& f2) noexcept;

Effects: Equivalent to f1.swap(f2).

🔗

friend bool operator=(const move_only_function& f, nullptr_t) noexcept;

The header provides partial specializations of copyable_function for each combination of the possible replacements of the placeholders cv, ref, and noex where

(1.1)
cv is either const or empty,
(1.2)
ref is either &, &&, or empty, and
(1.3)
noex is either true or false.

For each of the possible combinations of the placeholders mentioned above, there is a placeholder inv-quals defined as follows:

(2.1)
If ref is empty, let inv-quals be cv&,
(2.2)
otherwise, let inv-quals be cv ref.

22.10.17.5.2 Class template copyable_function [func.wrap.copy.class]

🔗

namespace std { template<class R, class. ArgTypes> class copyable_function<R(ArgTypes..) cv ref noexcept(noex)> { public: using result_type = R; / [func.wrap.copy.ctor], constructors, assignments, and destructor copyable_function() noexcept; copyable_function(nullptr_t) noexcept; copyable_function(const copyable_function&); copyable_function(copyable_function&&) noexcept; template<class F> copyable_function(F&&); template<class T, class. Args> explicit copyable_function(in_place_type_t<T>, Args&&.); template<class T, class U, class. Args> explicit copyable_function(in_place_type_t<T>, initializer_list, Args&&.); copyable_function& operator=(const copyable_function&); copyable_function& operator=(copyable_function&&); copyable_function& operator=(nullptr_t) noexcept; template<class F> copyable_function& operator=(F&&); ~copyable_function(); / [func.wrap.copy.inv], invocation explicit operator bool() const noexcept; R operator()(ArgTypes..) cv ref noexcept(noex); / [func.wrap.copy.util], utility void swap(copyable_function&) noexcept; friend void swap(copyable_function&, copyable_function&) noexcept; friend bool operator=(const copyable_function&, nullptr_t) noexcept; private: template<class VT> static constexpr bool is-callable-from = see below; / exposition only }; }

The copyable_function class template provides polymorphic wrappers that generalize the notion of a callable object ([func.def]).

These wrappers can store, copy, move, and call arbitrary callable objects, given a call signature.

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

[Note 1:

Such small-object optimization can only be applied to a type T for which is_nothrow_move_constructible_v<T> is true.

— end note]

22.10.17.5.3 Constructors, assignments, and destructor [func.wrap.copy.ctor]

🔗

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;

Postconditions: *this has no target object.

🔗

copyable_function(const copyable_function& f);

Postconditions: *this has no target object if f had no target object.

Otherwise, the target object of *this is a copy of the target object of f.

Throws: Any exception thrown by the initialization of the target object.

May throw bad_alloc.

🔗

copyable_function(copyable_function&& f) noexcept;

Postconditions: The target object of *this is the target object f had before construction, and f is in a valid state with an unspecified value.

🔗

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

Preconditions: VT meets the Cpp17Destructible and Cpp17CopyConstructible requirements.

Postconditions: *this has no target object if any of the following hold:

(10.1)
f is a null function pointer value, or
(10.2)
f is a null member pointer value, or
(10.3)
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).

Throws: Any exception thrown by the initialization of the target object.

May throw bad_alloc unless VT is a function pointer or a specialization of reference_wrapper.

🔗

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

Preconditions: VT meets the Cpp17Destructible and Cpp17CopyConstructible requirements.

Postconditions: *this has a target object of type VT direct-non-list-initialized with std::forward<Args>(args)..

Throws: Any exception thrown by the initialization of the target object.

May throw bad_alloc unless VT is a pointer or a specialization of reference_wrapper.

🔗

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

Constraints:

(19.1)
is_constructible_v<VT, initializer_list&, Args..> is true, and
(19.2)
is-callable-from<VT> is true.

Preconditions: VT meets the Cpp17Destructible and Cpp17CopyConstructible requirements.

Postconditions: *this has a target object of type VT direct-non-list-initialized with ilist, std::forward<Args>(args)..

Throws: Any exception thrown by the initialization of the target object.

May throw bad_alloc unless VT is a pointer or a specialization of reference_wrapper.

🔗

copyable_function& operator=(const copyable_function& f);

Returns: *this.

🔗

copyable_function& operator=(copyable_function&& f);

Returns: *this.

🔗

copyable_function& operator=(nullptr_t) noexcept;

Returns: *this.

🔗

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

Returns: *this.

🔗

~copyable_function();

Effects: Destroys the target object of *this, if any.

22.10.17.5.4 Invocation [func.wrap.copy.inv]

🔗

explicit operator bool() const noexcept;

Returns: true if *this has a target object, otherwise false.

🔗

R operator()(ArgTypes.. args) cv ref noexcept(noex);

Effects: Equivalent to: return INVOKE<R>(static_cast<F inv-quals>(f), std::forward<ArgTypes>(args).); where f is an lvalue designating the target object of *this and F is the type of f.

22.10.17.5.5 Utility [func.wrap.copy.util]

🔗

void swap(copyable_function& other) noexcept;

Effects: Exchanges the target objects of *this and other.

🔗

friend void swap(copyable_function& f1, copyable_function& f2) noexcept;

Effects: Equivalent to f1.swap(f2).

🔗

friend bool operator=(const copyable_function& f, nullptr_t) noexcept;

The header provides partial specializations of function_ref for each combination of the possible replacements of the placeholders cv and noex where:

(1.1)
cv is either const or empty, and
(1.2)
noex is either true or false.

22.10.17.6.2 Class template function_ref [func.wrap.ref.class]

🔗

namespace std { template<class R, class. ArgTypes> class function_ref<R(ArgTypes..) cv noexcept(noex)> { public: / [func.wrap.ref.ctor], constructors and assignment operators template<class F> function_ref(F*) noexcept; template<class F> constexpr function_ref(F&&) noexcept; template<auto f> constexpr function_ref(constant_arg_t<f>) noexcept; template<auto f, class U> constexpr function_ref(constant_arg_t<f>, U&&) noexcept; template<auto f, class T> constexpr function_ref(constant_arg_t<f>, cv T*) noexcept; constexpr function_ref(const function_ref&) noexcept = default; constexpr function_ref& operator=(const function_ref&) noexcept = default; template<class T> function_ref& operator=(T) = delete; / [func.wrap.ref.inv], invocation R operator()(ArgTypes..) const noexcept(noex); private: template<class. T> static constexpr bool is-invocable-using = see below; / exposition only R (*thunk-ptr)(BoundEntityType, ArgTypes&&.) noexcept(noex); / exposition only BoundEntityType bound-entity; / exposition only }; / [func.wrap.ref.deduct], deduction guides template<class F> function_ref(F*) -> function_ref<F>; template<auto f> function_ref(constant_arg_t<f>) -> function_ref<see below>; template<auto f, class T> function_ref(constant_arg_t<f>, T&&) -> function_ref<see below>; }

An object of class function_ref<R(Args..) cv noexcept(noex)> stores a pointer to function thunk-ptr and an object bound-entity.

The object bound-entity has an unspecified trivially copyable type BoundEntityType, that models copyable and is capable of storing a pointer to object value or a pointer to function value.

The type of thunk-ptr is R(*)(BoundEntityType, Args&&.) noexcept(noex).

Each specialization of function_ref is a trivially copyable type ([basic.types.general]) that models copyable .

Within subclause [func.wrap.ref], call-args is an argument pack with elements such that decltype(call-args)). denote ArgTypes&&. respectively.

22.10.17.6.3 Constructors and assignment operators [func.wrap.ref.ctor]

🔗

template<class. T>
  static constexpr bool is-invocable-using = see below;

If noex is true, is-invocable-using<T..> is equal to: is_nothrow_invocable_r_v<R, T.., ArgTypes..>

Otherwise, is-invocable-using<T..> is equal to: is_invocable_r_v<R, T.., ArgTypes..>

🔗

template<class F> function_ref(F* f) noexcept;

Effects: Initializes bound-entity with f, and thunk-ptr with the address of a function thunk such that thunk(bound-entity, call-args..) is expression-equivalent ([defns.expression.equivalent]) to invoke_r<R>(f, call-args..).

🔗

template<class F> constexpr function_ref(F&& f) noexcept;

Effects: Initializes bound-entity with addressof(f), and thunk-ptr with the address of a function thunk such that thunk(bound-entity, call-args..) is expression-equivalent ([defns.expression.equivalent]) to invoke_r<R>(static_cast<cv T&>(f), call-args..).

🔗

template<auto f> constexpr function_ref(constant_arg_t<f>) noexcept;

Mandates: If is_pointer_v<F> || is_member_pointer_v<F> is true, then f != nullptr is true.

Effects: Initializes bound-entity with a pointer to an unspecified object or null pointer value, and thunk-ptr with the address of a function thunk such that thunk(bound-entity, call-args..) is expression-equivalent ([defns.expression.equivalent]) to invoke_r<R>(f, call-args..).

🔗

template<auto f, class U>
  constexpr function_ref(constant_arg_t<f>, U&& obj) noexcept;

Let T be remove_reference_t and F be decltype(f).

Mandates: If is_pointer_v<F> || is_member_pointer_v<F> is true, then f != nullptr is true.

Effects: Initializes bound-entity with addressof(obj), and thunk-ptr with the address of a function thunk such that thunk(bound-entity, call-args..) is expression-equivalent ([defns.expression.equivalent]) to invoke_r<R>(f, static_cast<cv T&>(obj), call-args..).

🔗

template<auto f, class T>
  constexpr function_ref(constant_arg_t<f>, cv T* obj) noexcept;

Mandates: If is_pointer_v<F> || is_member_pointer_v<F> is true, then f != nullptr is true.

Preconditions: If is_member_pointer_v<F> is true, obj is not a null pointer.

Effects: Initializes bound-entity with obj, and thunk-ptr with the address of a function thunk such that thunk(bound-entity, call-args..) is expression-equivalent ([defns.expression.equivalent]) to invoke_r<R>(f, obj, call-args..).

🔗

template<class T> function_ref& operator=(T) = delete;

Constraints:

(21.1)
T is not the same type as function_ref,
(21.2)
is_pointer_v<T> is false, and
(21.3)
T is not a specialization of constant_arg_t.

22.10.17.6.4 Invocation [func.wrap.ref.inv]

🔗

R operator()(ArgTypes.. args) const noexcept(noex);

Effects: Equivalent to: return thunk-ptr(bound-entity, std::forward<ArgTypes>(args).);

22.10.17.6.5 Deduction guides [func.wrap.ref.deduct]

🔗

template<class F>
  function_ref(F*) -> function_ref<F>;

Constraints: is_function_v<F> is true.

🔗

template<auto f>
  function_ref(constant_arg_t<f>) -> function_ref<see below>;

Remarks: The deduced type is function_ref<F>.

🔗

template<auto f, class T>
  function_ref(constant_arg_t<f>, T&&) -> function_ref<see below>;

Constraints:

(6.1)
F is of the form R(G::*)(A..) cv & ${o p t noexcept (E) for a type G, or}_{o p t noexcept (E) for a type G, or}$
(6.2)
F is of the form M G::* for a type G and an object type M, in which case let R be invoke_result_t<F, T&>, A.. be an empty pack, and E be true, or
(6.3)
F is of the form R(*)(G, A..) noexcept(E) for a type G.

Remarks: The deduced type is function_ref<R(A..) noexcept(E)>.