[thread.threads] - C++20 → C++23

Files changed (1) hide show

tmp/tmp1s7aza06/{from.md → to.md} +75 -45

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

@@ -1,27 +1,30 @@
 ## Threads <a id="thread.threads">[[thread.threads]]</a>
 [[thread.threads]] describes components that can be used to create and
 manage threads.
 [*Note 1*: These threads are intended to map one-to-one with operating
 system threads. — *end note*]
 ### Header `<thread>` synopsis <a id="thread.syn">[[thread.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
-#include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   class thread;
   void swap(thread& x, thread& y) noexcept;
-  // [thread.jthread.class] class jthread
   class jthread;
   namespace this_thread {
     thread::id get_id() noexcept;
     void yield() noexcept;
     template<class Clock, class Duration>
@@ -32,10 +35,12 @@ namespace std {
 }
 ```
 ### Class `thread` <a id="thread.thread.class">[[thread.thread.class]]</a>
 The class `thread` provides a mechanism to create a new thread of
 execution, to join with a thread (i.e., wait for a thread to complete),
 and to perform other operations that manage and query the state of a
 thread. A `thread` object uniquely represents a particular thread of
 execution. That representation may be transferred to other `thread`
@@ -51,11 +56,11 @@ successful call to `detach` or `join`. — *end note*]
 ``` cpp
 namespace std {
   class thread {
   public:
-    // types
     class id;
     using native_handle_type = implementation-defined;         // see~[thread.req.native]
     // construct/copy/destroy
     thread() noexcept;
@@ -64,11 +69,11 @@ namespace std {
     thread(const thread&) = delete;
     thread(thread&&) noexcept;
     thread& operator=(const thread&) = delete;
     thread& operator=(thread&&) noexcept;
-    // members
     void swap(thread&) noexcept;
     bool joinable() const noexcept;
     void join();
     void detach();
     id get_id() const noexcept;
@@ -94,10 +99,12 @@ namespace std {
   template<class charT, class traits>
     basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& out, thread::id id);
   // hash support
   template<class T> struct hash;
   template<> struct hash<thread::id>;
 }
 ```
@@ -108,10 +115,16 @@ that do not represent a thread of execution [[thread.thread.class]].
 Each thread of execution has an associated `thread::id` object that is
 not equal to the `thread::id` object of any other thread of execution
 and that is not equal to the `thread::id` object of any `thread` object
 that does not represent threads of execution.
 `thread::id` is a trivially copyable class [[class.prop]]. The library
 may reuse the value of a `thread::id` of a terminated thread that can no
 longer be joined.
 [*Note 1*: Relational operators allow `thread::id` objects to be used
@@ -146,17 +159,37 @@ described in [[alg.sorting]].
 template<class charT, class traits>
   basic_ostream<charT, traits>&
     operator<< (basic_ostream<charT, traits>& out, thread::id id);
 ```
-*Effects:* Inserts an unspecified text representation of `id` into
-`out`. For two objects of type `thread::id` `x` and `y`, if `x == y` the
-`thread::id` objects have the same text representation and if `x != y`
-the `thread::id` objects have distinct text representations.
 *Returns:* `out`.
 ``` cpp
 template<> struct hash<thread::id>;
 ```
 The specialization is enabled [[unord.hash]].
@@ -178,33 +211,30 @@ template<class F, class... Args> explicit thread(F&& f, Args&&... args);
 *Constraints:* `remove_cvref_t<F>` is not the same type as `thread`.
 *Mandates:* The following are all `true`:
 - `is_constructible_v<decay_t<F>, F>`,
-- `(is_constructible_v<decay_t<Args>, Args> && ...)`,
-- `is_move_constructible_v<decay_t<F>>`,
-- `(is_move_constructible_v<decay_t<Args>> && ...)`, and
 - `is_invocable_v<decay_t<F>, decay_t<Args>...>`.
-*Preconditions:* `decay_t<F>` and each type in `decay_t<Args>` meet the
-*Cpp17MoveConstructible* requirements.
 *Effects:* The new thread of execution executes
 ``` cpp
-invoke(decay-copy(std::forward<F>(f)), decay-copy(std::forward<Args>(args))...)
 ```
-with the calls to *`decay-copy`* being evaluated in the constructing
-thread. Any return value from this invocation is ignored.
 [*Note 1*: This implies that any exceptions not thrown from the
 invocation of the copy of `f` will be thrown in the constructing thread,
 not the new thread. — *end note*]
 If the invocation of `invoke` terminates with an uncaught exception,
-`terminate` is called.
 *Synchronization:* The completion of the invocation of the constructor
 synchronizes with the beginning of the invocation of the copy of `f`.
 *Ensures:* `get_id() != id()`. `*this` represents the newly started
@@ -229,27 +259,29 @@ thread(thread&& x) noexcept;
 ``` cpp
 ~thread();
 ```
-*Effects:* If `joinable()`, calls `terminate()`. Otherwise, has no
-effects.
 [*Note 1*: Either implicitly detaching or joining a `joinable()` thread
-in its destructor could result in difficult to debug correctness (for
 detach) or performance (for join) bugs encountered only when an
-exception is thrown. Thus the programmer must ensure that the destructor
-is never executed while the thread is still joinable. — *end note*]
 #### Assignment <a id="thread.thread.assign">[[thread.thread.assign]]</a>
 ``` cpp
 thread& operator=(thread&& x) noexcept;
 ```
-*Effects:* If `joinable()`, calls `terminate()`. Otherwise, assigns the
-state of `x` to `*this` and sets `x` to a default constructed state.
 *Ensures:* `x.get_id() == id()` and `get_id()` returns the value of
 `x.get_id()` prior to the assignment.
 *Returns:* `*this`.
@@ -343,10 +375,12 @@ void swap(thread& x, thread& y) noexcept;
 *Effects:* As if by `x.swap(y)`.
 ### Class `jthread` <a id="thread.jthread.class">[[thread.jthread.class]]</a>
 The class `jthread` provides a mechanism to create a new thread of
 execution. The functionality is the same as for class `thread`
 [[thread.thread.class]] with the additional abilities to provide a
 `stop_token` [[thread.stoptoken]] to the new thread of execution, make
 stop requests, and automatically join.
@@ -412,34 +446,30 @@ template<class F, class... Args> explicit jthread(F&& f, Args&&... args);
 *Constraints:* `remove_cvref_t<F>` is not the same type as `jthread`.
 *Mandates:* The following are all `true`:
 - `is_constructible_v<decay_t<F>, F>`,
-- `(is_constructible_v<decay_t<Args>, Args> && ...)`,
-- `is_move_constructible_v<decay_t<F>>`,
-- `(is_move_constructible_v<decay_t<Args>> && ...)`, and
 - `is_invocable_v<decay_t<F>, decay_t<Args>...> ||`
   `is_invocable_v<decay_t<F>, stop_token, decay_t<Args>...>`.
-*Preconditions:* `decay_t<F>` and each type in `decay_t<Args>` meet the
-*Cpp17MoveConstructible* requirements.
 *Effects:* Initializes `ssource`. The new thread of execution executes
 ``` cpp
-invoke(decay-copy(std::forward<F>(f)), get_stop_token(),
- decay-copy(std::forward<Args>(args))...)
 ```
 if that expression is well-formed, otherwise
 ``` cpp
-invoke(decay-copy(std::forward<F>(f)), decay-copy(std::forward<Args>(args))...)
 ```
-with the calls to *`decay-copy`* being evaluated in the constructing
-thread. Any return value from this invocation is ignored.
 [*Note 1*: This implies that any exceptions not thrown from the
 invocation of the copy of `f` will be thrown in the constructing thread,
 not the new thread. — *end note*]
@@ -483,18 +513,18 @@ of `x.ssource` prior to the start of construction and
 ``` cpp
 jthread& operator=(jthread&& x) noexcept;
 ```
-*Effects:* If `joinable()` is `true`, calls `request_stop()` and then
-`join()`. Assigns the state of `x` to `*this` and sets `x` to a default
 constructed state.
-*Ensures:* `x.get_id() == id()` and `get_id()` returns the value of
-`x.get_id()` prior to the assignment. `ssource` has the value of
-`x.ssource` prior to the assignment and `x.ssource.stop_possible()` is
-`false`.
 *Returns:* `*this`.
 #### Members <a id="thread.jthread.mem">[[thread.jthread.mem]]</a>
@@ -616,13 +646,13 @@ namespace std::this_thread {
 ``` cpp
 thread::id this_thread::get_id() noexcept;
 ```
 *Returns:* An object of type `thread::id` that uniquely identifies the
-current thread of execution. No other thread of execution has this id
-and this thread of execution always has this id. The object returned
-does not compare equal to a default constructed `thread::id`.
 ``` cpp
 void this_thread::yield() noexcept;
 ```

 ## Threads <a id="thread.threads">[[thread.threads]]</a>
+### General <a id="thread.threads.general">[[thread.threads.general]]</a>
 [[thread.threads]] describes components that can be used to create and
 manage threads.
 [*Note 1*: These threads are intended to map one-to-one with operating
 system threads. — *end note*]
 ### Header `<thread>` synopsis <a id="thread.syn">[[thread.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
 namespace std {
+  // [thread.thread.class], class thread
   class thread;
   void swap(thread& x, thread& y) noexcept;
+  // [thread.jthread.class], class jthread
   class jthread;
+  // [thread.thread.this], namespace this_thread
   namespace this_thread {
     thread::id get_id() noexcept;
     void yield() noexcept;
     template<class Clock, class Duration>
 }
 ```
 ### Class `thread` <a id="thread.thread.class">[[thread.thread.class]]</a>
+#### General <a id="thread.thread.class.general">[[thread.thread.class.general]]</a>
 The class `thread` provides a mechanism to create a new thread of
 execution, to join with a thread (i.e., wait for a thread to complete),
 and to perform other operations that manage and query the state of a
 thread. A `thread` object uniquely represents a particular thread of
 execution. That representation may be transferred to other `thread`
 ``` cpp
 namespace std {
   class thread {
   public:
+    // [thread.thread.id], class thread::id
     class id;
     using native_handle_type = implementation-defined;         // see~[thread.req.native]
     // construct/copy/destroy
     thread() noexcept;
     thread(const thread&) = delete;
     thread(thread&&) noexcept;
     thread& operator=(const thread&) = delete;
     thread& operator=(thread&&) noexcept;
+    // [thread.thread.member], members
     void swap(thread&) noexcept;
     bool joinable() const noexcept;
     void join();
     void detach();
     id get_id() const noexcept;
   template<class charT, class traits>
     basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& out, thread::id id);
+  template<class charT> struct formatter<thread::id, charT>;
   // hash support
   template<class T> struct hash;
   template<> struct hash<thread::id>;
 }
 ```
 Each thread of execution has an associated `thread::id` object that is
 not equal to the `thread::id` object of any other thread of execution
 and that is not equal to the `thread::id` object of any `thread` object
 that does not represent threads of execution.
+The *text representation* for the character type `charT` of an object of
+type `thread::id` is an unspecified sequence of `charT` such that, for
+two objects of type `thread::id` `x` and `y`, if `x == y` is `true`, the
+`thread::id` objects have the same text representation, and if `x != y`
+is `true`, the `thread::id` objects have distinct text representations.
 `thread::id` is a trivially copyable class [[class.prop]]. The library
 may reuse the value of a `thread::id` of a terminated thread that can no
 longer be joined.
 [*Note 1*: Relational operators allow `thread::id` objects to be used
 template<class charT, class traits>
   basic_ostream<charT, traits>&
     operator<< (basic_ostream<charT, traits>& out, thread::id id);
 ```
+*Effects:* Inserts the text representation for `charT` of `id` into
+`out`.
 *Returns:* `out`.
+``` cpp
+template<class charT> struct formatter<thread::id, charT>;
+```
+`formatter<thread::id, charT>` interprets *format-spec* as a
+*thread-id-format-spec*. The syntax of format specifications is as
+follows:
+``` bnf
+thread-id-format-spec
+    fill-and-alignₒₚₜ widthₒₚₜ
+```
+[*Note 1*: The productions *fill-and-align* and *width* are described
+in [[format.string.std]]. — *end note*]
+If the *align* option is omitted it defaults to `>`.
+A `thread::id` object is formatted by writing its text representation
+for `charT` to the output with additional padding and adjustments as
+specified by the format specifiers.
 ``` cpp
 template<> struct hash<thread::id>;
 ```
 The specialization is enabled [[unord.hash]].
 *Constraints:* `remove_cvref_t<F>` is not the same type as `thread`.
 *Mandates:* The following are all `true`:
 - `is_constructible_v<decay_t<F>, F>`,
+- `(is_constructible_v<decay_t<Args>, Args> && ...)`, and
 - `is_invocable_v<decay_t<F>, decay_t<Args>...>`.
 *Effects:* The new thread of execution executes
 ``` cpp
+invoke(auto(std::forward<F>(f)),                // for invoke, see [func.invoke]
+       auto(std::forward<Args>(args))...)
 ```
+with the values produced by `auto` being materialized [[conv.rval]] in
+the constructing thread. Any return value from this invocation is
+ignored.
 [*Note 1*: This implies that any exceptions not thrown from the
 invocation of the copy of `f` will be thrown in the constructing thread,
 not the new thread. — *end note*]
 If the invocation of `invoke` terminates with an uncaught exception,
+`terminate` is invoked [[except.terminate]].
 *Synchronization:* The completion of the invocation of the constructor
 synchronizes with the beginning of the invocation of the copy of `f`.
 *Ensures:* `get_id() != id()`. `*this` represents the newly started
 ``` cpp
 ~thread();
 ```
+*Effects:* If `joinable()`, invokes `terminate` [[except.terminate]].
+Otherwise, has no effects.
 [*Note 1*: Either implicitly detaching or joining a `joinable()` thread
+in its destructor can result in difficult to debug correctness (for
 detach) or performance (for join) bugs encountered only when an
+exception is thrown. These bugs can be avoided by ensuring that the
+destructor is never executed while the thread is still
+joinable. — *end note*]
 #### Assignment <a id="thread.thread.assign">[[thread.thread.assign]]</a>
 ``` cpp
 thread& operator=(thread&& x) noexcept;
 ```
+*Effects:* If `joinable()`, invokes `terminate` [[except.terminate]].
+Otherwise, assigns the state of `x` to `*this` and sets `x` to a default
+constructed state.
 *Ensures:* `x.get_id() == id()` and `get_id()` returns the value of
 `x.get_id()` prior to the assignment.
 *Returns:* `*this`.
 *Effects:* As if by `x.swap(y)`.
 ### Class `jthread` <a id="thread.jthread.class">[[thread.jthread.class]]</a>
+#### General <a id="thread.jthread.class.general">[[thread.jthread.class.general]]</a>
 The class `jthread` provides a mechanism to create a new thread of
 execution. The functionality is the same as for class `thread`
 [[thread.thread.class]] with the additional abilities to provide a
 `stop_token` [[thread.stoptoken]] to the new thread of execution, make
 stop requests, and automatically join.
 *Constraints:* `remove_cvref_t<F>` is not the same type as `jthread`.
 *Mandates:* The following are all `true`:
 - `is_constructible_v<decay_t<F>, F>`,
+- `(is_constructible_v<decay_t<Args>, Args> && ...)`, and
 - `is_invocable_v<decay_t<F>, decay_t<Args>...> ||`
   `is_invocable_v<decay_t<F>, stop_token, decay_t<Args>...>`.
 *Effects:* Initializes `ssource`. The new thread of execution executes
 ``` cpp
+invoke(auto(std::forward<F>(f)), get_stop_token(),  // for invoke, see [func.invoke]
+ auto(std::forward<Args>(args))...)
 ```
 if that expression is well-formed, otherwise
 ``` cpp
+invoke(auto(std::forward<F>(f)), auto(std::forward<Args>(args))...)
 ```
+with the values produced by `auto` being materialized [[conv.rval]] in
+the constructing thread. Any return value from this invocation is
+ignored.
 [*Note 1*: This implies that any exceptions not thrown from the
 invocation of the copy of `f` will be thrown in the constructing thread,
 not the new thread. — *end note*]
 ``` cpp
 jthread& operator=(jthread&& x) noexcept;
 ```
+*Effects:* If `&x == this` is `true`, there are no effects. Otherwise,
+if `joinable()` is `true`, calls `request_stop()` and then `join()`,
+then assigns the state of `x` to `*this` and sets `x` to a default
 constructed state.
+*Ensures:* `get_id()` returns the value of `x.get_id()` prior to the
+assignment. `ssource` has the value of `x.ssource` prior to the
+assignment.
 *Returns:* `*this`.
 #### Members <a id="thread.jthread.mem">[[thread.jthread.mem]]</a>
 ``` cpp
 thread::id this_thread::get_id() noexcept;
 ```
 *Returns:* An object of type `thread::id` that uniquely identifies the
+current thread of execution. Every invocation from this thread of
+execution returns the same value. The object returned does not compare
+equal to a default-constructed `thread::id`.
 ``` cpp
 void this_thread::yield() noexcept;
 ```

Diff to HTML by rtfpessoa