[futures] - C++20 → C++23

Files changed (1) hide show

tmp/tmpushj7csb/{from.md → to.md} +201 -104

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

@@ -13,61 +13,68 @@ well. — *end note*]
 ### Header `<future>` synopsis <a id="future.syn">[[future.syn]]</a>
 ``` cpp
 namespace std {
   enum class future_errc {
-    broken_promise = implementation-defined,
-    future_already_retrieved = implementation-defined,
-    promise_already_satisfied = implementation-defined,
-    no_state = implementation-defined
   };
   enum class launch : unspecified{} {
     async = unspecified{},
     deferred = unspecified{},
-    implementation-defined
   };
   enum class future_status {
     ready,
     timeout,
     deferred
   };
   template<> struct is_error_code_enum<future_errc> : public true_type { };
   error_code make_error_code(future_errc e) noexcept;
   error_condition make_error_condition(future_errc e) noexcept;
   const error_category& future_category() noexcept;
   class future_error;
   template<class R> class promise;
   template<class R> class promise<R&>;
   template<> class promise<void>;
   template<class R>
     void swap(promise<R>& x, promise<R>& y) noexcept;
   template<class R, class Alloc>
     struct uses_allocator<promise<R>, Alloc>;
   template<class R> class future;
   template<class R> class future<R&>;
   template<> class future<void>;
   template<class R> class shared_future;
   template<class R> class shared_future<R&>;
   template<> class shared_future<void>;
   template<class> class packaged_task;  // not defined
   template<class R, class... ArgTypes>
     class packaged_task<R(ArgTypes...)>;
   template<class R, class... ArgTypes>
     void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&) noexcept;
   template<class F, class... Args>
     [[nodiscard]] future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
       async(F&& f, Args&&... args);
   template<class F, class... Args>
     [[nodiscard]] future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
@@ -93,13 +100,14 @@ const error_category& future_category() noexcept;
 ```
 *Returns:* A reference to an object of a type derived from class
 `error_category`.
-The object’s `default_error_condition` and equivalent virtual functions
-shall behave as specified for the class `error_category`. The object’s
-`name` virtual function returns a pointer to the string `"future"`.
 ``` cpp
 error_code make_error_code(future_errc e) noexcept;
 ```
@@ -151,11 +159,11 @@ const char* what() const noexcept;
 Many of the classes introduced in subclause  [[futures]] use some state
 to communicate results. This *shared state* consists of some state
 information and some (possibly not yet evaluated) *result*, which can be
 a (possibly void) value or an exception.
-[*Note 1*: Futures, promises, and tasks defined in this clause
 reference such shared state. — *end note*]
 [*Note 2*: The result can be any kind of object including a function to
 compute that result, as used by `async` when `policy` is
 `launch::deferred`. — *end note*]
@@ -261,18 +269,18 @@ namespace std {
     // setting the result with deferred notification
     void set_value_at_thread_exit(see below);
     void set_exception_at_thread_exit(exception_ptr p);
   };
-  template<class R>
-    void swap(promise<R>& x, promise<R>& y) noexcept;
   template<class R, class Alloc>
     struct uses_allocator<promise<R>, Alloc>;
 }
 ```
 The implementation provides the template `promise` and two
 specializations, `promise<R&>` and `promise<{}void>`. These differ only
 in the argument type of the member functions `set_value` and
 `set_value_at_thread_exit`, as set out in their descriptions, below.
@@ -285,12 +293,12 @@ the promise object.
 template<class R, class Alloc>
   struct uses_allocator<promise<R>, Alloc>
     : true_type { };
 ```
-*Preconditions:* `Alloc` meets the *Cpp17Allocator* requirements
-([[cpp17.allocator]]).
 ``` cpp
 promise();
 template<class Allocator>
   promise(allocator_arg_t, const Allocator& a);
@@ -335,19 +343,19 @@ to the call to `swap`. `other` has the shared state (if any) that
 ``` cpp
 future<R> get_future();
 ```
-*Returns:* A `future<R>` object with the same shared state as `*this`.
 *Synchronization:* Calls to this function do not introduce data
 races  [[intro.multithread]] with calls to `set_value`, `set_exception`,
 `set_value_at_thread_exit`, or `set_exception_at_thread_exit`.
 [*Note 1*: Such calls need not synchronize with each
 other. — *end note*]
 *Throws:* `future_error` if `*this` has no shared state or if
 `get_future` has already been called on a `promise` with the same shared
 state as `*this`.
 *Error conditions:*
@@ -471,13 +479,13 @@ move-assignment operator, `share`, or `valid` on a `future` object for
 which `valid() == false` is undefined.
 [*Note 2*: It is valid to move from a future object for which
 `valid() == false`. — *end note*]
-[*Note 3*: Implementations should detect this case and throw an object
-of type `future_error` with an error condition of
-`future_errc::no_state`. — *end note*]
 ``` cpp
 namespace std {
   template<class R>
   class future {
@@ -503,10 +511,13 @@ namespace std {
       future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
   };
 }
 ```
 The implementation provides the template `future` and two
 specializations, `future<R&>` and `future<{}void>`. These differ only in
 the return type and return value of the member function `get`, as set
 out in its description, below.
@@ -542,29 +553,30 @@ state that was originally referred to by `rhs` (if any).
 ``` cpp
 future& operator=(future&& rhs) noexcept;
 ```
-*Effects:*
 - Releases any shared state [[futures.state]].
 - move assigns the contents of `rhs` to `*this`.
 *Ensures:*
 - `valid()` returns the same value as `rhs.valid()` prior to the
   assignment.
-- `rhs.valid() == false`.
 ``` cpp
 shared_future<R> share() noexcept;
 ```
 *Returns:* `shared_future<R>(std::move(*this))`.
-*Ensures:* `valid() == false`.
 ``` cpp
 R future::get();
 R& future<R&>::get();
 void future<void>::get();
 ```
@@ -577,10 +589,12 @@ member function `get`. — *end note*]
 - `wait()`s until the shared state is ready, then retrieves the value
   stored in the shared state;
 - releases any shared state [[futures.state]].
 *Returns:*
 - `future::get()` returns the value `v` stored in the object’s shared
   state as `std::move(v)`.
 - `future<R&>::get()` returns the reference stored as value in the
@@ -588,12 +602,10 @@ member function `get`. — *end note*]
 - `future<void>::get()` returns nothing.
 *Throws:* The stored exception, if an exception was stored in the shared
 state.
-*Ensures:* `valid() == false`.
 ``` cpp
 bool valid() const noexcept;
 ```
 *Returns:* `true` only if `*this` refers to a shared state.
@@ -666,13 +678,13 @@ move-assignment operator, the copy-assignment operator, or `valid()` on
 a `shared_future` object for which `valid() == false` is undefined.
 [*Note 2*: It is valid to copy or move from a `shared_future` object
 for which `valid()` is `false`. — *end note*]
-[*Note 3*: Implementations should detect this case and throw an object
-of type `future_error` with an error condition of
-`future_errc::no_state`. — *end note*]
 ``` cpp
 namespace std {
   template<class R>
   class shared_future {
@@ -698,10 +710,13 @@ namespace std {
       future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
   };
 }
 ```
 The implementation provides the template `shared_future` and two
 specializations, `shared_future<R&>` and `shared_future<void>`. These
 differ only in the return type and return value of the member function
 `get`, as set out in its description, below.
@@ -746,29 +761,31 @@ shared state that was originally referred to by `rhs` (if any).
 ``` cpp
 shared_future& operator=(shared_future&& rhs) noexcept;
 ```
-*Effects:*
 - Releases any shared state [[futures.state]];
 - move assigns the contents of `rhs` to `*this`.
 *Ensures:*
 - `valid()` returns the same value as `rhs.valid()` returned prior to
   the assignment.
-- `rhs.valid() == false`.
 ``` cpp
 shared_future& operator=(const shared_future& rhs) noexcept;
 ```
-*Effects:*
 - Releases any shared state [[futures.state]];
-- assigns the contents of `rhs` to `*this`. \[*Note 4*: As a result,
   `*this` refers to the same shared state as `rhs` (if
   any). — *end note*]
 *Ensures:* `valid() == rhs.valid()`.
@@ -781,20 +798,20 @@ void shared_future<void>::get() const;
 [*Note 1*: As described above, the template and its two required
 specializations differ only in the return type and return value of the
 member function `get`. — *end note*]
 [*Note 2*: Access to a value object stored in the shared state is
-unsynchronized, so programmers should apply only those operations on `R`
-that do not introduce a data race [[intro.multithread]]. — *end note*]
 *Effects:* `wait()`s until the shared state is ready, then retrieves the
 value stored in the shared state.
 *Returns:*
 - `shared_future::get()` returns a const reference to the value stored
-  in the object’s shared state. \[*Note 5*: Access through that
   reference after the shared state has been destroyed produces undefined
   behavior; this can be avoided by not storing the reference in any
   storage with a greater lifetime than the `shared_future` object that
   returned the reference. — *end note*]
 - `shared_future<R&>::get()` returns the reference stored as value in
@@ -874,82 +891,64 @@ template<class F, class... Args>
 ```
 *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 first function behaves the same as a call to the second
 function with a `policy` argument of `launch::async | launch::deferred`
 and the same arguments for `F` and `Args`. The second function creates a
 shared state that is associated with the returned `future` object. The
 further behavior of the second function depends on the `policy` argument
 as follows (if more than one of these conditions applies, the
 implementation may choose any of the corresponding policies):
 - If `launch::async` is set in `policy`, calls
-  `invoke(`*`decay-copy`*`(std::forward<F>(f)),`
- *decay-copy*(std::forward\<Args\>(args))...) ([[func.require]],
- [[thread.thread.constr]]) as if in a new thread of execution
- represented by a `thread` object with the calls to *`decay-copy`*
- being evaluated in the thread that called `async`. Any return value is
- stored as the result in the shared state. Any exception propagated
- from the execution of
-  `invoke(`*`decay-copy`*`(std::forward<F>(f)), `*`decay-copy`*`(std::forward<Args>(args))...)`
   is stored as the exceptional result in the shared state. The `thread`
   object is stored in the shared state and affects the behavior of any
   asynchronous return objects that reference that state.
 - If `launch::deferred` is set in `policy`, stores
- *decay-copy*(std::forward\<F\>(f)) and
- *decay-copy*(std::forward\<Args\>(args))... in the shared state. These
- copies of `f` and `args` constitute a *deferred function*. Invocation
-  of the deferred function evaluates
   `invoke(std::move(g), std::move(xyz))` where `g` is the stored value
-  of *decay-copy*(std::forward\<F\>(f)) and `xyz` is the stored copy of
- *decay-copy*(std::forward\<Args\>(args)).... Any return value is
- stored as the result in the shared state. Any exception propagated
- from the execution of the deferred function is stored as the
- exceptional result in the shared state. The shared state is not made
- ready until the function has completed. The first call to a non-timed
- waiting function [[futures.state]] on an asynchronous return object
- referring to this shared state invokes the deferred function in the
- thread that called the waiting function. Once evaluation of
   `invoke(std::move(g), std::move(xyz))` begins, the function is no
-  longer considered deferred. \[*Note 1*: If this policy is specified
-  together with other policies, such as when using a `policy` value of
-  `launch::async | launch::deferred`, implementations should defer
-  invocation or the selection of the policy when no more concurrency can
-  be effectively exploited. — *end note*]
 - If no value is set in the launch policy, or a value is set that is
   neither specified in this document nor by the implementation, the
   behavior is undefined.
-*Returns:* An object of type
-`future<invoke_result_t<decay_t<F>, decay_t<Args>...>``>` that refers to
-the shared state created by this call to `async`.
-[*Note 1*: If a future obtained from `async` is moved outside the local
-scope, other code that uses the future should be aware that the future’s
-destructor can block for the shared state to become
-ready. — *end note*]
-*Synchronization:* Regardless of the provided `policy` argument,
-- the invocation of `async` synchronizes with [[intro.multithread]] the
-  invocation of `f`. \[*Note 2*: This statement applies even when the
-  corresponding `future` object is moved to another
-  thread. — *end note*] ; and
-- the completion of the function `f` is sequenced
-  before [[intro.multithread]] the shared state is made ready.
-  \[*Note 3*: `f` might not be called at all, so its completion might
-  never happen. — *end note*]
 If the implementation chooses the `launch::async` policy,
 - a call to a waiting function on an asynchronous return object that
   shares the shared state created by this `async` call shall block until
@@ -959,27 +958,37 @@ If the implementation chooses the `launch::async` policy,
   with [[intro.multithread]] the return from the first function that
   successfully detects the ready status of the shared state or with the
   return from the last function that releases the shared state,
   whichever happens first.
 *Throws:* `system_error` if `policy == launch::async` and the
 implementation is unable to start a new thread, or `std::bad_alloc` if
-memory for the internal data structures could not be allocated.
 *Error conditions:*
 - `resource_unavailable_try_again` — if `policy == launch::async` and
   the system is unable to start a new thread.
-[*Note 4*: Line \#1 might not result in concurrency because the `async`
-call uses the default policy, which may use `launch::deferred`, in which
-case the lambda might not be invoked until the `get()` call; in that
-case, `work1` and `work2` are called on the same thread and there is no
-concurrency. — *end note*]
 ### Class template `packaged_task` <a id="futures.task">[[futures.task]]</a>
 The class template `packaged_task` defines a type for wrapping a
 function or callable object so that the return value of the function or
 callable object is stored in a future when it is invoked.
 When the `packaged_task` object is invoked, its stored task is invoked
@@ -1020,11 +1029,13 @@ namespace std {
     void reset();
   };
   template<class R, class... ArgTypes>
- void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
 }
 ```
 #### Member functions <a id="futures.task.members">[[futures.task.members]]</a>
@@ -1034,11 +1045,11 @@ packaged_task() noexcept;
 *Effects:* The object has no shared state and no stored task.
 ``` cpp
 template<class F>
-  packaged_task(F&& f);
 ```
 *Constraints:* `remove_cvref_t<F>` is not the same type as
 `packaged_task<R(ArgTypes...)>`.
@@ -1049,13 +1060,29 @@ template<class F>
 *Effects:* Constructs a new `packaged_task` object with a shared state
 and initializes the object’s stored task with `std::forward<F>(f)`.
 *Throws:* Any exceptions thrown by the copy or move constructor of `f`,
-or `bad_alloc` if memory for the internal data structures could not be
 allocated.
 ``` cpp
 packaged_task(packaged_task&& rhs) noexcept;
 ```
 *Effects:* Transfers ownership of `rhs`’s shared state to `*this`,
@@ -1098,20 +1125,20 @@ bool valid() const noexcept;
 ``` cpp
 future<R> get_future();
 ```
-*Returns:* A `future` object that shares the same shared state as
-`*this`.
 *Synchronization:* Calls to this function do not introduce data
 races  [[intro.multithread]] with calls to `operator()` or
 `make_ready_at_thread_exit`.
 [*Note 1*: Such calls need not synchronize with each
 other. — *end note*]
 *Throws:* A `future_error` object if an error occurs.
 *Error conditions:*
 - `future_already_retrieved` if `get_future` has already been called on
@@ -1171,12 +1198,12 @@ task stored in `*this`.
 [*Note 2*: This constructs a new shared state for `*this`. The old
 state is abandoned [[futures.state]]. — *end note*]
 *Throws:*
-- `bad_alloc` if memory for the new shared state could not be allocated.
-- any exception thrown by the move constructor of the task stored in the
   shared state.
 - `future_error` with an error condition of `no_state` if `*this` has no
   shared state.
 #### Globals <a id="futures.task.nonmembers">[[futures.task.nonmembers]]</a>
@@ -1188,139 +1215,209 @@ template<class R, class... ArgTypes>
 *Effects:* As if by `x.swap(y)`.
 <!-- Link reference definitions -->
 [alg.sorting]: algorithms.md#alg.sorting
-[atomics]: atomics.md#atomics
 [barrier.syn]: #barrier.syn
 [basic.life]: basic.md#basic.life
 [basic.stc.thread]: basic.md#basic.stc.thread
 [bitmask.types]: library.md#bitmask.types
 [class.prop]: class.md#class.prop
 [condition.variable.syn]: #condition.variable.syn
-[cpp17.allocator]: #cpp17.allocator
 [cpp17.defaultconstructible]: #cpp17.defaultconstructible
 [cpp17.destructible]: #cpp17.destructible
 [cpp17.moveassignable]: #cpp17.moveassignable
 [cpp17.moveconstructible]: #cpp17.moveconstructible
 [defns.block]: intro.md#defns.block
 [except.terminate]: except.md#except.terminate
 [func.require]: utilities.md#func.require
 [future.syn]: #future.syn
 [futures]: #futures
 [futures.async]: #futures.async
 [futures.errors]: #futures.errors
 [futures.future.error]: #futures.future.error
 [futures.overview]: #futures.overview
 [futures.promise]: #futures.promise
 [futures.shared.future]: #futures.shared.future
 [futures.state]: #futures.state
 [futures.task]: #futures.task
 [futures.task.members]: #futures.task.members
 [futures.task.nonmembers]: #futures.task.nonmembers
 [futures.unique.future]: #futures.unique.future
 [intro.multithread]: basic.md#intro.multithread
 [intro.races]: basic.md#intro.races
 [latch.syn]: #latch.syn
 [mutex.syn]: #mutex.syn
 [res.on.data.races]: library.md#res.on.data.races
 [res.on.exception.handling]: library.md#res.on.exception.handling
 [semaphore.syn]: #semaphore.syn
 [shared.mutex.syn]: #shared.mutex.syn
 [stopcallback]: #stopcallback
 [stopcallback.cons]: #stopcallback.cons
 [stopsource]: #stopsource
 [stopsource.cons]: #stopsource.cons
 [stopsource.mem]: #stopsource.mem
 [stopsource.nonmembers]: #stopsource.nonmembers
 [stoptoken]: #stoptoken
 [stoptoken.cons]: #stoptoken.cons
 [stoptoken.mem]: #stoptoken.mem
 [stoptoken.nonmembers]: #stoptoken.nonmembers
 [syserr]: diagnostics.md#syserr
 [syserr.syserr]: diagnostics.md#syserr.syserr
 [thread]: #thread
 [thread.barrier]: #thread.barrier
 [thread.barrier.class]: #thread.barrier.class
 [thread.condition]: #thread.condition
 [thread.condition.condvar]: #thread.condition.condvar
 [thread.condition.condvarany]: #thread.condition.condvarany
 [thread.condition.nonmember]: #thread.condition.nonmember
 [thread.condvarany.intwait]: #thread.condvarany.intwait
 [thread.condvarany.wait]: #thread.condvarany.wait
 [thread.coord]: #thread.coord
 [thread.general]: #thread.general
 [thread.jthread.class]: #thread.jthread.class
 [thread.jthread.cons]: #thread.jthread.cons
 [thread.jthread.mem]: #thread.jthread.mem
 [thread.jthread.special]: #thread.jthread.special
 [thread.jthread.static]: #thread.jthread.static
 [thread.jthread.stop]: #thread.jthread.stop
 [thread.latch]: #thread.latch
 [thread.latch.class]: #thread.latch.class
 [thread.lock]: #thread.lock
 [thread.lock.algorithm]: #thread.lock.algorithm
 [thread.lock.guard]: #thread.lock.guard
 [thread.lock.scoped]: #thread.lock.scoped
 [thread.lock.shared]: #thread.lock.shared
 [thread.lock.shared.cons]: #thread.lock.shared.cons
 [thread.lock.shared.locking]: #thread.lock.shared.locking
 [thread.lock.shared.mod]: #thread.lock.shared.mod
 [thread.lock.shared.obs]: #thread.lock.shared.obs
 [thread.lock.unique]: #thread.lock.unique
 [thread.lock.unique.cons]: #thread.lock.unique.cons
 [thread.lock.unique.locking]: #thread.lock.unique.locking
 [thread.lock.unique.mod]: #thread.lock.unique.mod
 [thread.lock.unique.obs]: #thread.lock.unique.obs
 [thread.mutex]: #thread.mutex
 [thread.mutex.class]: #thread.mutex.class
 [thread.mutex.recursive]: #thread.mutex.recursive
 [thread.mutex.requirements]: #thread.mutex.requirements
 [thread.mutex.requirements.general]: #thread.mutex.requirements.general
 [thread.mutex.requirements.mutex]: #thread.mutex.requirements.mutex
 [thread.once]: #thread.once
 [thread.once.callonce]: #thread.once.callonce
 [thread.once.onceflag]: #thread.once.onceflag
 [thread.req]: #thread.req
 [thread.req.exception]: #thread.req.exception
 [thread.req.lockable]: #thread.req.lockable
 [thread.req.lockable.basic]: #thread.req.lockable.basic
 [thread.req.lockable.general]: #thread.req.lockable.general
 [thread.req.lockable.req]: #thread.req.lockable.req
 [thread.req.lockable.timed]: #thread.req.lockable.timed
 [thread.req.native]: #thread.req.native
 [thread.req.paramname]: #thread.req.paramname
 [thread.req.timing]: #thread.req.timing
 [thread.sema]: #thread.sema
 [thread.sema.cnt]: #thread.sema.cnt
 [thread.sharedmutex.class]: #thread.sharedmutex.class
 [thread.sharedmutex.requirements]: #thread.sharedmutex.requirements
 [thread.sharedtimedmutex.class]: #thread.sharedtimedmutex.class
 [thread.sharedtimedmutex.requirements]: #thread.sharedtimedmutex.requirements
 [thread.stoptoken]: #thread.stoptoken
 [thread.stoptoken.intro]: #thread.stoptoken.intro
 [thread.stoptoken.syn]: #thread.stoptoken.syn
 [thread.summary]: #thread.summary
 [thread.syn]: #thread.syn
 [thread.thread.algorithm]: #thread.thread.algorithm
 [thread.thread.assign]: #thread.thread.assign
 [thread.thread.class]: #thread.thread.class
 [thread.thread.constr]: #thread.thread.constr
 [thread.thread.destr]: #thread.thread.destr
 [thread.thread.id]: #thread.thread.id
 [thread.thread.member]: #thread.thread.member
 [thread.thread.static]: #thread.thread.static
 [thread.thread.this]: #thread.thread.this
 [thread.threads]: #thread.threads
 [thread.timedmutex.class]: #thread.timedmutex.class
 [thread.timedmutex.recursive]: #thread.timedmutex.recursive
 [thread.timedmutex.requirements]: #thread.timedmutex.requirements
 [time]: time.md#time
 [time.clock]: time.md#time.clock
 [time.clock.req]: time.md#time.clock.req
 [time.duration]: time.md#time.duration
 [time.point]: time.md#time.point
 [unord.hash]: utilities.md#unord.hash
-[^1]: All implementations for which standard time units are meaningful
- must necessarily have a steady clock within their hardware
-    implementation.

 ### Header `<future>` synopsis <a id="future.syn">[[future.syn]]</a>
 ``` cpp
 namespace std {
   enum class future_errc {
+    broken_promise = implementation-defined  // value of future_errc::broken_promise,
+    future_already_retrieved = implementation-defined  // value of future_errc::future_already_retrieved,
+    promise_already_satisfied = implementation-defined  // value of future_errc::promise_already_satisfied,
+    no_state = implementation-defined  // value of future_errc::no_state
   };
   enum class launch : unspecified{} {
     async = unspecified{},
     deferred = unspecified{},
+    implementation-defined  // last enumerator of launch
   };
   enum class future_status {
     ready,
     timeout,
     deferred
   };
+  // [futures.errors], error handling
   template<> struct is_error_code_enum<future_errc> : public true_type { };
   error_code make_error_code(future_errc e) noexcept;
   error_condition make_error_condition(future_errc e) noexcept;
   const error_category& future_category() noexcept;
+  // [futures.future.error], class future_error
   class future_error;
+  // [futures.promise], class template promise
   template<class R> class promise;
   template<class R> class promise<R&>;
   template<> class promise<void>;
   template<class R>
     void swap(promise<R>& x, promise<R>& y) noexcept;
   template<class R, class Alloc>
     struct uses_allocator<promise<R>, Alloc>;
+  // [futures.unique.future], class template future
   template<class R> class future;
   template<class R> class future<R&>;
   template<> class future<void>;
+  // [futures.shared.future], class template shared_future
   template<class R> class shared_future;
   template<class R> class shared_future<R&>;
   template<> class shared_future<void>;
+  // [futures.task], class template packaged_task
   template<class> class packaged_task;  // not defined
   template<class R, class... ArgTypes>
     class packaged_task<R(ArgTypes...)>;
   template<class R, class... ArgTypes>
     void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&) noexcept;
+  // [futures.async], function template async
   template<class F, class... Args>
     [[nodiscard]] future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
       async(F&& f, Args&&... args);
   template<class F, class... Args>
     [[nodiscard]] future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
 ```
 *Returns:* A reference to an object of a type derived from class
 `error_category`.
+The object’s `default_error_condition` and `equivalent` virtual
+functions shall behave as specified for the class `error_category`. The
+object’s `name` virtual function returns a pointer to the string
+`"future"`.
 ``` cpp
 error_code make_error_code(future_errc e) noexcept;
 ```
 Many of the classes introduced in subclause  [[futures]] use some state
 to communicate results. This *shared state* consists of some state
 information and some (possibly not yet evaluated) *result*, which can be
 a (possibly void) value or an exception.
+[*Note 1*: Futures, promises, and tasks defined in this Clause
 reference such shared state. — *end note*]
 [*Note 2*: The result can be any kind of object including a function to
 compute that result, as used by `async` when `policy` is
 `launch::deferred`. — *end note*]
     // setting the result with deferred notification
     void set_value_at_thread_exit(see below);
     void set_exception_at_thread_exit(exception_ptr p);
   };
   template<class R, class Alloc>
     struct uses_allocator<promise<R>, Alloc>;
 }
 ```
+For the primary template, `R` shall be an object type that meets the
+*Cpp17Destructible* requirements.
 The implementation provides the template `promise` and two
 specializations, `promise<R&>` and `promise<{}void>`. These differ only
 in the argument type of the member functions `set_value` and
 `set_value_at_thread_exit`, as set out in their descriptions, below.
 template<class R, class Alloc>
   struct uses_allocator<promise<R>, Alloc>
     : true_type { };
 ```
+*Preconditions:* `Alloc` meets the *Cpp17Allocator*
+requirements [[allocator.requirements.general]].
 ``` cpp
 promise();
 template<class Allocator>
   promise(allocator_arg_t, const Allocator& a);
 ``` cpp
 future<R> get_future();
 ```
 *Synchronization:* Calls to this function do not introduce data
 races  [[intro.multithread]] with calls to `set_value`, `set_exception`,
 `set_value_at_thread_exit`, or `set_exception_at_thread_exit`.
 [*Note 1*: Such calls need not synchronize with each
 other. — *end note*]
+*Returns:* A `future<R>` object with the same shared state as `*this`.
 *Throws:* `future_error` if `*this` has no shared state or if
 `get_future` has already been called on a `promise` with the same shared
 state as `*this`.
 *Error conditions:*
 which `valid() == false` is undefined.
 [*Note 2*: It is valid to move from a future object for which
 `valid() == false`. — *end note*]
+*Recommended practice:* Implementations should detect this case and
+throw an object of type `future_error` with an error condition of
+`future_errc::no_state`.
 ``` cpp
 namespace std {
   template<class R>
   class future {
       future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
   };
 }
 ```
+For the primary template, `R` shall be an object type that meets the
+*Cpp17Destructible* requirements.
 The implementation provides the template `future` and two
 specializations, `future<R&>` and `future<{}void>`. These differ only in
 the return type and return value of the member function `get`, as set
 out in its description, below.
 ``` cpp
 future& operator=(future&& rhs) noexcept;
 ```
+*Effects:* If `addressof(rhs) == this` is `true`, there are no effects.
+Otherwise:
 - Releases any shared state [[futures.state]].
 - move assigns the contents of `rhs` to `*this`.
 *Ensures:*
 - `valid()` returns the same value as `rhs.valid()` prior to the
   assignment.
+- If `addressof(rhs) == this` is `false`, `rhs.valid() == false`.
 ``` cpp
 shared_future<R> share() noexcept;
 ```
+*Ensures:* `valid() == false`.
 *Returns:* `shared_future<R>(std::move(*this))`.
 ``` cpp
 R future::get();
 R& future<R&>::get();
 void future<void>::get();
 ```
 - `wait()`s until the shared state is ready, then retrieves the value
   stored in the shared state;
 - releases any shared state [[futures.state]].
+*Ensures:* `valid() == false`.
 *Returns:*
 - `future::get()` returns the value `v` stored in the object’s shared
   state as `std::move(v)`.
 - `future<R&>::get()` returns the reference stored as value in the
 - `future<void>::get()` returns nothing.
 *Throws:* The stored exception, if an exception was stored in the shared
 state.
 ``` cpp
 bool valid() const noexcept;
 ```
 *Returns:* `true` only if `*this` refers to a shared state.
 a `shared_future` object for which `valid() == false` is undefined.
 [*Note 2*: It is valid to copy or move from a `shared_future` object
 for which `valid()` is `false`. — *end note*]
+*Recommended practice:* Implementations should detect this case and
+throw an object of type `future_error` with an error condition of
+`future_errc::no_state`.
 ``` cpp
 namespace std {
   template<class R>
   class shared_future {
       future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
   };
 }
 ```
+For the primary template, `R` shall be an object type that meets the
+*Cpp17Destructible* requirements.
 The implementation provides the template `shared_future` and two
 specializations, `shared_future<R&>` and `shared_future<void>`. These
 differ only in the return type and return value of the member function
 `get`, as set out in its description, below.
 ``` cpp
 shared_future& operator=(shared_future&& rhs) noexcept;
 ```
+*Effects:* If `addressof(rhs) == this` is `true`, there are no effects.
+Otherwise:
 - Releases any shared state [[futures.state]];
 - move assigns the contents of `rhs` to `*this`.
 *Ensures:*
 - `valid()` returns the same value as `rhs.valid()` returned prior to
   the assignment.
+- If `addressof(rhs) == this` is `false`, `rhs.valid() == false`.
 ``` cpp
 shared_future& operator=(const shared_future& rhs) noexcept;
 ```
+*Effects:* If `addressof(rhs) == this` is `true`, there are no effects.
+Otherwise:
 - Releases any shared state [[futures.state]];
+- assigns the contents of `rhs` to `*this`. \[*Note 3*: As a result,
   `*this` refers to the same shared state as `rhs` (if
   any). — *end note*]
 *Ensures:* `valid() == rhs.valid()`.
 [*Note 1*: As described above, the template and its two required
 specializations differ only in the return type and return value of the
 member function `get`. — *end note*]
 [*Note 2*: Access to a value object stored in the shared state is
+unsynchronized, so operations on `R` might introduce a data
+race [[intro.multithread]]. — *end note*]
 *Effects:* `wait()`s until the shared state is ready, then retrieves the
 value stored in the shared state.
 *Returns:*
 - `shared_future::get()` returns a const reference to the value stored
+  in the object’s shared state. \[*Note 4*: Access through that
   reference after the shared state has been destroyed produces undefined
   behavior; this can be avoided by not storing the reference in any
   storage with a greater lifetime than the `shared_future` object that
   returned the reference. — *end note*]
 - `shared_future<R&>::get()` returns the reference stored as value in
 ```
 *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 first function behaves the same as a call to the second
 function with a `policy` argument of `launch::async | launch::deferred`
 and the same arguments for `F` and `Args`. The second function creates a
 shared state that is associated with the returned `future` object. The
 further behavior of the second function depends on the `policy` argument
 as follows (if more than one of these conditions applies, the
 implementation may choose any of the corresponding policies):
 - If `launch::async` is set in `policy`, calls
+  `invoke(auto(std::forward<F>(f)), auto(std::forward<Args>(args))...)`
+  [[func.invoke]], [[thread.thread.constr]] as if in a new thread of
+ execution represented by a `thread` object with the values produced by
+  `auto` being materialized [[conv.rval]] in the thread that called
+  `async`. Any return value is stored as the result in the shared state.
+ Any exception propagated from the execution of
+ `invoke(auto(std::forward<F>(f)), auto(std::forward<Args>(args))...)`
   is stored as the exceptional result in the shared state. The `thread`
   object is stored in the shared state and affects the behavior of any
   asynchronous return objects that reference that state.
 - If `launch::deferred` is set in `policy`, stores
+ `auto(std::forward<F>(f))` and `auto(std::forward<Args>(args))...` in
+  the shared state. These copies of `f` and `args` constitute a
+ *deferred function*. Invocation of the deferred function evaluates
   `invoke(std::move(g), std::move(xyz))` where `g` is the stored value
+  of `auto(std::forward<F>(f))` and `xyz` is the stored copy of
+ `auto(std::forward<Args>(args))...`. Any return value is stored as the
+  result in the shared state. Any exception propagated from the
+  execution of the deferred function is stored as the exceptional result
+  in the shared state. The shared state is not made ready until the
+  function has completed. The first call to a non-timed waiting
+  function [[futures.state]] on an asynchronous return object referring
+  to this shared state invokes the deferred function in the thread that
+  called the waiting function. Once evaluation of
   `invoke(std::move(g), std::move(xyz))` begins, the function is no
+  longer considered deferred. *Recommended practice:* If this policy is
+ specified together with other policies, such as when using a `policy`
+ value of `launch::async | launch::deferred`, implementations should
+ defer invocation or the selection of the policy when no more
+ concurrency can be effectively exploited.
 - If no value is set in the launch policy, or a value is set that is
   neither specified in this document nor by the implementation, the
   behavior is undefined.
+*Synchronization:* The invocation of `async` synchronizes with the
+invocation of `f`. The completion of the function `f` is sequenced
+before the shared state is made ready.
+[*Note 1*: These apply regardless of the provided `policy` argument,
+and even if the corresponding `future` object is moved to another
+thread. However, it is possible for `f` not to be called at all, in
+which case its completion never happens. — *end note*]
 If the implementation chooses the `launch::async` policy,
 - a call to a waiting function on an asynchronous return object that
   shares the shared state created by this `async` call shall block until
   with [[intro.multithread]] the return from the first function that
   successfully detects the ready status of the shared state or with the
   return from the last function that releases the shared state,
   whichever happens first.
+*Returns:* An object of type
+`future<invoke_result_t<decay_t<F>, decay_t<Args>...>>` that refers to
+the shared state created by this call to `async`.
+[*Note 2*: If a future obtained from `async` is moved outside the local
+scope, the future’s destructor can block for the shared state to become
+ready. — *end note*]
 *Throws:* `system_error` if `policy == launch::async` and the
 implementation is unable to start a new thread, or `std::bad_alloc` if
+memory for the internal data structures cannot be allocated.
 *Error conditions:*
 - `resource_unavailable_try_again` — if `policy == launch::async` and
   the system is unable to start a new thread.
+[*Note 1*: Line \#1 might not result in concurrency because the `async`
+call uses the default policy, which might use `launch::deferred`, in
+which case the lambda might not be invoked until the `get()` call; in
+that case, `work1` and `work2` are called on the same thread and there
+is no concurrency. — *end note*]
 ### Class template `packaged_task` <a id="futures.task">[[futures.task]]</a>
+#### General <a id="futures.task.general">[[futures.task.general]]</a>
 The class template `packaged_task` defines a type for wrapping a
 function or callable object so that the return value of the function or
 callable object is stored in a future when it is invoked.
 When the `packaged_task` object is invoked, its stored task is invoked
     void reset();
   };
   template<class R, class... ArgTypes>
+    packaged_task(R (*)(ArgTypes...)) -> packaged_task<R(ArgTypes...)>;
+  template<class F> packaged_task(F) -> packaged_task<see below>;
 }
 ```
 #### Member functions <a id="futures.task.members">[[futures.task.members]]</a>
 *Effects:* The object has no shared state and no stored task.
 ``` cpp
 template<class F>
+ explicit packaged_task(F&& f);
 ```
 *Constraints:* `remove_cvref_t<F>` is not the same type as
 `packaged_task<R(ArgTypes...)>`.
 *Effects:* Constructs a new `packaged_task` object with a shared state
 and initializes the object’s stored task with `std::forward<F>(f)`.
 *Throws:* Any exceptions thrown by the copy or move constructor of `f`,
+or `bad_alloc` if memory for the internal data structures cannot be
 allocated.
+``` cpp
+template<class F> packaged_task(F) -> packaged_task<see below>;
+```
+*Constraints:* `&F::operator()` is well-formed when treated as an
+unevaluated operand [[term.unevaluated.operand]] and either
+- `F::operator()` is a non-static member function and
+  `decltype(&F::operator())` is either of the form
+  `R(G::*)(A...)` cv \\ₒₚₜ ` `noexceptₒₚₜ  or of the form
+  `R(*)(G, A...) `noexceptₒₚₜ  for a type `G`, or
+- `F::operator()` is a static member function and
+  `decltype(&F::operator())` is of the form `R(*)(A...) `noexceptₒₚₜ .
+*Remarks:* The deduced type is `packaged_task<R(A...)>`.
 ``` cpp
 packaged_task(packaged_task&& rhs) noexcept;
 ```
 *Effects:* Transfers ownership of `rhs`’s shared state to `*this`,
 ``` cpp
 future<R> get_future();
 ```
 *Synchronization:* Calls to this function do not introduce data
 races  [[intro.multithread]] with calls to `operator()` or
 `make_ready_at_thread_exit`.
 [*Note 1*: Such calls need not synchronize with each
 other. — *end note*]
+*Returns:* A `future` object that shares the same shared state as
+`*this`.
 *Throws:* A `future_error` object if an error occurs.
 *Error conditions:*
 - `future_already_retrieved` if `get_future` has already been called on
 [*Note 2*: This constructs a new shared state for `*this`. The old
 state is abandoned [[futures.state]]. — *end note*]
 *Throws:*
+- `bad_alloc` if memory for the new shared state cannot be allocated.
+- Any exception thrown by the move constructor of the task stored in the
   shared state.
 - `future_error` with an error condition of `no_state` if `*this` has no
   shared state.
 #### Globals <a id="futures.task.nonmembers">[[futures.task.nonmembers]]</a>
 *Effects:* As if by `x.swap(y)`.
 <!-- Link reference definitions -->
 [alg.sorting]: algorithms.md#alg.sorting
+[allocator.requirements.general]: library.md#allocator.requirements.general
+[atomic.types.int.comp]: #atomic.types.int.comp
+[atomic.types.pointer.comp]: #atomic.types.pointer.comp
+[atomics]: #atomics
+[atomics.alias]: #atomics.alias
+[atomics.fences]: #atomics.fences
+[atomics.flag]: #atomics.flag
+[atomics.general]: #atomics.general
+[atomics.lockfree]: #atomics.lockfree
+[atomics.nonmembers]: #atomics.nonmembers
+[atomics.order]: #atomics.order
+[atomics.ref.float]: #atomics.ref.float
+[atomics.ref.generic]: #atomics.ref.generic
+[atomics.ref.generic.general]: #atomics.ref.generic.general
+[atomics.ref.int]: #atomics.ref.int
+[atomics.ref.memop]: #atomics.ref.memop
+[atomics.ref.ops]: #atomics.ref.ops
+[atomics.ref.pointer]: #atomics.ref.pointer
+[atomics.syn]: #atomics.syn
+[atomics.types.float]: #atomics.types.float
+[atomics.types.generic]: #atomics.types.generic
+[atomics.types.generic.general]: #atomics.types.generic.general
+[atomics.types.int]: #atomics.types.int
+[atomics.types.memop]: #atomics.types.memop
+[atomics.types.operations]: #atomics.types.operations
+[atomics.types.pointer]: #atomics.types.pointer
+[atomics.wait]: #atomics.wait
 [barrier.syn]: #barrier.syn
+[basic.align]: basic.md#basic.align
+[basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.stc.thread]: basic.md#basic.stc.thread
 [bitmask.types]: library.md#bitmask.types
+[cfenv]: numerics.md#cfenv
 [class.prop]: class.md#class.prop
+[compliance]: library.md#compliance
+[concept.booleantestable]: concepts.md#concept.booleantestable
 [condition.variable.syn]: #condition.variable.syn
+[conv.rval]: expr.md#conv.rval
 [cpp17.defaultconstructible]: #cpp17.defaultconstructible
 [cpp17.destructible]: #cpp17.destructible
 [cpp17.moveassignable]: #cpp17.moveassignable
 [cpp17.moveconstructible]: #cpp17.moveconstructible
 [defns.block]: intro.md#defns.block
 [except.terminate]: except.md#except.terminate
+[expr.pre]: expr.md#expr.pre
+[format.string.std]: utilities.md#format.string.std
+[func.invoke]: utilities.md#func.invoke
 [func.require]: utilities.md#func.require
+[function.objects]: utilities.md#function.objects
 [future.syn]: #future.syn
 [futures]: #futures
 [futures.async]: #futures.async
 [futures.errors]: #futures.errors
 [futures.future.error]: #futures.future.error
 [futures.overview]: #futures.overview
 [futures.promise]: #futures.promise
 [futures.shared.future]: #futures.shared.future
 [futures.state]: #futures.state
 [futures.task]: #futures.task
+[futures.task.general]: #futures.task.general
 [futures.task.members]: #futures.task.members
 [futures.task.nonmembers]: #futures.task.nonmembers
 [futures.unique.future]: #futures.unique.future
 [intro.multithread]: basic.md#intro.multithread
+[intro.progress]: basic.md#intro.progress
 [intro.races]: basic.md#intro.races
 [latch.syn]: #latch.syn
+[limits.syn]: support.md#limits.syn
 [mutex.syn]: #mutex.syn
 [res.on.data.races]: library.md#res.on.data.races
 [res.on.exception.handling]: library.md#res.on.exception.handling
 [semaphore.syn]: #semaphore.syn
 [shared.mutex.syn]: #shared.mutex.syn
+[stdatomic.h.syn]: #stdatomic.h.syn
 [stopcallback]: #stopcallback
 [stopcallback.cons]: #stopcallback.cons
+[stopcallback.general]: #stopcallback.general
 [stopsource]: #stopsource
 [stopsource.cons]: #stopsource.cons
+[stopsource.general]: #stopsource.general
 [stopsource.mem]: #stopsource.mem
 [stopsource.nonmembers]: #stopsource.nonmembers
 [stoptoken]: #stoptoken
 [stoptoken.cons]: #stoptoken.cons
+[stoptoken.general]: #stoptoken.general
 [stoptoken.mem]: #stoptoken.mem
 [stoptoken.nonmembers]: #stoptoken.nonmembers
 [syserr]: diagnostics.md#syserr
 [syserr.syserr]: diagnostics.md#syserr.syserr
+[term.padding.bits]: basic.md#term.padding.bits
+[term.unevaluated.operand]: expr.md#term.unevaluated.operand
 [thread]: #thread
 [thread.barrier]: #thread.barrier
 [thread.barrier.class]: #thread.barrier.class
+[thread.barrier.general]: #thread.barrier.general
 [thread.condition]: #thread.condition
 [thread.condition.condvar]: #thread.condition.condvar
 [thread.condition.condvarany]: #thread.condition.condvarany
+[thread.condition.condvarany.general]: #thread.condition.condvarany.general
+[thread.condition.general]: #thread.condition.general
 [thread.condition.nonmember]: #thread.condition.nonmember
 [thread.condvarany.intwait]: #thread.condvarany.intwait
 [thread.condvarany.wait]: #thread.condvarany.wait
 [thread.coord]: #thread.coord
+[thread.coord.general]: #thread.coord.general
 [thread.general]: #thread.general
 [thread.jthread.class]: #thread.jthread.class
+[thread.jthread.class.general]: #thread.jthread.class.general
 [thread.jthread.cons]: #thread.jthread.cons
 [thread.jthread.mem]: #thread.jthread.mem
 [thread.jthread.special]: #thread.jthread.special
 [thread.jthread.static]: #thread.jthread.static
 [thread.jthread.stop]: #thread.jthread.stop
 [thread.latch]: #thread.latch
 [thread.latch.class]: #thread.latch.class
+[thread.latch.general]: #thread.latch.general
 [thread.lock]: #thread.lock
 [thread.lock.algorithm]: #thread.lock.algorithm
+[thread.lock.general]: #thread.lock.general
 [thread.lock.guard]: #thread.lock.guard
 [thread.lock.scoped]: #thread.lock.scoped
 [thread.lock.shared]: #thread.lock.shared
 [thread.lock.shared.cons]: #thread.lock.shared.cons
+[thread.lock.shared.general]: #thread.lock.shared.general
 [thread.lock.shared.locking]: #thread.lock.shared.locking
 [thread.lock.shared.mod]: #thread.lock.shared.mod
 [thread.lock.shared.obs]: #thread.lock.shared.obs
 [thread.lock.unique]: #thread.lock.unique
 [thread.lock.unique.cons]: #thread.lock.unique.cons
+[thread.lock.unique.general]: #thread.lock.unique.general
 [thread.lock.unique.locking]: #thread.lock.unique.locking
 [thread.lock.unique.mod]: #thread.lock.unique.mod
 [thread.lock.unique.obs]: #thread.lock.unique.obs
 [thread.mutex]: #thread.mutex
 [thread.mutex.class]: #thread.mutex.class
+[thread.mutex.general]: #thread.mutex.general
 [thread.mutex.recursive]: #thread.mutex.recursive
 [thread.mutex.requirements]: #thread.mutex.requirements
 [thread.mutex.requirements.general]: #thread.mutex.requirements.general
 [thread.mutex.requirements.mutex]: #thread.mutex.requirements.mutex
+[thread.mutex.requirements.mutex.general]: #thread.mutex.requirements.mutex.general
 [thread.once]: #thread.once
 [thread.once.callonce]: #thread.once.callonce
 [thread.once.onceflag]: #thread.once.onceflag
 [thread.req]: #thread.req
 [thread.req.exception]: #thread.req.exception
 [thread.req.lockable]: #thread.req.lockable
 [thread.req.lockable.basic]: #thread.req.lockable.basic
 [thread.req.lockable.general]: #thread.req.lockable.general
 [thread.req.lockable.req]: #thread.req.lockable.req
+[thread.req.lockable.shared]: #thread.req.lockable.shared
+[thread.req.lockable.shared.timed]: #thread.req.lockable.shared.timed
 [thread.req.lockable.timed]: #thread.req.lockable.timed
 [thread.req.native]: #thread.req.native
 [thread.req.paramname]: #thread.req.paramname
 [thread.req.timing]: #thread.req.timing
 [thread.sema]: #thread.sema
 [thread.sema.cnt]: #thread.sema.cnt
+[thread.sema.general]: #thread.sema.general
 [thread.sharedmutex.class]: #thread.sharedmutex.class
 [thread.sharedmutex.requirements]: #thread.sharedmutex.requirements
+[thread.sharedmutex.requirements.general]: #thread.sharedmutex.requirements.general
 [thread.sharedtimedmutex.class]: #thread.sharedtimedmutex.class
 [thread.sharedtimedmutex.requirements]: #thread.sharedtimedmutex.requirements
+[thread.sharedtimedmutex.requirements.general]: #thread.sharedtimedmutex.requirements.general
 [thread.stoptoken]: #thread.stoptoken
 [thread.stoptoken.intro]: #thread.stoptoken.intro
 [thread.stoptoken.syn]: #thread.stoptoken.syn
 [thread.summary]: #thread.summary
 [thread.syn]: #thread.syn
 [thread.thread.algorithm]: #thread.thread.algorithm
 [thread.thread.assign]: #thread.thread.assign
 [thread.thread.class]: #thread.thread.class
+[thread.thread.class.general]: #thread.thread.class.general
 [thread.thread.constr]: #thread.thread.constr
 [thread.thread.destr]: #thread.thread.destr
 [thread.thread.id]: #thread.thread.id
 [thread.thread.member]: #thread.thread.member
 [thread.thread.static]: #thread.thread.static
 [thread.thread.this]: #thread.thread.this
 [thread.threads]: #thread.threads
+[thread.threads.general]: #thread.threads.general
 [thread.timedmutex.class]: #thread.timedmutex.class
 [thread.timedmutex.recursive]: #thread.timedmutex.recursive
 [thread.timedmutex.requirements]: #thread.timedmutex.requirements
+[thread.timedmutex.requirements.general]: #thread.timedmutex.requirements.general
 [time]: time.md#time
 [time.clock]: time.md#time.clock
 [time.clock.req]: time.md#time.clock.req
 [time.duration]: time.md#time.duration
 [time.point]: time.md#time.point
 [unord.hash]: utilities.md#unord.hash
+[util.sharedptr]: mem.md#util.sharedptr
+[util.smartptr.atomic]: #util.smartptr.atomic
+[util.smartptr.atomic.general]: #util.smartptr.atomic.general
+[util.smartptr.atomic.shared]: #util.smartptr.atomic.shared
+[util.smartptr.atomic.weak]: #util.smartptr.atomic.weak
+[^1]: Implementations for which standard time units are meaningful will
+ typically have a steady clock within their hardware implementation.
+[^2]: That is, atomic operations on the same memory location via two
+    different addresses will communicate atomically.

Diff to HTML by rtfpessoa