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

Files changed (1) hide show

tmp/tmpm42z4c8s/{from.md → to.md} +242 -193

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

@@ -2,13 +2,17 @@
 ### Overview <a id="futures.overview">[[futures.overview]]</a>
 [[futures]] describes components that a C++program can use to retrieve
 in one thread the result (value or exception) from a function that has
-run in the same thread or another thread. These components are not
-restricted to multi-threaded programs but can be useful in
-single-threaded programs as well.
 ``` cpp
 namespace std {
   enum class future_errc {
     broken_promise = implementation-defined,
@@ -53,36 +57,37 @@ namespace std {
   template <class R> class shared_future;
   template <class R> class shared_future<R&>;
   template <> class shared_future<void>;
-  template <class> class packaged_task;   // undefined
   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 R, class Alloc>
     struct uses_allocator<packaged_task<R>, Alloc>;
   template <class F, class... Args>
-    future<result_of_t<decay_t<F>(decay_t<Args>...)>>
     async(F&& f, Args&&... args);
   template <class F, class... Args>
-    future<result_of_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
-`launch::async` and `launch::deferred` denoting individual bits.
-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
 extend the behavior of the first overload of `async()` by adding their
-extensions to the launch policy under the “as if” rule.
 The enum values of `future_errc` are distinct and not zero.
 ### Error handling <a id="futures.errors">[[futures.errors]]</a>
@@ -113,53 +118,67 @@ error_condition make_error_condition(future_errc e) noexcept;
 ``` cpp
 namespace std {
   class future_error : public logic_error {
   public:
-    future_error(error_code ec);  // exposition only
     const error_code& code() const noexcept;
     const char*       what() const noexcept;
   };
 }
 ```
 ``` cpp
 const error_code& code() const noexcept;
 ```
-*Returns:* The value of `ec` that was passed to the object’s
-constructor.
 ``` cpp
 const char* what() const noexcept;
 ```
 *Returns:* An NTBSincorporating `code().message()`.
 ### Shared state <a id="futures.state">[[futures.state]]</a>
-Many of the classes introduced in this sub-clause 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. Futures, promises, and tasks
-defined in this clause reference such shared state.
-The result can be any kind of object including a function to compute
-that result, as used by `async` when `policy` is `launch::deferred`.
 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. Such as promises or tasks. The
-means of setting the result of a shared state is specified in the
 description of those classes and functions that create such a state
 object.
 When an asynchronous return object or an asynchronous provider is said
 to release its shared state, it means:
@@ -206,16 +225,18 @@ 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]]). 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.
 ### Class template `promise` <a id="futures.promise">[[futures.promise]]</a>
 ``` cpp
 namespace std {
@@ -240,11 +261,10 @@ namespace std {
     // setting the result
     void set_value(see below);
     void set_exception(exception_ptr p);
     // setting the result with deferred notification
-    void set_value_at_thread_exit(const R& r);
     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;
@@ -253,12 +273,12 @@ namespace std {
 }
 ```
 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 function `set_value`, as set out in
-its description, below.
 The `set_value`, `set_exception`, `set_value_at_thread_exit`, and
 `set_exception_at_thread_exit` member functions behave as though they
 acquire a single mutex associated with the promise object while updating
 the promise object.
@@ -286,11 +306,11 @@ 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.
-`rhs` has no shared state.
 ``` cpp
 ~promise();
 ```
@@ -309,13 +329,13 @@ promise& operator=(promise&& rhs) noexcept;
 void swap(promise& other) noexcept;
 ```
 *Effects:* Exchanges the shared state of `*this` and `other`.
-`*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();
 ```
@@ -336,11 +356,11 @@ void promise::set_value(const R& r);
 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
@@ -358,11 +378,13 @@ that state ready ([[futures.state]]).
 ``` cpp
 void set_exception(exception_ptr p);
 ```
-*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.
@@ -401,10 +423,12 @@ associated with the current thread have been destroyed.
 ``` cpp
 void set_exception_at_thread_exit(exception_ptr p);
 ```
 *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.
@@ -416,14 +440,14 @@ duration associated with the current thread have been destroyed.
   value or exception.
 - `no_state` if `*this` has no shared state.
 ``` cpp
 template <class R>
-  void swap(promise<R>& x, promise<R>& y);
 ```
-*Effects:* `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
@@ -433,18 +457,23 @@ 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.
-Member functions of `future` do not synchronize with themselves or with
-member functions of `shared_future`.
 The effect of calling any member function other than the destructor, the
-move-assignment operator, or `valid` on a `future` object for which
-`valid() == false` is undefined. Implementations are encouraged to
-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 {
@@ -453,11 +482,11 @@ namespace std {
     future(future&&) noexcept;
     future(const future& rhs) = delete;
     ~future();
     future& operator=(const future& rhs) = delete;
     future& operator=(future&&) noexcept;
-    shared_future<R> share();
     // retrieving the value
     see below get();
     // functions to check state
@@ -479,20 +508,20 @@ out in its description, below.
 ``` cpp
 future() noexcept;
 ```
-*Effects:* constructs an *empty* `future` object that does not refer to
 a shared state.
-`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
@@ -503,48 +532,51 @@ 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`.
 ``` cpp
-shared_future<R> share();
 ```
 *Returns:* `shared_future<R>(std::move(*this))`.
-`valid() == false`.
 ``` cpp
 R future::get();
 R& future<R&>::get();
 void future<void>::get();
 ```
-*Note:* as described above, the template and its two required
 specializations differ only in the return type and return value of the
-member function `get`.
-*Effects:* `wait()`s until the shared state is ready, then retrieves the
-value stored in the shared state.
 *Returns:*
 - `future::get()` returns the value `v` stored in the object’s shared
   state as `std::move(v)`.
@@ -553,11 +585,11 @@ value stored in the shared state.
 - `future<void>::get()` returns nothing.
 *Throws:* the stored exception, if an exception was stored in the shared
 state.
-`valid() == false`.
 ``` cpp
 bool valid() const noexcept;
 ```
@@ -565,18 +597,18 @@ bool valid() const noexcept;
 ``` cpp
 void wait() const;
 ```
-*Effects:* blocks until the shared state is ready.
 ``` cpp
 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:*
@@ -593,11 +625,11 @@ specified by `rel_time` has expired.
 ``` 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:*
@@ -621,31 +653,35 @@ 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.
-Member functions of `shared_future` do not synchronize with themselves,
-but they synchronize with the shared shared state.
 The effect of calling any member function other than the destructor, the
-move-assignment operator, or `valid()` on a `shared_future` object for
-which `valid() ==
-false` is undefined. Implementations are encouraged to 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 {
   public:
     shared_future() noexcept;
-    shared_future(const shared_future& rhs);
     shared_future(future<R>&&) noexcept;
     shared_future(shared_future&& rhs) noexcept;
     ~shared_future();
-    shared_future& operator=(const shared_future& rhs);
     shared_future& operator=(shared_future&& rhs) noexcept;
     // retrieving the value
     see below get() const;
@@ -668,30 +704,30 @@ differ only in the return type and return value of the member function
 ``` cpp
 shared_future() noexcept;
 ```
-*Effects:* constructs an *empty* `shared_future` object that does not
 refer to a shared state.
-`valid() == false`.
 ``` cpp
-shared_future(const shared_future& rhs);
 ```
-*Effects:* constructs a `shared_future` object that refers to the same
 shared state as `rhs` (if any).
-`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
@@ -702,64 +738,67 @@ 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`.
 ``` cpp
-shared_future& operator=(const shared_future& rhs);
 ```
 *Effects:*
-- releases any shared state ([[futures.state]]);
-- assigns the contents of `rhs` to `*this`. As a result, `*this` refers
-  to the same shared state as `rhs` (if any).
 *Postconditions:* `valid() == rhs.valid()`.
 ``` cpp
 const R& shared_future::get() const;
 R& shared_future<R&>::get() const;
 void shared_future<void>::get() const;
 ```
-*Note:* as described above, the template and its two required
 specializations differ only in the return type and return value of the
-member function `get`.
-*Note:* 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]]).
 *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. 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.
 - `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
@@ -773,18 +812,18 @@ bool valid() const noexcept;
 ``` cpp
 void wait() const;
 ```
-*Effects:* blocks until the shared state is ready.
 ``` cpp
 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:*
@@ -801,11 +840,11 @@ specified by `rel_time` has expired.
 ``` 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:*
@@ -825,81 +864,91 @@ 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<result_of_t<decay_t<F>(decay_t<Args>...)>> async(F&& f, Args&&... args);
 template <class F, class... Args>
-  future<result_of_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.
-*`INVOKE`*`(`*`DECAY_COPY`*`(std::forward<F>(f)), `*`DECAY_COPY`*`(std::forward<Args>(args))...)`
-([[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 `policy & launch::async` is non-zero — 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 `policy & launch::deferred` is non-zero — 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. 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 International Standard or by the
-  implementation, the behaviour is undefined.
 *Returns:* An object of type
-`future<result_of_t<decay_t<F>(decay_t<Args>...)>``>` that refers to the
-shared state created by this call to `async`. If a future obtained from
-std::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.
 *Synchronization:* Regardless of the provided `policy` argument,
 - the invocation of `async` synchronizes with ([[intro.multithread]])
-  the invocation of `f`. This statement applies even when the
-  corresponding `future` object is moved to another thread. ; and
 - the completion of the function `f` is sequenced
-  before ([[intro.multithread]]) the shared state is made ready. `f`
-  might not be called at all, so its completion might never happen.
 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
@@ -910,32 +959,23 @@ If the implementation chooses the `launch::async` policy,
   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.
 *Error conditions:*
 - `resource_unavailable_try_again` — if `policy == launch::async` and
   the system is unable to start a new thread.
-``` cpp
-int work1(int value);
-int work2(int value);
-int work(int value) {
-  auto handle = std::async([=]{ return work2(value); });
-  int tmp = work1(value);
-  return tmp + handle.get();    // #1
-}
-```
-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.
 ### 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
@@ -946,21 +986,19 @@ and the result (whether normal or exceptional) stored in the shared
 state. Any futures that share the shared state will then be able to
 access the stored result.
 ``` cpp
 namespace std {
-  template<class> class packaged_task; // undefined
   template<class R, class... ArgTypes>
   class packaged_task<R(ArgTypes...)> {
   public:
     // construction and destruction
     packaged_task() noexcept;
     template <class F>
       explicit packaged_task(F&& f);
-    template <class F, class Allocator>
-      explicit packaged_task(allocator_arg_t, const Allocator& a, F&& f);
     ~packaged_task();
     // no copy
     packaged_task(const packaged_task&) = delete;
     packaged_task& operator=(const packaged_task&) = delete;
@@ -992,73 +1030,73 @@ namespace std {
 ``` 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);
-template <class F, class Allocator>
-  explicit packaged_task(allocator_arg_t, const Allocator& a, F&& f);
 ```
-*Requires:* *`INVOKE`*`(f, t1, t2, ..., tN, R)`, 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:* These constructors shall not participate in overload
-resolution if `decay_t<F>` is the same type as
-`std::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)`. The
-constructors that take an `Allocator` argument use it to allocate memory
-needed to store the internal data structures.
-*Throws:* any exceptions thrown by the copy or move constructor of `f`,
-or `std::bad_alloc` if memory for the internal data structures could not
-be allocated.
 ``` 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`.
-`rhs` has no shared state.
 ``` cpp
 packaged_task& operator=(packaged_task&& rhs) noexcept;
 ```
 *Effects:*
-- releases any shared state ([[futures.state]]).
-- `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`.
-`*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;
 ```
@@ -1081,14 +1119,14 @@ future<R> get_future();
 ``` cpp
 void operator()(ArgTypes... args);
 ```
-*Effects:* *`INVOKE`*`(f, t1, t2, ..., tN, R)`, 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
@@ -1102,18 +1140,18 @@ or the stored task has already been invoked.
 ``` cpp
 void make_ready_at_thread_exit(ArgTypes... args);
 ```
-*Effects:* *`INVOKE`*`(f, t1, t2, ..., tN, R)`, 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:*
@@ -1124,13 +1162,15 @@ destroyed.
 ``` cpp
 void reset();
 ```
-*Effects:* as if `*this = packaged_task(std::move(f))`, where `f` is the
-task stored in `*this`. This constructs a new shared state for `*this`.
-The old state is abandoned ([[futures.state]]).
 *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
@@ -1143,11 +1183,11 @@ The old state is abandoned ([[futures.state]]).
 ``` cpp
 template <class R, class... ArgTypes>
   void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y) noexcept;
 ```
-*Effects:* `x.swap(y)`
 ``` cpp
 template <class R, class Alloc>
   struct uses_allocator<packaged_task<R>, Alloc>
     : true_type { };
@@ -1161,12 +1201,14 @@ template <class R, class Alloc>
 [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
 [except.terminate]: except.md#except.terminate
 [func.require]: utilities.md#func.require
 [futures]: #futures
 [futures.async]: #futures.async
 [futures.errors]: #futures.errors
 [futures.future_error]: #futures.future_error
 [futures.overview]: #futures.overview
@@ -1176,24 +1218,28 @@ template <class R, class Alloc>
 [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
 [res.on.data.races]: library.md#res.on.data.races
 [res.on.exception.handling]: library.md#res.on.exception.handling
 [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.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.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
@@ -1219,12 +1265,15 @@ 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.sharedtimedmutex.class]: #thread.sharedtimedmutex.class
 [thread.sharedtimedmutex.requirements]: #thread.sharedtimedmutex.requirements
 [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

 ### Overview <a id="futures.overview">[[futures.overview]]</a>
 [[futures]] describes components that a C++program can use to retrieve
 in one thread the result (value or exception) from a function that has
+run in the same thread or another thread.
+[*Note 1*: These components are not restricted to multi-threaded
+programs but can be useful in single-threaded programs as
+well. — *end note*]
+### Header `<future>` synopsis <a id="future.syn">[[future.syn]]</a>
 ``` cpp
 namespace std {
   enum class future_errc {
     broken_promise = implementation-defined,
   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 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
 extend the behavior of the first overload of `async()` by adding their
+extensions to the launch policy under the “as if” rule. — *end note*]
 The enum values of `future_errc` are distinct and not zero.
 ### Error handling <a id="futures.errors">[[futures.errors]]</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;
 ```
+*Returns:* `ec_`.
 ``` cpp
 const char* what() const noexcept;
 ```
 *Returns:* An NTBSincorporating `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*]
+[*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*]
 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.
+[*Note 3*: Such as promises or tasks. — *end note*]
+The means of setting the result of a shared state is specified in the
 description of those classes and functions that create such a state
 object.
 When an asynchronous return object or an asynchronous provider is said
 to release its shared state, it means:
 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
 namespace std {
     // setting the result
     void set_value(see below);
     void set_exception(exception_ptr p);
     // 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;
 }
 ```
 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
 `set_exception_at_thread_exit` member functions behave as though they
 acquire a single mutex associated with the promise object while updating
 the promise object.
 ```
 *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();
 ```
 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();
 ```
 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
 ``` 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.
 ``` 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.
   value or exception.
 - `no_state` if `*this` has no shared state.
 ``` cpp
 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
 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
+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 {
     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();
     // functions to check state
 ``` 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
 ~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`.
 ``` cpp
+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();
 ```
+[*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*]
+*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<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;
 ```
 ``` cpp
 void wait() const;
 ```
+*Effects:* Blocks until the shared state is ready.
 ``` cpp
 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:*
 ``` 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:*
 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
+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>
   class shared_future {
   public:
     shared_future() noexcept;
+    shared_future(const shared_future& rhs) noexcept;
     shared_future(future<R>&&) noexcept;
     shared_future(shared_future&& rhs) noexcept;
     ~shared_future();
+    shared_future& operator=(const shared_future& rhs) noexcept;
     shared_future& operator=(shared_future&& rhs) noexcept;
     // retrieving the value
     see below get() const;
 ``` 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
 ~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`.
 ``` 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*]
 *Postconditions:* `valid() == rhs.valid()`.
 ``` cpp
 const R& shared_future::get() const;
 R& shared_future<R&>::get() const;
 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
   the object’s shared state.
 - `shared_future<void>::get()` returns nothing.
 *Throws:* the stored exception, if an exception was stored in the shared
 ``` cpp
 void wait() const;
 ```
+*Effects:* Blocks until the shared state is ready.
 ``` cpp
 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:*
 ``` 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:*
 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
   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
 state. Any futures that share the shared state will then be able to
 access the stored result.
 ``` cpp
 namespace std {
+  template<class> class packaged_task; // not defined
   template<class R, class... ArgTypes>
   class packaged_task<R(ArgTypes...)> {
   public:
     // construction and destruction
     packaged_task() noexcept;
     template <class F>
       explicit packaged_task(F&& f);
     ~packaged_task();
     // no copy
     packaged_task(const packaged_task&) = delete;
     packaged_task& operator=(const packaged_task&) = delete;
 ``` 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;
 ```
 ``` 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
 ``` 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:*
 ``` cpp
 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
 ``` 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 { };
 [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.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
 [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.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
 [thread.thread.destr]: #thread.thread.destr

Diff to HTML by rtfpessoa