[function.objects] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp9tvgs9l2/{from.md → to.md} +730 -31

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

@@ -100,16 +100,21 @@ namespace std {
   // [func.identity], identity
   struct identity;                                                                  // freestanding
   // [func.not.fn], function template not_fn
   template<class F> constexpr unspecified not_fn(F&& f);                            // freestanding
   // [func.bind.partial], function templates bind_front and bind_back
   template<class F, class... Args>
     constexpr unspecified bind_front(F&&, Args&&...);                               // freestanding
   template<class F, class... Args>
     constexpr unspecified bind_back(F&&, Args&&...);                                // freestanding
   // [func.bind], bind
   template<class T> struct is_bind_expression;                                      // freestanding
   template<class T>
     constexpr bool is_bind_expression_v =                                           // freestanding
@@ -126,39 +131,49 @@ namespace std {
   namespace placeholders {
     // M is the implementation-defined number of placeholders
     see belownc _1;                                                                   // freestanding
     see belownc _2;                                                                   // freestanding
- .
-               .
-               .
     see belownc _M;                                                                   // freestanding
   }
   // [func.memfn], member function adaptors
   template<class R, class T>
     constexpr unspecified mem_fn(R T::*) noexcept;                                  // freestanding
   // [func.wrap], polymorphic function wrappers
   class bad_function_call;
   template<class> class function;       // not defined
   template<class R, class... ArgTypes> class function<R(ArgTypes...)>;
-  // [func.wrap.func.alg], specialized algorithms
   template<class R, class... ArgTypes>
     void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
-  // [func.wrap.func.nullptr], null pointer comparison operator functions
   template<class R, class... ArgTypes>
     bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
-  // [func.wrap.move], move only wrapper
   template<class... S> class move_only_function;                        // not defined
   template<class R, class... ArgTypes>
     class move_only_function<R(ArgTypes...) cv ref noexcept(noex)>;     // see below
   // [func.search], searchers
   template<class ForwardIterator1, class BinaryPredicate = equal_to<>>
     class default_searcher;                                                         // freestanding
   template<class RandomAccessIterator,
@@ -182,10 +197,29 @@ namespace std {
     struct greater;                                                                 // freestanding
     struct less;                                                                    // freestanding
     struct greater_equal;                                                           // freestanding
     struct less_equal;                                                              // freestanding
   }
 }
 ```
 [*Example 1*:
@@ -237,19 +271,19 @@ collectively referred to as *state entities*.
 ### Requirements <a id="func.require">[[func.require]]</a>
 Define `INVOKE(f, t₁, t₂, …, t_N)` as follows:
 - `(t₁.*f)(t₂, …, t_N)` when `f` is a pointer to a member function of a
-  class `T` and `is_same_v<T, remove_cvref_t<decltype(t1)>> ||`
   `is_base_of_v<T, remove_cvref_t<decltype(t₁)>>` is `true`;
 - `(t₁.get().*f)(t₂, …, t_N)` when `f` is a pointer to a member function
   of a class `T` and `remove_cvref_t<decltype(t₁)>` is a specialization
   of `reference_wrapper`;
 - `((*t₁).*f)(t₂, …, t_N)` when `f` is a pointer to a member function of
   a class `T` and `t₁` does not satisfy the previous two items;
 - `t₁.*f` when N = 1 and `f` is a pointer to data member of a class `T`
-  and `is_same_v<T, remove_cvref_t<decltype(t1)>> ||`
   `is_base_of_v<T, remove_cvref_t<decltype(t₁)>>` is `true`;
 - `t₁.get().*f` when N = 1 and `f` is a pointer to data member of a
   class `T` and `remove_cvref_t<decltype(t₁)>` is a specialization of
   `reference_wrapper`;
 - `(*t₁).*f` when N = 1 and `f` is a pointer to data member of a class
@@ -363,10 +397,19 @@ namespace std {
     // [refwrap.invoke], invocation
     template<class... ArgTypes>
       constexpr invoke_result_t<T&, ArgTypes...> operator()(ArgTypes&&...) const
         noexcept(is_nothrow_invocable_v<T&, ArgTypes...>);
   };
   template<class T>
     reference_wrapper(T&) -> reference_wrapper<T>;
 }
@@ -380,10 +423,15 @@ function of type `T`.
 [[term.trivially.copyable.type]].
 The template parameter `T` of `reference_wrapper` may be an incomplete
 type.
 #### Constructors <a id="refwrap.const">[[refwrap.const]]</a>
 ``` cpp
 template<class U>
   constexpr reference_wrapper(U&& u) noexcept(see below);
@@ -444,11 +492,68 @@ template<class... ArgTypes>
 ```
 *Mandates:* `T` is a complete type.
 *Returns:* *INVOKE*(get(),
-std::forward\<ArgTypes\>(args)...). [[func.require]]
 #### Helper functions <a id="refwrap.helpers">[[refwrap.helpers]]</a>
 The template parameter `T` of the following `ref` and `cref` function
 templates may be an incomplete type.
@@ -1361,10 +1466,28 @@ is `true`.
 wrapper [[term.perfect.forwarding.call.wrapper]] `g` with call pattern
 `!invoke(fd, call_args...)`.
 *Throws:* Any exception thrown by the initialization of `fd`.
 ### Function templates `bind_front` and `bind_back` <a id="func.bind.partial">[[func.bind.partial]]</a>
 ``` cpp
 template<class F, class... Args>
   constexpr unspecified bind_front(F&& f, Args&&... args);
@@ -1410,10 +1533,48 @@ wrapper [[term.perfect.forwarding.call.wrapper]] `g` with call pattern:
   invocation.
 *Throws:* Any exception thrown by the initialization of the state
 entities of `g` [[func.def]].
 ### Function object binders <a id="func.bind">[[func.bind]]</a>
 #### General <a id="func.bind.general">[[func.bind.general]]</a>
 Subclause [[func.bind]] describes a uniform mechanism for binding
@@ -1548,13 +1709,11 @@ type `V`_`fd` is `cv FD&`.
 ``` cpp
 namespace std::placeholders {
   // M is the number of placeholders
   see below _1;
   see below _2;
-              .
-              .
-              .
   see below _M;
 }
 ```
 The number `M` of placeholders is *implementation-defined*.
@@ -1598,10 +1757,31 @@ expression [[expr.call]] of `fn`.
 #### 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.
@@ -1626,12 +1806,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;
@@ -1675,16 +1853,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*]
@@ -1706,11 +1878,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.
@@ -1740,12 +1912,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`.
@@ -1826,12 +1997,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`.
@@ -1911,11 +2082,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,
@@ -1933,18 +2104,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>
@@ -1984,11 +2153,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;
 ```
@@ -2177,10 +2346,540 @@ 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`.
 ### Searchers <a id="func.search">[[func.search]]</a>
 #### General <a id="func.search.general">[[func.search.general]]</a>
 Subclause [[func.search]] provides function object types
@@ -2292,11 +2991,11 @@ boyer_moore_searcher(RandomAccessIterator1 pat_first,
                      Hash hf = Hash(),
                      BinaryPredicate pred = BinaryPredicate());
 ```
 *Preconditions:* The value type of `RandomAccessIterator1` meets the
-*Cpp17DefaultConstructible*, the *Cpp17CopyConstructible*, and the
 *Cpp17CopyAssignable* requirements.
 Let `V` be `iterator_traits<RandomAccessIterator1>::value_type`. For any
 two values `A` and `B` of type `V`, if `pred(A, B) == true`, then
 `hf(A) == hf(B)` is `true`.

   // [func.identity], identity
   struct identity;                                                                  // freestanding
   // [func.not.fn], function template not_fn
   template<class F> constexpr unspecified not_fn(F&& f);                            // freestanding
+  template<auto f> constexpr unspecified not_fn() noexcept;                         // freestanding
   // [func.bind.partial], function templates bind_front and bind_back
   template<class F, class... Args>
     constexpr unspecified bind_front(F&&, Args&&...);                               // freestanding
+  template<auto f, class... Args>
+    constexpr unspecified bind_front(Args&&...);                                    // freestanding
   template<class F, class... Args>
     constexpr unspecified bind_back(F&&, Args&&...);                                // freestanding
+  template<auto f, class... Args>
+    constexpr unspecified bind_back(Args&&...);                                     // freestanding
   // [func.bind], bind
   template<class T> struct is_bind_expression;                                      // freestanding
   template<class T>
     constexpr bool is_bind_expression_v =                                           // freestanding
   namespace placeholders {
     // M is the implementation-defined number of placeholders
     see belownc _1;                                                                   // freestanding
     see belownc _2;                                                                   // freestanding
+ ⋮
     see belownc _M;                                                                   // freestanding
   }
   // [func.memfn], member function adaptors
   template<class R, class T>
     constexpr unspecified mem_fn(R T::*) noexcept;                                  // freestanding
   // [func.wrap], polymorphic function wrappers
+  // [func.wrap.badcall], class bad_function_call
   class bad_function_call;
+  // [func.wrap.func], class template function
   template<class> class function;       // not defined
   template<class R, class... ArgTypes> class function<R(ArgTypes...)>;
+  // [func.wrap.func.alg], function specialized algorithms
   template<class R, class... ArgTypes>
     void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
+  // [func.wrap.func.nullptr], function null pointer comparison operator functions
   template<class R, class... ArgTypes>
     bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
+  // [func.wrap.move], move-only wrapper
   template<class... S> class move_only_function;                        // not defined
   template<class R, class... ArgTypes>
     class move_only_function<R(ArgTypes...) cv ref noexcept(noex)>;     // see below
+  // [func.wrap.copy], copyable wrapper
+  template<class... S> class copyable_function;                         // not defined
+  template<class R, class... ArgTypes>
+    class copyable_function<R(ArgTypes...) cv ref noexcept(noex)>;      // see below
+  // [func.wrap.ref], non-owning wrapper
+  template<class... S> class function_ref;                              // freestanding, not defined
+  template<class R, class... ArgTypes>
+    class function_ref<R(ArgTypes...) cv noexcept(noex)>;               // freestanding, see below
   // [func.search], searchers
   template<class ForwardIterator1, class BinaryPredicate = equal_to<>>
     class default_searcher;                                                         // freestanding
   template<class RandomAccessIterator,
     struct greater;                                                                 // freestanding
     struct less;                                                                    // freestanding
     struct greater_equal;                                                           // freestanding
     struct less_equal;                                                              // freestanding
   }
+  template<class Fn, class... Args>
+    concept callable =                                                  // exposition only
+      requires (Fn&& fn, Args&&... args) {
+        std::forward<Fn>(fn)(std::forward<Args>(args)...);
+      };
+  template<class Fn, class... Args>
+    concept nothrow-callable =                                          // exposition only
+      callable<Fn, Args...> &&
+      requires (Fn&& fn, Args&&... args) {
+        { std::forward<Fn>(fn)(std::forward<Args>(args)...) } noexcept;
+      };
+  template<class Fn, class... Args>
+    using call-result-t = decltype(declval<Fn>()(declval<Args>()...));  // exposition only
+  template<const auto& T>
+    using decayed-typeof = decltype(auto(T));                           // exposition only
 }
 ```
 [*Example 1*:
 ### Requirements <a id="func.require">[[func.require]]</a>
 Define `INVOKE(f, t₁, t₂, …, t_N)` as follows:
 - `(t₁.*f)(t₂, …, t_N)` when `f` is a pointer to a member function of a
+  class `T` and `is_same_v<T, remove_cvref_t<decltype(t₁)>> ||`
   `is_base_of_v<T, remove_cvref_t<decltype(t₁)>>` is `true`;
 - `(t₁.get().*f)(t₂, …, t_N)` when `f` is a pointer to a member function
   of a class `T` and `remove_cvref_t<decltype(t₁)>` is a specialization
   of `reference_wrapper`;
 - `((*t₁).*f)(t₂, …, t_N)` when `f` is a pointer to a member function of
   a class `T` and `t₁` does not satisfy the previous two items;
 - `t₁.*f` when N = 1 and `f` is a pointer to data member of a class `T`
+  and `is_same_v<T, remove_cvref_t<decltype(t₁)>> ||`
   `is_base_of_v<T, remove_cvref_t<decltype(t₁)>>` is `true`;
 - `t₁.get().*f` when N = 1 and `f` is a pointer to data member of a
   class `T` and `remove_cvref_t<decltype(t₁)>` is a specialization of
   `reference_wrapper`;
 - `(*t₁).*f` when N = 1 and `f` is a pointer to data member of a class
     // [refwrap.invoke], invocation
     template<class... ArgTypes>
       constexpr invoke_result_t<T&, ArgTypes...> operator()(ArgTypes&&...) const
         noexcept(is_nothrow_invocable_v<T&, ArgTypes...>);
+    // [refwrap.comparisons], comparisons
+    friend constexpr bool operator==(reference_wrapper, reference_wrapper);
+    friend constexpr bool operator==(reference_wrapper, const T&);
+    friend constexpr bool operator==(reference_wrapper, reference_wrapper<const T>);
+    friend constexpr auto operator<=>(reference_wrapper, reference_wrapper);
+    friend constexpr auto operator<=>(reference_wrapper, const T&);
+    friend constexpr auto operator<=>(reference_wrapper, reference_wrapper<const T>);
   };
   template<class T>
     reference_wrapper(T&) -> reference_wrapper<T>;
 }
 [[term.trivially.copyable.type]].
 The template parameter `T` of `reference_wrapper` may be an incomplete
 type.
+[*Note 1*: Using the comparison operators described in
+[[refwrap.comparisons]] with `T` being an incomplete type can lead to an
+ill-formed program with no diagnostic required
+[[temp.point]], [[temp.constr.atomic]]. — *end note*]
 #### Constructors <a id="refwrap.const">[[refwrap.const]]</a>
 ``` cpp
 template<class U>
   constexpr reference_wrapper(U&& u) noexcept(see below);
 ```
 *Mandates:* `T` is a complete type.
 *Returns:* *INVOKE*(get(),
+std::forward\<ArgTypes\>(args)...) [[func.require]].
+#### Comparisons <a id="refwrap.comparisons">[[refwrap.comparisons]]</a>
+``` cpp
+friend constexpr bool operator==(reference_wrapper x, reference_wrapper y);
+```
+*Constraints:* The expression `x.get() == y.get()` is well-formed and
+its result is convertible to `bool`.
+*Returns:* `x.get() == y.get()`.
+``` cpp
+friend constexpr bool operator==(reference_wrapper x, const T& y);
+```
+*Constraints:* The expression `x.get() == y` is well-formed and its
+result is convertible to `bool`.
+*Returns:* `x.get() == y`.
+``` cpp
+friend constexpr bool operator==(reference_wrapper x, reference_wrapper<const T> y);
+```
+*Constraints:* `is_const_v<T>` is `false` and the expression
+`x.get() == y.get()` is well-formed and its result is convertible to
+`bool`.
+*Returns:* `x.get() == y.get()`.
+``` cpp
+friend constexpr auto operator<=>(reference_wrapper x, reference_wrapper y);
+```
+*Constraints:* The expression *`synth-three-way`*`(x.get(), y.get())` is
+well-formed.
+*Returns:* *`synth-three-way`*`(x.get(), y.get())`.
+``` cpp
+friend constexpr auto operator<=>(reference_wrapper x, const T& y);
+```
+*Constraints:* The expression *`synth-three-way`*`(x.get(), y)` is
+well-formed.
+*Returns:* *`synth-three-way`*`(x.get(), y)`.
+``` cpp
+friend constexpr auto operator<=>(reference_wrapper x, reference_wrapper<const T> y);
+```
+*Constraints:* `is_const_v<T>` is `false`. The expression
+*`synth-three-way`*`(x.get(), y.get())` is well-formed.
+*Returns:* *`synth-three-way`*`(x.get(), y.get())`.
 #### Helper functions <a id="refwrap.helpers">[[refwrap.helpers]]</a>
 The template parameter `T` of the following `ref` and `cref` function
 templates may be an incomplete type.
 wrapper [[term.perfect.forwarding.call.wrapper]] `g` with call pattern
 `!invoke(fd, call_args...)`.
 *Throws:* Any exception thrown by the initialization of `fd`.
+``` cpp
+template<auto f> constexpr unspecified not_fn() noexcept;
+```
+In the text that follows:
+- `F` is the type of `f`,
+- `g` is a value of the result of a `not_fn` invocation,
+- `call_args` is an argument pack used in a function call
+  expression [[expr.call]] of `g`.
+*Mandates:* If `is_pointer_v<F> || is_member_pointer_v<F>` is `true`,
+then `f != nullptr` is `true`.
+*Returns:* A perfect forwarding call wrapper [[func.require]] `g` that
+does not have state entities, and has the call pattern
+`!invoke(f, call_args...)`.
 ### Function templates `bind_front` and `bind_back` <a id="func.bind.partial">[[func.bind.partial]]</a>
 ``` cpp
 template<class F, class... Args>
   constexpr unspecified bind_front(F&& f, Args&&... args);
   invocation.
 *Throws:* Any exception thrown by the initialization of the state
 entities of `g` [[func.def]].
+``` cpp
+template<auto f, class... Args>
+  constexpr unspecified bind_front(Args&&... args);
+template<auto f, class... Args>
+  constexpr unspecified bind_back(Args&&... args);
+```
+Within this subclause:
+- `F` is the type of `f`,
+- `g` is a value of the result of a `bind_front` or `bind_back`
+  invocation,
+- `BoundArgs` is a pack that denotes `decay_t<Args>...`,
+- `bound_args` is a pack of bound argument entities of `g` [[func.def]]
+  of types `BoundArgs...`, direct-non-list-initialized with
+  `std::forward<Args>(args)...`, respectively, and
+- `call_args` is an argument pack used in a function call
+  expression [[expr.call]] of `g`.
+*Mandates:*
+- `(is_constructible_v<BoundArgs, Args> && ...)` is `true`, and
+- `(is_move_constructible_v<BoundArgs> && ...)` is `true`, and
+- if `is_pointer_v<F> || is_member_pointer_v<F>` is `true`, then
+  `f != nullptr` is `true`.
+*Preconditions:* For each `Tᵢ` in `BoundArgs`, `Tᵢ` meets the
+*Cpp17MoveConstructible* requirements.
+*Returns:* A perfect forwarding call wrapper [[func.require]] `g` that
+does not have a target object, and has the call pattern:
+- `invoke(f, bound_args..., call_args...)` for a `bind_front`
+  invocation, or
+- `invoke(f, call_args..., bound_args...)` for a `bind_back` invocation.
+*Throws:* Any exception thrown by the initialization of `bound_args`.
 ### Function object binders <a id="func.bind">[[func.bind]]</a>
 #### General <a id="func.bind.general">[[func.bind.general]]</a>
 Subclause [[func.bind]] describes a uniform mechanism for binding
 ``` cpp
 namespace std::placeholders {
   // M is the number of placeholders
   see below _1;
   see below _2;
+             ⋮
   see below _M;
 }
 ```
 The number `M` of placeholders is *implementation-defined*.
 #### 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)>`.
 ### Searchers <a id="func.search">[[func.search]]</a>
 #### General <a id="func.search.general">[[func.search.general]]</a>
 Subclause [[func.search]] provides function object types
                      Hash hf = Hash(),
                      BinaryPredicate pred = BinaryPredicate());
 ```
 *Preconditions:* The value type of `RandomAccessIterator1` meets the
+*Cpp17DefaultConstructible*, *Cpp17CopyConstructible*, and
 *Cpp17CopyAssignable* requirements.
 Let `V` be `iterator_traits<RandomAccessIterator1>::value_type`. For any
 two values `A` and `B` of type `V`, if `pred(A, B) == true`, then
 `hf(A) == hf(B)` is `true`.

Diff to HTML by rtfpessoa