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

Files changed (1) hide show

tmp/tmplhakgs7a/{from.md → to.md} +246 -217

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

@@ -64,23 +64,20 @@ namespace std {
     class packaged_task<R(ArgTypes...)>;
   template<class R, class... ArgTypes>
     void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&) noexcept;
-  template <class R, class Alloc>
-    struct uses_allocator<packaged_task<R>, Alloc>;
   template<class F, class... Args>
-    future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
       async(F&& f, Args&&... args);
   template<class F, class... Args>
-    future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
       async(launch policy, F&& f, Args&&... args);
 }
 ```
-The `enum` type `launch` is a bitmask type ([[bitmask.types]]) with
 elements `launch::async` and `launch::deferred`.
 [*Note 1*: Implementations can provide bitmasks to specify restrictions
 on task interaction by functions launched by `async()` applicable to a
 corresponding subset of available launch policies. Implementations can
@@ -93,16 +90,16 @@ The enum values of `future_errc` are distinct and not zero.
 ``` cpp
 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 shall return a pointer to the string `"future"`.
 ``` cpp
 error_code make_error_code(future_errc e) noexcept;
 ```
@@ -112,32 +109,32 @@ error_code make_error_code(future_errc e) noexcept;
 error_condition make_error_condition(future_errc e) noexcept;
 ```
 *Returns:* `error_condition(static_cast<int>(e), future_category())`.
-### Class `future_error` <a id="futures.future_error">[[futures.future_error]]</a>
 ``` cpp
 namespace std {
   class future_error : public logic_error {
   public:
     explicit future_error(future_errc e);
     const error_code& code() const noexcept;
     const char*       what() const noexcept;
   private:
     error_code ec_;             // exposition only
   };
 }
 ```
 ``` cpp
 explicit future_error(future_errc e);
 ```
-*Effects:* Constructs an object of class `future_error` and initializes
-`ec_` with `make_error_code(e)`.
 ``` cpp
 const error_code& code() const noexcept;
 ```
@@ -149,12 +146,12 @@ const char* what() const noexcept;
 *Returns:* An NTBS incorporating `code().message()`.
 ### Shared state <a id="futures.state">[[futures.state]]</a>
-Many of the classes introduced in this subclause 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*]
@@ -165,11 +162,11 @@ compute that result, as used by `async` when `policy` is
 An *asynchronous return object* is an object that reads results from a
 shared state. A *waiting function* of an asynchronous return object is
 one that potentially blocks to wait for the shared state to be made
 ready. If a waiting function can return before the state is made ready
-because of a timeout ([[thread.req.lockable]]), then it is a *timed
 waiting function*, otherwise it is a *non-timed waiting function*.
 An *asynchronous provider* is an object that provides a result to a
 shared state. The result of a shared state is set by respective
 functions on the asynchronous provider.
@@ -212,30 +209,29 @@ A shared state is *ready* only if it holds a value or an exception ready
 for retrieval. Waiting for a shared state to become ready may invoke
 code to compute the result on the waiting thread if so specified in the
 description of the class or function that creates the state object.
 Calls to functions that successfully set the stored result of a shared
-state synchronize with ([[intro.multithread]]) calls to functions
 successfully detecting the ready state resulting from that setting. The
 storage of the result (whether normal or exceptional) into the shared
-state synchronizes with ([[intro.multithread]]) the successful return
-from a call to a waiting function on the shared state.
 Some functions (e.g., `promise::set_value_at_thread_exit`) delay making
 the shared state ready until the calling thread exits. The destruction
-of each of that thread’s objects with thread storage duration (
-[[basic.stc.thread]]) is sequenced before making that shared state
-ready.
-Access to the result of the same shared state may conflict (
-[[intro.multithread]]).
 [*Note 4*: This explicitly specifies that the result of the shared
 state is visible in the objects that reference this state in the sense
-of data race avoidance ([[res.on.data.races]]). For example, concurrent
-accesses through references returned by `shared_future::get()` (
-[[futures.shared_future]]) must either use read-only operations or
 provide additional synchronization. — *end note*]
 ### Class template `promise` <a id="futures.promise">[[futures.promise]]</a>
 ``` cpp
@@ -245,16 +241,16 @@ namespace std {
   public:
     promise();
     template<class Allocator>
       promise(allocator_arg_t, const Allocator& a);
     promise(promise&& rhs) noexcept;
-    promise(const promise& rhs) = delete;
     ~promise();
     // assignment
     promise& operator=(promise&& rhs) noexcept;
-    promise& operator=(const promise& rhs) = delete;
     void swap(promise& other) noexcept;
     // retrieving the result
     future<R> get_future();
@@ -264,18 +260,20 @@ 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 shall provide 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.
 The `set_value`, `set_exception`, `set_value_at_thread_exit`, and
@@ -287,62 +285,69 @@ the promise object.
 template<class R, class Alloc>
   struct uses_allocator<promise<R>, Alloc>
     : true_type { };
 ```
-*Requires:* `Alloc` shall be an Allocator ([[allocator.requirements]]).
 ``` cpp
 promise();
 template<class Allocator>
   promise(allocator_arg_t, const Allocator& a);
 ```
-*Effects:* constructs a `promise` object and a shared state. The second
-constructor uses the allocator `a` to allocate memory for the shared
-state.
 ``` cpp
 promise(promise&& rhs) noexcept;
 ```
-*Effects:* constructs a new `promise` object and transfers ownership of
-the shared state of `rhs` (if any) to the newly-constructed object.
-*Postconditions:* `rhs` has no shared state.
 ``` cpp
 ~promise();
 ```
-*Effects:* Abandons any shared state ([[futures.state]]).
 ``` cpp
 promise& operator=(promise&& rhs) noexcept;
 ```
-*Effects:* Abandons any shared state ([[futures.state]]) and then as if
 `promise(std::move(rhs)).swap(*this)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(promise& other) noexcept;
 ```
 *Effects:* Exchanges the shared state of `*this` and `other`.
-*Postconditions:* `*this` has the shared state (if any) that `other` had
-prior to the call to `swap`. `other` has the shared state (if any) that
 `*this` had prior to the call to `swap`.
 ``` cpp
 future<R> get_future();
 ```
 *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:*
@@ -357,11 +362,11 @@ void promise::set_value(R&& r);
 void promise<R&>::set_value(R& r);
 void promise<void>::set_value();
 ```
 *Effects:* Atomically stores the value `r` in the shared state and makes
-that state ready ([[futures.state]]).
 *Throws:*
 - `future_error` if its shared state already has a stored value or
   exception, or
@@ -378,14 +383,14 @@ that state ready ([[futures.state]]).
 ``` cpp
 void set_exception(exception_ptr p);
 ```
-*Requires:* `p` is not null.
 *Effects:* Atomically stores the exception pointer `p` in the shared
-state and makes that state ready ([[futures.state]]).
 *Throws:* `future_error` if its shared state already has a stored value
 or exception.
 *Error conditions:*
@@ -423,11 +428,11 @@ associated with the current thread have been destroyed.
 ``` cpp
 void set_exception_at_thread_exit(exception_ptr p);
 ```
-*Requires:* `p` is not null.
 *Effects:* Stores the exception pointer `p` in the shared state without
 making that state ready immediately. Schedules that state to be made
 ready when the current thread exits, after all objects of thread storage
 duration associated with the current thread have been destroyed.
@@ -445,21 +450,20 @@ template <class R>
   void swap(promise<R>& x, promise<R>& y) noexcept;
 ```
 *Effects:* As if by `x.swap(y)`.
-### Class template `future` <a id="futures.unique_future">[[futures.unique_future]]</a>
 The class template `future` defines a type for asynchronous return
 objects which do not share their shared state with other asynchronous
 return objects. A default-constructed `future` object has no shared
 state. A `future` object with shared state can be created by functions
-on asynchronous providers ([[futures.state]]) or by the move
-constructor and shares its shared state with the original asynchronous
-provider. The result (value or exception) of a `future` object can be
-set by calling a respective function on an object that shares the same
-shared state.
 [*Note 1*: Member functions of `future` do not synchronize with
 themselves or with member functions of `shared_future`. — *end note*]
 The effect of calling any member function other than the destructor, the
@@ -467,24 +471,24 @@ 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 are encouraged to 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 {
   public:
     future() noexcept;
     future(future&&) noexcept;
-    future(const future& rhs) = delete;
     ~future();
-    future& operator=(const future& rhs) = delete;
     future& operator=(future&&) noexcept;
     shared_future<R> share() noexcept;
     // retrieving the value
     see below get();
@@ -499,32 +503,31 @@ namespace std {
       future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
   };
 }
 ```
-The implementation shall provide 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() noexcept;
 ```
-*Effects:* Constructs an *empty* `future` object that does not refer to
-a shared state.
-*Postconditions:* `valid() == false`.
 ``` cpp
 future(future&& rhs) noexcept;
 ```
 *Effects:* Move constructs a `future` object that refers to the shared
 state that was originally referred to by `rhs` (if any).
-*Postconditions:*
 - `valid()` returns the same value as `rhs.valid()` prior to the
   constructor invocation.
 - `rhs.valid() == false`.
@@ -532,23 +535,23 @@ state that was originally referred to by `rhs` (if any).
 ~future();
 ```
 *Effects:*
-- Releases any shared state ([[futures.state]]);
 - destroys `*this`.
 ``` cpp
 future& operator=(future&& rhs) noexcept;
 ```
 *Effects:*
-- Releases any shared state ([[futures.state]]).
 - move assigns the contents of `rhs` to `*this`.
-*Postconditions:*
 - `valid()` returns the same value as `rhs.valid()` prior to the
   assignment.
 - `rhs.valid() == false`.
@@ -556,11 +559,11 @@ future& operator=(future&& rhs) noexcept;
 shared_future<R> share() noexcept;
 ```
 *Returns:* `shared_future<R>(std::move(*this))`.
-*Postconditions:* `valid() == false`.
 ``` cpp
 R future::get();
 R& future<R&>::get();
 void future<void>::get();
@@ -572,24 +575,24 @@ member function `get`. — *end note*]
 *Effects:*
 - `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
   object’s shared state.
 - `future<void>::get()` returns nothing.
-*Throws:* the stored exception, if an exception was stored in the shared
 state.
-*Postconditions:* `valid() == false`.
 ``` cpp
 bool valid() const noexcept;
 ```
@@ -605,57 +608,57 @@ void wait() const;
 template<class Rep, class Period>
   future_status wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 ```
 *Effects:* None if the shared state contains a deferred
-function ([[futures.async]]), otherwise blocks until the shared state
-is ready or until the relative timeout ([[thread.req.timing]])
-specified by `rel_time` has expired.
 *Returns:*
 - `future_status::deferred` if the shared state contains a deferred
   function.
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
-  relative timeout ([[thread.req.timing]]) specified by `rel_time` has
   expired.
-*Throws:* timeout-related exceptions ([[thread.req.timing]]).
 ``` cpp
 template<class Clock, class Duration>
   future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 ```
 *Effects:* None if the shared state contains a deferred
-function ([[futures.async]]), otherwise blocks until the shared state
-is ready or until the absolute timeout ([[thread.req.timing]])
-specified by `abs_time` has expired.
 *Returns:*
 - `future_status::deferred` if the shared state contains a deferred
   function.
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
-  absolute timeout ([[thread.req.timing]]) specified by `abs_time` has
   expired.
-*Throws:* timeout-related exceptions ([[thread.req.timing]]).
-### Class template `shared_future` <a id="futures.shared_future">[[futures.shared_future]]</a>
 The class template `shared_future` defines a type for asynchronous
 return objects which may share their shared state with other
 asynchronous return objects. A default-constructed `shared_future`
 object has no shared state. A `shared_future` object with shared state
 can be created by conversion from a `future` object and shares its
-shared state with the original asynchronous provider (
-[[futures.state]]) of the shared state. The result (value or exception)
-of a `shared_future` object can be set by calling a respective function
-on an object that shares the same shared state.
 [*Note 1*: Member functions of `shared_future` do not synchronize with
 themselves, but they synchronize with the shared state. — *end note*]
 The effect of calling any member function other than the destructor, the
@@ -663,12 +666,12 @@ 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 are encouraged to 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>
@@ -695,42 +698,40 @@ namespace std {
       future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
   };
 }
 ```
-The implementation shall provide 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() noexcept;
 ```
-*Effects:* Constructs an *empty* `shared_future` object that does not
-refer to a shared state.
-*Postconditions:* `valid() == false`.
 ``` cpp
 shared_future(const shared_future& rhs) noexcept;
 ```
-*Effects:* Constructs a `shared_future` object that refers to the same
-shared state as `rhs` (if any).
-*Postconditions:* `valid()` returns the same value as `rhs.valid()`.
 ``` cpp
 shared_future(future<R>&& rhs) noexcept;
 shared_future(shared_future&& rhs) noexcept;
 ```
 *Effects:* Move constructs a `shared_future` object that refers to the
 shared state that was originally referred to by `rhs` (if any).
-*Postconditions:*
 - `valid()` returns the same value as `rhs.valid()` returned prior to
   the constructor invocation.
 - `rhs.valid() == false`.
@@ -738,23 +739,23 @@ shared state that was originally referred to by `rhs` (if any).
 ~shared_future();
 ```
 *Effects:*
-- Releases any shared state ([[futures.state]]);
 - destroys `*this`.
 ``` cpp
 shared_future& operator=(shared_future&& rhs) noexcept;
 ```
 *Effects:*
-- Releases any shared state ([[futures.state]]);
 - move assigns the contents of `rhs` to `*this`.
-*Postconditions:*
 - `valid()` returns the same value as `rhs.valid()` returned prior to
   the assignment.
 - `rhs.valid() == false`.
@@ -762,16 +763,16 @@ shared_future& operator=(shared_future&& rhs) noexcept;
 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*]
-*Postconditions:* `valid() == rhs.valid()`.
 ``` cpp
 const R& shared_future::get() const;
 R& shared_future<R&>::get() const;
 void shared_future<void>::get() const;
@@ -781,12 +782,11 @@ void shared_future<void>::get() const;
 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:*
@@ -799,11 +799,11 @@ value stored in the shared state.
   returned the reference. — *end note*]
 - `shared_future<R&>::get()` returns the reference stored as value in
   the object’s shared state.
 - `shared_future<void>::get()` returns nothing.
-*Throws:* the stored exception, if an exception was stored in the shared
 state.
 ``` cpp
 bool valid() const noexcept;
 ```
@@ -820,144 +820,145 @@ void wait() const;
 template<class Rep, class Period>
   future_status wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 ```
 *Effects:* None if the shared state contains a deferred
-function ([[futures.async]]), otherwise blocks until the shared state
-is ready or until the relative timeout ([[thread.req.timing]])
-specified by `rel_time` has expired.
 *Returns:*
 - `future_status::deferred` if the shared state contains a deferred
   function.
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
-  relative timeout ([[thread.req.timing]]) specified by `rel_time` has
   expired.
-*Throws:* timeout-related exceptions ([[thread.req.timing]]).
 ``` cpp
 template<class Clock, class Duration>
   future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 ```
 *Effects:* None if the shared state contains a deferred
-function ([[futures.async]]), otherwise blocks until the shared state
-is ready or until the absolute timeout ([[thread.req.timing]])
-specified by `abs_time` has expired.
 *Returns:*
 - `future_status::deferred` if the shared state contains a deferred
   function.
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
-  absolute timeout ([[thread.req.timing]]) specified by `abs_time` has
   expired.
-*Throws:* timeout-related exceptions ([[thread.req.timing]]).
 ### Function template `async` <a id="futures.async">[[futures.async]]</a>
 The function template `async` provides a mechanism to launch a function
 potentially in a new thread and provides the result of the function in a
 `future` object with which it shares a shared state.
 ``` cpp
 template<class F, class... Args>
-  future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
     async(F&& f, Args&&... args);
 template<class F, class... Args>
-  future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
     async(launch policy, F&& f, Args&&... args);
 ```
-*Requires:* `F` and each `Ti` in `Args` shall satisfy the
-`MoveConstructible` requirements, and
-``` cpp
-INVOKE(DECAY_COPY(std::forward<F>(f)),
-       DECAY_COPY(std::forward<Args>(args))...)     // see [func.require] [thread.thread.constr]
-```
-shall be a valid expression.
 *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 shall invoke 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 International Standard 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 must be aware that the future’s
-destructor may 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
   the associated thread has completed, as if joined, or else time
-  out ([[thread.thread.member]]);
 - the associated thread completion synchronizes
-  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
@@ -1017,86 +1018,79 @@ namespace std {
     void operator()(ArgTypes... );
     void make_ready_at_thread_exit(ArgTypes...);
     void reset();
   };
   template<class R, class... ArgTypes>
     void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
-  template <class R, class Alloc>
-    struct uses_allocator<packaged_task<R>, Alloc>;
 }
 ```
-#### `packaged_task` member functions <a id="futures.task.members">[[futures.task.members]]</a>
 ``` cpp
 packaged_task() noexcept;
 ```
-*Effects:* Constructs a `packaged_task` object with no shared state and
-no stored task.
 ``` cpp
 template<class F>
   packaged_task(F&& f);
 ```
-*Requires:* *INVOKE*\<R\>(f, t1, t2, ..., tN), where `t1, t2, ..., tN`
-are values of the corresponding types in `ArgTypes...`, shall be a valid
-expression. Invoking a copy of `f` shall behave the same as invoking
 `f`.
-*Remarks:* This constructor shall not participate in overload resolution
-if `decay_t<F>` is 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`.
-- For the first version, `bad_alloc` if memory for the internal data
-  structures could not be allocated.
-- For the second version, any exceptions thrown by
-  `allocator_traits<Allocator>::template`
-  `rebind_traits<`*`unspecified`*`>::allocate`.
 ``` cpp
 packaged_task(packaged_task&& rhs) noexcept;
 ```
-*Effects:* Constructs a new `packaged_task` object and transfers
-ownership of `rhs`’s shared state to `*this`, leaving `rhs` with no
-shared state. Moves the stored task from `rhs` to `*this`.
-*Postconditions:* `rhs` has no shared state.
 ``` cpp
 packaged_task& operator=(packaged_task&& rhs) noexcept;
 ```
 *Effects:*
-- Releases any shared state ([[futures.state]]);
 - calls `packaged_task(std::move(rhs)).swap(*this)`.
 ``` cpp
 ~packaged_task();
 ```
-*Effects:* Abandons any shared state ([[futures.state]]).
 ``` cpp
 void swap(packaged_task& other) noexcept;
 ```
 *Effects:* Exchanges the shared states and stored tasks of `*this` and
 `other`.
-*Postconditions:* `*this` has the same shared state and stored task (if
-any) as `other` prior to the call to `swap`. `other` has the same shared
-state and stored task (if any) as `*this` prior to the call to `swap`.
 ``` cpp
 bool valid() const noexcept;
 ```
@@ -1107,11 +1101,18 @@ future<R> get_future();
 ```
 *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
   a `packaged_task` object with the same shared state as `*this`.
@@ -1119,19 +1120,19 @@ future<R> get_future();
 ``` cpp
 void operator()(ArgTypes... args);
 ```
-*Effects:* As if by *INVOKE*\<R\>(f, t1, t2, ..., tN), where `f` is the
-stored task of `*this` and `t1, t2, ..., tN` are the values in
-`args...`. If the task returns normally, the return value is stored as
-the asynchronous result in the shared state of `*this`, otherwise the
-exception thrown by the task is stored. The shared state of `*this` is
-made ready, and any threads blocked in a function waiting for the shared
-state of `*this` to become ready are unblocked.
-*Throws:* a `future_error` exception object if there is no shared state
 or the stored task has already been invoked.
 *Error conditions:*
 - `promise_already_satisfied` if the stored task has already been
@@ -1140,19 +1141,19 @@ or the stored task has already been invoked.
 ``` cpp
 void make_ready_at_thread_exit(ArgTypes... args);
 ```
-*Effects:* As if by *INVOKE*\<R\>(f, t1, t2, ..., tN), where `f` is the
-stored task and `t1, t2, ..., tN` are the values in `args...`. If the
-task returns normally, the return value is stored as the asynchronous
-result in the shared state of `*this`, otherwise the exception thrown by
-the task is stored. In either case, this shall be done without making
-that state ready ([[futures.state]]) immediately. Schedules the shared
-state to be made ready when the current thread exits, after all objects
-of thread storage duration associated with the current thread have been
-destroyed.
 *Throws:* `future_error` if an error condition occurs.
 *Error conditions:*
@@ -1165,77 +1166,99 @@ void reset();
 ```
 *Effects:* As if `*this = packaged_task(std::move(f))`, where `f` is the
 task stored in `*this`.
-[*Note 1*: 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.
-#### `packaged_task` globals <a id="futures.task.nonmembers">[[futures.task.nonmembers]]</a>
 ``` cpp
 template<class R, class... ArgTypes>
   void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
 ```
 *Effects:* As if by `x.swap(y)`.
-``` cpp
-template <class R, class Alloc>
-  struct uses_allocator<packaged_task<R>, Alloc>
-    : true_type { };
-```
-*Requires:* `Alloc` shall be an Allocator ([[allocator.requirements]]).
 <!-- Link reference definitions -->
 [alg.sorting]: algorithms.md#alg.sorting
-[allocator.requirements]: library.md#allocator.requirements
 [atomics]: atomics.md#atomics
 [basic.life]: basic.md#basic.life
 [basic.stc.thread]: basic.md#basic.stc.thread
 [bitmask.types]: library.md#bitmask.types
-[class]: class.md#class
-[condition_variable.syn]: #condition_variable.syn
 [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]: intro.md#intro.multithread
 [mutex.syn]: #mutex.syn
 [res.on.data.races]: library.md#res.on.data.races
 [res.on.exception.handling]: library.md#res.on.exception.handling
-[shared_mutex.syn]: #shared_mutex.syn
 [syserr]: diagnostics.md#syserr
 [syserr.syserr]: diagnostics.md#syserr.syserr
-[tab:thread.lib.summary]: #tab:thread.lib.summary
 [thread]: #thread
 [thread.condition]: #thread.condition
 [thread.condition.condvar]: #thread.condition.condvar
 [thread.condition.condvarany]: #thread.condition.condvarany
 [thread.condition.nonmember]: #thread.condition.nonmember
-[thread.decaycopy]: #thread.decaycopy
 [thread.general]: #thread.general
 [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
@@ -1265,14 +1288,20 @@ template <class R, class Alloc>
 [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.sharedmutex.class]: #thread.sharedmutex.class
 [thread.sharedmutex.requirements]: #thread.sharedmutex.requirements
 [thread.sharedtimedmutex.class]: #thread.sharedtimedmutex.class
 [thread.sharedtimedmutex.requirements]: #thread.sharedtimedmutex.requirements
 [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
@@ -1283,15 +1312,15 @@ template <class R, class Alloc>
 [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]: utilities.md#time
-[time.clock]: utilities.md#time.clock
-[time.clock.req]: utilities.md#time.clock.req
-[time.duration]: utilities.md#time.duration
-[time.point]: utilities.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.

     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>...>>
       async(launch policy, F&& f, Args&&... args);
 }
 ```
+The `enum` type `launch` is a bitmask type [[bitmask.types]] with
 elements `launch::async` and `launch::deferred`.
 [*Note 1*: Implementations can provide bitmasks to specify restrictions
 on task interaction by functions launched by `async()` applicable to a
 corresponding subset of available launch policies. Implementations can
 ``` cpp
 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;
 ```
 error_condition make_error_condition(future_errc e) noexcept;
 ```
 *Returns:* `error_condition(static_cast<int>(e), future_category())`.
+### Class `future_error` <a id="futures.future.error">[[futures.future.error]]</a>
 ``` cpp
 namespace std {
   class future_error : public logic_error {
   public:
     explicit future_error(future_errc e);
     const error_code& code() const noexcept;
     const char*       what() const noexcept;
   private:
     error_code ec_;             // exposition only
   };
 }
 ```
 ``` cpp
 explicit future_error(future_errc e);
 ```
+*Effects:* Initializes `ec_` with `make_error_code(e)`.
 ``` cpp
 const error_code& code() const noexcept;
 ```
 *Returns:* An NTBS incorporating `code().message()`.
 ### Shared state <a id="futures.state">[[futures.state]]</a>
+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*]
 An *asynchronous return object* is an object that reads results from a
 shared state. A *waiting function* of an asynchronous return object is
 one that potentially blocks to wait for the shared state to be made
 ready. If a waiting function can return before the state is made ready
+because of a timeout [[thread.req.lockable]], then it is a *timed
 waiting function*, otherwise it is a *non-timed waiting function*.
 An *asynchronous provider* is an object that provides a result to a
 shared state. The result of a shared state is set by respective
 functions on the asynchronous provider.
 for retrieval. Waiting for a shared state to become ready may invoke
 code to compute the result on the waiting thread if so specified in the
 description of the class or function that creates the state object.
 Calls to functions that successfully set the stored result of a shared
+state synchronize with [[intro.multithread]] calls to functions
 successfully detecting the ready state resulting from that setting. The
 storage of the result (whether normal or exceptional) into the shared
+state synchronizes with [[intro.multithread]] the successful return from
+a call to a waiting function on the shared state.
 Some functions (e.g., `promise::set_value_at_thread_exit`) delay making
 the shared state ready until the calling thread exits. The destruction
+of each of that thread’s objects with thread storage duration
+[[basic.stc.thread]] is sequenced before making that shared state ready.
+Access to the result of the same shared state may conflict
+[[intro.multithread]].
 [*Note 4*: This explicitly specifies that the result of the shared
 state is visible in the objects that reference this state in the sense
+of data race avoidance [[res.on.data.races]]. For example, concurrent
+accesses through references returned by `shared_future::get()`
+[[futures.shared.future]] must either use read-only operations or
 provide additional synchronization. — *end note*]
 ### Class template `promise` <a id="futures.promise">[[futures.promise]]</a>
 ``` cpp
   public:
     promise();
     template<class Allocator>
       promise(allocator_arg_t, const Allocator& a);
     promise(promise&& rhs) noexcept;
+    promise(const promise&) = delete;
     ~promise();
     // assignment
     promise& operator=(promise&& rhs) noexcept;
+    promise& operator=(const promise&) = delete;
     void swap(promise& other) noexcept;
     // retrieving the result
     future<R> get_future();
     // 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.
 The `set_value`, `set_exception`, `set_value_at_thread_exit`, and
 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);
 ```
+*Effects:* Creates a shared state. The second constructor uses the
+allocator `a` to allocate memory for the shared state.
 ``` cpp
 promise(promise&& rhs) noexcept;
 ```
+*Effects:* Transfers ownership of the shared state of `rhs` (if any) to
+the newly-constructed object.
+*Ensures:* `rhs` has no shared state.
 ``` cpp
 ~promise();
 ```
+*Effects:* Abandons any shared state [[futures.state]].
 ``` cpp
 promise& operator=(promise&& rhs) noexcept;
 ```
+*Effects:* Abandons any shared state [[futures.state]] and then as if
 `promise(std::move(rhs)).swap(*this)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(promise& other) noexcept;
 ```
 *Effects:* Exchanges the shared state of `*this` and `other`.
+*Ensures:* `*this` has the shared state (if any) that `other` had prior
+to the call to `swap`. `other` has the shared state (if any) that
 `*this` had prior to the call to `swap`.
 ``` 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:*
 void promise<R&>::set_value(R& r);
 void promise<void>::set_value();
 ```
 *Effects:* Atomically stores the value `r` in the shared state and makes
+that state ready [[futures.state]].
 *Throws:*
 - `future_error` if its shared state already has a stored value or
   exception, or
 ``` cpp
 void set_exception(exception_ptr p);
 ```
+*Preconditions:* `p` is not null.
 *Effects:* Atomically stores the exception pointer `p` in the shared
+state and makes that state ready [[futures.state]].
 *Throws:* `future_error` if its shared state already has a stored value
 or exception.
 *Error conditions:*
 ``` cpp
 void set_exception_at_thread_exit(exception_ptr p);
 ```
+*Preconditions:* `p` is not null.
 *Effects:* Stores the exception pointer `p` in the shared state without
 making that state ready immediately. Schedules that state to be made
 ready when the current thread exits, after all objects of thread storage
 duration associated with the current thread have been destroyed.
   void swap(promise<R>& x, promise<R>& y) noexcept;
 ```
 *Effects:* As if by `x.swap(y)`.
+### Class template `future` <a id="futures.unique.future">[[futures.unique.future]]</a>
 The class template `future` defines a type for asynchronous return
 objects which do not share their shared state with other asynchronous
 return objects. A default-constructed `future` object has no shared
 state. A `future` object with shared state can be created by functions
+on asynchronous providers [[futures.state]] or by the move constructor
+and shares its shared state with the original asynchronous provider. The
+result (value or exception) of a `future` object can be set by calling a
+respective function on an object that shares the same shared state.
 [*Note 1*: Member functions of `future` do not synchronize with
 themselves or with member functions of `shared_future`. — *end note*]
 The effect of calling any member function other than the destructor, the
 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 {
   public:
     future() noexcept;
     future(future&&) noexcept;
+    future(const future&) = delete;
     ~future();
+    future& operator=(const future&) = delete;
     future& operator=(future&&) noexcept;
     shared_future<R> share() noexcept;
     // retrieving the value
     see below get();
       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.
 ``` cpp
 future() noexcept;
 ```
+*Effects:* The object does not refer to a shared state.
+*Ensures:* `valid() == false`.
 ``` cpp
 future(future&& rhs) noexcept;
 ```
 *Effects:* Move constructs a `future` object that refers to the shared
 state that was originally referred to by `rhs` (if any).
+*Ensures:*
 - `valid()` returns the same value as `rhs.valid()` prior to the
   constructor invocation.
 - `rhs.valid() == false`.
 ~future();
 ```
 *Effects:*
+- Releases any shared state [[futures.state]];
 - destroys `*this`.
 ``` 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`.
 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();
 *Effects:*
 - `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
   object’s shared state.
 - `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;
 ```
 template<class Rep, class Period>
   future_status wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 ```
 *Effects:* None if the shared state contains a deferred
+function [[futures.async]], otherwise blocks until the shared state is
+ready or until the relative timeout [[thread.req.timing]] specified by
+`rel_time` has expired.
 *Returns:*
 - `future_status::deferred` if the shared state contains a deferred
   function.
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
+  relative timeout [[thread.req.timing]] specified by `rel_time` has
   expired.
+*Throws:* timeout-related exceptions [[thread.req.timing]].
 ``` cpp
 template<class Clock, class Duration>
   future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 ```
 *Effects:* None if the shared state contains a deferred
+function [[futures.async]], otherwise blocks until the shared state is
+ready or until the absolute timeout [[thread.req.timing]] specified by
+`abs_time` has expired.
 *Returns:*
 - `future_status::deferred` if the shared state contains a deferred
   function.
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
+  absolute timeout [[thread.req.timing]] specified by `abs_time` has
   expired.
+*Throws:* timeout-related exceptions [[thread.req.timing]].
+### Class template `shared_future` <a id="futures.shared.future">[[futures.shared.future]]</a>
 The class template `shared_future` defines a type for asynchronous
 return objects which may share their shared state with other
 asynchronous return objects. A default-constructed `shared_future`
 object has no shared state. A `shared_future` object with shared state
 can be created by conversion from a `future` object and shares its
+shared state with the original asynchronous provider [[futures.state]]
+of the shared state. The result (value or exception) of a
+`shared_future` object can be set by calling a respective function on an
+object that shares the same shared state.
 [*Note 1*: Member functions of `shared_future` do not synchronize with
 themselves, but they synchronize with the shared state. — *end note*]
 The effect of calling any member function other than the destructor, the
 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>
       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.
 ``` cpp
 shared_future() noexcept;
 ```
+*Effects:* The object does not refer to a shared state.
+*Ensures:* `valid() == false`.
 ``` cpp
 shared_future(const shared_future& rhs) noexcept;
 ```
+*Effects:* The object refers to the same shared state as `rhs` (if any).
+*Ensures:* `valid()` returns the same value as `rhs.valid()`.
 ``` cpp
 shared_future(future<R>&& rhs) noexcept;
 shared_future(shared_future&& rhs) noexcept;
 ```
 *Effects:* Move constructs a `shared_future` object that refers to the
 shared state that was originally referred to by `rhs` (if any).
+*Ensures:*
 - `valid()` returns the same value as `rhs.valid()` returned prior to
   the constructor invocation.
 - `rhs.valid() == false`.
 ~shared_future();
 ```
 *Effects:*
+- Releases any shared state [[futures.state]];
 - destroys `*this`.
 ``` 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`.
 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()`.
 ``` cpp
 const R& shared_future::get() const;
 R& shared_future<R&>::get() const;
 void shared_future<void>::get() const;
 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:*
   returned the reference. — *end note*]
 - `shared_future<R&>::get()` returns the reference stored as value in
   the object’s shared state.
 - `shared_future<void>::get()` returns nothing.
+*Throws:* The stored exception, if an exception was stored in the shared
 state.
 ``` cpp
 bool valid() const noexcept;
 ```
 template<class Rep, class Period>
   future_status wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 ```
 *Effects:* None if the shared state contains a deferred
+function [[futures.async]], otherwise blocks until the shared state is
+ready or until the relative timeout [[thread.req.timing]] specified by
+`rel_time` has expired.
 *Returns:*
 - `future_status::deferred` if the shared state contains a deferred
   function.
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
+  relative timeout [[thread.req.timing]] specified by `rel_time` has
   expired.
+*Throws:* timeout-related exceptions [[thread.req.timing]].
 ``` cpp
 template<class Clock, class Duration>
   future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 ```
 *Effects:* None if the shared state contains a deferred
+function [[futures.async]], otherwise blocks until the shared state is
+ready or until the absolute timeout [[thread.req.timing]] specified by
+`abs_time` has expired.
 *Returns:*
 - `future_status::deferred` if the shared state contains a deferred
   function.
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
+  absolute timeout [[thread.req.timing]] specified by `abs_time` has
   expired.
+*Throws:* timeout-related exceptions [[thread.req.timing]].
 ### Function template `async` <a id="futures.async">[[futures.async]]</a>
 The function template `async` provides a mechanism to launch a function
 potentially in a new thread and provides the result of the function in a
 `future` object with which it shares a shared state.
 ``` cpp
 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>...>>
     async(launch policy, F&& f, Args&&... 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
   the associated thread has completed, as if joined, or else time
+  out [[thread.thread.member]];
 - the associated thread completion synchronizes
+  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
     void operator()(ArgTypes... );
     void make_ready_at_thread_exit(ArgTypes...);
     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>
 ``` cpp
 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...)>`.
+*Mandates:* `is_invocable_r_v<R, F&, ArgTypes...>` is `true`.
+*Preconditions:* Invoking a copy of `f` behaves the same as invoking
 `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`,
+leaving `rhs` with no shared state. Moves the stored task from `rhs` to
+`*this`.
+*Ensures:* `rhs` has no shared state.
 ``` cpp
 packaged_task& operator=(packaged_task&& rhs) noexcept;
 ```
 *Effects:*
+- Releases any shared state [[futures.state]];
 - calls `packaged_task(std::move(rhs)).swap(*this)`.
 ``` cpp
 ~packaged_task();
 ```
+*Effects:* Abandons any shared state [[futures.state]].
 ``` cpp
 void swap(packaged_task& other) noexcept;
 ```
 *Effects:* Exchanges the shared states and stored tasks of `*this` and
 `other`.
+*Ensures:* `*this` has the same shared state and stored task (if any) as
+`other` prior to the call to `swap`. `other` has the same shared state
+and stored task (if any) as `*this` prior to the call to `swap`.
 ``` cpp
 bool valid() const noexcept;
 ```
 ```
 *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
   a `packaged_task` object with the same shared state as `*this`.
 ``` cpp
 void operator()(ArgTypes... args);
 ```
+*Effects:* As if by *INVOKE*\<R\>(f, t₁, t₂, …, t$_N$) [[func.require]],
+where `f` is the stored task of `*this` and `t`₁`, t`₂`, `…`, t`$_N$ are
+the values in `args...`. If the task returns normally, the return value
+is stored as the asynchronous result in the shared state of `*this`,
+otherwise the exception thrown by the task is stored. The shared state
+of `*this` is made ready, and any threads blocked in a function waiting
+for the shared state of `*this` to become ready are unblocked.
+*Throws:* A `future_error` exception object if there is no shared state
 or the stored task has already been invoked.
 *Error conditions:*
 - `promise_already_satisfied` if the stored task has already been
 ``` cpp
 void make_ready_at_thread_exit(ArgTypes... args);
 ```
+*Effects:* As if by *INVOKE*\<R\>(f, t₁, t₂, …, t$_N$) [[func.require]],
+where `f` is the stored task and `t`₁`, t`₂`, `…`, t`$_N$ are the values
+in `args...`. If the task returns normally, the return value is stored
+as the asynchronous result in the shared state of `*this`, otherwise the
+exception thrown by the task is stored. In either case, this is done
+without making that state ready [[futures.state]] immediately. Schedules
+the shared state to be made ready when the current thread exits, after
+all objects of thread storage duration associated with the current
+thread have been destroyed.
 *Throws:* `future_error` if an error condition occurs.
 *Error conditions:*
 ```
 *Effects:* As if `*this = packaged_task(std::move(f))`, where `f` is the
 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>
 ``` cpp
 template<class R, class... ArgTypes>
   void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
 ```
 *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.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.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.

Diff to HTML by rtfpessoa