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

Files changed (1) hide show

tmp/tmp33eqjmv5/{from.md → to.md} +62 -40

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

@@ -1,126 +1,148 @@
 ##### `function` construct/copy/destroy <a id="func.wrap.func.con">[[func.wrap.func.con]]</a>
-When any `function` constructor that takes a first argument of type
-`allocator_arg_t` is invoked, the second argument shall have a type that
-conforms to the requirements for Allocator (Table
-[[allocator.requirements]]). A copy of the allocator argument is used to
-allocate memory, if necessary, for the internal data structures of the
-constructed `function` object.
 ``` cpp
 function() noexcept;
-template <class A> function(allocator_arg_t, const A& a) noexcept;
 ```
 *Postconditions:* `!*this`.
 ``` cpp
 function(nullptr_t) noexcept;
-template <class A> function(allocator_arg_t, const A& a, nullptr_t) noexcept;
 ```
 *Postconditions:* `!*this`.
 ``` cpp
 function(const function& f);
-template <class A> function(allocator_arg_t, const A& a, 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 callable
-object passed via `reference_wrapper` or a function pointer. Otherwise,
-may throw `bad_alloc` or any exception thrown by the copy constructor of
-the stored callable object. 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.
 ``` cpp
 function(function&& f);
-template <class A> function(allocator_arg_t, const A& a, function&& f);
 ```
-*Effects:* If `!f`, `*this` has no target; otherwise, move-constructs
-the target of `f` into the target of `*this`, leaving `f` in a valid
-state with an unspecified value.
 ``` cpp
 template<class F> function(F f);
-template <class F, class A> function(allocator_arg_t, const A& a, F f);
 ```
 *Requires:* `F` shall be `CopyConstructible`.
-*Remarks:* These constructors shall not participate in overload
-resolution unless `f` is 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)`. 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.
 *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
 function& operator=(const function& f);
 ```
-*Effects:* `function(f).swap(*this);`
-*Returns:* `*this`
 ``` cpp
 function& operator=(function&& f);
 ```
 *Effects:* Replaces the target of `*this` with the target of `f`.
-*Returns:* `*this`
 ``` cpp
-function& operator=(nullptr_t);
 ```
 *Effects:* If `*this != nullptr`, destroys the target of `this`.
 *Postconditions:* `!(*this)`.
-*Returns:* `*this`
 ``` cpp
 template<class F> function& operator=(F&& f);
 ```
-*Effects:* `function(std::forward<F>(f)).swap(*this);`
-*Returns:* `*this`
 *Remarks:* This assignment operator shall not participate in overload
-resolution unless `declval<typename decay<F>::type&>()` is
-Callable ([[func.wrap.func]]) for argument types `ArgTypes...` and
-return type `R`.
 ``` cpp
 template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 ```
-*Effects:* `function(f).swap(*this);`
-*Returns:* `*this`
 ``` cpp
 ~function();
 ```

 ##### `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() {
+  int i{5};
+  function g = [&](double) { return i; }; // deduces function<int(double)>
+}
+```
+— *end example*]
 ``` cpp
 function& operator=(const function& f);
 ```
+*Effects:* As if by `function(f).swap(*this);`
+*Returns:* `*this`.
 ``` cpp
 function& operator=(function&& f);
 ```
 *Effects:* Replaces the target of `*this` with the target of `f`.
+*Returns:* `*this`.
 ``` cpp
+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);`
+*Returns:* `*this`.
 ``` cpp
 ~function();
 ```

Diff to HTML by rtfpessoa