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

Files changed (1) hide show

tmp/tmptr_xwt7_/{from.md → to.md} +56 -84

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

@@ -11,11 +11,11 @@ namespace std {
     // [func.wrap.func.con], construct/copy/destroy
     function() noexcept;
     function(nullptr_t) noexcept;
     function(const function&);
-    function(function&&);
     template<class F> function(F);
     function& operator=(const function&);
     function& operator=(function&&);
     function& operator=(nullptr_t) noexcept;
@@ -42,132 +42,116 @@ namespace std {
   template<class R, class... ArgTypes>
     function(R(*)(ArgTypes...)) -> function<R(ArgTypes...)>;
   template<class F> function(F) -> function<see below>;
-  // [func.wrap.func.nullptr], Null pointer comparisons
   template<class R, class... ArgTypes>
     bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
-  template <class R, class... ArgTypes>
-    bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
-  template <class R, class... ArgTypes>
-    bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
-  template <class R, class... ArgTypes>
-    bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
   // [func.wrap.func.alg], specialized algorithms
   template<class R, class... ArgTypes>
     void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
 }
 ```
 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]]), allowing functions to be first-class objects.
-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 (Clause  [[expr]]), 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` may
 change in future versions of this International Standard. — *end note*]
-##### `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() {
@@ -198,26 +182,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);`
@@ -228,40 +211,40 @@ template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ~function();
 ```
 *Effects:* If `*this != nullptr`, destroys the target of `this`.
-##### `function` modifiers <a id="func.wrap.func.mod">[[func.wrap.func.mod]]</a>
 ``` cpp
 void swap(function& other) noexcept;
 ```
-*Effects:* interchanges the targets of `*this` and `other`.
-##### `function` capacity <a id="func.wrap.func.cap">[[func.wrap.func.cap]]</a>
 ``` cpp
 explicit operator bool() const noexcept;
 ```
 *Returns:* `true` if `*this` has a target, otherwise `false`.
-##### `function` invocation <a id="func.wrap.func.inv">[[func.wrap.func.inv]]</a>
 ``` cpp
 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 wrapped callable object.
-##### `function` target access <a id="func.wrap.func.targ">[[func.wrap.func.targ]]</a>
 ``` cpp
 const type_info& target_type() const noexcept;
 ```
@@ -274,31 +257,20 @@ 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.
-##### null pointer comparison functions <a id="func.wrap.func.nullptr">[[func.wrap.func.nullptr]]</a>
 ``` cpp
 template<class R, class... ArgTypes>
   bool operator==(const function<R(ArgTypes...)>& f, nullptr_t) noexcept;
-template <class R, class... ArgTypes>
-  bool operator==(nullptr_t, const function<R(ArgTypes...)>& f) noexcept;
 ```
 *Returns:* `!f`.
-``` cpp
-template <class R, class... ArgTypes>
-  bool operator!=(const function<R(ArgTypes...)>& f, nullptr_t) noexcept;
-template <class R, class... ArgTypes>
-  bool operator!=(nullptr_t, const function<R(ArgTypes...)>& f) noexcept;
-```
-*Returns:* `(bool)f`.
-##### specialized algorithms <a id="func.wrap.func.alg">[[func.wrap.func.alg]]</a>
 ``` cpp
 template<class R, class... ArgTypes>
   void swap(function<R(ArgTypes...)>& f1, function<R(ArgTypes...)>& f2) noexcept;
 ```

     // [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 R, class... ArgTypes>
     function(R(*)(ArgTypes...)) -> function<R(ArgTypes...)>;
   template<class F> function(F) -> function<see below>;
+  // [func.wrap.func.nullptr], null pointer comparison functions
   template<class R, class... ArgTypes>
     bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
   // [func.wrap.func.alg], specialized algorithms
   template<class R, class... ArgTypes>
     void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
 }
 ```
 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]], allowing functions to be first-class objects.
+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 [[expr.prop]], 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` may
 change in future versions of this International Standard. — *end note*]
+##### 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);`
 ~function();
 ```
 *Effects:* If `*this != nullptr`, destroys the target of `this`.
+##### Modifiers <a id="func.wrap.func.mod">[[func.wrap.func.mod]]</a>
 ``` cpp
 void swap(function& other) noexcept;
 ```
+*Effects:* Interchanges the targets of `*this` and `other`.
+##### Capacity <a id="func.wrap.func.cap">[[func.wrap.func.cap]]</a>
 ``` cpp
 explicit operator bool() const noexcept;
 ```
 *Returns:* `true` if `*this` has a target, otherwise `false`.
+##### Invocation <a id="func.wrap.func.inv">[[func.wrap.func.inv]]</a>
 ``` cpp
 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 wrapped callable object.
+##### Target access <a id="func.wrap.func.targ">[[func.wrap.func.targ]]</a>
 ``` cpp
 const type_info& target_type() const noexcept;
 ```
 ```
 *Returns:* If `target_type() == typeid(T)` a pointer to the stored
 function target; otherwise a null pointer.
+##### Null pointer comparison functions <a id="func.wrap.func.nullptr">[[func.wrap.func.nullptr]]</a>
 ``` cpp
 template<class R, class... ArgTypes>
   bool operator==(const function<R(ArgTypes...)>& f, nullptr_t) noexcept;
 ```
 *Returns:* `!f`.
+##### Specialized algorithms <a id="func.wrap.func.alg">[[func.wrap.func.alg]]</a>
 ``` cpp
 template<class R, class... ArgTypes>
   void swap(function<R(ArgTypes...)>& f1, function<R(ArgTypes...)>& f2) noexcept;
 ```

Diff to HTML by rtfpessoa