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

Files changed (1) hide show

tmp/tmp5h04vzmx/{from.md → to.md} +38 -45

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

@@ -1,91 +1,85 @@
-##### `function` construct/copy/destroy <a id="func.wrap.func.con">[[func.wrap.func.con]]</a>
 ``` cpp
 function() noexcept;
 ```
-*Postconditions:* `!*this`.
 ``` cpp
 function(nullptr_t) noexcept;
 ```
-*Postconditions:* `!*this`.
 ``` cpp
 function(const function& f);
 ```
-*Postconditions:* `!*this` if `!f`; otherwise, `*this` targets a copy of
 `f.target()`.
-*Throws:* shall not throw exceptions 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 are encouraged to 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);
 ```
-*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.
-*Throws:* shall not throw exceptions 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 or move constructor of
-the stored callable object.
-[*Note 2*: Implementations are encouraged to 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);
 ```
-*Requires:* `F` shall be `CopyConstructible`.
-*Remarks:* This constructor template shall not participate in overload
-resolution unless `F` is Lvalue-Callable ([[func.wrap.func]]) for
-argument types `ArgTypes...` and return type `R`.
-*Postconditions:* `!*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 are encouraged to 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:* shall not throw exceptions when `f` is a function pointer or a
-`reference_wrapper<T>` for some `T`. 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>;
 ```
-*Remarks:* This deduction guide participates in overload resolution only
-if `&F::operator()` is well-formed when treated as an unevaluated
-operand. In that case, if `decltype(&F::operator())` is of the form
-`R(G::*)(A...)` cv `&`ₒₚₜ ` noexcept` for a class type `G`, then the
-deduced type is `function<R(A...)>`.
 [*Example 1*:
 ``` cpp
 void f() {
@@ -116,26 +110,25 @@ function& operator=(function&& f);
 function& operator=(nullptr_t) noexcept;
 ```
 *Effects:* If `*this != nullptr`, destroys the target of `this`.
-*Postconditions:* `!(*this)`.
 *Returns:* `*this`.
 ``` cpp
 template<class F> function& operator=(F&& f);
 ```
 *Effects:* As if by: `function(std::forward<F>(f)).swap(*this);`
 *Returns:* `*this`.
-*Remarks:* This assignment operator shall not participate in overload
-resolution unless `decay_t<F>` is Lvalue-Callable ([[func.wrap.func]])
-for argument types `ArgTypes...` and return type `R`.
 ``` cpp
 template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ```
 *Effects:* As if by: `function(f).swap(*this);`

+##### Constructors and destructor <a id="func.wrap.func.con">[[func.wrap.func.con]]</a>
 ``` cpp
 function() noexcept;
 ```
+*Ensures:* `!*this`.
 ``` cpp
 function(nullptr_t) noexcept;
 ```
+*Ensures:* `!*this`.
 ``` 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
 void f() {
 function& operator=(nullptr_t) noexcept;
 ```
 *Effects:* If `*this != nullptr`, destroys the target of `this`.
+*Ensures:* `!(*this)`.
 *Returns:* `*this`.
 ``` 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`.
 ``` cpp
 template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ```
 *Effects:* As if by: `function(f).swap(*this);`

Diff to HTML by rtfpessoa