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

Files changed (1) hide show

tmp/tmptf5xwyvr/{from.md → to.md} +66 -84

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

@@ -13,18 +13,18 @@ namespace std {
 The class template `is_bind_expression` can be used to detect function
 objects generated by `bind`. The function template `bind` uses
 `is_bind_expression` to detect subexpressions.
-Instantiations of the `is_bind_expression` template shall meet the
-`UnaryTypeTrait` requirements ([[meta.rqmts]]). The implementation
-shall provide a definition that has a base characteristic of `true_type`
-if `T` is a type returned from `bind`, otherwise it shall have a base
 characteristic of `false_type`. A program may specialize this template
-for a user-defined type `T` to have a base characteristic of `true_type`
-to indicate that `T` should be treated as a subexpression in a `bind`
-call.
 #### Class template `is_placeholder` <a id="func.bind.isplace">[[func.bind.isplace]]</a>
 ``` cpp
 namespace std {
@@ -34,120 +34,100 @@ namespace std {
 The class template `is_placeholder` can be used to detect the standard
 placeholders `_1`, `_2`, and so on. The function template `bind` uses
 `is_placeholder` to detect placeholders.
-Instantiations of the `is_placeholder` template shall meet the
-`UnaryTypeTrait` requirements ([[meta.rqmts]]). The implementation
-shall provide a definition that has the base characteristic of
 `integral_constant<int, J>` if `T` is the type of
-`std::placeholders::_J`, otherwise it shall have a base characteristic
-of `integral_constant<int, 0>`. A program may specialize this template
-for a user-defined type `T` to have a base characteristic of
 `integral_constant<int, N>` with `N > 0` to indicate that `T` should be
 treated as a placeholder type.
 #### Function template `bind` <a id="func.bind.bind">[[func.bind.bind]]</a>
 In the text that follows:
 - `FD` is the type `decay_t<F>`,
-- `fd` is an lvalue of type `FD` constructed from `std::forward<F>(f)`,
 - `Tᵢ` is the iᵗʰ type in the template parameter pack `BoundArgs`,
 - `TDᵢ` is the type `decay_t<Tᵢ>`,
 - `tᵢ` is the iᵗʰ argument in the function parameter pack `bound_args`,
-- `tdᵢ` is an lvalue of type `TDᵢ` constructed from
-  `std::forward<Tᵢ>(tᵢ)`,
 - `Uⱼ` is the jᵗʰ deduced type of the `UnBoundArgs&&...` parameter of
-  the forwarding call wrapper, and
 - `uⱼ` is the jᵗʰ argument associated with `Uⱼ`.
 ``` cpp
 template<class F, class... BoundArgs>
-  unspecified bind(F&& f, BoundArgs&&... bound_args);
-```
-*Requires:* `is_constructible_v<FD, F>` shall be `true`. For each `Tᵢ`
-in `BoundArgs`, `is_constructible_v<``TDᵢ``, ``Tᵢ``>` shall be `true`.
-*INVOKE*(fd, w₁, w₂, …, $w_N$) ([[func.require]]) shall be a valid
-expression for some values `w₁`, `w₂`, …, `w_N`, where N has the value
-`sizeof...(bound_args)`. The cv-qualifiers cv of the call wrapper `g`,
-as specified below, shall be neither `volatile` nor `const volatile`.
-*Returns:* A forwarding call wrapper `g` ([[func.require]]). The effect
-of `g(``u₁``, ``u₂``, …, ``u_M``)` shall be
-``` cpp
-INVOKE(fd, std::forward<$V_1$>($v_1$), std::forward<$V_2$>($v_2$), … , std::forward<$V_N$>($v_N$))
-```
-where the values and types of the bound arguments `v₁`, `v₂`, …, `v_N`
-are determined as specified below. The copy constructor and move
-constructor of the forwarding call wrapper shall throw an exception if
-and only if the corresponding constructor of `FD` or of any of the types
-`TDᵢ` throws an exception.
-*Throws:* Nothing unless the construction of `fd` or of one of the
-values `tdᵢ` throws an exception.
-*Remarks:* The return type shall satisfy the requirements of
-`MoveConstructible`. If all of `FD` and `TDᵢ` satisfy the requirements
-of `CopyConstructible`, then the return type shall satisfy the
-requirements of `CopyConstructible`.
-[*Note 1*: This implies that all of `FD` and `TDᵢ` are
-`MoveConstructible`. — *end note*]
-``` cpp
 template<class R, class F, class... BoundArgs>
-  unspecified bind(F&& f, BoundArgs&&... bound_args);
 ```
-*Requires:* `is_constructible_v<FD, F>` shall be `true`. For each `Tᵢ`
-in `BoundArgs`, `is_constructible_v<``TDᵢ``, ``Tᵢ``>` shall be `true`.
-*INVOKE*(fd, w₁, w₂, …, $w_N$) shall be a valid expression for some
-values `w₁`, `w₂`, …, `w_N`, where N has the value
-`sizeof...(bound_args)`. The cv-qualifiers cv of the call wrapper `g`,
-as specified below, shall be neither `volatile` nor `const volatile`.
-*Returns:* A forwarding call wrapper `g` ([[func.require]]). The effect
-of `g(``u₁``, ``u₂``, …, ``u_M``)` shall be
 ``` cpp
-INVOKE<R>(fd, std::forward<$V_1$>($v_1$), std::forward<$V_2$>($v_2$), … , std::forward<$V_N$>($v_N$))
 ```
-where the values and types of the bound arguments `v₁`, `v₂`, …, `v_N`
-are determined as specified below. The copy constructor and move
-constructor of the forwarding call wrapper shall throw an exception if
-and only if the corresponding constructor of `FD` or of any of the types
-`TDᵢ` throws an exception.
-*Throws:* Nothing unless the construction of `fd` or of one of the
-values `tdᵢ` throws an exception.
-*Remarks:* The return type shall satisfy the requirements of
-`MoveConstructible`. If all of `FD` and `TDᵢ` satisfy the requirements
-of `CopyConstructible`, then the return type shall satisfy the
-requirements of `CopyConstructible`.
-[*Note 2*: This implies that all of `FD` and `TDᵢ` are
-`MoveConstructible`. — *end note*]
 The values of the *bound arguments* `v₁`, `v₂`, …, `v_N` and their
 corresponding types `V₁`, `V₂`, …, `V_N` depend on the types `TDᵢ`
 derived from the call to `bind` and the cv-qualifiers cv of the call
 wrapper `g` as follows:
 - if `TDᵢ` is `reference_wrapper<T>`, the argument is `tdᵢ.get()` and
   its type `Vᵢ` is `T&`;
 - if the value of `is_bind_expression_v<TDᵢ>` is `true`, the argument is
-  `tdᵢ(std::forward<Uⱼ>(uⱼ)...)` and its type `Vᵢ` is
- `invoke_result_t<TDᵢ cv &, Uⱼ...>&&`;
 - if the value `j` of `is_placeholder_v<TDᵢ>` is not zero, the argument
   is `std::forward<Uⱼ>(uⱼ)` and its type `Vᵢ` is `Uⱼ&&`;
-- otherwise, the value is `tdᵢ` and its type `Vᵢ` is `TDᵢ cv &`.
 #### Placeholders <a id="func.bind.place">[[func.bind.place]]</a>
 ``` cpp
 namespace std::placeholders {
@@ -159,23 +139,25 @@ namespace std::placeholders {
               .
   see below _M;
 }
 ```
-All placeholder types shall be `DefaultConstructible` and
-`CopyConstructible`, and their default constructors and copy/move
-constructors shall not throw exceptions. It is *implementation-defined*
-whether placeholder types are `CopyAssignable`. `CopyAssignable`
-placeholders’ copy assignment operators shall not throw exceptions.
 Placeholders should be defined as:
 ``` cpp
 inline constexpr unspecified _1{};
 ```
-If they are not, they shall be declared as:
 ``` cpp
 extern unspecified _1;
 ```

 The class template `is_bind_expression` can be used to detect function
 objects generated by `bind`. The function template `bind` uses
 `is_bind_expression` to detect subexpressions.
+Specializations of the `is_bind_expression` template shall meet the
+*Cpp17UnaryTypeTrait* requirements [[meta.rqmts]]. The implementation
+provides a definition that has a base characteristic of `true_type` if
+`T` is a type returned from `bind`, otherwise it has a base
 characteristic of `false_type`. A program may specialize this template
+for a program-defined type `T` to have a base characteristic of
+`true_type` to indicate that `T` should be treated as a subexpression in
+a `bind` call.
 #### Class template `is_placeholder` <a id="func.bind.isplace">[[func.bind.isplace]]</a>
 ``` cpp
 namespace std {
 The class template `is_placeholder` can be used to detect the standard
 placeholders `_1`, `_2`, and so on. The function template `bind` uses
 `is_placeholder` to detect placeholders.
+Specializations of the `is_placeholder` template shall meet the
+*Cpp17UnaryTypeTrait* requirements [[meta.rqmts]]. The implementation
+provides a definition that has the base characteristic of
 `integral_constant<int, J>` if `T` is the type of
+`std::placeholders::_J`, otherwise it has a base characteristic of
+`integral_constant<int, 0>`. A program may specialize this template for
+a program-defined type `T` to have a base characteristic of
 `integral_constant<int, N>` with `N > 0` to indicate that `T` should be
 treated as a placeholder type.
 #### Function template `bind` <a id="func.bind.bind">[[func.bind.bind]]</a>
 In the text that follows:
+- `g` is a value of the result of a `bind` invocation,
 - `FD` is the type `decay_t<F>`,
+- `fd` is an lvalue that is a target object of `g` [[func.def]] of type
+  `FD` direct-non-list-initialized with `std::forward<F>(f)`,
 - `Tᵢ` is the iᵗʰ type in the template parameter pack `BoundArgs`,
 - `TDᵢ` is the type `decay_t<Tᵢ>`,
 - `tᵢ` is the iᵗʰ argument in the function parameter pack `bound_args`,
+- `tdᵢ` is a bound argument entity of `g` [[func.def]] of type `TDᵢ`
+ direct-non-list-initialized with `std::forward<{}Tᵢ>(tᵢ)`,
 - `Uⱼ` is the jᵗʰ deduced type of the `UnBoundArgs&&...` parameter of
+  the argument forwarding call wrapper, and
 - `uⱼ` is the jᵗʰ argument associated with `Uⱼ`.
 ``` cpp
 template<class F, class... BoundArgs>
+ constexpr unspecified bind(F&& f, BoundArgs&&... bound_args);
 template<class R, class F, class... BoundArgs>
+ constexpr unspecified bind(F&& f, BoundArgs&&... bound_args);
 ```
+*Mandates:* `is_constructible_v<FD, F>` is `true`. For each `Tᵢ` in
+`BoundArgs`, `is_constructible_v<``TDᵢ``, ``Tᵢ``>` is `true`.
+*Preconditions:* `FD` and each `TDᵢ` meet the *Cpp17MoveConstructible*
+and *Cpp17Destructible* requirements. *INVOKE*(fd, w₁, w₂, …,
+$w_N$) [[func.require]] is a valid expression for some values `w₁`,
+`w₂`, …, `w_N`, where N has the value `sizeof...(bound_args)`.
+*Returns:* An argument forwarding call wrapper `g` [[func.require]]. A
+program that attempts to invoke a volatile-qualified `g` is ill-formed.
+When `g` is not volatile-qualified, invocation of
+`g(``u₁``, ``u₂``, `…`, ``u_M``)` is
+expression-equivalent [[defns.expression-equivalent]] to
 ``` cpp
+INVOKE(static_cast<$V_fd$>($v_fd$),
+       static_cast<$V_1$>($v_1$), static_cast<$V_2$>($v_2$), …, static_cast<$V_N$>($v_N$))
 ```
+for the first overload, and
+``` cpp
+INVOKE<R>(static_cast<$V_fd$>($v_fd$),
+          static_cast<$V_1$>($v_1$), static_cast<$V_2$>($v_2$), …, static_cast<$V_N$>($v_N$))
+```
+for the second overload, where the values and types of the target
+argument `v`_`fd` and of the bound arguments `v₁`, `v₂`, …, `v_N` are
+determined as specified below.
+*Throws:* Any exception thrown by the initialization of the state
+entities of `g`.
+[*Note 1*: If all of `FD` and `TDᵢ` meet the requirements of
+*Cpp17CopyConstructible*, then the return type meets the requirements of
+*Cpp17CopyConstructible*. — *end note*]
 The values of the *bound arguments* `v₁`, `v₂`, …, `v_N` and their
 corresponding types `V₁`, `V₂`, …, `V_N` depend on the types `TDᵢ`
 derived from the call to `bind` and the cv-qualifiers cv of the call
 wrapper `g` as follows:
 - if `TDᵢ` is `reference_wrapper<T>`, the argument is `tdᵢ.get()` and
   its type `Vᵢ` is `T&`;
 - if the value of `is_bind_expression_v<TDᵢ>` is `true`, the argument is
+  ``` cpp
+ static_cast<cv `TD`_i&>(td_i)(std::forward<U_j>(u_j)...)
+  ```
+  and its type `Vᵢ` is `invoke_result_t<cv TDᵢ&, Uⱼ...>&&`;
 - if the value `j` of `is_placeholder_v<TDᵢ>` is not zero, the argument
   is `std::forward<Uⱼ>(uⱼ)` and its type `Vᵢ` is `Uⱼ&&`;
+- otherwise, the value is `tdᵢ` and its type `Vᵢ` is `cv TDᵢ&`.
+The value of the target argument `v`_`fd` is `fd` and its corresponding
+type `V`_`fd` is `cv FD&`.
 #### Placeholders <a id="func.bind.place">[[func.bind.place]]</a>
 ``` cpp
 namespace std::placeholders {
               .
   see below _M;
 }
 ```
+All placeholder types meet the *Cpp17DefaultConstructible* and
+*Cpp17CopyConstructible* requirements, and their default constructors
+and copy/move constructors are constexpr functions that do not throw
+exceptions. It is *implementation-defined* whether placeholder types
+meet the *Cpp17CopyAssignable* requirements, but if so, their copy
+assignment operators are constexpr functions that do not throw
+exceptions.
 Placeholders should be defined as:
 ``` cpp
 inline constexpr unspecified _1{};
 ```
+If they are not, they are declared as:
 ``` cpp
 extern unspecified _1;
 ```

Diff to HTML by rtfpessoa