[func.wrap.func.con] - C++20 → C++23

Files changed (1) hide show

tmp/tmpbottwk9p/{from.md → to.md} +44 -27

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

@@ -14,70 +14,87 @@ function(nullptr_t) noexcept;
 ``` cpp
 function(const function& f);
 ```
-*Ensures:* `!*this` if `!f`; otherwise, `*this` targets 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.
-[*Note 1*: 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. — *end note*]
 ``` cpp
 function(function&& f) noexcept;
 ```
 *Ensures:* 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.
-[*Note 2*: 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. — *end note*]
 ``` cpp
-template<class F> function(F f);
 ```
-*Constraints:* `F` is Lvalue-Callable [[func.wrap.func]] for argument
-types `ArgTypes...` and return type `R`.
-*Preconditions:* `F` meets the *Cpp17CopyConstructible* requirements.
-*Ensures:* `!*this` if any of the following hold:
 - `f` is a null function pointer value.
 - `f` is a null member pointer value.
-- `F` is an instance of the `function` class template, and `!f`.
-Otherwise, `*this` targets a copy of `f` initialized with
-`std::move(f)`.
-[*Note 3*: Implementations should avoid the use of dynamically
-allocated memory for small callable objects, for example, where `f` is
-an object holding only a pointer or reference to an object and a member
-function pointer. — *end note*]
-*Throws:* Nothing if `f` is a specialization of `reference_wrapper` or a
-function pointer. Otherwise, may throw `bad_alloc` or any exception
-thrown by `F`’s copy or move constructor.
 ``` cpp
 template<class F> function(F) -> function<see below>;
 ```
 *Constraints:* `&F::operator()` is well-formed when treated as an
-unevaluated operand and `decltype(&F::operator())` is of the form
-`R(G::*)(A...)` cv \\ₒₚₜ ` `noexceptₒₚₜ  for a class type `G`.
 *Remarks:* The deduced type is `function<R(A...)>`.
 [*Example 1*:

 ``` 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.
+*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.
 ``` cpp
 function(function&& f) noexcept;
 ```
 *Ensures:* 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.
+*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.
 ``` cpp
+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`.
+*Preconditions:* `FD` meets the *Cpp17CopyConstructible* requirements.
+*Ensures:* `!*this` is `true` if any of the following hold:
 - `f` is a null function pointer value.
 - `f` is a null member pointer value.
+- `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.
 ``` cpp
 template<class F> function(F) -> function<see below>;
 ```
 *Constraints:* `&F::operator()` is well-formed when treated as an
+unevaluated operand and either
+- `F::operator()` is a non-static member function and
+  `decltype(&F::operator())` is either of the form
+  `R(G::*)(A...)` cv \\ₒₚₜ ` `noexceptₒₚₜ  or of the form
+  `R(*)(G, A...) `noexceptₒₚₜ  for a type `G`, or
+- `F::operator()` is a static member function and
+  `decltype(&F::operator())` is of the form `R(*)(A...) `noexceptₒₚₜ .
 *Remarks:* The deduced type is `function<R(A...)>`.
 [*Example 1*:

Diff to HTML by rtfpessoa