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

Files changed (1) hide show

tmp/tmpm8nv4mu2/{from.md → to.md} +45 -65

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

@@ -1,101 +1,81 @@
 #### 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 &`.

 #### 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&`.

Diff to HTML by rtfpessoa