[func.wrap] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpu6_q5h8z/{from.md → to.md} +558 -18

tmp/tmpu6_q5h8z/{from.md → to.md} RENAMED Viewed

@@ -3,10 +3,31 @@
 #### General <a id="func.wrap.general">[[func.wrap.general]]</a>
 Subclause [[func.wrap]] describes polymorphic wrapper classes that
 encapsulate arbitrary callable objects.
 #### Class `bad_function_call` <a id="func.wrap.badcall">[[func.wrap.badcall]]</a>
 An exception of type `bad_function_call` is thrown by
 `function::operator()` [[func.wrap.func.inv]] when the function wrapper
 object has no target.
@@ -31,12 +52,10 @@ const char* what() const noexcept override;
 ##### General <a id="func.wrap.func.general">[[func.wrap.func.general]]</a>
 ``` cpp
 namespace std {
-  template<class> class function;       // not defined
   template<class R, class... ArgTypes>
   class function<R(ArgTypes...)> {
   public:
     using result_type = R;
@@ -80,16 +99,10 @@ namespace std {
 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]].
-A callable type [[func.def]] `F` is *Lvalue-Callable* for argument types
-`ArgTypes` and return type `R` if the expression
-`INVOKE<R>(declval<F&>(), declval<ArgTypes>()...)`, considered as an
-unevaluated operand [[term.unevaluated.operand]], is well-formed
-[[func.require]].
 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*]
@@ -111,11 +124,11 @@ function(nullptr_t) noexcept;
 ``` cpp
 function(const function& f);
 ```
 *Ensures:* `!*this` if `!f`; otherwise, the target object of `*this` is
-a copy of `f.target()`.
 *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.
@@ -145,12 +158,11 @@ template<class F> function(F&& f);
 Let `FD` be `decay_t<F>`.
 *Constraints:*
 - `is_same_v<remove_cvref_t<F>, function>` is `false`, and
-- `FD` is Lvalue-Callable [[func.wrap.func]] for argument types
-  `ArgTypes...` and return type `R`.
 *Mandates:*
 - `is_copy_constructible_v<FD>` is `true`, and
 - `is_constructible_v<FD, F>` is `true`.
@@ -231,12 +243,12 @@ function& operator=(nullptr_t) noexcept;
 ``` cpp
 template<class F> function& operator=(F&& f);
 ```
-*Constraints:* `decay_t<F>` is Lvalue-Callable [[func.wrap.func]] for
-argument types `ArgTypes...` and return type `R`.
 *Effects:* As if by: `function(std::forward<F>(f)).swap(*this);`
 *Returns:* `*this`.
@@ -316,11 +328,11 @@ template<class R, class... ArgTypes>
   void swap(function<R(ArgTypes...)>& f1, function<R(ArgTypes...)>& f2) noexcept;
 ```
 *Effects:* As if by: `f1.swap(f2);`
-#### Move only wrapper <a id="func.wrap.move">[[func.wrap.move]]</a>
 ##### General <a id="func.wrap.move.general">[[func.wrap.move.general]]</a>
 The header provides partial specializations of `move_only_function` for
 each combination of the possible replacements of the placeholders cv,
@@ -338,18 +350,16 @@ above, there is a placeholder *inv-quals* defined as follows:
 ##### Class template `move_only_function` <a id="func.wrap.move.class">[[func.wrap.move.class]]</a>
 ``` cpp
 namespace std {
-  template<class... S> class move_only_function;                // not defined
   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, assignment, 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>
@@ -389,11 +399,11 @@ 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*]
-##### Constructors, assignment, and destructor <a id="func.wrap.move.ctor">[[func.wrap.move.ctor]]</a>
 ``` cpp
 template<class VT>
   static constexpr bool is-callable-from = see below;
 ```
@@ -582,5 +592,535 @@ friend void swap(move_only_function& f1, move_only_function& f2) noexcept;
 friend bool operator==(const move_only_function& f, nullptr_t) noexcept;
 ```
 *Returns:* `true` if `f` has no target object, otherwise `false`.

 #### General <a id="func.wrap.general">[[func.wrap.general]]</a>
 Subclause [[func.wrap]] describes polymorphic wrapper classes that
 encapsulate arbitrary callable objects.
+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*:
+``` cpp
+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.
 #### Class `bad_function_call` <a id="func.wrap.badcall">[[func.wrap.badcall]]</a>
 An exception of type `bad_function_call` is thrown by
 `function::operator()` [[func.wrap.func.inv]] when the function wrapper
 object has no target.
 ##### General <a id="func.wrap.func.general">[[func.wrap.func.general]]</a>
 ``` cpp
 namespace std {
   template<class R, class... ArgTypes>
   class function<R(ArgTypes...)> {
   public:
     using result_type = R;
 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*]
 ``` cpp
 function(const function& f);
 ```
 *Ensures:* `!*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.
 Let `FD` be `decay_t<F>`.
 *Constraints:*
 - `is_same_v<remove_cvref_t<F>, function>` is `false`, and
+- `is_invocable_r_v<R, FD&, ArgTypes...>` is `true`.
 *Mandates:*
 - `is_copy_constructible_v<FD>` is `true`, and
 - `is_constructible_v<FD, F>` is `true`.
 ``` cpp
 template<class F> function& operator=(F&& f);
 ```
+*Constraints:* `is_invocable_r_v<R, decay_t<F>&, ArgTypes...>` is
+`true`.
 *Effects:* As if by: `function(std::forward<F>(f)).swap(*this);`
 *Returns:* `*this`.
   void swap(function<R(ArgTypes...)>& f1, function<R(ArgTypes...)>& f2) noexcept;
 ```
 *Effects:* As if by: `f1.swap(f2);`
+#### Move-only wrapper <a id="func.wrap.move">[[func.wrap.move]]</a>
 ##### General <a id="func.wrap.move.general">[[func.wrap.move.general]]</a>
 The header provides partial specializations of `move_only_function` for
 each combination of the possible replacements of the placeholders cv,
 ##### Class template `move_only_function` <a id="func.wrap.move.class">[[func.wrap.move.class]]</a>
 ``` cpp
 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>
 [*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*]
+##### Constructors, assignments, and destructor <a id="func.wrap.move.ctor">[[func.wrap.move.ctor]]</a>
 ``` cpp
 template<class VT>
   static constexpr bool is-callable-from = see below;
 ```
 friend bool operator==(const move_only_function& f, nullptr_t) noexcept;
 ```
 *Returns:* `true` if `f` has no target object, otherwise `false`.
+#### Copyable wrapper <a id="func.wrap.copy">[[func.wrap.copy]]</a>
+##### General <a id="func.wrap.copy.general">[[func.wrap.copy.general]]</a>
+The header provides partial specializations of `copyable_function` for
+each combination of the possible replacements of the placeholders cv,
+*ref*, and *noex* where
+- cv is either const or empty,
+- *ref* is either `&`, `&&`, or empty, and
+- *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:
+- If *ref* is empty, let *inv-quals* be cv`&`,
+- otherwise, let *inv-quals* be cv *ref*.
+##### Class template `copyable_function` <a id="func.wrap.copy.class">[[func.wrap.copy.class]]</a>
+``` cpp
+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<U>, 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*]
+##### Constructors, assignments, and destructor <a id="func.wrap.copy.ctor">[[func.wrap.copy.ctor]]</a>
+``` cpp
+template<class VT>
+  static constexpr bool is-callable-from = see below;
+```
+If *noex* is `true`, *`is-callable-from`*`<VT>` is equal to:
+``` cpp
+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:
+``` cpp
+is_invocable_r_v<R, VT cv ref, ArgTypes...> &&
+is_invocable_r_v<R, VT inv-quals, ArgTypes...>
+```
+``` cpp
+copyable_function() noexcept;
+copyable_function(nullptr_t) noexcept;
+```
+*Ensures:* `*this` has no target object.
+``` cpp
+copyable_function(const copyable_function& f);
+```
+*Ensures:* `*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`.
+``` cpp
+copyable_function(copyable_function&& f) noexcept;
+```
+*Ensures:* The target object of `*this` is the target object `f` had
+before construction, and `f` is in a valid state with an unspecified
+value.
+``` cpp
+template<class F> copyable_function(F&& f);
+```
+Let `VT` be `decay_t<F>`.
+*Constraints:*
+- `remove_cvref_t<F>` is not the same type as `copyable_function`, and
+- `remove_cvref_t<F>` is not a specialization of `in_place_type_t`, and
+- *`is-callable-from`*`<VT>` is `true`.
+*Mandates:*
+- `is_constructible_v<VT, F>` is `true`, and
+- `is_copy_constructible_v<VT>` is `true`.
+*Preconditions:* `VT` meets the *Cpp17Destructible* and
+*Cpp17CopyConstructible* requirements.
+*Ensures:* `*this` has no target object if any of the following hold:
+- `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)`.
+*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`.
+``` cpp
+template<class T, class... Args>
+  explicit copyable_function(in_place_type_t<T>, Args&&... args);
+```
+Let `VT` be `decay_t<T>`.
+*Constraints:*
+- `is_constructible_v<VT, Args...>` is `true`, and
+- *`is-callable-from`*`<VT>` is `true`.
+*Mandates:*
+- `VT` is the same type as `T`, and
+- `is_copy_constructible_v<VT>` is `true`.
+*Preconditions:* `VT` meets the *Cpp17Destructible* and
+*Cpp17CopyConstructible* requirements.
+*Ensures:* `*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`.
+``` cpp
+template<class T, class U, class... Args>
+  explicit copyable_function(in_place_type_t<T>, initializer_list<U> ilist, Args&&... args);
+```
+Let `VT` be `decay_t<T>`.
+*Constraints:*
+- `is_constructible_v<VT, initializer_list<U>&, Args...>` is `true`, and
+- *`is-callable-from`*`<VT>` is `true`.
+*Mandates:*
+- `VT` is the same type as `T`, and
+- `is_copy_constructible_v<VT>` is `true`.
+*Preconditions:* `VT` meets the *Cpp17Destructible* and
+*Cpp17CopyConstructible* requirements.
+*Ensures:* `*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`.
+``` cpp
+copyable_function& operator=(const copyable_function& f);
+```
+*Effects:* Equivalent to: `copyable_function(f).swap(*this);`
+*Returns:* `*this`.
+``` cpp
+copyable_function& operator=(copyable_function&& f);
+```
+*Effects:* Equivalent to: `copyable_function(std::move(f)).swap(*this);`
+*Returns:* `*this`.
+``` cpp
+copyable_function& operator=(nullptr_t) noexcept;
+```
+*Effects:* Destroys the target object of `*this`, if any.
+*Returns:* `*this`.
+``` cpp
+template<class F> copyable_function& operator=(F&& f);
+```
+*Effects:* Equivalent to:
+`copyable_function(std::forward<F>(f)).swap(*this);`
+*Returns:* `*this`.
+``` cpp
+~copyable_function();
+```
+*Effects:* Destroys the target object of `*this`, if any.
+##### Invocation <a id="func.wrap.copy.inv">[[func.wrap.copy.inv]]</a>
+``` cpp
+explicit operator bool() const noexcept;
+```
+*Returns:* `true` if `*this` has a target object, otherwise `false`.
+``` cpp
+R operator()(ArgTypes... args) cv ref noexcept(noex);
+```
+*Preconditions:* `*this` has a target object.
+*Effects:* Equivalent to:
+``` cpp
+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`.
+##### Utility <a id="func.wrap.copy.util">[[func.wrap.copy.util]]</a>
+``` cpp
+void swap(copyable_function& other) noexcept;
+```
+*Effects:* Exchanges the target objects of `*this` and `other`.
+``` cpp
+friend void swap(copyable_function& f1, copyable_function& f2) noexcept;
+```
+*Effects:* Equivalent to `f1.swap(f2)`.
+``` cpp
+friend bool operator==(const copyable_function& f, nullptr_t) noexcept;
+```
+*Returns:* `true` if `f` has no target object, otherwise `false`.
+#### Non-owning wrapper <a id="func.wrap.ref">[[func.wrap.ref]]</a>
+##### General <a id="func.wrap.ref.general">[[func.wrap.ref.general]]</a>
+The header provides partial specializations of `function_ref` for each
+combination of the possible replacements of the placeholders cv and
+*noex* where:
+- cv is either const or empty, and
+- *noex* is either `true` or `false`.
+##### Class template `function_ref` <a id="func.wrap.ref.class">[[func.wrap.ref.class]]</a>
+``` cpp
+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(nontype_t<f>) noexcept;
+    template<auto f, class U> constexpr function_ref(nontype_t<f>, U&&) noexcept;
+    template<auto f, class T> constexpr function_ref(nontype_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 belownc;             // 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(nontype_t<f>) -> function_ref<see below>;
+  template<auto f, class T>
+    function_ref(nontype_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
+[[term.trivially.copyable.type]] that models `copyable`.
+Within subclause  [[func.wrap.ref]], `call-args` is an argument pack
+with elements such that
+``` cpp
+decltype((call-args))...
+```
+denote `ArgTypes&&...` respectively.
+##### Constructors and assignment operators <a id="func.wrap.ref.ctor">[[func.wrap.ref.ctor]]</a>
+``` cpp
+template<class... T>
+  static constexpr bool is-invocable-using = see below;
+```
+If *noex* is `true`, *`is-invocable-using`*`<T...>` is equal to:
+``` cpp
+is_nothrow_invocable_r_v<R, T..., ArgTypes...>
+```
+Otherwise, *`is-invocable-using`*`<T...>` is equal to:
+``` cpp
+is_invocable_r_v<R, T..., ArgTypes...>
+```
+``` cpp
+template<class F> function_ref(F* f) noexcept;
+```
+*Constraints:*
+- `is_function_v<F>` is `true`, and
+- *`is-invocable-using`*`<F>` is `true`.
+*Preconditions:* `f` is not a null pointer.
+*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`*`...)`.
+``` cpp
+template<class F> constexpr function_ref(F&& f) noexcept;
+```
+Let `T` be `remove_reference_t<F>`.
+*Constraints:*
+- `remove_cvref_t<F>` is not the same type as `function_ref`,
+- `is_member_pointer_v<T>` is `false`, and
+- *`is-invocable-using`*`<cv T&>` is `true`.
+*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`*`...)`.
+``` cpp
+template<auto f> constexpr function_ref(nontype_t<f>) noexcept;
+```
+Let `F` be `decltype(f)`.
+*Constraints:* *`is-invocable-using`*`<F>` is `true`.
+*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`*`...)`.
+``` cpp
+template<auto f, class U>
+  constexpr function_ref(nontype_t<f>, U&& obj) noexcept;
+```
+Let `T` be `remove_reference_t<U>` and `F` be `decltype(f)`.
+*Constraints:*
+- `is_rvalue_reference_v<U&&>` is `false`, and
+- *`is-invocable-using`*`<F, cv T&>` is `true`.
+*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`*`...)`.
+``` cpp
+template<auto f, class T>
+  constexpr function_ref(nontype_t<f>, cv T* obj) noexcept;
+```
+Let `F` be `decltype(f)`.
+*Constraints:* *`is-invocable-using`*`<F, cv T*>` is `true`.
+*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`*`...)`.
+``` cpp
+template<class T> function_ref& operator=(T) = delete;
+```
+*Constraints:*
+- `T` is not the same type as `function_ref`,
+- `is_pointer_v<T>` is `false`, and
+- `T` is not a specialization of `nontype_t`.
+##### Invocation <a id="func.wrap.ref.inv">[[func.wrap.ref.inv]]</a>
+``` cpp
+R operator()(ArgTypes... args) const noexcept(noex);
+```
+*Effects:* Equivalent to:
+`return `*`thunk-ptr`*`(`*`bound-entity`*`, std::forward<ArgTypes>(args)...);`
+##### Deduction guides <a id="func.wrap.ref.deduct">[[func.wrap.ref.deduct]]</a>
+``` cpp
+template<class F>
+  function_ref(F*) -> function_ref<F>;
+```
+*Constraints:* `is_function_v<F>` is `true`.
+``` cpp
+template<auto f>
+  function_ref(nontype_t<f>) -> function_ref<see below>;
+```
+Let `F` be `remove_pointer_t<decltype(f)>`.
+*Constraints:* `is_function_v<F>` is `true`.
+*Remarks:* The deduced type is `function_ref<F>`.
+``` cpp
+template<auto f, class T>
+  function_ref(nontype_t<f>, T&&) -> function_ref<see below>;
+```
+Let `F` be `decltype(f)`.
+*Constraints:*
+- `F` is of the form `R(G::*)(A...) cv `\\ₒₚₜ ` noexcept(E)` for a type
+  `G`, or
+- `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 `false`, or
+- `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)>`.

Diff to HTML by rtfpessoa