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

Files changed (1) hide show

tmp/tmp3q8zyauu/{from.md → to.md} +102 -102

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

@@ -9,84 +9,75 @@ An exception of type `bad_function_call` is thrown by
 `function::operator()` ([[func.wrap.func.inv]]) when the function
 wrapper object has no target.
 ``` cpp
 namespace std {
-  class bad_function_call : public std::exception {
   public:
-    // [func.wrap.badcall.const], constructor:
     bad_function_call() noexcept;
   };
-} // namespace std
 ```
 ##### `bad_function_call` constructor <a id="func.wrap.badcall.const">[[func.wrap.badcall.const]]</a>
 ``` cpp
 bad_function_call() noexcept;
 ```
-*Effects:* constructs a `bad_function_call` object.
 #### Class template `function` <a id="func.wrap.func">[[func.wrap.func]]</a>
 ``` cpp
 namespace std {
-  template<class> class function; // undefined
   template<class R, class... ArgTypes>
   class function<R(ArgTypes...)> {
   public:
- typedef R result_type;
-    typedef T1 argument_type;           // only if sizeof...(ArgTypes) == 1 and
-                                        // the type in ArgTypes is T1
-    typedef T1 first_argument_type;     // only if sizeof...(ArgTypes) == 2 and
-                                        // ArgTypes contains T1 and T2
-    typedef T2 second_argument_type;    // only if sizeof...(ArgTypes) == 2 and
-                                        // ArgTypes contains T1 and T2
-    // [func.wrap.func.con], construct/copy/destroy:
     function() noexcept;
     function(nullptr_t) noexcept;
     function(const function&);
     function(function&&);
     template<class F> function(F);
-    template<class A> function(allocator_arg_t, const A&) noexcept;
-    template<class A> function(allocator_arg_t, const A&,
-      nullptr_t) noexcept;
-    template<class A> function(allocator_arg_t, const A&,
-      const function&);
-    template<class A> function(allocator_arg_t, const A&,
-      function&&);
-    template<class F, class A> function(allocator_arg_t, const A&, F);
     function& operator=(const function&);
     function& operator=(function&&);
-    function& operator=(nullptr_t);
     template<class F> function& operator=(F&&);
     template<class F> function& operator=(reference_wrapper<F>) noexcept;
     ~function();
-    // [func.wrap.func.mod], function modifiers:
     void swap(function&) noexcept;
-    template<class F, class A> void assign(F&&, const A&);
-    // [func.wrap.func.cap], function capacity:
     explicit operator bool() const noexcept;
-    // [func.wrap.func.inv], function invocation:
     R operator()(ArgTypes...) const;
-    // [func.wrap.func.targ], function target access:
-    const std::type_info& target_type() const noexcept;
     template<class T>       T* target() noexcept;
     template<class T> const T* target() const noexcept;
   };
- // [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;
@@ -95,154 +86,176 @@ namespace std {
     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...)>&);
-  template<class R, class... ArgTypes, class Alloc>
-    struct uses_allocator<function<R(ArgTypes...)>, Alloc>
-      : true_type { };
 }
 ```
 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 object `f` of type `F` is *Callable* for argument types
-`ArgTypes` and return type `R` if the expression
-`INVOKE(f, declval<ArgTypes>()..., R)`, 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...)`.
 ##### `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();
 ```
@@ -254,17 +267,10 @@ template<class F> function& operator=(reference_wrapper<F> f) noexcept;
 void swap(function& other) noexcept;
 ```
 *Effects:* interchanges the targets of `*this` and `other`.
-``` cpp
-template<class F, class A>
-  void assign(F&& f, const A& a);
-```
-*Effects:* `function(allocator_arg, a, std::forward<F>(f)).swap(*this)`
 ##### `function` capacity <a id="func.wrap.func.cap">[[func.wrap.func.cap]]</a>
 ``` cpp
 explicit operator bool() const noexcept;
 ```
@@ -272,44 +278,38 @@ 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
 ```
-*Effects:*
-*`INVOKE`*`(f, std::forward<ArgTypes>(args)..., R)` ([[func.require]]),
-where `f` is the target object ([[func.def]]) of `*this`.
-*Returns:* Nothing if `R` is `void`, otherwise the return value of
-*`INVOKE`*`(f, std::forward<ArgTypes>(args)..., R)`.
 *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 std::type_info& target_type() const noexcept;
 ```
 *Returns:* If `*this` has a target of type `T`, `typeid(T)`; otherwise,
 `typeid(void)`.
 ``` cpp
 template<class T>       T* target() noexcept;
 template<class T> const T* target() const noexcept;
 ```
-*Requires:* `T` shall be a type that is Callable ([[func.wrap.func]])
-for parameter types `ArgTypes` and return type `R`.
 *Returns:* If `target_type() == typeid(T)` a pointer to the stored
 function target; otherwise a null pointer.
-##### null pointer comparison operators <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>
@@ -329,10 +329,10 @@ template <class R, class... ArgTypes>
 ##### 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);
 ```
-*Effects:* `f1.swap(f2);`

 `function::operator()` ([[func.wrap.func.inv]]) when the function
 wrapper object has no target.
 ``` cpp
 namespace std {
+  class bad_function_call : public exception {
   public:
+    // [func.wrap.badcall.const], constructor
     bad_function_call() noexcept;
   };
+}
 ```
 ##### `bad_function_call` constructor <a id="func.wrap.badcall.const">[[func.wrap.badcall.const]]</a>
 ``` cpp
 bad_function_call() noexcept;
 ```
+*Effects:* Constructs a `bad_function_call` object.
+*Postconditions:* `what()` returns an *implementation-defined* NTBS.
 #### Class template `function` <a id="func.wrap.func">[[func.wrap.func]]</a>
 ``` cpp
 namespace std {
+  template<class> class function; // not defined
   template<class R, class... ArgTypes>
   class function<R(ArgTypes...)> {
   public:
+ using result_type = R;
+    // [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;
     template<class F> function& operator=(F&&);
     template<class F> function& operator=(reference_wrapper<F>) noexcept;
     ~function();
+    // [func.wrap.func.mod], function modifiers
     void swap(function&) noexcept;
+    // [func.wrap.func.cap], function capacity
     explicit operator bool() const noexcept;
+    // [func.wrap.func.inv], function invocation
     R operator()(ArgTypes...) const;
+    // [func.wrap.func.targ], function target access
+    const type_info& target_type() const noexcept;
     template<class T>       T* target() noexcept;
     template<class T> const T* target() const 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 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;
     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() {
+  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();
 ```
 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;
 ```
 *Returns:* If `*this` has a target of type `T`, `typeid(T)`; otherwise,
 `typeid(void)`.
 ``` cpp
 template<class T>       T* target() noexcept;
 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>
 ##### 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;
 ```
+*Effects:* As if by: `f1.swap(f2);`

Diff to HTML by rtfpessoa