Define terms-of-art for
releasing,
making ready,
and abandoning
an associated asynchronous state.
Define a term-of-art for waiting functions
on an associated asynchronous state.
Use those terms where appropriate.

This solution implements the intent of the existing wording.
That is, there is no new functionality.

An asynchronous return object is an object that
reads results from an associated asynchronous state.
A waiting function of an asynchronous return object
is one that potentially blocks
to wait for the associated asynchronous state to be made ready.

Edit paragraph 5 as follows.

When the last reference to an associated asynchronous state is given up,
any resources held by that associated asynchronous state are released.
An asynchronous return object or an asynchronous provider
release their associated asynchronous state
as follows.

If the return object or provider contains the last reference to that state,
destroys that state.

The return object or provider destroys the reference to that state.

An asynchronous provider makes ready an associated asynchronous state
as follows.

The provider marks that state as ready.

The provider unblocks any concurrent agent
waiting for the associated state to become ready.

An asynchronous provider
abandons an associated asynchronous state as follows.

If that state is not ready,

the provider stores an exception object of type future_error
with an error condition of broken_promise
within that state, and then

Effects:
if the associated asynchronous state of *this is not ready,
stores an exception object of type future_error
with an error condition of broken_promise
Any threads blocked in a function waiting for
the asynchronous state associated with *this to become ready
are unblocked.
Destroys *this and
releases its reference to its associated asynchronous state if any.
If this is the last reference to that
associated asynchronous state, destroys that state.
abandons any associated asynchronous state ([futures.state]).

Edit paragraph 8, regarding the move assignment operator, as follows.

Effects:
abandons any associated asynchronous state ([futures.state])
and then as if
promise<R>(std::move(rhs)).swap(*this).

Remove paragraph 9, as it is now redundant with the effects.

Postcondition:rhs has no associated asynchronous state.
*this has the associated asynchronous state
of rhs prior to the assignment.

Edit paragraph 18, regarding set_value, as follows.

Effects:
atomically stores r in the associated asynchronous state and
sets that state to ready.
Any threads blocked in a call of a blocking function of any future
that refers to the same associated asynchronous state as *this
are unblocked.
makes ready that state ([futures.state]).

Edit paragraph 22, regarding set_exception, as follows.

Effects:
atomically stores p in the associated asynchronous state and
sets that state to ready.
Any threads blocked in a call of a blocking function of any future
that refers to the same associated asynchronous state as *this
are unblocked.
makes ready that state ([futures.state]).

Edit paragraph 26, regarding set_value_at_thread_exit, as follows.

Effects:
Stores r in the associated asynchronous state without
making readythe associated asynchronousthat state
ready immediately.
Schedules the associated asynchronousthat 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.

Effects:
Stores p in the associated asynchronous state without
making readythe associated asynchronousthat state
ready immediately.
Schedules the associated asynchronousthat 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.

Effects:
if the associated asynchronous state of *this is not ready,
stores an exception object of type future_error
with an error code of broken_promise.
Any threads blocked in a function
waiting for the associated asynchronous state of *this
to become ready are unblocked.
Destroys *this
and releases its reference to its associated asynchronous state (if any).
If this is the last reference to that associated asynchronous state,
destroys that state.
abandons any associated asynchronous state ([futures.state]).

....
this shall be done without
making the state readymaking ready that state ([futures.state]) immediately.
....

Edit paragraph 27, regarding reset, as follows.

Effects:returns the object to a state
as if
a newly-constructed instance
had just been assigned to *this by*this = packaged_task(std::move(f)),
where f is the task stored in *this.
[Note:
this constructs a new associated asynchronous state for *this.
The old state is discarded,abandoned ([futures.state]).as described in the destructor for packaged_task.
get_future may now be called again for *this.
—end note]