<html>
<head>
<title>Networking TS changes to support proposed Executors TS</title>
<style>
ins {color:#00A000}
ins p code {color:#00A000}
p ins code {color:#00A000}
del {color:#A00000}
del p code {color:#A00000}
p del code {color:#A00000}
.changed {
  border-right: 0.5em solid #4040d0;
  background-color: #f0f0ff;
}
.instructions {
  border-top: 0.1em solid #404040;
  border-bottom: 0.1em solid #404040;
  background-color: #b0b0b0;
}
pre .changed {
  display:inline-block;
  width:100%;
}
table, th, td {
  border:1px solid #C0C0C0;
}
</style>
</head>
<body>

<pre>
Document number: P0958R3
Date:            2021-02-06
Project:         Programming Language C++
Audience:        SG4 - Networking
Reply-to:        Christopher Kohlhoff &lt;chris&#x40;kohlhoff.com&gt;
</pre>

<h1>Networking TS changes to support proposed Executors TS</h1>

<h2>Introduction</h2>

<p>The purpose of this paper is to illustrate the changes to the Networking TS to conform to the proposed Executors TS in P0443R13.</p>

<p>All changes are relative to N4711.</p>

<h2>Summary of changes</h2>

<p>This paper proposes the following changes to the Networking TS:</p>

<ul>
<li><a href="#add.reference">Add a reference to the executors proposal.</a></li>
<li><a href="#remove.work.guard">Remove <code>executor_work_guard</code> and <code>make_work_guard</code>, as these have been superseded by the executors proposal's <code>execution::outstanding_work</code> property.</a></li>
<li><a href="#remove.executor.reqmts">Remove the Executor type requirements and the <code>is_executor</code> type trait.</a></li>
<li><a href="#specify.async.ops">Specify the "Requirements on asynchronous operations" in terms of the new executors model.</a></li>
<li><a href="#update.system.executor">Update <code>system_executor</code> and <code>system_context</code> to conform to the new executors model.</a></li>
<li><a href="#remove.polymorphic.wrapper">Remove the polymorphic wrapper <code>executor</code> and uses of it as a default executor.</a> As a consequence of this change:
<ul>
  <li>The <code>basic_</code> prefixes have been removed from the timer, socket, and resolver class templates, as users are now likely to utilise these directly.</li>
  <li>Type aliases that relied on a default executor (such as <code>X::socket</code>) have been replaced with template type aliases taking an executor (such as <code>X::socket_for</code>).
</ul>
</li>
<li><a href="#specify.free.functions">Specify the free functions <code>dispatch</code>, <code>post</code>, and <code>defer</code> in terms of the new executors model.</a></li>
<li><a href="#update.strand">Update the <code>strand</code> adapter to conform to the new executors model.</a></li>
<li><a href="#update.use_future">Update the <code>use_future</code> completion token to conform to the new executors model.</a></li>
<li><a href="#update.io_context">Update <code>io_context</code> to conform to the new executors model.</a></li>
</ul>

<h2>Deployment experience</h2>

<p>An implementation of the changes below, including a complete implementation of the executors-related specifications P0443R13, P1348R0, and P1393R0, can be found the Asio library at <a href="https://github.com/chriskohlhoff/asio">https://github.com/chriskohlhoff/asio</a> and in Boost 1.74.</p>

<p>This implementation has been used to recompile libraries that depend on Asio, and has been tested in a number of applications. Some library modifications were required, but the majority of the applications needed minor or no modifications.</p>

<h2>Proposed wording</h2>

<h3 id="add.reference">Add a reference to the executors proposal</h3>

<p class="instructions"><em>Add a reference to the executors proposal in <b>-5- Namespaces and headers [namespaces]</b>:</em></p>

<p>
-2- Unless otherwise specified, references to other entities described in this Technical Specification are assumed to be qualified with <code>std::experimental::net::v1::</code>, references to entities described in the C++ standard are assumed to be qualified with <code>std::</code>, <del>and</del> references to entities described in C++ Extensions for Library Fundamentals are assumed to be qualified with <code>std::experimental::fundamentals_v2::</code><ins>, and references to entities described in P1393R0 A General Property Customization Mechanism and in P0443R13 A Unified Executors Proposal for C++ are assumed to be qualified with <code>std::</code></ins>.
</p>

<h3 id="remove.work.guard">Remove superseded <code>executor_work_guard</code> and <code>make_work_guard</code></h3>

<p class="instructions"><em>Remove <code>executor_work_guard</code> from <b>-12.1- Header &lt;experimental/netfwd&gt; synopsis [fwd.decl.synop]</b>:</em></p>

<pre><del>
  template&lt;class Executor&gt;
    class executor_work_guard;
</del></pre>

<p class="instructions"><em>Remove <code>executor_work_guard</code> and <code>make_work_guard</code> from <b>-13.1- Header &lt;experimental/executor&gt; synopsis [async.synop]</b>:</em></p>

<pre><del>
  template&lt;class Executor&gt;
    class executor_work_guard;

  // 13.17, make_work_guard:

  template&lt;class Executor&gt;
    executor_work_guard&lt;Executor&gt;
      make_work_guard(const Executor&amp; ex);
  template&lt;class ExecutionContext&gt;
    executor_work_guard&lt;typename ExecutionContext::executor_type&gt;
      make_work_guard(ExecutionContext&amp; ctx);
  template&lt;class T&gt;
    executor_work_guard&lt;associated_executor_t&lt;T&gt;&gt;
      make_work_guard(const T&amp; t);
  template&lt;class T, class U&gt;
    auto make_work_guard(const T&amp; t, U&amp; u)
      -&gt; decltype(make_work_guard(get_associated_executor(t, forward&lt;U&gt;(u))));
</del></pre>

<p class="instructions"><em>Remove sections <b>-13.16- Class template executor_work_guard [async.exec.work.guard]</b> and <b>-13.17- Function make_work_guard [async.make.work.guard]</b> in their entirety.</em></p>

<h3 id="remove.executor.reqmts">Remove Executor requirements and <code>is_executor</code> type trait</h3>

<p class="instructions"><em>Modify <b>Table 3 - Template parameters and type requirements [summary]</b> as follows:</em></p>

<table border="1">
<tr>
<td><code>Executor</code></td>
<td><del>executor (13.2.2)</del><br/><ins><code>execution::executor</code> concept (P0443R13)</ins></td>
</tr>
</table>

<p class="instructions"><em>Remove <code>is_executor</code> and <code>is_executor_v</code> from <b>-13.1- Header &lt;experimental/executor&gt; synopsis [async.synop]</b>:</em></p>

<pre><del>
  template&lt;class T&gt; struct is_executor;

  template&lt;class T&gt;
    constexpr bool is_executor_v = is_executor&lt;T&gt;::value;
</del></pre>

<p class="instructions"><em>Remove section <b>-13.2.2- Executor requirements [async.reqmts.executor]</b> in its entirety.</em></p>

<p class="instructions"><em>Modify <b>Table 5 - ExecutionContext requirements [async.reqmts.executioncontext]</b> as follows:</em></p>

<div class="changed">
<table border="1">
<tr>
<th>expression</th>
<th>return type</th>
<th>assertion/note pre/post-condition</th>
</tr>
<tr>
<td><code>X::executor_type</code></td>
<td><del>type meeting <code>Executor</code> (13.2.2) requirements</del><br/><ins>A type that models <code>execution::executor</code> (P0443R13).</ins></td>
<td></td>
</tr>
</table>
</div>

<p class="instructions"><em>Modify section <b>-13.2.7.8- I/O executor [async.reqmts.async.io.exec]</b> as follows.</em></p>

<p class="changed">-1- An asynchronous operation has an associated executor <del>satisfying the <code>Executor</code> (13.2.2) requirements</del><ins>whose type models <code>execution::executor</code> (P0443R13)</ins>. If not otherwise specified by the asynchronous operation, this associated executor is an object of type <code>system_executor</code>.</p>

<p><em>[...]</em></p>

<p>-3- Let <code>Executor1</code> be the type of the associated executor. Let <code>ex1</code> be a value of type <code>Executor1</code>, representing the associated executor object obtained as described above. <ins><code>can_query_v&lt;Executor1, execution::context_t&gt;</code> shall be <code>true</code>, and <code>std::query(ex1, execution::context_t)</code> shall yield a value of type <code>execution_context&amp;</code> or of type <code>E&amp;</code>, where <code>E</code> satisifies the <code>ExecutionContext</code> (13.2.3) requirements.</ins></p>

<p class="instructions"><em>Modify section <b>-13.2.7.9- Completion handler executor [async.reqmts.async.handler.exec]</b> as follows.</em></p>

<p class="changed">-1- A completion handler object of type <code>CompletionHandler</code> has an associated executor <del>satisfying the Executor requirements (13.2.2)</del><ins>whose type models <code>execution::executor</code> (P0443R13)</ins>. The type of this associated executor is <code>associated_executor_t&lt;CompletionHandler, Executor1&gt;</code>. Let <code>Executor2</code> be the type <code>associated_executor_t&lt;CompletionHandler, Executor1&gt;</code>. Let <code>ex2</code> be a value of type <code>Executor2</code> obtained by performing <code>get_associated_executor(completion_handler, ex1)</code>. <ins><code>can_query_v&lt;Executor2, execution::context_t&gt;</code> shall be <code>true</code>, and <code>std::query(ex2, execution::context_t)</code> shall yield a value of type <code>execution_context&amp;</code> or of type <code>E&amp;</code>, where <code>E</code> satisifies the <code>ExecutionContext</code> (13.2.3) requirements.</ins></p>

<p class="instructions"><em>Modify section <b>-13.2.7.14- Composed asynchronous operations [async.reqmts.async.composed]</b> as follows.</em></p>

<p>An intermediate operation's completion handler shall have an associated executor that is either:</p>

<ul>
<li>the type <code>Executor2</code> and object <code>ex2</code> obtained from the completion handler type <code>CompletionHandler</code> and object <code>completion_handler</code>; or</li>
<li class="changed">an object of an unspecified type <del>satisfying the Executor requirements (13.2.2)</del><ins>that models <code>execution::executor</code> (P0443R13)</ins>, that delegates executor operations to the type <code>Executor2</code> and object <code>ex2</code>.</li>
</ul>

<p class="instructions"><em>Remove section <b>-13.9- Class template is_executor [async.is.exec]</b> in its entirety.</em></p>

<p class="instructions"><em>Modify section <b>-13.10- Executor argument tag [async.executor.arg]</b> as follows.</em></p>

<div class="changed">
The <code>executor_arg_t</code> struct is an empty structure type used as a unique type to disambiguate constructor and function overloading. Specifically, types may have constructors with <code>executor_arg_t</code> as the first argument, immediately followed by an argument of a type that <del>satisfies the Executor requirements (13.2.2)</del>models <ins><code>execution::executor</code> (P0443R13)</ins>.
</div>

<p class="instructions"><em>Modify section <b>-13.12- Class template associated_executor [async.assoc.exec]</b> as follows.</em></p>

<p>-1- Class template <code>associated_executor</code> is an associator (13.2.6) for <del>the <code>Executor</code> (13.2.2) type requirements</del><ins>executors</ins>, with default candidate type <code>system_executor</code> and default candidate object <code>system_executor()</code>.</p>

<p class="instructions"><em>Modify <b>Table 9 - associated_executor specialization requirements</b> as follows:</em></p>

<div class="changed">
<table border="1">
<tr>
<th>Expression</th>
<th>Return type</th>
<th>Note</th>
</tr>
<tr>
<td><code>typename X::type</code></td>
<td><del>A type meeting <code>Executor</code> requirements (13.2.2)</del><br/><ins>A type that models <code>execution::executor</code> (P0443R13)</ins>.</td>
<td></td>
</tr>
</table>
</div>

<p class="instructions"><em>Modify section <b>-13.13- Function get_associated_executor [async.assoc.exec.get]</b> as follows.</em></p>

<p>-3- <b>Remarks:</b> This function shall not participate in overload resolution unless
<del><code>is_executor_v&lt;Executor&gt;</code> is <code>true</code></del><ins><code>is_convertible&lt;Executor&amp;, execution_context&amp;&gt;::value</code> is <code>false</code></ins>.</p>

<p class="instructions"><em>Modify section <b>-13.14- Class template executor_binder [async.exec.binder]</b> as follows.</em></p>

<p class="changed">-1- The class template <code>executor_binder</code> binds executors to objects. A specialization <code>executor_binder&lt;T, Executor&gt;</code> binds an executor of type <code>Executor</code> <del>satisfying the Executor requirements (13.2.2)</del><ins>that models <code>execution::executor</code> (P0443R13)</ins> to an object or function of type <code>T</code>.</p>

<p class="instructions"><em>Modify section <b>-13.15- Function bind_executor [async.bind.executor]</b> as follows.</em></p>

<p>-2- <b>Remarks:</b> This function shall not participate in overload resolution unless
<del><code>is_executor_v&lt;Executor&gt;</code> is <code>true</code></del><ins><code>is_convertible&lt;Executor&amp;, execution_context&amp;&gt;::value</code> is <code>false</code></ins>.</p>

<p class="instructions"><em>Modify section <b>-13.22- Function dispatch [async.dispatch]</b> as follows.</em></p>

<p>-8- <b>Remarks:</b> This function shall not participate in overload resolution unless
<del><code>is_executor_v&lt;Executor&gt;</code> is <code>true</code></del><ins><code>is_convertible&lt;Executor&amp;, execution_context&amp;&gt;::value</code> is <code>false</code></ins>.</p>

<p class="instructions"><em>Modify section <b>-13.23- Function post [async.post]</b> as follows.</em></p>

<p>-8- <b>Remarks:</b> This function shall not participate in overload resolution unless
<del><code>is_executor_v&lt;Executor&gt;</code> is <code>true</code></del><ins><code>is_convertible&lt;Executor&amp;, execution_context&amp;&gt;::value</code> is <code>false</code></ins>.</p>

<p class="instructions"><em>Modify section <b>-13.24- Function defer [async.defer]</b> as follows.</em></p>

<p>-8- <b>Remarks:</b> This function shall not participate in overload resolution unless
<del><code>is_executor_v&lt;Executor&gt;</code> is <code>true</code></del><ins><code>is_convertible&lt;Executor&amp;, execution_context&amp;&gt;::value</code> is <code>false</code></ins>.</p>

<p class="instructions"><em>Modify section <b>-13.25- Class template strand [async.strand]</b> as follows.</em></p>

<p class="changed">-1- The class template <code>strand</code> is a wrapper around an object of type <code>Executor</code> <del>satisfying the <code>Executor</code> requirements (13.2.2)</del><ins>that models <code>execution::executor</code> (P0443R13)</ins>.

<p><em>[...]</em></p>

<p class="changed">-2- <code>strand&lt;Executor&gt;</code> <del>satisfies the <code>Executor</code> (13.2.2) requirements</del><ins>models <code>execution::executor</code> (P0443R13)</ins>.</p>

<p class="instructions"><em>Modify <b>Table 17 - AsyncReadStream requirements [buffer.stream.reqmts.asyncreadstream]</b> as follows:</em></p>

<div class="changed">
<table border="1">
<tr>
<th>operation</th>
<th>type</th>
<th>semantics, pre/post-conditions</th>
</tr>
<tr>
<td><code>a.get_executor()</code></td>
<td>A type <del>satisfying the <code>Executor</code> requirements (13.2.2)</del><ins>that models <code>execution::executor</code> (P0443R13)</ins>.</td>
<td>Returns the associated I/O executor.</td>
</tr>
</table>
</div>

<p class="instructions"><em>Modify <b>Table 19 - AsyncWriteStream requirements [buffer.stream.reqmts.asyncwritestream]</b> as follows:</em></p>

<div class="changed">
<table border="1">
<tr>
<th>operation</th>
<th>type</th>
<th>semantics, pre/post-conditions</th>
</tr>
<tr>
<td><code>a.get_executor()</code></td>
<td>A type <del>satisfying the <code>Executor</code> requirements (13.2.2)</del><ins>that models <code>execution::executor</code> (P0443R13)</ins>.</td>
<td>Returns the associated I/O executor.</td>
</tr>
</table>
</div>

<h3 id="specify.async.ops">Specify the "Requirements on asynchronous operations" in terms of the new executors model</h3>

<p class="instructions"><em>Modify section <b>-13.2.7.10- Outstanding work [async.reqmts.async.work]</b> as follows.</em></p>

<p>-1- Until the asynchronous operation has completed, the asynchronous operation shall maintain:</p>
<del><ul>
<li>an object <code>work1</code> of type <code>executor_work_guard&lt;Executor1&gt;</code>, initialized as <code>work1(ex1)</code>, and where <code>work1.owns_work() == true</code>; and</li>
<li>an object <code>work2</code> of type <code>executor_work_guard&lt;Executor2&gt;</code>, initialized as <code>work2(ex2)</code>, and where <code>work2.owns_work() == true</code>.</li>
</ul></del>
<ins><ul>
<li>an executor object <code>work1</code>, initialized as <code>std::prefer(ex1, execution::outstanding_work.tracked)</code>; and</li>
<li>an executor object <code>work2</code>, initialized as <code>std::prefer(ex2, execution::outstanding_work.tracked)</code>.</li>
</ul></ins>

<p class="instructions"><em>Modify section <b>-13.2.7.12- Execution of completion handler on completion of asynchronous operation [async.reqmts.async.completion]</b> as follows:</em></p>

<p>-3- If an asynchronous operation completes immediately (that is, within the thread of execution calling the initiating function, and before the initiating function returns), the completion handler shall be submitted for execution as if by performing<del><code>ex2.post(std::move(f), alloc2)</code>. Otherwise, the completion handler shall be submitted for execution as if by performing <code>ex2.dispatch(std::move(f), alloc2)</code>.</del><ins>:</ins></p>
<ins>
<pre>
  execution::execute(
    std::prefer(
      std::require(ex2, execution::blocking.never),
        execution::allocator(alloc2)),
    std::move(f));
</pre>
<p>Otherwise, the completion handler shall be submitted for execution as if by performing:</p>
<pre>
  execution::execute(
    std::prefer(work2, execution::blocking.possibly,
      execution::allocator(alloc2)),
    std::move(f));
</pre></ins>

<h3 id="update.system.executor">Update <code>system_executor</code> and <code>system_context</code> to conform to the new executors model</h3>

<p class="instructions"><em>Remove <code>system_executor</code> from, and add <code>system_context</code> to, <b>-12.1- Header &lt;experimental/netfwd&gt; synopsis [fwd.decl.synop]</b>:</em></p>

<pre>
  <del>class system_executor;</del>
  <ins>class system_context;</ins>
</pre>

<p class="instructions"><em>Update <code>system_executor</code> to be a type alias in <b>-13.1- Header &lt;experimental/executor&gt; synopsis [async.synop]</b>:</em></p>

<pre>
  <del>class system_executor;</del>
  class system_context;
  <ins>using system_executor = system_context::executor_type;</ins>

  <del>bool operator==(const system_executor&amp;, const system_executor&amp;);
  bool operator!=(const system_executor&amp;, const system_executor&amp;);</del>
</pre>

<p class="instructions"><em>Remove section <b>-13.18- Class system_executor [async.system.exec]</b> in its entirety.</em></p>

<p class="instructions"><em>Modify section <b>-13.19- Class system_context [async.system.context]</b> as follows:</em></p>

<p>-1- Class <code>system_context</code> implements <del>the execution context associated with <code>system_executor</code> objects</del><ins>an execution context that represents the ability to run a submitted function object on any thread</ins>.

<pre>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {

  class system_context : public execution_context
  {
  public:
    // types:

    using executor_type = <del>system_executor</del><ins><em>see below</em></ins>;
</pre>

<p><em>[...]</em></p>

<p>-2- The class <code>system_context</code> satisfies the <code>ExecutionContext</code> (13.2.3) type requirements.</p>

<ins><p>-?- <code>executor_type</code> is an executor type conforming to the specification for <code>system_context</code> executor types described below. Executor objects of type <code>executor_type</code> have the following properties established:</p>
<ul>
<li><code>execution::blocking.possibly</code></li>
<li><code>execution::relationship.fork</code></li>
<li><code>execution::mapping.thread</code></li>
<li><code>execution::allocator(std::allocator&lt;void&gt;())</code></li>
</ul>
<p>-?- <code>system_context</code> executors having a different set of established properties may be represented by distinct, unspecified types. Function objects submitted via a <code>system_context</code> executor object are permitted to execute on any thread. To satisfy the requirements for the <code>execution::blocking.never</code> property, a <code>system_context</code> executor may create <code>thread</code> objects to run the submitted function objects. These <code>thread</code> objects are collectively referred to as system threads.</p></ins>

<p><em>[...]</em></p>

<pre>
executor_type get_executor() noexcept;
</pre>

<p>-5- <b>Returns:</b> <del><code>system_executor()</code></del><ins><code>executor_type()</code></ins>.</p>

<p class="instructions"><em>After section <b>-13.19- Class system_context [async.system.context]</b> insert a new section as follows:</em></p>

<ins>
<h3>-13.?- <code>system_context</code> executor types</h3>

<p class="changed">-1- Class <em>system-context-executor</em> is for exposition only. It is used to specify a bounded set of types that model <code>execution::executor</code> (P0443R13). All executor types accessible through <code>system_context::executor_type</code>, <code>system_context::get_executor()</code>, and subsequent calls to the member function <code>require</code>, are members of this set and conform to the specification of <em>system-context-executor</em>. [<em>Note:</em> An implementation may provide distinct types for executors that have different properties established. <em>--end note</em>]</p>

<pre>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {

  class <em>system-context-executor</em>
  {
  public:
    // construct / copy / destroy:

    <em>system-context-executor</em>() {}

    // executor operations:

    <em>see below</em> require(execution::blocking_t::possibly_t) const;
    <em>see below</em> require(execution::blocking_t::never_t) const;
    <em>see below</em> require(execution::blocking_t::always_t) const;
    <em>see below</em> require(execution::relationship_t::fork_t) const;
    <em>see below</em> require(execution::relationship_t::continuation_t) const;
    <em>see below</em> require(execution::allocator_t&lt;void&gt;) const;
    template&lt;class ProtoAllocator&gt;
      <em>see below</em> require(const execution::allocator_t&lt;ProtoAllocator&gt;&amp; a) const;

    static constexpr execution::mapping_t query(execution::mapping_t) noexcept;
    system_context&amp; query(execution::context_t) const noexcept;
    execution::blocking_t query(execution::blocking_t) const noexcept;
    execution::relationship_t query(execution::relationship_t) const noexcept;
    <em>see below</em> query(execution::allocator_t&lt;void&gt;) const noexcept;
    template&lt;class ProtoAllocator&gt;
      <em>see below</em> query(const execution::allocator_t&lt;ProtoAllocator&gt;&amp;) const noexcept;

    template&lt;class Function&gt;
      void execute(Function&amp;&amp; f) const;
  };

  bool operator==(const <em>system-context-executor</em>&amp; a, const <em>system-context-executor</em>&amp; b) noexcept;
  bool operator!=(const <em>system-context-executor</em>&amp; a, const <em>system-context-executor</em>&amp; b) noexcept;

} // inline namespace v1
} // namespace net
} // namespace experimental
} // namespace std
</pre>

<h4>-13.?.1- <code>system_context</code> executor operations</h4>

<pre>
<em>see below</em> require(execution::blocking_t::possibly_t) const;
<em>see below</em> require(execution::blocking_t::never_t) const;
<em>see below</em> require(execution::blocking_t::always_t) const;
<em>see below</em> require(execution::relationship_t::fork_t) const;
<em>see below</em> require(execution::relationship_t::continuation_t) const;
</pre>

<p class="changed">-1- <b>Returns:</b> An object of a <em><code>system-context-executor</code></em> class, with the requested property established. When the requested property is part of a group that is defined as a mutually exclusive set, any other properties in the group are removed from the returned executor object. All other properties of the returned executor object are identical to those of <code>*this</code>.</p>

<pre>
<em>see below</em> require(execution::allocator_t&lt;void&gt;) const;
</pre>

<p>-2- <b>Returns:</b> <code>require(execution::allocator(std::allocator&lt;void&gt;()))</code>.</p>

<pre>
template&lt;class ProtoAllocator&gt;
  <em>see below</em> require(const execution::allocator_t&lt;ProtoAllocator&gt;&amp; a) const;
</pre>

<p class="changed">-3- <b>Returns:</b> An object of a <em><code>system-context-executor</code></em> class, with the <code>execution::allocator_t&lt;ProtoAllocator&gt;</code> property established such that allocation and deallocation associated with function submission will be performed using a copy of <code>a.value()</code>. All other properties of the returned executor object are identical to those of <code>*this</code>.</p>

<pre>
static constexpr execution::mapping_t query(execution::mapping_t) noexcept;
</pre>

<p>-4- <b>Returns:</b> <code>true</code>.</p>

<pre>
system_context&amp; query(execution::context_t) const;
</pre>

<p>-5- <b>Returns:</b> A reference to the <code>system_context</code> object.</p>

<pre>
execution::blocking_t query(execution::blocking_t) const noexcept;
execution::relationship_t query(execution::relationship_t) const noexcept;
</pre>

<p>-6- <b>Returns:</b> The established value of the property for the executor object <code>*this</code>.</p>

<pre>
<em>see below</em> query(execution::allocator_t&lt;void&gt;) const noexcept;
template&lt;class ProtoAllocator&gt;
  <em>see below</em> query(const execution::allocator_t&lt;ProtoAllocator&gt;&amp;) const noexcept;
</pre>

<p>-7- <b>Returns:</b> The allocator object associated with the executor, with type and value as previously established by the <code>execution::allocator_t&lt;ProtoAllocator&gt;</code> property.</p>

<pre>
template&lt;class Function&gt;
  void execute(Function&amp;&amp; f) const
</pre>

<p>-8- <b>Effects:</b> Submits the function <code>f</code> for execution according to the <code>execution::executor</code> concept and the properties established for <code>*this</code>. If <code>f</code> exits via an exception, calls <code>std::terminate()</code>.</p>

<h4>-13.?.2- <code>system_context</code> executor comparisons</h4>

<pre>
bool operator==(const <em>system-context-executor</em>&amp; a, const <em>system-context-executor</em>&amp; b) noexcept;
</pre>

<p>-1- <b>Returns:</b> <code>true</code> if <code>a</code> and <code>b</code> have identical properties, otherwise <code>false</code>.</p>

<pre>
bool operator!=(const <em>system-context-executor</em>&amp; a, const <em>system-context-executor</em>&amp; b) noexcept;
</pre>

<p>-2- <b>Returns:</b> <code>!(a == b)</code>.</p>
</ins>

<div class="changed">
<h3 id="remove.polymorphic.wrapper">Remove the polymorphic wrapper <code>executor</code> and uses of it as a default executor</h3>

<p class="instructions"><em>Remove <code>executor</code> from <b>-12.1- Header &lt;experimental/netfwd&gt; synopsis [fwd.decl.synop]</b>:</em></p>

<pre>
  <del>class executor;</del>
</pre>

<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,</p>
<ul>
<li>remove <code>executor</code> as the default for <code>Executor</code> template parameters,</li>
<li>use <code>io_context::executor_type</code> as the default for the iostream class templates' <code>Executor</code> tempalte parameters,</li>
<li>reorder template parameters so that the remaining defaulted ones come last,</li>
<li>remove the <code>basic_</code> prefixes, and</li>
<li>remove the <code>system_timer</code>, <code>steady_timer</code>, and <code>high_resolution_timer</code> type aliases</li>
</ul>
<p>in <b>-12.1- Header &lt;experimental/netfwd&gt; synopsis [fwd.decl.synop]</b>:</em></p>
</div>

<pre>
  template&lt;class Clock&gt; struct wait_traits;
  template&lt;class Clock, <ins>class Executor, </ins>class WaitTraits = wait_traits&lt;Clock&gt;<del>, class Executor = executor</del>&gt;
    class <del>basic_</del>waitable_timer;
  <del>using system_timer = basic_waitable_timer&lt;chrono::system_clock&gt;;
  using steady_timer = basic_waitable_timer&lt;chrono::steady_clock&gt;;
  using high_resolution_timer = basic_waitable_timer&lt;chrono::high_resolution_clock&gt;;</del>

  template&lt;class Protocol, class Executor<del> = executor</del>&gt;
    class <del>basic_</del>socket;
  template&lt;class Protocol, class Executor<del> = executor</del>&gt;
    class <del>basic_</del>datagram_socket;
  template&lt;class Protocol, class Executor<del> = executor</del>&gt;
    class <del>basic_</del>stream_socket;
  template&lt;class Protocol, class Executor<del> = executor</del>&gt;
    class <del>basic_</del>socket_acceptor;
  template&lt;class Protocol, class Clock = chrono::steady_clock,
    class WaitTraits = wait_traits&lt;Clock&gt;, class Executor = <del>executor</del><ins>io_context::executor_type</ins>&gt;
      class <del>basic_</del>socket_streambuf;
  template&lt;class Protocol, class Clock = chrono::steady_clock,
    class WaitTraits = wait_traits&lt;Clock&gt;, class Executor = <del>executor</del><ins>io_context::executor_type</ins>&gt;
      class <del>basic_</del>socket_iostream;

  namespace ip {
</pre>

<p><em>[...]</em></p>

<pre>
    template&lt;class InternetProtocol, class Executor<del> = executor</del>&gt;
      class <del>basic_</del>resolver;
</pre>
</div>

<p class="instructions"><em>Remove classes <code>bad_executor</code> and <code>executor</code> from <b>-13.1- Header &lt;experimental/executor&gt; synopsis [async.synop]</b>:</em></p>

<pre>
  <del>class bad_executor;

  class executor;

  bool operator==(const executor&amp; a, const executor&amp; b) noexcept;
  bool operator==(const executor&amp; e, nullptr_t) noexcept;
  bool operator==(nullptr_t, const executor&amp; e) noexcept;
  bool operator!=(const executor&amp; a, const executor&amp; b) noexcept;
  bool operator!=(const executor&amp; e, nullptr_t) noexcept;
  bool operator!=(nullptr_t, const executor&amp; e) noexcept;</del>
</pre>

<p><em>[...]</em></p>

<pre>
} // inline namespace v1
} // namespace net
} // namespace experimental
<del>
  template&lt;class Allocator&gt;
    struct uses_allocator&lt;experimental::net::v1::executor, Allocator&gt;
      : true_type {};

</del>} // namespace std
</pre>

<p class="instructions"><em>Remove sections <b>-13.20- Class bad_executor [async.bad.exec]</b> and <b>-13.21- Class executor [async.executor]</b> in their entirety.</em></p>

<div class="changed">
<p class="instructions"><em>Use the <code>waitable_timer</code> class template directly, instead of the <code>steady_timer</code> alias, in <b>-15- Timers [timer]</b>:</em></p>

<p>-1- This clause defines components for performing timer operations.</p>

<p>-2- [&nbsp;<em>Example</em><span class='textit'>:</span> Performing a synchronous wait operation on a timer:
<pre class='codeblock'>
io_context c;
<del >steady_&shy;timer</del><ins >waitable_&shy;timer&lt;chrono&#x200b;::&#x200b;steady_&shy;clock&gt;</ins> t(c);
t.expires_after(seconds(5));
t.wait();
</pre> --&nbsp;<i>end example</i>&nbsp;] </p>

<p>-3- [&nbsp;<em>Example</em><span class='textit'>:</span> Performing an asynchronous wait operation on a timer:
<pre class='codeblock'>
void handler(error_code ec) { ... }
...
io_context c;
<del >steady_&shy;timer</del><ins >waitable_&shy;timer&lt;chrono&#x200b;::&#x200b;steady_&shy;clock&gt;</ins> t(c);
t.expires_after(seconds(5));
t.async_wait(handler);
c.run();
</pre> --&nbsp;<i>end example</i>&nbsp;]  </p>

<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,</p>
<ul>
<li>remove <code>executor</code> as the default for the <code>Executor</code> template parameter,</li>
<li>reorder the template parameters so that the remaining defaulted ones come last, and</li>
<li>remove the <code>basic_</code> prefix, and</li>
<li>remove the <code>system_timer</code>, <code>steady_timer</code>, and <code>high_resolution_timer</code> type aliases</li>
</ul>
<p>from <b>-15.1- Header <code>&lt;experimental/timer&gt;</code> synopsis [timer.synop]</b></em></p>
</div>

<pre class='codeblock'>
#include &lt;chrono&gt;

namespace std {
namespace experimental {
namespace net {
inline namespace v1 {

  template&lt;class Clock&gt; struct wait_traits;

  template&lt;class Clock, <ins >class Executor, </ins>class WaitTraits = wait_traits&lt;Clock&gt;<del >, class Executor = executor</del>&gt;
    class <del >basic_&shy;</del>waitable_timer;

  <del >using system_&shy;timer = basic_&shy;waitable_&shy;timer&lt;chrono&#x200b;::&#x200b;system_&shy;clock&gt;;</del>
  <del >using steady_&shy;timer = basic_&shy;waitable_&shy;timer&lt;chrono&#x200b;::&#x200b;steady_&shy;clock&gt;;</del>
  <del >using high_&shy;resolution_&shy;timer = basic_&shy;waitable_&shy;timer&lt;chrono&#x200b;::&#x200b;high_&shy;resolution_&shy;clock&gt;;</del>

} // inline namespace v1
} // namespace net
} // namespace experimental
} // namespace std
</pre>

<p class="instructions"><em>Remove the <code>basic_</code> prefix from <code>basic_waitable_timer</code> in <b>-15.2.1- Wait traits requirements [timer.reqmts.waittraits]</b> as follows:</em></p>

<p>-1- The <code><del ><code>basic_&shy;</code></del>waitable_&shy;timer</code> template uses wait traits to allow programs to customize <code>wait</code> and <code>async_&shy;wait</code> behavior. [&nbsp;<em>Note</em><span class='textit'>:</span> Possible uses of wait traits include:

<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,</p>
<ul>
<li>remove <code>executor</code> as the default for the <code>Executor</code> template parameter,</li>
<li>reorder the template parameters so that the remaining defaulted ones come last, and</li>
<li>remove the <code>basic_</code> prefix</li>
</ul>
<p>from <b>-15.4- Class template <code>basic_&shywaitable_&shy;timer</code> [timer.waitable]</b></em></p>
</div>

<p><b>15.4 Class template <code><del ><code>basic_&shy;</code></del>waitable_&shy;timer</code> [timer.waitable]</b></p>

<pre class='codeblock'>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {

  template&lt;class Clock, <ins >class Executor, </ins>class WaitTraits = wait_traits&lt;Clock&gt;<del >, class Executor = executor</del>&gt;
  class <del >basic_&shy;</del>waitable_timer
  {
  public:
    // types:

    using executor_type = Executor;
    using clock_type = Clock;
    using duration = typename clock_type::duration;
    using time_point = typename clock_type::time_point;
    using traits_type = WaitTraits;

    template&lt;class OtherExecutor&gt;
    using rebind_executor =
      <del >basic_&shy;</del>waitable_timer&lt;Clock, WaitTraits, OtherExecutor&gt;;

    // [timer.waitable.cons], construct / copy / destroy:

    explicit <del >basic_&shy;</del>waitable_timer();
    template&lt;class ExecutionContext&gt;
      explicit <del >basic_&shy;</del>waitable_timer(ExecutionContext&amp; ctx);
    <del >basic_&shy;</del>waitable_timer(const executor_type&amp; ex, const time_point&amp; t);
    template&lt;class ExecutionContext&gt;
      <del >basic_&shy;</del>waitable_timer(ExecutionContext&amp; ctx, const time_point&amp; t);
    <del >basic_&shy;</del>waitable_timer(const executor_type&amp; ex, const duration&amp; d);
    template&lt;class ExecutionContext&gt;
      <del >basic_&shy;</del>waitable_timer(ExecutionContext&amp; ctx, const duration&amp; d);
    <del >basic_&shy;</del>waitable_timer(const <del >basic_&shy;</del>waitable_timer&amp;) = delete;
    <del >basic_&shy;</del>waitable_timer(<del >basic_&shy;</del>waitable_timer&amp;&amp; rhs);

    ~<del >basic_&shy;</del>waitable_timer();

    <del >basic_&shy;</del>waitable_timer&amp; operator=(const <del >basic_&shy;</del>waitable_timer&amp;) = delete;
    <del >basic_&shy;</del>waitable_timer&amp; operator=(<del >basic_&shy;</del>waitable_timer&amp;&amp; rhs);

    // [timer.waitable.ops], <del >basic_&shy;</del>waitable_timer operations:

    executor_type get_executor() noexcept;

    size_t cancel();
    size_t cancel_one();

    time_point expiry() const;
    size_t expires_at(const time_point&amp; t);
    size_t expires_after(const duration&amp; d);

    void wait();
    void wait(error_code&amp; ec);

    template&lt;class CompletionToken&gt;
      <em>DEDUCED</em> async_wait(CompletionToken&amp;&amp; token);
  };

} // inline namespace v1
} // namespace net
} // namespace experimental
} // namespace std
</pre>
<p>-1- Instances of class template <code><del ><code>basic_&shy;</code></del>waitable_&shy;timer</code> meet the requirements of <code>Destructible</code> (C++2014[destructible]), <code>MoveConstructible</code> (C++2014[moveconstructible]), and <code>MoveAssignable</code> (C++2014[moveassignable]).</p>
<h4 >15.4.1 <code><del ><code>basic_&shy;</code></del>waitable_&shy;timer</code> constructors [timer.waitable.cons]</h4>

<p><pre class='itemdeclcode'>explicit <del ><code>basic_&shy;</code></del>waitable_timer(const executor_type&amp; ex);
</pre></p><p></p>
<p>-1- <em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>waitable_&shy;timer(ex, time_&shy;point())</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  explicit <del ><code>basic_&shy;</code></del>waitable_timer(ExecutionContext&amp; ctx);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>waitable_&shy;timer(ctx.get_&shy;executor()).</code></p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>waitable_timer(const executor_type&amp; ex, const time_point&amp; t);
</pre></p><p></p>
<p>-2- <em>Postconditions:</em>
<ul class='itemize'><li id='waitable.cons-2.1'>(2.1) <code>get_&shy;executor() == ex</code>.</li><li id='waitable.cons-2.2'>(2.2) <code>expiry() == t</code>.</li></ul></p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  <del ><code>basic_&shy;</code></del>waitable_timer(ExecutionContext&amp; ctx, const time_point&amp; t);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>waitable_&shy;timer(ctx.get_&shy;executor(), t).</code></p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>waitable_timer(const executor_type&amp; ex, const duration&amp; d);
</pre></p><p></p>
<p>-3- <em>Effects:</em>Sets the expiry time as if by calling <code>expires_&shy;after(d)</code>.</p>

<p>-4- <em>Postconditions:</em><code>get_&shy;executor() == ex</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  <del ><code>basic_&shy;</code></del>waitable_timer(ExecutionContext&amp; ctx, const duration&amp; d);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>waitable_&shy;timer(ctx.get_&shy;executor(), d).</code></p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>waitable_timer(<del ><code>basic_&shy;</code></del>waitable_timer&amp;&amp; rhs);
</pre></p><p></p>
<p>-5- <em>Effects:</em>Move constructs an object of class <code><del ><code>basic_&shy;</code></del>waitable_&shy;timer&lt;Clock, WaitTraits&gt;</code> that refers to the state originally represented by <code>rhs</code>.</p>

<p>-6- <em>Postconditions:</em>
<ul class='itemize'><li id='waitable.cons-6.1'>(6.1) <code>get_&shy;executor() == rhs.get_&shy;executor()</code>.</li><li id='waitable.cons-6.2'>(6.2) <code>expiry()</code> returns the same value as <code>rhs.expiry()</code> prior to the constructor invocation.</li><li id='waitable.cons-6.3'>(6.3) <code>rhs.expiry() == time_&shy;point()</code>.</li></ul></p>


<h4 >15.4.2 <code><del ><code>basic_&shy;</code></del>waitable_&shy;timer</code> destructor [timer.waitable.dtor]</h4>

<p><pre class='itemdeclcode'>~<del ><code>basic_&shy;</code></del>waitable_timer();
</pre></p><p></p>
<p>-1- <em>Effects:</em>Destroys the timer, canceling any asynchronous wait operations associated with the timer as if by calling <code>cancel()</code>.</p>


<h4 >15.4.3 <code><del ><code>basic_&shy;</code></del>waitable_&shy;timer</code> assignment [timer.waitable.assign]</h4>

<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>waitable_timer&amp; operator=(<del ><code>basic_&shy;</code></del>waitable_timer&amp;&amp; rhs);
</pre></p><p></p>
<p>-1- <em>Effects:</em>Cancels any outstanding asynchronous operations associated with <code>*this</code> as if by calling <code>cancel()</code>, then moves into <code>*this</code> the state originally represented by <code>rhs</code>.</p>

<p>-2- <em>Postconditions:</em>
<ul class='itemize'><li id='waitable.assign-2.1'>(2.1) <code>get_&shy;executor() == rhs.get_&shy;executor()</code>.</li><li id='waitable.assign-2.2'>(2.2) <code>expiry()</code> returns the same value as <code>rhs.expiry()</code> prior to the assignment.</li><li id='waitable.assign-2.3'>(2.3) <code>rhs.expiry() == time_&shy;point()</code>.</li></ul></p>

<p>-3- <em>Returns:</em><code>*this</code>.</p>


<h4 >15.4.4 <code><del ><code>basic_&shy;</code></del>waitable_&shy;timer</code> operations [timer.waitable.ops]</h4>

<p><em>[...]</em></p>

<p><pre class='itemdeclcode'>template&lt;class CompletionToken&gt;
  <em>DEDUCED</em> async_wait(CompletionToken&amp;&amp; token);
</pre></p><p></p>
<p>-15- <em>Completion signature:</em><code>void(error_&shy;code ec)</code>.</p>

<p>-16- <em>Effects:</em>Initiates an asynchronous wait operation to repeatedly wait for the relative time produced by <code>WaitTraits&#x200b;::&#x200b;to_&shy;wait_&shy;duration(e)</code>, where <code>e</code> is a value of type <code>time_&shy;point</code> such that <code>e &lt;= expiry()</code>. The completion handler is submitted for execution only when the condition <code>ec || expiry() &lt;= clock_&shy;type&#x200b;::&#x200b;now()</code> yields <code>true</code>.</p>

<p>-17- [&nbsp;<em>Note</em><span class='textit'>:</span> To implement <code>async_&shy;wait</code>, an <code>io_&shy;context</code> object <code>ctx</code> could maintain a priority queue for each specialization of <code><del ><code>basic_&shy;</code></del>waitable_&shy;timer&lt;Clock, WaitTraits&gt;</code> for which a timer object was initialized with <code>ctx</code>. Only the time point <code>e</code> of the earliest outstanding expiry need be passed to <code>WaitTraits&#x200b;::&#x200b;to_&shy;wait_&shy;duration(e)</code>. --&nbsp;<i>end note</i>&nbsp;] </p>

<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,</p>
<ul>
<li>remove <code>executor</code> as the default for <code>Executor</code> template parameters,</li>
<li>use <code>io_context::executor_type</code> as the default for the iostream class templates' <code>Executor</code> template parameters,</li>
<li>remove the <code>basic_</code> prefixes</li>
</ul>
<p>in <b>-18.1- Header <code>&lt;experimental/socket&gt;</code> synopsis [socket.synop]</b>:</em></p>
</div>

<pre class='codeblock'>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {

  enum class socket_errc {
    already_open = <em>an implementation-defined non-zero value</em>,
    not_found = <em>an implementation-defined non-zero value</em>
  };

  const error_category&amp; socket_category() noexcept;

  error_code make_error_code(socket_errc e) noexcept;
  error_condition make_error_condition(socket_errc e) noexcept;

  // Sockets:

  class socket_base;

  template&lt;class Protocol, class Executor<del > = executor</del>&gt;
    class <del >basic_&shy;</del>socket;

  template&lt;class Protocol, class Executor<del > = executor</del>&gt;
    class <del >basic_&shy;</del>datagram_socket;

  template&lt;class Protocol, class Executor<del > = executor</del>&gt;
    class <del >basic_&shy;</del>stream_socket;

  template&lt;class Protocol, class Executor<del > = executor</del>&gt;
    class <del >basic_&shy;</del>socket_acceptor;

  // [socket.iostreams], Socket streams:

  template&lt;class Protocol, class Clock = chrono::steady_clock,
    class WaitTraits = wait_traits&lt;Clock&gt;, class Executor = <del >executor</del><ins >io_&shy;context&#x200b;::&#x200b;executor_&shy;type</ins>&gt;
      class <del >basic_&shy;</del>socket_streambuf;

  template&lt;class Protocol, class Clock = chrono::steady_clock,
    class WaitTraits = wait_traits&lt;Clock&gt;, class Executor = <del >executor</del><ins >io_&shy;context&#x200b;::&#x200b;executor_&shy;type</ins>&gt;
      class <del >basic_&shy;</del>socket_iostream;

  // [socket.algo.connect], synchronous connect operations:

  template&lt;class Protocol, class Executor, class EndpointSequence&gt;
    typename Protocol::endpoint connect(<del >basic_&shy;</del>socket&lt;Protocol, Executor&gt;&amp; s,
                                        const EndpointSequence&amp; endpoints);
  template&lt;class Protocol, class Executor, class EndpointSequence&gt;
    typename Protocol::endpoint connect(<del >basic_&shy;</del>socket&lt;Protocol, Executor&gt;&amp; s,
                                        const EndpointSequence&amp; endpoints,
                                        error_code&amp; ec);
  template&lt;class Protocol, class Executor, class EndpointSequence, class ConnectCondition&gt;
    typename Protocol::endpoint connect(<del >basic_&shy;</del>socket&lt;Protocol, Executor&gt;&amp; s,
                                        const EndpointSequence&amp; endpoints,
                                        ConnectCondition c);
  template&lt;class Protocol, class Executor, class EndpointSequence, class ConnectCondition&gt;
    typename Protocol::endpoint connect(<del >basic_&shy;</del>socket&lt;Protocol, Executor&gt;&amp; s,
                                        const EndpointSequence&amp; endpoints,
                                        ConnectCondition c,
                                        error_code&amp; ec);

  template&lt;class Protocol, class Executor, class InputIterator&gt;
    InputIterator connect(<del >basic_&shy;</del>socket&lt;Protocol, Executor&gt;&amp; s,
                          InputIterator first, InputIterator last);
  template&lt;class Protocol, class Executor, class InputIterator&gt;
    InputIterator connect(<del >basic_&shy;</del>socket&lt;Protocol, Executor&gt;&amp; s,
                          InputIterator first, InputIterator last,
                          error_code&amp; ec);
  template&lt;class Protocol, class Executor, class InputIterator, class ConnectCondition&gt;
    InputIterator connect(<del >basic_&shy;</del>socket&lt;Protocol, Executor&gt;&amp; s,
                          InputIterator first, InputIterator last,
                          ConnectCondition c);
  template&lt;class Protocol, class Executor, class InputIterator, class ConnectCondition&gt;
    InputIterator connect(<del >basic_&shy;</del>socket&lt;Protocol, Executor&gt;&amp; s,
                          InputIterator first, InputIterator last,
                          ConnectCondition c,
                          error_code&amp; ec);

  // [socket.algo.async.connect], asynchronous connect operations:

  template&lt;class Protocol, class Executor, class EndpointSequence, class CompletionToken&gt;
    <em>DEDUCED</em> async_connect(<del >basic_&shy;</del>socket&lt;Protocol, Executor&gt;&amp; s,
                          const EndpointSequence&amp; endpoints,
                          CompletionToken&amp;&amp; token);
  template&lt;class Protocol, class Executor, class EndpointSequence, class ConnectCondition,
           class CompletionToken&gt;
    <em>DEDUCED</em> async_connect(<del >basic_&shy;</del>socket&lt;Protocol, Executor&gt;&amp; s,
                          const EndpointSequence&amp; endpoints,
                          ConnectCondition c,
                          CompletionToken&amp;&amp; token);

  template&lt;class Protocol, class Executor, class InputIterator, class CompletionToken&gt;
    <em>DEDUCED</em> async_connect(<del >basic_&shy;</del>socket&lt;Protocol, Executor&gt;&amp; s,
                          InputIterator first, InputIterator last,
                          CompletionToken&amp;&amp; token);
  template&lt;class Protocol, class Executor, class InputIterator, class ConnectCondition,
           class CompletionToken&gt;
    <em>DEDUCED</em> async_connect(<del >basic_&shy;</del>socket&lt;Protocol, Executor&gt;&amp; s,
                          InputIterator first, InputIterator last,
                          ConnectCondition c,
                          CompletionToken&amp;&amp; token);

} // inline namespace v1
} // namespace net
} // namespace experimental

  template&lt;&gt; struct is_error_code_enum&lt;experimental::net::v1::socket_errc&gt;
    : public true_type {};

} // namespace std
</pre>

<p><em>[...]</em></p>

<div class="instructions">
<p><em>Update Figure 1 "Socket and socket stream types [non-normative]" in
<b>-18.1- Header <code>&lt;experimental/socket&gt;</code> synopsis [socket.synop]</b>
to the following:</em></p>
</div>

<p><img src="data:image/png;base64,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" width="600"></p>

<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,</p>
<ul>
<li>remove the <code>socket</code> type alias from the <code>AcceptableProtocol</code> requirements,</li>
<li>refer to the <code>execution::executor</code> concept, and</li>
<li>remove the <code>basic_</code> prefixes</li>
</ul>
<p>from <b>-18.2.7- Acceptable protocol requirements [socket.reqmts.acceptableprotocol] </b>:</em></p>
</div>

<p>-1- A type <code>X</code> meets the <code>AcceptableProtocol</code> requirements if it satisfies the requirements of <code>Protocol</code> ([socket.reqmts.protocol]) as well as the additional requirements listed below.</p>
In the table below, <code>E</code> is a type that <del >satisfies the Executor requirements ([async.reqmts.executor])</del><ins >models <code>execution&#x200b;::&#x200b;executor</code> (P0443R13)</ins>.<div class='numberedTable' id='tab:socket.reqmts.acceptableprotocol.requirements'>Table 26: AcceptableProtocol requirements<br><table ><tr class='rowsep'><td class='center'><b>expression</b></td><td class='center'><b>return type</b></td><td class='center'><b>assertion/note pre/post-conditions</b></td></tr><tr class='capsep'><td class='left'><div style='height:0.6em;display:block'></div><del ><code>X&#x200b;::&#x200b;socket</code></del></td><td class='left'><del >A type that satisfies the requirements of <code>Destructible</code> (C++2014[destructible]) and <code>MoveConstructible</code> (C++2014[moveconstructible]), and that is publicly and unambiguously derived from <code>basic_&shy;socket&lt;X&gt;</code></del>.</td><td class='empty left'></td></tr><tr ><td class='left'><code>X&#x200b;::&#x200b;socket_&shy;for&lt;E&gt;</code></td><td class='left'>A type that satisfies the requirements of <code>Destructible</code> (C++2014[destructible]) and <code>MoveConstructible</code> (C++2014[moveconstructible]), and that is publicly and unambiguously derived from <code><del >basic_&shy;</del>socket&lt;X, E&gt;</code>.</td><td class='empty left'></td></tr></table></div>


<p><em>[...]</em></p>

<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,
remove the <code>basic_</code> prefixes
from <b>-18.4- Class <code>socket_&shy;base</code> [socket.base]</b>:</em></p>
</div>

<p><em>[...]</em></p>

<p>-1- <code>socket_&shy;base</code> defines several member types:<ul class='itemize'><li id='base-1.1'>(1.1) socket option classes <code>broadcast</code>, <code>debug</code>, <code>do_&shy;not_&shy;route</code>, <code>keep_&shy;alive</code>, <code>linger</code>, <code>out_&shy;of_&shy;band_&shy;inline</code>, <code>receive_&shy;buffer_&shy;size</code>, <code>receive_&shy;low_&shy;watermark</code>, <code>reuse_&shy;address</code>, <code>send_&shy;buffer_&shy;size</code>, and <code>send_&shy;low_&shy;watermark</code>;</li><li id='base-1.2'>(1.2) an enumerated type, <code>shutdown_&shy;type</code>, for use with the <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;</code> class's <code>shutdown</code> member function.</li><li id='base-1.3'>(1.3) an enumerated type, <code>wait_&shy;type</code>, for use with the <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;</code> and <code><del ><code>basic_&shy;</code></del>socket_&shy;acceptor&lt;Protocol, Executor&gt;</code> classes' <code>wait</code> and <code>async_&shy;wait</code> member functions,</li><li id='base-1.4'>(1.4) a bitmask type, <code>message_&shy;flags</code>, for use with the <code><del ><code>basic_&shy;</code></del>stream_&shy;socket&lt;Protocol, Executor&gt;</code> class's <code>send</code>, <code>async_&shy;send</code>, <code>receive</code>, and <code>async_&shy;receive</code> member functions, and the <code><del ><code>basic_&shy;</code></del>datagram_&shy;socket&lt;Protocol&gt;</code> class's <code>send</code>, <code>async_&shy;send</code>, <code>send_&shy;to</code>, <code>async_&shy;send_&shy;to</code>, <code>receive</code>, <code>async_&shy;receive</code>, <code>receive_&shy;from</code>, and <code>async_&shy;receive_&shy;from</code> member functions.</li><li id='base-1.5'>(1.5) a constant, <code>max_&shy;listen_&shy;connections</code>, for use with the <code><del ><code>basic_&shy;</code></del>socket_&shy;acceptor&lt;Protocol, Executor&gt;</code> class's <code>listen</code> member function.</li></ul></p>

<p><em>[...]</em></p>

<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,
remove the <code>basic_</code> prefixes
from <b>-18.6- Class <code>basic_&shy;socket</code> [socket.basic]</b>:</em></p>
</div>

<h4>18.6 Class template <code><del >basic_&shy;</del>socket</code> [socket.basic]</h4>

<p>-1- Class template <code><del >basic_&shy;</del>socket&lt;Protocol, Executor&gt;</code> is used as the base class for the <code><del >basic_&shy;</del>datagram_&shy;socket&lt;Protocol, Executor&gt;</code> and <code><del >basic_&shy;</del>stream_&shy;socket&lt;Protocol, Executor&gt;</code> class templates. It provides functionality that is common to both types of socket.<pre class='codeblock'>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {

  template&lt;class Protocol, class Executor&gt;
  class <del >basic_&shy;</del>socket : public socket_base
  {
  public:
    // types:

    using executor_type = Executor;
    using native_handle_type = <em>implementation-defined</em>; // see [socket.reqmts.native]
    using protocol_type = Protocol;
    using endpoint_type = typename protocol_type::endpoint;

    template&lt;class OtherExecutor&gt;
    using rebind_executor =
      <del >basic_&shy;</del>socket&lt;Protocol, OtherExecutor&gt;;

    // [socket.basic.ops], <del >basic_&shy;</del>socket operations:
</pre>
<p><em>[...]</em></p>
<pre>
  protected:
    // [socket.basic.cons], construct / copy / destroy:

    explicit <del >basic_&shy;</del>socket(const executor_type&amp; ex);
    template&lt;class ExecutionContext&gt;
      explicit <del >basic_&shy;</del>socket(ExecutionContext&amp; ctx);
    <del >basic_&shy;</del>socket(const executor_type&amp; ex, const protocol_type&amp; protocol);
    template&lt;class ExecutionContext&gt;
      <del >basic_&shy;</del>socket(ExecutionContext&amp; ctx, const protocol_type&amp; protocol);
    <del >basic_&shy;</del>socket(const executor_type&amp; ex, const endpoint_type&amp; endpoint);
    template&lt;class ExecutionContext&gt;
      <del >basic_&shy;</del>socket(ExecutionContext&amp; ctx, const endpoint_type&amp; endpoint);
    <del >basic_&shy;</del>socket(const executor_type&amp; ex, const protocol_type&amp; protocol,
                 const native_handle_type&amp; native_socket); // see [socket.reqmts.native]
    template&lt;class ExecutionContext&gt;
      <del >basic_&shy;</del>socket(ExecutionContext&amp; ctx, const protocol_type&amp; protocol,
                   const native_handle_type&amp; native_socket); // see [socket.reqmts.native]
    <del >basic_&shy;</del>socket(const <del >basic_&shy;</del>socket&amp;) = delete;
    <del >basic_&shy;</del>socket(<del >basic_&shy;</del>socket&amp;&amp; rhs);
    template&lt;class OtherProtocol, class OtherExecutor&gt;
      <del >basic_&shy;</del>socket(<del >basic_&shy;</del>socket&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);

    ~<del >basic_&shy;</del>socket();

    <del >basic_&shy;</del>socket&amp; operator=(const <del >basic_&shy;</del>socket&amp;) = delete;
    <del >basic_&shy;</del>socket&amp; operator=(<del >basic_&shy;</del>socket&amp;&amp; rhs);
    template&lt;class OtherProtocol, class OtherExecutor&gt;
      <del >basic_&shy;</del>socket&amp; operator=(<del >basic_&shy;</del>socket&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);

  private:
    protocol_type protocol_; // <em>exposition only</em>
  };

} // inline namespace v1
} // namespace net
} // namespace experimental
} // namespace std
</pre></p>

<p>-2- Instances of class template <code><del ><code>basic_&shy;</code></del>socket</code> meet the requirements of <code>Destructible</code> (C++2014[destructible]), <code>MoveConstructible</code> (C++2014[moveconstructible]), and <code>MoveAssignable</code> (C++2014[moveassignable]).</p>

<p>-3- When an operation has its effects specified as if by passing the result of <code>native_&shy;handle()</code> to a POSIX function, then the operation fails with error condition <code>errc&#x200b;::&#x200b;bad_&shy;file_&shy;descriptor</code> if <code>is_&shy;open() == false</code> at the point in the effects when the POSIX function is called.</p>
<h4 >18.6.1 <code><del ><code>basic_&shy;</code></del>socket</code> constructors [socket.basic.cons]</h4>

<p><pre class='itemdeclcode'>explicit <del ><code>basic_&shy;</code></del>socket(const executor_type&amp; ex);
</pre></p><p></p>
<p>-1- <em>Postconditions:</em>
<ul class='itemize'><li id='basic.cons-1.1'>(1.1) <code>get_&shy;executor() == ex</code>.</li><li id='basic.cons-1.2'>(1.2) <code>is_&shy;open() == false</code>.</li></ul></p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  explicit <del ><code>basic_&shy;</code></del>socket(ExecutionContext&amp; ctx);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>socket(ctx.get_&shy;executor()).</code></p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket(const executor_type&amp; ex, const protocol_type&amp; protocol);
</pre></p><p></p>
<p>-2- <em>Effects:</em>Opens this socket as if by calling <code>open(protocol)</code>.</p>

<p>-3- <em>Postconditions:</em>
<ul class='itemize'><li id='basic.cons-3.1'>(3.1) <code>get_&shy;executor() == ex</code>.</li><li id='basic.cons-3.2'>(3.2) <code>is_&shy;open() == true</code>.</li><li id='basic.cons-3.3'>(3.3) <code>non_&shy;blocking() == false</code>.</li><li id='basic.cons-3.4'>(3.4) <code>protocol_&shy; == protocol</code>.</li></ul></p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  explicit <del ><code>basic_&shy;</code></del>socket(ExecutionContext&amp; ctx, const protocol_type&amp; protocol);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>socket(ctx.get_&shy;executor(), protocol).</code></p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket(const executor_type&amp; ex, const endpoint_type&amp; endpoint);
</pre></p><p></p>
<p>-4- <em>Effects:</em>Opens and binds this socket as if by calling:
<pre class='codeblock'>
open(endpoint.protocol());
bind(endpoint);
</pre></p>

<p>-5- <em>Postconditions:</em>
<ul class='itemize'><li id='basic.cons-5.1'>(5.1) <code>get_&shy;executor() == ex</code>.</li><li id='basic.cons-5.2'>(5.2) <code>is_&shy;open() == true</code>.</li><li id='basic.cons-5.3'>(5.3) <code>non_&shy;blocking() == false</code>.</li><li id='basic.cons-5.4'>(5.4) <code>protocol_&shy; == endpoint.protocol()</code>.</li></ul></p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  explicit <del ><code>basic_&shy;</code></del>socket(ExecutionContext&amp; ctx, const endpoint_type&amp; endpoint);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>socket(ctx.get_&shy;executor(), endpoint).</code></p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket(const executor_type&amp; ex, const protocol_type&amp; protocol,
             const native_handle_type&amp; native_socket);
</pre></p><p></p>
<p>-6- <em>Requires:</em><code>native_&shy;socket</code> is a native handle to an open socket.</p>

<p>-7- <em>Effects:</em>Assigns the existing native socket into this socket as if by calling <code>assign(protocol, native_&shy;socket)</code>.</p>

<p>-8- <em>Postconditions:</em>
<ul class='itemize'><li id='basic.cons-8.1'>(8.1) <code>get_&shy;executor() == ex</code>.</li><li id='basic.cons-8.2'>(8.2) <code>is_&shy;open() == true</code>.</li><li id='basic.cons-8.3'>(8.3) <code>non_&shy;blocking() == false</code>.</li><li id='basic.cons-8.4'>(8.4) <code>protocol_&shy; == protocol</code>.</li></ul></p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  <del ><code>basic_&shy;</code></del>socket(ExecutionContext&amp; ctx, const protocol_type&amp; protocol,
               const native_handle_type&amp; native_socket);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>socket(ctx.get_&shy;executor(), protocol, native_&shy;socket).</code></p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket(<del ><code>basic_&shy;</code></del>socket&amp;&amp; rhs);
</pre></p><p></p>
<p>-9- <em>Effects:</em>Move constructs an object of class <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;</code> that refers to the state originally represented by <code>rhs</code>.</p>

<p>-10- <em>Postconditions:</em>
<ul class='itemize'><li id='basic.cons-10.1'>(10.1) <code>get_&shy;executor() == rhs.get_&shy;executor()</code>.</li><li id='basic.cons-10.2'>(10.2) <code>is_&shy;open()</code> returns the same value as <code>rhs.is_&shy;open()</code> prior to the constructor invocation.</li><li id='basic.cons-10.3'>(10.3) <code>non_&shy;blocking()</code> returns the same value as <code>rhs.non_&shy;blocking()</code> prior to the constructor invocation.</li><li id='basic.cons-10.4'>(10.4) <code>native_&shy;handle()</code> returns the prior value of <code>rhs.native_&shy;handle()</code>.</li><li id='basic.cons-10.5'>(10.5) <code>protocol_&shy;</code> is the prior value of <code>rhs.protocol_&shy;</code>.</li><li id='basic.cons-10.6'>(10.6) <code>rhs.is_&shy;open() == false</code>.</li></ul></p>
<p><pre class='itemdeclcode'>template&lt;class OtherProtocol, class OtherExecutor&gt;
  <del ><code>basic_&shy;</code></del>socket(<del ><code>basic_&shy;</code></del>socket&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);
</pre></p><p></p>
<p>-11- <em>Requires:</em><code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>

<p>-12- <em>Effects:</em>Move constructs an object of class <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;</code> that refers to the state originally represented by <code>rhs</code>.</p>

<p>-13- <em>Postconditions:</em>
<ul class='itemize'><li id='basic.cons-13.1'>(13.1) <code>get_&shy;executor() == rhs.get_&shy;executor()</code>.</li><li id='basic.cons-13.2'>(13.2) <code>is_&shy;open()</code> returns the same value as <code>rhs.is_&shy;open()</code> prior to the constructor invocation.</li><li id='basic.cons-13.3'>(13.3) <code>non_&shy;blocking()</code> returns the same value as <code>rhs.non_&shy;blocking()</code> prior to the constructor invocation.</li><li id='basic.cons-13.4'>(13.4) <code>native_&shy;handle()</code> returns the prior value of <code>rhs.native_&shy;handle()</code>.</li><li id='basic.cons-13.5'>(13.5) <code>protocol_&shy;</code> is the result of converting the prior value of <code>rhs.protocol_&shy;</code>.</li><li id='basic.cons-13.6'>(13.6) <code>rhs.is_&shy;open() == false</code>.</li></ul></p>

<p>-14- <em>Remarks:</em>This constructor shall not participate in overload resolution unless <code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>


<h4 >18.6.2 <code><del ><code>basic_&shy;</code></del>socket</code> destructor [socket.basic.dtor]</h4>

<p><pre class='itemdeclcode'>~<del ><code>basic_&shy;</code></del>socket();
</pre></p><p></p>
<p>-1- <em>Effects:</em>If <code>is_&shy;open()</code> is <code>true</code>, cancels all outstanding asynchronous operations associated with this socket, disables the linger socket option to prevent the destructor from blocking, and releases socket resources as if by POSIX <code>close(native_&shy;handle())</code>. Completion handlers for canceled operations are passed an error code <code>ec</code> such that <code>ec == errc&#x200b;::&#x200b;operation_&shy;canceled</code> yields <code>true</code>.</p>


<h4 >18.6.3 <code><del ><code>basic_&shy;</code></del>socket</code> assignment [socket.basic.assign]</h4>

<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket&amp; operator=(<del ><code>basic_&shy;</code></del>socket&amp;&amp; rhs);
</pre></p><p></p>
<p>-1- <em>Effects:</em>If <code>is_&shy;open()</code> is <code>true</code>, cancels all outstanding asynchronous operations associated with this socket. Completion handlers for canceled operations are passed an error code <code>ec</code> such that <code>ec == errc&#x200b;::&#x200b;operation_&shy;canceled</code> yields <code>true</code>. Disables the linger socket option to prevent the assignment from blocking, and releases socket resources as if by POSIX <code>close(native_&shy;handle())</code>. Moves into <code>*this</code> the state originally represented by <code>rhs</code>.</p>

<p>-2- <em>Postconditions:</em>
<ul class='itemize'><li id='basic.assign-2.1'>(2.1) <code>get_&shy;executor() == rhs.get_&shy;executor()</code>.</li><li id='basic.assign-2.2'>(2.2) <code>is_&shy;open()</code> returns the same value as <code>rhs.is_&shy;open()</code> prior to the assignment.</li><li id='basic.assign-2.3'>(2.3) <code>non_&shy;blocking()</code> returns the same value as <code>rhs.non_&shy;blocking()</code> prior to the assignment.</li><li id='basic.assign-2.4'>(2.4) <code>protocol_&shy;</code> is the prior value of <code>rhs.protocol_&shy;</code>.</li><li id='basic.assign-2.5'>(2.5) <code>rhs.is_&shy;open() == false</code>.</li></ul></p>

<p>-3- <em>Returns:</em><code>*this</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class OtherProtocol, class OtherExecutor&gt;
  <del ><code>basic_&shy;</code></del>socket&amp; operator=(<del ><code>basic_&shy;</code></del>socket&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);
</pre></p><p></p>
<p>-4- <em>Requires:</em><code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>

<p>-5- <em>Effects:</em>If <code>is_&shy;open()</code> is <code>true</code>, cancels all outstanding asynchronous operations associated with this socket. Completion handlers for canceled operations are passed an error code <code>ec</code> such that <code>ec == errc&#x200b;::&#x200b;operation_&shy;canceled</code> yields <code>true</code>. Disables the linger socket option to prevent the assignment from blocking, and releases socket resources as if by POSIX <code>close(native_&shy;handle())</code>. Moves into <code>*this</code> the state originally represented by <code>rhs</code>.</p>

<p>-6- <em>Postconditions:</em>
<ul class='itemize'><li id='basic.assign-6.1'>(6.1) <code>get_&shy;executor() == rhs.get_&shy;executor()</code>.</li><li id='basic.assign-6.2'>(6.2) <code>is_&shy;open()</code> returns the same value as <code>rhs.is_&shy;open()</code> prior to the assignment.</li><li id='basic.assign-6.3'>(6.3) <code>non_&shy;blocking()</code> returns the same value as <code>rhs.non_&shy;blocking()</code> prior to the assignment.</li><li id='basic.assign-6.4'>(6.4) <code>protocol_&shy;</code> is the result of converting the prior value of <code>rhs.protocol_&shy;</code>.</li><li id='basic.assign-6.5'>(6.5) <code>rhs.is_&shy;open() == false</code>.</li></ul></p>

<p>-7- <em>Returns:</em><code>*this</code>.</p>

<p>-8- <em>Remarks:</em>This assignment operator shall not participate in overload resolution unless <code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>

<h4 >18.6.4 <code><del ><code>basic_&shy;</code></del>socket</code> operations [socket.basic.ops]</h4>

<p><em>[...]</em></p>

<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,
remove the <code>basic_</code> prefixes
from <b>-18.7- Class <code>basic_&shy;datagram_&shy;socket</code> [socket.dgram]</b>:</em></p>
</div>

<h4>18.7 Class template <code><del >basic_&shy;</del>datagram_&shy;socket</code> [socket.dgram]</h4>

<p>-1- The class template <code><del >basic_&shy;</del>datagram_&shy;socket&lt;Protocol, Executor&gt;</code> is used to send and receive discrete messages of fixed maximum length.<pre class='codeblock'>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {

  template&lt;class Protocol, class Executor&gt;
  class <del >basic_&shy;</del>datagram_socket : public <del >basic_&shy;</del>socket&lt;Protocol, Executor&gt;
  {
  public:
    // types:

    using executor_type = Executor;
    using native_handle_type = <em>implementation-defined</em>; // see [socket.reqmts.native]
    using protocol_type = Protocol;
    using endpoint_type = typename protocol_type::endpoint;

    template&lt;class OtherExecutor&gt;
    using rebind_executor =
      <del >basic_&shy;</del>datagram_socket&lt;Protocol, OtherExecutor&gt;;

    // [socket.dgram.cons], construct / copy / destroy:

    explicit <del >basic_&shy;</del>datagram_socket(const executor_type&amp; ex);
    template&lt;class ExecutionContext&gt;
      explicit <del >basic_&shy;</del>datagram_socket(ExecutionContext&amp; ctx);
    <del >basic_&shy;</del>datagram_socket(const executor_type&amp; ex, const protocol_type&amp; protocol);
    template&lt;class ExecutionContext&gt;
      <del >basic_&shy;</del>datagram_socket(ExecutionContext&amp; ctx, const protocol_type&amp; protocol);
    <del >basic_&shy;</del>datagram_socket(const executor_type&amp; ex, const endpoint_type&amp; endpoint);
    template&lt;class ExecutionContext&gt;
      <del >basic_&shy;</del>datagram_socket(ExecutionContext&amp; ctx, const endpoint_type&amp; endpoint);
    <del >basic_&shy;</del>datagram_socket(const executor_type&amp; ex, const protocol_type&amp; protocol,
                          const native_handle_type&amp; native_socket);
    template&lt;class ExecutionContext&gt;
      <del >basic_&shy;</del>datagram_socket(ExecutionContext&amp; ctx, const protocol_type&amp; protocol,
                            const native_handle_type&amp; native_socket);
    <del >basic_&shy;</del>datagram_socket(const <del >basic_&shy;</del>datagram_socket&amp;) = delete;
    <del >basic_&shy;</del>datagram_socket(<del >basic_&shy;</del>datagram_socket&amp;&amp; rhs);
    template&lt;class OtherProtocol, class OtherExecutor&gt;
      <del >basic_&shy;</del>datagram_socket(<del >basic_&shy;</del>datagram_socket&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);

    ~<del >basic_&shy;</del>datagram_socket();

    <del >basic_&shy;</del>datagram_socket&amp; operator=(const <del >basic_&shy;</del>datagram_socket&amp;) = delete;
    <del >basic_&shy;</del>datagram_socket&amp; operator=(<del >basic_&shy;</del>datagram_socket&amp;&amp; rhs);
    template&lt;class OtherProtocol, class OtherExecutor&gt;
      <del >basic_&shy;</del>datagram_socket&amp; operator=(<del >basic_&shy;</del>datagram_socket&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);

    // [socket.dgram.op], <del >basic_&shy;</del>datagram_socket operations:
</pre>
<p><em>[...]</em></p>
<pre>
  };

} // inline namespace v1
} // namespace net
} // namespace experimental
} // namespace std
</pre></p>

<p>-2- Instances of class template <code><del ><code>basic_&shy;</code></del>datagram_&shy;socket</code> meet the requirements of <code>Destructible</code> (C++2014[destructible]), <code>MoveConstructible</code> (C++2014[moveconstructible]), and <code>MoveAssignable</code> (C++2014[moveassignable]).</p>

<p>-3- If a program performs a synchronous operation on this socket, other than <code>close</code>, <code>cancel</code>, <code>shutdown</code>, <code>send</code>, or <code>send_&shy;to</code>, while there is an outstanding asynchronous read operation, the behavior is undefined.</p>

<p>-4- If a program performs a synchronous operation on this socket, other than <code>close</code>, <code>cancel</code>, <code>shutdown</code>, <code>receive</code>, or <code>receive_&shy;from</code>, while there is an outstanding asynchronous write operation, the behavior is undefined.</p>

<p>-5- When an operation has its effects specified as if by passing the result of <code>native_&shy;handle()</code> to a POSIX function, then the operation fails with error condition <code>errc&#x200b;::&#x200b;bad_&shy;file_&shy;descriptor</code> if <code>is_&shy;open() == false</code> at the point in the effects when the POSIX function is called.</p>

<p>-6- If <code>native_&shy;handle_&shy;type</code> and <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&#x200b;::&#x200b;native_&shy;handle_&shy;type</code>
are both defined then they name the same type.</p>
<h4 >18.7.1 <code><del ><code>basic_&shy;</code></del>datagram_&shy;socket</code> constructors [socket.dgram.cons]</h4>

<p><pre class='itemdeclcode'>explicit <del ><code>basic_&shy;</code></del>datagram_socket(const executor_type&amp; ex);
</pre></p><p></p>
<p>-1- <em>Effects:</em>Initializes the base class with <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;(ex)</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  explicit <del ><code>basic_&shy;</code></del>datagram_socket(ExecutionContext&amp; ctx);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>datagram_&shy;socket(ctx.get_&shy;executor()).</code></p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>datagram_socket(const executor_type&amp; ex, const protocol_type&amp; protocol);
</pre></p><p></p>
<p>-2- <em>Effects:</em>Initializes the base class with <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;(ctx, protocol)</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  explicit <del ><code>basic_&shy;</code></del>datagram_socket(ExecutionContext&amp; ctx, const protocol_type&amp; protocol);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>datagram_&shy;socket(ctx.get_&shy;executor(), protocol).</code></p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>datagram_socket(const executor_type&amp; ex, const endpoint_type&amp; endpoint);
</pre></p><p></p>
<p>-3- <em>Effects:</em>Initializes the base class with <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;(ctx, endpoint)</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  explicit <del ><code>basic_&shy;</code></del>datagram_socket(ExecutionContext&amp; ctx, const endpoint_type&amp; endpoint);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>datagram_&shy;socket(ctx.get_&shy;executor(), endpoint).</code></p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>datagram_socket(io_context&amp; ctx, const protocol_type&amp; protocol,
                      const native_handle_type&amp; native_socket);
</pre></p><p></p>
<p>-4- <em>Effects:</em>Initializes the base class with <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;(ctx, protocol, native_&shy;socket)</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  <del ><code>basic_&shy;</code></del>datagram_socket(ExecutionContext&amp; ctx, const protocol_type&amp; protocol,
                        const native_handle_type&amp; native_socket);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>datagram_&shy;socket(ctx.get_&shy;executor(), protocol, native_&shy;socket).</code></p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>datagram_socket(<del ><code>basic_&shy;</code></del>datagram_socket&amp;&amp; rhs);
</pre></p><p></p>
<p>-5- <em>Effects:</em>Move constructs an object of class <code><del ><code>basic_&shy;</code></del>datagram_&shy;socket&lt;Protocol, Executor&gt;</code>, initializing the base class with <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;(std&#x200b;::&#x200b;move(rhs))</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class OtherProtocol, class OtherExecutor&gt;
  <del ><code>basic_&shy;</code></del>datagram_socket(<del ><code>basic_&shy;</code></del>datagram_socket&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);
</pre></p><p></p>
<p>-6- <em>Requires:</em><code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>

<p>-7- <em>Effects:</em>Move constructs an object of class <code><del ><code>basic_&shy;</code></del>datagram_&shy;socket&lt;Protocol, Executor&gt;</code>, initializing the base class with <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;(std&#x200b;::&#x200b;move(rhs))</code>.</p>

<p>-8- <em>Remarks:</em>This constructor shall not participate in overload resolution unless <code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>


<h4 >18.7.2 <code><del ><code>basic_&shy;</code></del>datagram_&shy;socket</code> assignment [socket.dgram.assign]</h4>

<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>datagram_socket&amp; operator=(<del ><code>basic_&shy;</code></del>datagram_socket&amp;&amp; rhs);
</pre></p><p></p>
<p>-1- <em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&#x200b;::&#x200b;operator=(std&#x200b;::&#x200b;move(rhs))</code>.</p>

<p>-2- <em>Returns:</em><code>*this</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class OtherProtocol, class OtherExecutor&gt;
  <del ><code>basic_&shy;</code></del>datagram_socket&amp; operator=(<del ><code>basic_&shy;</code></del>datagram_socket&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);
</pre></p><p></p>
<p>-3- <em>Requires:</em><code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>

<p>-4- <em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&#x200b;::&#x200b;operator=(std&#x200b;::&#x200b;move(rhs))</code>.</p>

<p>-5- <em>Returns:</em><code>*this</code>.</p>

<p>-6- <em>Remarks:</em>This assignment operator not participate in overload resolution unless <code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>


<h4 >18.7.3 <code><del ><code>basic_&shy;</code></del>datagram_&shy;socket</code> operations [socket.dgram.op]</h4>

<p><em>[...]</em></p>

<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,
remove the <code>basic_</code> prefixes
from <b>-18.8- Class <code>basic_&shy;stream_&shy;socket</code> [socket.stream]</b>:</em></p>
</div>

<h4>18.8 Class template <code><del >basic_&shy;</del>stream_&shy;socket</code> [socket.stream]</h4>

<p>-1- The class template <code><del >basic_&shy;</del>stream_&shy;socket&lt;Protocol, Executor&gt;</code> is used to exchange data with a peer over a sequenced, reliable, bidirectional, connection-mode byte stream.<pre class='codeblock'>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {

  template&lt;class Protocol, class Executor&gt;
  class <del >basic_&shy;</del>stream_socket : public <del >basic_&shy;</del>socket&lt;Protocol, Executor&gt;
  {
  public:
    // types:

    using executor_type = Executor;
    using native_handle_type = <em>implementation-defined</em>; // see [socket.reqmts.native]
    using protocol_type = Protocol;
    using endpoint_type = typename protocol_type::endpoint;

    template&lt;class OtherExecutor&gt;
    using rebind_executor =
      <del >basic_&shy;</del>stream_socket&lt;Protocol, OtherExecutor&gt;;

    // [socket.stream.cons], construct / copy / destroy:

    explicit <del >basic_&shy;</del>stream_socket(const executor_type&amp; ex);
    template&lt;class ExecutionContext&gt;
      explicit <del >basic_&shy;</del>stream_socket(ExecutionContext&amp; ctx);
    <del >basic_&shy;</del>stream_socket(const executor_type&amp; ex, const protocol_type&amp; protocol);
    template&lt;class ExecutionContext&gt;
      <del >basic_&shy;</del>stream_socket(ExecutionContext&amp; ctx, const protocol_type&amp; protocol);
    <del >basic_&shy;</del>stream_socket(const executor_type&amp; ex, const endpoint_type&amp; endpoint);
    template&lt;class ExecutionContext&gt;
      <del >basic_&shy;</del>stream_socket(ExecutionContext&amp; ctx, const endpoint_type&amp; endpoint);
    <del >basic_&shy;</del>stream_socket(const executor_type&amp; ex, const protocol_type&amp; protocol,
                        const native_handle_type&amp; native_socket);
    template&lt;class ExecutionContext&gt;
      <del >basic_&shy;</del>stream_socket(ExecutionContext&amp; ctx, const protocol_type&amp; protocol,
                          const native_handle_type&amp; native_socket);
    <del >basic_&shy;</del>stream_socket(const <del >basic_&shy;</del>stream_socket&amp;) = delete;
    <del >basic_&shy;</del>stream_socket(<del >basic_&shy;</del>stream_socket&amp;&amp; rhs);
    template&lt;class OtherProtocol, class OtherExecutor&gt;
      <del >basic_&shy;</del>stream_socket(<del >basic_&shy;</del>stream_socket&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);

    ~<del >basic_&shy;</del>stream_socket();

    <del >basic_&shy;</del>stream_socket&amp; operator=(const <del >basic_&shy;</del>stream_socket&amp;) = delete;
    <del >basic_&shy;</del>stream_socket&amp; operator=(<del >basic_&shy;</del>stream_socket&amp;&amp; rhs);
    template&lt;class OtherProtocol, class OtherExecutor&gt;
      <del >basic_&shy;</del>stream_socket&amp; operator=(<del >basic_&shy;</del>stream_socket&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);

    // [socket.stream.ops], <del >basic_&shy;</del>stream_socket operations:
</pre>
<p><em>[...]</em></p>
<pre>
  };

} // inline namespace v1
} // namespace net
} // namespace experimental
} // namespace std
</pre></p>

<p>-2- Instances of class template <code><del ><code>basic_&shy;</code></del>stream_&shy;socket</code> meet the requirements of <code>Destructible</code> (C++2014[destructible]), <code>MoveConstructible</code> (C++2014[moveconstructible]), <code>MoveAssignable</code> (C++2014[moveassignable]), <code>SyncReadStream</code> ([buffer.stream.reqmts.syncreadstream]), <code>SyncWriteStream</code> ([buffer.stream.reqmts.syncwritestream]), <code>AsyncReadStream</code> ([buffer.stream.reqmts.asyncreadstream]), and <code>AsyncWriteStream</code> ([buffer.stream.reqmts.asyncwritestream]).</p>

<p>-3- If a program performs a synchronous operation on this socket, other than <code>close</code>, <code>cancel</code>, <code>shutdown</code>, or <code>send</code>, while there is an outstanding asynchronous read operation, the behavior is undefined.</p>

<p>-4- If a program performs a synchronous operation on this socket, other than <code>close</code>, <code>cancel</code>, <code>shutdown</code>, or <code>receive</code>, while there is an outstanding asynchronous write operation, the behavior is undefined.</p>

<p>-5- When an operation has its effects specified as if by passing the result of <code>native_&shy;handle()</code> to a POSIX function, then the operation fails with error condition <code>errc&#x200b;::&#x200b;bad_&shy;file_&shy;descriptor</code> if <code>is_&shy;open() == false</code> at the point in the effects when the POSIX function is called.</p>

<p>-6- If <code>native_&shy;handle_&shy;type</code> and <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&#x200b;::&#x200b;native_&shy;handle_&shy;type</code>
are both defined then they name the same type.</p>
<h4 >18.8.1 <code><del ><code>basic_&shy;</code></del>stream_&shy;socket</code> constructors [socket.stream.cons]</h4>

<p><pre class='itemdeclcode'>explicit <del ><code>basic_&shy;</code></del>stream_socket(const executor_type&amp; ex);
</pre></p><p></p>
<p>-1- <em>Effects:</em>Initializes the base class with <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;(ctx)</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  explicit <del ><code>basic_&shy;</code></del>stream_socket(ExecutionContext&amp; ctx);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>stream_&shy;socket(ctx.get_&shy;executor()).</code></p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>stream_socket(const executor_type&amp; ex, const protocol_type&amp; protocol);
</pre></p><p></p>
<p>-2- <em>Effects:</em>Initializes the base class with <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;(ctx, protocol)</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  explicit <del ><code>basic_&shy;</code></del>stream_socket(ExecutionContext&amp; ctx, const protocol_type&amp; protocol);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>stream_&shy;socket(ctx.get_&shy;executor(), protocol)</code>.</p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>stream_socket(const executor_type&amp; ex, const endpoint_type&amp; endpoint);
</pre></p><p></p>
<p>-3- <em>Effects:</em>Initializes the base class with <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;(ctx, endpoint)</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  explicit <del ><code>basic_&shy;</code></del>stream_socket(ExecutionContext&amp; ctx, const endpoint_type&amp; endpoint);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>stream_&shy;socket(ctx.get_&shy;executor(), endpoint)</code>.</p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>stream_socket(const executor_type&amp; ex, const protocol_type&amp; protocol,
                    const native_handle_type&amp; native_socket);
</pre></p><p></p>
<p>-4- <em>Effects:</em>Initializes the base class with <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;(ctx, protocol, native_&shy;socket)</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  <del ><code>basic_&shy;</code></del>stream_socket(ExecutionContext&amp; ctx, const protocol_type&amp; protocol,
                      const native_handle_type&amp; native_socket);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>stream_&shy;socket(ctx.get_&shy;executor(), protocol, native_&shy;socket)</code>.</p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>stream_socket(<del ><code>basic_&shy;</code></del>stream_socket&amp;&amp; rhs);
</pre></p><p></p>
<p>-5- <em>Effects:</em>Move constructs an object of class <code><del ><code>basic_&shy;</code></del>stream_&shy;socket&lt;Protocol, Executor&gt;</code>, initializing the base class with <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;(std&#x200b;::&#x200b;move(rhs))</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class OtherProtocol, class OtherExecutor&gt;
  <del ><code>basic_&shy;</code></del>stream_socket(<del ><code>basic_&shy;</code></del>stream_socket&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);
</pre></p><p></p>
<p>-6- <em>Requires:</em><code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>

<p>-7- <em>Effects:</em>Move constructs an object of class <code><del ><code>basic_&shy;</code></del>stream_&shy;socket&lt;Protocol, Executor&gt;</code>, initializing the base class with <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;(std&#x200b;::&#x200b;move(rhs))</code>.</p>

<p>-8- <em>Remarks:</em>This constructor shall not participate in overload resolution unless <code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>


<h4 >18.8.2 <code><del ><code>basic_&shy;</code></del>stream_&shy;socket</code> assignment [socket.stream.assign]</h4>

<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>stream_socket&amp; operator=(<del ><code>basic_&shy;</code></del>stream_socket&amp;&amp; rhs);
</pre></p><p></p>
<p>-1- <em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&#x200b;::&#x200b;operator=(std&#x200b;::&#x200b;move(rhs))</code>.</p>

<p>-2- <em>Returns:</em><code>*this</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class OtherProtocol, class OtherExecutor&gt;
  <del ><code>basic_&shy;</code></del>stream_socket&amp; operator=(<del ><code>basic_&shy;</code></del>stream_socket&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);
</pre></p><p></p>
<p>-3- <em>Requires:</em><code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>

<p>-4- <em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&#x200b;::&#x200b;operator=(std&#x200b;::&#x200b;move(rhs))</code>.</p>

<p>-5- <em>Returns:</em><code>*this</code>.</p>

<p>-6- <em>Remarks:</em>This assignment operator shall not participate in overload resolution unless <code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>


<h4 >18.8.3 <code><del ><code>basic_&shy;</code></del>stream_&shy;socket</code> operations [socket.stream.ops]</h4>

<p><em>[...]</em></p>

<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,
remove the <code>basic_</code> prefixes
from <b>-18.9- Class <code>basic_&shy;socket_&shy;acceptor</code> [socket.acceptor]</b>:</em></p>
</div>

<h4>18.9 Class template <code><del >basic_&shy;</del>socket_&shy;acceptor</code> [socket.acceptor]</h4>

<p>-1- An object of class template <code><del >basic_&shy;</del>socket_&shy;acceptor&lt;AcceptableProtocol, Executor&gt;</code> is used to listen for, and queue, incoming socket connections. Socket objects that represent the incoming connections are dequeued by calling <code>accept</code> or <code>async_&shy;accept</code>.<pre class='codeblock'>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {

  template&lt;class AcceptableProtocol, class Executor&gt;
  class <del >basic_&shy;</del>socket_acceptor : public socket_base
  {
  public:
    // types:

    using executor_type = Executor;
    using native_handle_type = <em>implementation-defined</em>; // see [socket.reqmts.native]
    using protocol_type = AcceptableProtocol;
    using endpoint_type = typename protocol_type::endpoint;
    using socket_type = typename protocol_type::socket<ins >_&shy;for&lt;executor_&shy;type&gt;</ins>;
    template&lt;class OtherExecutor&gt;
    using socket_type_for
      = typename protocol_type::socket_for&lt;OtherExecutor&gt;;

    template&lt;class OtherExecutor&gt;
    using rebind_executor =
      <del >basic_&shy;</del>socket_acceptor&lt;AcceptableProtocol, OtherExecutor&gt;;

    // [socket.acceptor.cons], construct / copy / destroy:

    explicit <del >basic_&shy;</del>socket_acceptor(const executor_type&amp; ex);
    template&lt;class ExecutionContext&gt;
      explicit <del >basic_&shy;</del>socket_acceptor(ExecutionContext&amp; ctx);
    <del >basic_&shy;</del>socket_acceptor(const executor_type&amp; ex, const protocol_type&amp; protocol);
    template&lt;class ExecutionContext&gt;
      <del >basic_&shy;</del>socket_acceptor(ExecutionContext&amp; ctx, const protocol_type&amp; protocol);
    <del >basic_&shy;</del>socket_acceptor(const executor_type&amp; ex, const endpoint_type&amp; endpoint,
                          bool reuse_addr = true);
    template&lt;class ExecutionContext&gt;
      <del >basic_&shy;</del>socket_acceptor(ExecutionContext&amp; ctx, const endpoint_type&amp; endpoint,
                            bool reuse_addr = true);
    <del >basic_&shy;</del>socket_acceptor(const executor_type&amp; ex, const protocol_type&amp; protocol,
                          const native_handle_type&amp; native_socket);
    template&lt;class ExecutionContext&gt;
      <del >basic_&shy;</del>socket_acceptor(ExecutionContext&amp; ctx, const protocol_type&amp; protocol,
                            const native_handle_type&amp; native_socket);
    <del >basic_&shy;</del>socket_acceptor(const <del >basic_&shy;</del>socket_acceptor&amp;) = delete;
    <del >basic_&shy;</del>socket_acceptor(<del >basic_&shy;</del>socket_acceptor&amp;&amp; rhs);
    template&lt;class OtherProtocol, class OtherExecutor&gt;
      <del >basic_&shy;</del>socket_acceptor(<del >basic_&shy;</del>socket_acceptor&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);

    ~<del >basic_&shy;</del>socket_acceptor();

    <del >basic_&shy;</del>socket_acceptor&amp; operator=(const <del >basic_&shy;</del>socket_acceptor&amp;) = delete;
    <del >basic_&shy;</del>socket_acceptor&amp; operator=(<del >basic_&shy;</del>socket_acceptor&amp;&amp; rhs);
    template&lt;class OtherProtocol, class OtherExecutor&gt;
      <del >basic_&shy;</del>socket_acceptor&amp; operator=(<del >basic_&shy;</del>socket_acceptor&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);

    // [socket.acceptor.ops], <del >basic_&shy;</del>socket_acceptor operations:
</pre>
<p><em>[...]</em></p>
<pre>
  };

} // inline namespace v1
} // namespace net
} // namespace experimental
} // namespace std
</pre></p>

<p>-2- Instances of class template <code><del ><code>basic_&shy;</code></del>socket_&shy;acceptor</code> meet the requirements of <code>Destructible</code> (C++2014[destructible]), <code>MoveConstructible</code> (C++2014[moveconstructible]), and <code>MoveAssignable</code> (C++2014[moveassignable]).</p>

<p>-3- When there are multiple outstanding asynchronous accept operations the order in which the incoming connections are dequeued, and the order of invocation of the completion handlers for these operations, is unspecified.</p>

<p>-4- When an operation has its effects specified as if by passing the result of <code>native_&shy;handle()</code> to a POSIX function, then the operation fails with error condition <code>errc&#x200b;::&#x200b;bad_&shy;file_&shy;descriptor</code> if <code>is_&shy;open() == false</code> at the point in the effects when the POSIX function is called.</p>
<h4 >18.9.1 <code><del ><code>basic_&shy;</code></del>socket_&shy;acceptor</code> constructors [socket.acceptor.cons]</h4>

<p><pre class='itemdeclcode'>explicit <del ><code>basic_&shy;</code></del>socket_acceptor(const executor_type&amp; ex);
</pre></p><p></p>
<p>-1- <em>Postconditions:</em>
<ul class='itemize'><li id='acceptor.cons-1.1'>(1.1) <code>get_&shy;executor() == ex</code>.</li><li id='acceptor.cons-1.2'>(1.2) <code>is_&shy;open() == false</code>.</li></ul></p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  explicit <del ><code>basic_&shy;</code></del>socket_acceptor(ExecutionContext&amp; ctx);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>socket_&shy;acceptor(ctx.get_&shy;executor())</code>.</p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket_acceptor(const executor_type&amp; ex, const protocol_type&amp; protocol);
</pre></p><p></p>
<p>-2- <em>Effects:</em>Opens this acceptor as if by calling <code>open(protocol)</code>.</p>

<p>-3- <em>Postconditions:</em>
<ul class='itemize'><li id='acceptor.cons-3.1'>(3.1) <code>get_&shy;executor() == ex</code>.</li><li id='acceptor.cons-3.2'>(3.2) <code>is_&shy;open() == true</code>.</li><li id='acceptor.cons-3.3'>(3.3) <code>non_&shy;blocking() == false</code>.</li><li id='acceptor.cons-3.4'>(3.4) <code>enable_&shy;connection_&shy;aborted() == false</code>.</li><li id='acceptor.cons-3.5'>(3.5) <code>protocol_&shy; == protocol</code>.</li></ul></p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  explicit <del ><code>basic_&shy;</code></del>socket_acceptor(ExecutionContext&amp; ctx, const protocol_type&amp; protocol);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>socket_&shy;acceptor(ctx.get_&shy;executor(), protocol)</code>.</p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket_acceptor(const executor_type&amp; ex, const endpoint_type&amp; endpoint,
                      bool reuse_addr = true);
</pre></p><p></p>
<p>-4- <em>Effects:</em>Opens and binds this acceptor as if by calling:
<pre class='codeblock'>
open(endpoint.protocol());
if (reuse_addr)
  set_option(reuse_address(true));
bind(endpoint);
listen();
</pre></p>

<p>-5- <em>Postconditions:</em>
<ul class='itemize'><li id='acceptor.cons-5.1'>(5.1) <code>get_&shy;executor() == ex</code>.</li><li id='acceptor.cons-5.2'>(5.2) <code>is_&shy;open() == true</code>.</li><li id='acceptor.cons-5.3'>(5.3) <code>non_&shy;blocking() == false</code>.</li><li id='acceptor.cons-5.4'>(5.4) <code>enable_&shy;connection_&shy;aborted() == false</code>.</li><li id='acceptor.cons-5.5'>(5.5) <code>protocol_&shy; == endpoint.protocol()</code>.</li></ul></p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  explicit <del ><code>basic_&shy;</code></del>socket_acceptor(ExecutionContext&amp; ctx, const endpoint_type&amp; endpoint,
                                 bool reuse_addr = true);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>socket_&shy;acceptor(ctx.get_&shy;executor(), endpoint, reuse_&shy;addr)</code>.</p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket_acceptor(const executor_type&amp; ex, const protocol_type&amp; protocol,
                      const native_handle_type&amp; native_acceptor);
</pre></p><p></p>
<p>-6- <em>Requires:</em><code>native_&shy;acceptor</code> is a native handle to an open acceptor.</p>

<p>-7- <em>Effects:</em>Assigns the existing native acceptor into this acceptor as if by calling <code>assign(protocol, native_&shy;acceptor)</code>.</p>

<p>-8- <em>Postconditions:</em>
<ul class='itemize'><li id='acceptor.cons-8.1'>(8.1) <code>get_&shy;executor() == ex</code>.</li><li id='acceptor.cons-8.2'>(8.2) <code>is_&shy;open() == true</code>.</li><li id='acceptor.cons-8.3'>(8.3) <code>non_&shy;blocking() == false</code>.</li><li id='acceptor.cons-8.4'>(8.4) <code>enable_&shy;connection_&shy;aborted() == false</code>.</li><li id='acceptor.cons-8.5'>(8.5) <code>protocol_&shy; == protocol</code>.</li></ul></p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt;
  <del ><code>basic_&shy;</code></del>socket_acceptor(ExecutionContext&amp; ctx, const protocol_type&amp; protocol,
                        const native_handle_type&amp; native_socket);
</pre></p><p></p><p><em>Effects:</em>Equivalent to <code><del ><code>basic_&shy;</code></del>socket_&shy;acceptor(ctx.get_&shy;executor(), protocol, native_&shy;socket)</code>.</p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket_acceptor(<del ><code>basic_&shy;</code></del>socket_acceptor&amp;&amp; rhs);
</pre></p><p></p>
<p>-9- <em>Effects:</em>Move constructs an object of class <code><del ><code>basic_&shy;</code></del>socket_&shy;acceptor&lt;AcceptableProtocol, Executor&gt;</code> that refers to the state originally represented by <code>rhs</code>.</p>

<p>-10- <em>Postconditions:</em>
<ul class='itemize'><li id='acceptor.cons-10.1'>(10.1) <code>get_&shy;executor() == rhs.get_&shy;executor()</code>.</li><li id='acceptor.cons-10.2'>(10.2) <code>is_&shy;open()</code> returns the same value as <code>rhs.is_&shy;open()</code> prior to the constructor invocation.</li><li id='acceptor.cons-10.3'>(10.3) <code>non_&shy;blocking()</code> returns the same value as <code>rhs.non_&shy;blocking()</code> prior to the constructor invocation.</li><li id='acceptor.cons-10.4'>(10.4) <code>enable_&shy;connection_&shy;aborted()</code> returns the same value as <code>rhs.enable_&shy;connection_&shy;aborted()</code> prior to the constructor invocation.</li><li id='acceptor.cons-10.5'>(10.5) <code>native_&shy;handle()</code> returns the same value as <code>rhs.native_&shy;handle()</code> prior to the constructor invocation.</li><li id='acceptor.cons-10.6'>(10.6) <code>protocol_&shy;</code> is equal to the prior value of <code>rhs.protocol_&shy;</code>.</li><li id='acceptor.cons-10.7'>(10.7) <code>rhs.is_&shy;open() == false</code>.</li></ul></p>
<p><pre class='itemdeclcode'>template&lt;class OtherProtocol, class OtherExecutor&gt;
  <del ><code>basic_&shy;</code></del>socket_acceptor(<del ><code>basic_&shy;</code></del>socket_acceptor&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);
</pre></p><p></p>
<p>-11- <em>Requires:</em><code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>

<p>-12- <em>Effects:</em>Move constructs an object of class <code><del ><code>basic_&shy;</code></del>socket_&shy;acceptor&lt;AcceptableProtocol, Executor&gt;</code> that refers to the state originally represented by <code>rhs</code>.</p>

<p>-13- <em>Postconditions:</em>
<ul class='itemize'><li id='acceptor.cons-13.1'>(13.1) <code>get_&shy;executor() == rhs.get_&shy;executor()</code>.</li><li id='acceptor.cons-13.2'>(13.2) <code>is_&shy;open()</code> returns the same value as <code>rhs.is_&shy;open()</code> prior to the constructor invocation.</li><li id='acceptor.cons-13.3'>(13.3) <code>non_&shy;blocking()</code> returns the same value as <code>rhs.non_&shy;blocking()</code> prior to the constructor invocation.</li><li id='acceptor.cons-13.4'>(13.4) <code>enable_&shy;connection_&shy;aborted()</code> returns the same value as <code>rhs.enable_&shy;connection_&shy;aborted()</code> prior to the constructor invocation.</li><li id='acceptor.cons-13.5'>(13.5) <code>native_&shy;handle()</code> returns the prior value of <code>rhs.native_&shy;handle()</code>.</li><li id='acceptor.cons-13.6'>(13.6) <code>protocol_&shy;</code> is the result of converting the prior value of <code>rhs.protocol_&shy;</code>.</li><li id='acceptor.cons-13.7'>(13.7) <code>rhs.is_&shy;open() == false</code>.</li></ul></p>

<p>-14- <em>Remarks:</em>This constructor shall not participate in overload resolution unless <code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>


<h4 >18.9.2 <code><del ><code>basic_&shy;</code></del>socket_&shy;acceptor</code> destructor [socket.acceptor.dtor]</h4>

<p><pre class='itemdeclcode'>~<del ><code>basic_&shy;</code></del>socket_acceptor();
</pre></p><p></p>
<p>-1- <em>Effects:</em>If <code>is_&shy;open()</code> is <code>true</code>, cancels all outstanding asynchronous operations associated with this acceptor, and releases acceptor resources as if by POSIX <code>close(native_&shy;handle())</code>. Completion handlers for canceled operations are passed an error code <code>ec</code> such that <code>ec == errc&#x200b;::&#x200b;operation_&shy;canceled</code> yields <code>true</code>.</p>


<h4 >18.9.3 <code><del ><code>basic_&shy;</code></del>socket_&shy;acceptor</code> assignment [socket.acceptor.assign]</h4>

<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket_acceptor&amp; operator=(<del ><code>basic_&shy;</code></del>socket_acceptor&amp;&amp; rhs);
</pre></p><p></p>
<p>-1- <em>Effects:</em>If <code>is_&shy;open()</code> is <code>true</code>, cancels all outstanding asynchronous operations associated with this acceptor, and releases acceptor resources as if by POSIX <code>close(native_&shy;handle())</code>. Then moves into <code>*this</code> the state originally represented by <code>rhs</code>. Completion handlers for canceled operations are passed an error code <code>ec</code> such that <code>ec == errc&#x200b;::&#x200b;operation_&shy;canceled</code> yields <code>true</code>.</p>

<p>-2- <em>Postconditions:</em>
<ul class='itemize'><li id='acceptor.assign-2.1'>(2.1) <code>get_&shy;executor() == rhs.get_&shy;executor()</code>.</li><li id='acceptor.assign-2.2'>(2.2) <code>is_&shy;open()</code> returns the same value as <code>rhs.is_&shy;open()</code> prior to the assignment.</li><li id='acceptor.assign-2.3'>(2.3) <code>non_&shy;blocking()</code> returns the same value as <code>rhs.non_&shy;blocking()</code> prior to the assignment.</li><li id='acceptor.assign-2.4'>(2.4) <code>enable_&shy;connection_&shy;aborted()</code> returns the same value as <code>rhs.enable_&shy;connection_&shy;aborted()</code> prior to the assignment.</li><li id='acceptor.assign-2.5'>(2.5) <code>native_&shy;handle()</code> returns the same value as <code>rhs.native_&shy;handle()</code> prior to the assignment.</li><li id='acceptor.assign-2.6'>(2.6) <code>protocol_&shy;</code> is the same value as <code>rhs.protocol_&shy;</code> prior to the assignment.</li><li id='acceptor.assign-2.7'>(2.7) <code>rhs.is_&shy;open() == false</code>.</li></ul></p>

<p>-3- <em>Returns:</em><code>*this</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class OtherProtocol, class OtherExecutor&gt;
  <del ><code>basic_&shy;</code></del>socket_acceptor&amp; operator=(<del ><code>basic_&shy;</code></del>socket_acceptor&lt;OtherProtocol, OtherExecutor&gt;&amp;&amp; rhs);
</pre></p><p></p>
<p>-4- <em>Requires:</em><code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>

<p>-5- <em>Effects:</em>If <code>is_&shy;open()</code> is <code>true</code>, cancels all outstanding asynchronous operations associated with this acceptor, and releases acceptor resources as if by POSIX <code>close(native_&shy;handle())</code>. Then moves into <code>*this</code> the state originally represented by <code>rhs</code>. Completion handlers for canceled operations are passed an error code <code>ec</code> such that <code>ec == errc&#x200b;::&#x200b;operation_&shy;canceled</code> yields <code>true</code>.</p>

<p>-6- <em>Postconditions:</em>
<ul class='itemize'><li id='acceptor.assign-6.1'>(6.1) <code>get_&shy;executor() == rhs.get_&shy;executor()</code>.</li><li id='acceptor.assign-6.2'>(6.2) <code>is_&shy;open()</code> returns the same value as <code>rhs.is_&shy;open()</code> prior to the assignment.</li><li id='acceptor.assign-6.3'>(6.3) <code>non_&shy;blocking()</code> returns the same value as <code>rhs.non_&shy;blocking()</code> prior to the assignment.</li><li id='acceptor.assign-6.4'>(6.4) <code>enable_&shy;connection_&shy;aborted()</code> returns the same value as <code>rhs.enable_&shy;connection_&shy;aborted()</code> prior to the assignment.</li><li id='acceptor.assign-6.5'>(6.5) <code>native_&shy;handle()</code> returns the same value as <code>rhs.native_&shy;handle()</code> prior to the assignment.</li><li id='acceptor.assign-6.6'>(6.6) <code>protocol_&shy;</code> is the result of converting the value of <code>rhs.protocol_&shy;</code> prior to the assignment.</li><li id='acceptor.assign-6.7'>(6.7) <code>rhs.is_&shy;open() == false</code>.</li></ul></p>

<p>-7- <em>Returns:</em><code>*this</code>.</p>

<p>-8- <em>Remarks:</em>This assignment operator shall not participate in overload resolution unless <code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code> and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>

<h4 >18.9.4 <code><del ><code>basic_&shy;</code></del>socket_&shy;acceptor</code> operations [socket.acceptor.ops]</h4>

<p><em>[...]</em></p>

<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,</p>
<ul>
<li>use <code>io_context::executor_type</code> as the default for the iostream class templates' <code>Executor</code> template parameters,</li>
<li>use the <code>protocol_type</code>'s <code>resolver_for</code> type alias instead of <code>resolver</code>, and</li>
<li>remove the <code>basic_</code> prefixes</li>
</ul>
<p>in <b>-19.1- Class template <code>basic_&shy;socket_&shy;streambuf</code> [socket.streambuf]</b>:</em></p>
</div>

<h4>19.1 Class template <code><del ><code>basic_&shy;</code></del>socket_&shy;streambuf</code> [socket.streambuf]</h4>

<p>-1- The class <code><del ><code>basic_&shy;</code></del>socket_&shy;streambuf&lt;Protocol, Clock, WaitTraits, Executor&gt;</code> associates both the input sequence and the output sequence with a socket. The input and output sequences do not support seeking. [&nbsp;<em>Note</em><span class='textit'>:</span> The input and output sequences are independent as a stream socket provides full duplex I/O. --&nbsp;<i>end note</i>&nbsp;] </p>

<p>-2- [&nbsp;<em>Note</em><span class='textit'>:</span> This class is intended for sending and receiving bytes, not characters. Any conversion from characters to bytes, and vice versa, occurs elsewhere. --&nbsp;<i>end note</i>&nbsp;] <pre class='codeblock'>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {

  template&lt;class Protocol, class Clock, class WaitTraits, class Executor = <del >executor</del><ins >io_&shy;context&#x200b;::&#x200b;executor_&shy;type</ins>&gt;
  class <del >basic_&shy;</del>socket_streambuf : public basic_streambuf&lt;char&gt;
  {
  public:
    // types:

    using executor_type = Executor;
    using protocol_type = Protocol;
    using endpoint_type = typename protocol_type::endpoint;
    using clock_type = Clock;
    using time_point = typename clock_type::time_point;
    using duration = typename clock_type::duration;
    using wait_traits_type = WaitTraits;

    // [socket.streambuf.cons], construct / copy / destroy:

    <del >basic_&shy;</del>socket_streambuf();
    explicit <del >basic_&shy;</del>socket_streambuf(<del >basic_&shy;</del>stream_socket&lt;protocol_type, executor_type&gt; s);
    <del >basic_&shy;</del>socket_streambuf(const <del >basic_&shy;</del>socket_streambuf&amp;) = delete;
    <del >basic_&shy;</del>socket_streambuf(<del >basic_&shy;</del>socket_streambuf&amp;&amp; rhs);

    virtual ~<del >basic_&shy;</del>socket_streambuf();

    <del >basic_&shy;</del>socket_streambuf&amp; operator=(const <del >basic_&shy;</del>socket_streambuf&amp;) = delete;
    <del >basic_&shy;</del>socket_streambuf&amp; operator=(<del >basic_&shy;</del>socket_streambuf&amp;&amp; rhs);

    // [socket.streambuf.members], members:

    <del >basic_&shy;</del>socket_streambuf* connect(const endpoint_type&amp; e);
    template&lt;class... Args&gt; <del >basic_&shy;</del>socket_streambuf* connect(Args&amp;&amp;... );

    <del >basic_&shy;</del>socket_streambuf* close();

    <del >basic_&shy;</del>socket&lt;protocol_type, executor_type&gt;&amp; socket();
    error_code error() const;

    time_point expiry() const;
    void expires_at(const time_point&amp; t);
    void expires_after(const duration&amp; d);

  protected:
    // overridden virtual functions:
    virtual int_type underflow() override;
    virtual int_type pbackfail(int_type c = traits_type::eof()) override;
    virtual int_type overflow(int_type c = traits_type::eof()) override;
    virtual int sync() override;
    virtual streambuf* setbuf(char_type* s, streamsize n) override;

  private:
    <del >basic_&shy;</del>stream_socket&lt;protocol_type, executor_type&gt; socket_; // <em>exposition only</em>
    error_code ec_; // <em>exposition only</em>
    time_point expiry_; // <em>exposition only</em>
  };

} // inline namespace v1
} // namespace net
} // namespace experimental
} // namespace std
</pre></p>

<p>-3- Instances of class template <code><del ><code>basic_&shy;</code></del>socket_&shy;streambuf</code> meet the requirements of <code>Destructible</code> (C++2014[destructible]), <code>MoveConstructible</code> (C++2014[moveconstructible]), and <code>MoveAssignable</code> (C++2014[moveassignable]).</p>
<h4 >19.1.1 <code><del ><code>basic_&shy;</code></del>socket_&shy;streambuf</code> constructors [socket.streambuf.cons]</h4>

<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket_streambuf();
</pre></p><p></p>
<p>-1- <em>Effects:</em>Initializes <code>socket_&shy;</code> with <code>ctx</code>, where <code>ctx</code> is an unspecified object of class <code>io_&shy;context</code>.</p>

<p>-2- <em>Postconditions:</em><code>expiry() == time_&shy;point&#x200b;::&#x200b;max()</code> and <code>!error()</code>.</p>
<p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;constructible&lt;executor_&shy;type, io_&shy;context&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'>explicit <del ><code>basic_&shy;</code></del>socket_streambuf(<del ><code>basic_&shy;</code></del>stream_socket&lt;protocol_type, executor_type&gt; s);
</pre></p><p></p>
<p>-3- <em>Effects:</em>Initializes <code>socket_&shy;</code> with <code>std&#x200b;::&#x200b;move(s)</code>.</p>

<p>-4- <em>Postconditions:</em><code>expiry() == time_&shy;point&#x200b;::&#x200b;max()</code> and <code>!error()</code>.</p>
<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket_streambuf(<del ><code>basic_&shy;</code></del>socket_streambuf&amp;&amp; rhs);
</pre></p><p></p>
<p>-5- <em>Effects:</em>Move constructs from the rvalue <code>rhs</code>. It is implementation-defined whether the sequence pointers in <code>*this</code> (<code>eback()</code>, <code>gptr()</code>, <code>egptr()</code>, <code>pbase()</code>, <code>pptr()</code>, <code>epptr()</code>) obtain the values which <code>rhs</code> had. Whether they do or not, <code>*this</code> and <code>rhs</code> reference separate buffers (if any at all) after the construction. Additionally <code>*this</code> references the socket which <code>rhs</code> did before the construction, and <code>rhs</code> references no open socket after the construction.</p>

<p>-6- <em>Postconditions:</em>Let <code>rhs_&shy;p</code> refer to the state of <code>rhs</code> just prior to this construction and let <code>rhs_&shy;a</code> refer to the state of <code>rhs</code> just after this construction. <ul class='itemize'><li id='socket.streambuf.cons-6.1'>(6.1) <code>is_&shy;open() == rhs_&shy;p.is_&shy;open()</code></li><li id='socket.streambuf.cons-6.2'>(6.2) <code>rhs_&shy;a.is_&shy;open() == false</code></li><li id='socket.streambuf.cons-6.3'>(6.3) <code>error() == rhs_&shy;p.error()</code></li><li id='socket.streambuf.cons-6.4'>(6.4) <code>!rhs_&shy;a.error()</code></li><li id='socket.streambuf.cons-6.5'>(6.5) <code>expiry() == rhs_&shy;p.expiry()</code></li><li id='socket.streambuf.cons-6.6'>(6.6) <code>rhs_&shy;a.expiry() == time_&shy;point&#x200b;::&#x200b;max()</code></li><li id='socket.streambuf.cons-6.7'>(6.7) <code>gptr() - eback() == rhs_&shy;p.gptr() - rhs_&shy;p.eback()</code></li><li id='socket.streambuf.cons-6.8'>(6.8) <code>egptr() - eback() == rhs_&shy;p.egptr() - rhs_&shy;p.eback()</code></li><li id='socket.streambuf.cons-6.9'>(6.9) <code>ptr() - pbase() == rhs_&shy;p.pptr() - rhs_&shy;p.pbase()</code></li><li id='socket.streambuf.cons-6.10'>(6.10) <code>pptr() - pbase() == rhs_&shy;p.epptr() - rhs_&shy;p.pbase()</code></li><li id='socket.streambuf.cons-6.11'>(6.11) <code>if (eback()) eback() != rhs_&shy;a.eback()</code></li><li id='socket.streambuf.cons-6.12'>(6.12) <code>if (gptr()) gptr() != rhs_&shy;a.gptr()</code></li><li id='socket.streambuf.cons-6.13'>(6.13) <code>if (egptr()) egptr() != rhs_&shy;a.egptr()</code></li><li id='socket.streambuf.cons-6.14'>(6.14) <code>if (pbase()) pbase() != rhs_&shy;a.pbase()</code></li><li id='socket.streambuf.cons-6.15'>(6.15) <code>if (pptr()) pptr() != rhs_&shy;a.pptr()</code></li><li id='socket.streambuf.cons-6.16'>(6.16) <code>if (epptr()) epptr() != rhs_&shy;a.epptr()</code></li></ul></p>
<p><pre class='itemdeclcode'>virtual ~<del ><code>basic_&shy;</code></del>socket_streambuf();
</pre></p><p></p>
<p>-7- <em>Effects:</em>If a put area exists, calls <code>overflow(traits_&shy;type&#x200b;::&#x200b;eof())</code> to flush characters. [&nbsp;<em>Note</em><span class='textit'>:</span> The socket is closed by the <code><del ><code>basic_&shy;</code></del>stream_&shy;socket&lt;protocol_&shy;type, executor_&shy;type&gt;</code> destructor. --&nbsp;<i>end note</i>&nbsp;] </p>
<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket_streambuf&amp; operator=(<del ><code>basic_&shy;</code></del>socket_streambuf&amp;&amp; rhs);
</pre></p><p></p>
<p>-8- <em>Effects:</em>Calls <code>this-&gt;close()</code> then move assigns from <code>rhs</code>. After the move assignment <code>*this</code> and <code>rhs</code> have the observable state
they would have had if <code>*this</code> had been move constructed from <code>rhs</code>.</p>

<p>-9- <em>Returns:</em><code>*this</code>.</p>


<h4 >19.1.2 <code><del ><code>basic_&shy;</code></del>socket_&shy;streambuf</code> members [socket.streambuf.members]</h4>

<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket_streambuf* connect(const endpoint_type&amp; e);
</pre></p><p></p>
<p>-1- <em>Effects:</em>Initializes the <code><del ><code>basic_&shy;</code></del>socket_&shy;streambuf</code> as required, closes and re-opens the socket by performing <code>socket_&shy;.close(ec_&shy;)</code> and <code>socket_&shy;.open(e.protocol(), ec_&shy;)</code>, then attempts to establish a connection as if by POSIX <code>connect(socket_&shy;.native_&shy;handle(), static_&shy;cast&lt;sockaddr*&gt;(e.data()), e.size())</code>. <code>ec_&shy;</code> is set to reflect the error code produced by the operation. If the operation does not complete before the absolute timeout specified by <code>expiry_&shy;</code>, the socket is closed and <code>ec_&shy;</code> is set to <code>errc&#x200b;::&#x200b;timed_&shy;out</code>.</p>

<p>-2- <em>Returns:</em>if <code>!ec_&shy;</code>, <code>this</code>; otherwise, a null pointer.</p>
<p><pre class='itemdeclcode'>template&lt;class... Args&gt;
  <del ><code>basic_&shy;</code></del>socket_streambuf* connect(Args&amp;&amp;... args);
</pre></p><p></p>
<p>-3- <em>Effects:</em>Initializes the <code><del ><code>basic_&shy;</code></del>socket_&shy;streambuf</code> as required and closes the socket as if by calling <code>socket_&shy;.close(ec_&shy;)</code>. Obtains an endpoint sequence <code>endpoints</code> by performing <code>protocol_&shy;type&#x200b;::&#x200b;resolver<ins ><code>_&shy;for&lt;executor_&shy;type&gt;</code></ins>(ctx).resolve(forward&lt;Args&gt;(args)...)</code>, where <code>ctx</code> is an unspecified object of class <code>io_&shy;context</code>. For each endpoint <code>e</code> in the sequence, closes and re-opens the socket by performing <code>socket_&shy;.close(ec_&shy;)</code> and <code>socket_&shy;.open(e.protocol(), ec_&shy;)</code>, then attempts to establish a connection as if by POSIX <code>connect(socket_&shy;.native_&shy;handle(), static_&shy;cast&lt;sockaddr*&gt;(e.data()), e.size())</code>. <code>ec_&shy;</code> is set to reflect the error code produced by the operation. If the operation does not complete before the absolute timeout specified by <code>expiry_&shy;</code>, the socket is closed and <code>ec_&shy;</code> is set to <code>errc&#x200b;::&#x200b;timed_&shy;out</code>.</p>

<p>-4- <em>Returns:</em>if <code>!ec_&shy;</code>, <code>this</code>; otherwise, a null pointer.</p>

<p>-5- <em>Remarks:</em>This function shall not participate in overload resolution unless <code>Protocol</code> meets the requirements for an internet protocol ([internet.reqmts.protocol]).</p>
<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket_streambuf* close();
</pre></p><p></p>
<p>-6- <em>Effects:</em>If a put area exists, calls <code>overflow(traits_&shy;type&#x200b;::&#x200b;eof())</code> to flush characters. Regardless of whether the preceding call fails or throws an exception, the function closes the socket as if by <code><del ><code>basic_&shy;</code></del>socket&lt;protocol_&shy;type, executor_&shy;type&gt;&#x200b;::&#x200b;close(ec_&shy;)</code>. If any of the calls made by the function fail, <code>close</code> fails by returning a null pointer. If one of these calls throws an exception, the exception is caught and rethrown after closing the socket.</p>

<p>-7- <em>Returns:</em><code>this</code> on success, a null pointer otherwise.</p>

<p>-8- <em>Postconditions:</em><code>is_&shy;open() == false</code>.</p>
<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket&lt;protocol_type, executor_type&gt;&amp; socket();
</pre></p><p></p>
<p>-9- <em>Returns:</em><code>socket_&shy;</code>.</p>
<p><pre class='itemdeclcode'>error_code error() const;
</pre></p><p></p>
<p>-10- <em>Returns:</em><code>ec_&shy;</code>.</p>
<p><pre class='itemdeclcode'>time_point expiry() const;
</pre></p><p></p>
<p>-11- <em>Returns:</em><code>expiry_&shy;</code>.</p>
<p><pre class='itemdeclcode'>void expires_at(const time_point&amp; t);
</pre></p><p></p>
<p>-12- <em>Postconditions:</em><code>expiry_&shy; == t</code>.</p>
<p><pre class='itemdeclcode'>void expires_after(const duration&amp; d);
</pre></p><p></p>
<p>-13- <em>Effects:</em>Equivalent to <code>expires_&shy;at(clock_&shy;type&#x200b;::&#x200b;now() + d)</code>.</p>


<h4 >19.1.3 <code><del ><code>basic_&shy;</code></del>socket_&shy;streambuf</code> overridden virtual functions [socket.streambuf.virt]</h4>

<p><em>[...]</em></p>

<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,</p>
<ul>
<li>use <code>io_context::executor_type</code> as the default for the iostream class templates' <code>Executor</code> template parameters,</li>
<li>remove the <code>basic_</code> prefixes</li>
</ul>
<p>in <b>-19.2- Class template <code>basic_&shy;socket_&shy;iostream</code> [socket.iostream]</b>:</em></p>
</div>

<h4>19.2 Class template <code><del ><code>basic_&shy;</code></del>socket_&shy;iostream</code> [socket.iostream]</h4>


<p>-1- The class template <code><del >basic_&shy;</del>socket_&shy;iostream&lt;Protocol, Clock, WaitTraits, Executor&gt;</code> supports reading and writing on sockets. It uses a <code><del >basic_&shy;</del>socket_&shy;streambuf&lt;Protocol, Clock, WaitTraits, Executor&gt;</code> object to control the associated sequences.</p>

<p>-2- [&nbsp;<em>Note</em><span class='textit'>:</span> This class is intended for sending and receiving bytes, not characters. Any conversion from characters to bytes, and vice versa, occurs elsewhere. --&nbsp;<i>end note</i>&nbsp;] <pre class='codeblock'>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {

  template&lt;class Protocol, class Clock, class WaitTraits, class Executor = <del >executor</del><ins >io_&shy;context&#x200b;::&#x200b;executor_&shy;type</ins>&gt;
  class <del >basic_&shy;</del>socket_iostream : public basic_iostream&lt;char&gt;
  {
  public:
    // types:

    using executor_type = Executor;
    using protocol_type = Protocol;
    using endpoint_type = typename protocol_type::endpoint;
    using clock_type = Clock;
    using time_point = typename clock_type::time_point;
    using duration = typename clock_type::duration;
    using wait_traits_type = WaitTraits;

    // [socket.iostream.cons], construct / copy / destroy:

    <del >basic_&shy;</del>socket_iostream();
    explicit <del >basic_&shy;</del>socket_iostream(<del >basic_&shy;</del>stream_socket&lt;protocol_type, executor_type&gt; s);
    <del >basic_&shy;</del>socket_iostream(const <del >basic_&shy;</del>socket_iostream&amp;) = delete;
    <del >basic_&shy;</del>socket_iostream(<del >basic_&shy;</del>socket_iostream&amp;&amp; rhs);
    template&lt;class... Args&gt;
      explicit <del >basic_&shy;</del>socket_iostream(Args&amp;&amp;... args);

    <del >basic_&shy;</del>socket_iostream&amp; operator=(const <del >basic_&shy;</del>socket_iostream&amp;) = delete;
    <del >basic_&shy;</del>socket_iostream&amp; operator=(<del >basic_&shy;</del>socket_iostream&amp;&amp; rhs);

    // [socket.iostream.members], members:

    template&lt;class... Args&gt; void connect(Args&amp;&amp;... args);

    void close();

    <del >basic_&shy;</del>socket_streambuf&lt;protocol_type, clock_type, wait_traits_type, executor_type&gt;* rdbuf() const;

    <del >basic_&shy;</del>socket&lt;protocol_type, executor_type&gt;&amp; socket();
    error_code error() const;

    time_point expiry() const;
    void expires_at(const time_point&amp; t);
    void expires_after(const duration&amp; d);

  private:
    <del >basic_&shy;</del>socket_streambuf&lt;protocol_type, clock_type, wait_traits_type, executor_type&gt; sb_; // <em>exposition only</em>
  };

} // inline namespace v1
} // namespace net
} // namespace experimental
} // namespace std
</pre></p>

<p>-3- Instances of class template <code><del ><code>basic_&shy;</code></del>socket_&shy;iostream</code> meet the requirements of <code>Destructible</code> (C++2014[destructible]), <code>MoveConstructible</code> (C++2014[moveconstructible]), and <code>MoveAssignable</code> (C++2014[moveassignable]).</p>
<h4 >19.2.1 <code><del ><code>basic_&shy;</code></del>socket_&shy;iostream</code> constructors [socket.iostream.cons]</h4>

<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket_iostream();
</pre></p><p></p>
<p>-1- <em>Effects:</em>Initializes the base class as <code>basic_&shy;iostream&lt;char&gt;(&amp;sb_&shy;)</code>, value-initializes <code>sb_&shy;</code>, and performs <code>setf(std&#x200b;::&#x200b;ios_&shy;base&#x200b;::&#x200b;unitbuf)</code>.</p>
<p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;default_&shy;constructible&lt;<del ><code>basic_&shy;</code></del>socket_&shy;streambuf&lt;protocol_&shy;type, clock_&shy;type, wait_&shy;traits_&shy;type, executor_&shy;type&gt;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'>explicit <del ><code>basic_&shy;</code></del>socket_iostream(<del ><code>basic_&shy;</code></del>stream_socket&lt;protocol_type, executor_type&gt; s);
</pre></p><p></p>
<p>-2- <em>Effects:</em>Initializes the base class as <code>basic_&shy;iostream&lt;char&gt;(&amp;sb_&shy;)</code>, initializes <code>sb_&shy;</code> with <code>std&#x200b;::&#x200b;move(s)</code>, and performs <code>setf(std&#x200b;::&#x200b;ios_&shy;base&#x200b;::&#x200b;unitbuf)</code>.</p>
<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket_iostream(<del ><code>basic_&shy;</code></del>socket_iostream&amp;&amp; rhs);
</pre></p><p></p>
<p>-3- <em>Effects:</em>Move constructs from the rvalue <code>rhs</code>. This is accomplished by move constructing the base class, and the contained <code><del ><code>basic_&shy;</code></del>socket_&shy;streambuf</code>. Next <code>basic_&shy;iostream&lt;char&gt;&#x200b;::&#x200b;set_&shy;rdbuf(&amp;sb_&shy;)</code> is called to install the contained <code><del ><code>basic_&shy;</code></del>socket_&shy;streambuf</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class... Args&gt;
  explicit <del ><code>basic_&shy;</code></del>socket_iostream(Args&amp;&amp;... args);
</pre></p><p></p>
<p>-4- <em>Effects:</em>Initializes the base class as <code>basic_&shy;iostream&lt;char&gt;(&amp;sb_&shy;)</code>, value-initializes <code>sb_&shy;</code>, and performs <code>setf(std&#x200b;::&#x200b;ios_&shy;base&#x200b;::&#x200b;unitbuf)</code>. Then calls <code>rdbuf()-&gt;connect(forward&lt;Args&gt;(args)...)</code>. If that function returns a null pointer, calls <code>setstate(failbit)</code>.</p>
<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket_iostream&amp; operator=(<del ><code>basic_&shy;</code></del>socket_iostream&amp;&amp; rhs);
</pre></p><p></p>
<p>-5- <em>Effects:</em>Move assigns the base and members of <code>*this</code> from the base and corresponding members of <code>rhs</code>.</p>

<p>-6- <em>Returns:</em><code>*this</code>.</p>


<h4 >19.2.2 <code><del ><code>basic_&shy;</code></del>socket_&shy;iostream</code> members [socket.iostream.members]</h4>

<p><pre class='itemdeclcode'>template&lt;class... Args&gt;
  void connect(Args&amp;&amp;... args);
</pre></p><p></p>
<p>-1- <em>Effects:</em>Calls <code>rdbuf()-&gt;connect(forward&lt;Args&gt;(args)...)</code>. If that function returns a null pointer, calls <code>setstate(failbit)</code> (which may throw <code>ios_&shy;base&#x200b;::&#x200b;failure</code>).</p>
<p><pre class='itemdeclcode'>void close();
</pre></p><p></p>
<p>-2- <em>Effects:</em>Calls <code>rdbuf()-&gt;close()</code>. If that function returns a null pointer, calls <code>setstate(failbit)</code> (which may throw <code>ios_&shy;base&#x200b;::&#x200b;failure</code>).</p>
<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket_streambuf&lt;protocol_type, clock_type, wait_traits_type, executor_type&gt;* rdbuf() const;
</pre></p><p></p>
<p>-3- Let <code>SB</code> be the type <code><del ><code>basic_&shy;</code></del>socket_&shy;streambuf&lt;protocol_&shy;type, clock_&shy;type, wait_&shy;traits_&shy;type, executor_&shy;type&gt;</code>.</p>

<p>-4- <em>Returns:</em><code>const_&shy;cast&lt;SB*&gt;(addressof(sb_&shy;))</code>.</p>
<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>socket&lt;protocol_type, executor_type&gt;&amp; socket();
</pre></p><p></p>
<p>-5- <em>Returns:</em><code>rdbuf()-&gt;socket()</code>.</p>

<p><em>[...]</em></p>


<p class="instructions"><em>Remove the <code>basic_</code> prefix from <code>basic_socket</code> in <b>-20.1- Synchronous connect operations [socket.algo.connect]</b> as follows:</em></p>

<p><pre class='itemdeclcode'>template&lt;class Protocol, class Executor, class EndpointSequence&gt;
  typename Protocol::endpoint connect(<del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&amp; s,
                                      const EndpointSequence&amp; endpoints);
template&lt;class Protocol, class Executor, class EndpointSequence&gt;
  typename Protocol::endpoint connect(<del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&amp; s,
                                      const EndpointSequence&amp; endpoints,
                                      error_code&amp; ec);
</pre></p><p></p>

<p><em>[...]</em></p>

<p><pre class='itemdeclcode'>template&lt;class Protocol, class Executor, class EndpointSequence, class ConnectCondition&gt;
  typename Protocol::endpoint connect(<del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&amp; s,
                                      const EndpointSequence&amp; endpoints,
                                      ConnectCondition c);
template&lt;class Protocol, class Executor, class EndpointSequence, class ConnectCondition&gt;
  typename Protocol::endpoint connect(<del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&amp; s,
                                      const EndpointSequence&amp; endpoints,
                                      ConnectCondition c, error_code&amp; ec);

</pre></p><p></p>

<p><em>[...]</em></p>

<p><pre class='itemdeclcode'>template&lt;class Protocol, class Executor, class InputIterator&gt;
  InputIterator connect(<del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&amp; s,
                        InputIterator first, InputIterator last);
template&lt;class Protocol, class Executor, class InputIterator&gt;
  InputIterator connect(<del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&amp; s,
                        InputIterator first, InputIterator last,
                        error_code&amp; ec);
</pre></p><p></p>

<p><em>[...]</em></p>

<p><pre class='itemdeclcode'>template&lt;class Protocol, class Executor, class InputIterator, class ConnectCondition&gt;
  InputIterator connect(<del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&amp; s,
                        InputIterator first, InputIterator last,
                        ConnectCondition c);
template&lt;class Protocol, class Executor, class InputIterator, class ConnectCondition&gt;
  InputIterator connect(<del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&amp; s,
                        InputIterator first, InputIterator last,
                        ConnectCondition c, error_code&amp; ec);
</pre></p><p></p>

<p><em>[...]</em></p>

<p class="instructions"><em>Remove the <code>basic_</code> prefix from <code>basic_socket</code> in <b>-20.2- Asynchronous connect operations [socket.algo.async.connect]</b> as follows:</em></p>

<p><pre class='itemdeclcode'>template&lt;class Protocol, class Executor, class EndpointSequence, class CompletionToken&gt;
  <em>DEDUCED</em> async_connect(<del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&amp; s,
                        const EndpointSequence&amp; endpoints,
                        CompletionToken&amp;&amp; token);
</pre></p><p></p>

<p><em>[...]</em></p>

<p><pre class='itemdeclcode'>template&lt;class Protocol, class Executor, class EndpointSequence,
  class ConnectCondition, class CompletionToken&gt;
    <em>DEDUCED</em> async_connect(<del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&amp; s,
                          const EndpointSequence&amp; endpoints,
                          ConnectCondition c,
                          CompletionToken&amp;&amp; token);
</pre></p><p></p>

<p><em>[...]</em></p>

<p><pre class='itemdeclcode'>template&lt;class Protocol, class Executor, class InputIterator, class CompletionToken&gt;
  <em>DEDUCED</em> async_connect(<del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&amp; s,
                        InputIterator first, InputIterator last,
                        CompletionToken&amp;&amp; token);
</pre></p><p></p>

<p><em>[...]</em></p>

<p><pre class='itemdeclcode'>template&lt;class Protocol, class Executor, class InputIterator,
  class ConnectCondition, class CompletionToken&gt;
    <em>DEDUCED</em> async_connect(<del ><code>basic_&shy;</code></del>socket&lt;Protocol, Executor&gt;&amp; s,
                          InputIterator first, InputIterator last,
                          ConnectCondition c,
                          CompletionToken&amp;&amp; token);
</pre></p><p></p>

<p><em>[...]</em></p>


<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,</p>
<ul>
<li>remove <code>executor</code> as the default for the <code>Executor</code> template parameter,</li>
<li>remove the <code>basic_</code> prefix</li>
</ul>
<p>in <b>-21.1- Header &lt;experimental/internet&gt; synopsis [internet.synop]</b>:</em></p>
</div>

<pre>
  template&lt;class InternetProtocol, class Executor<del> = executor</del>&gt;
    class <del>basic_</del>resolver;
</pre>

<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,</p>
<ul>
<li>require a nested type alias <code>resolver_for</code> instead of <code>resolver</code>, and</li>
<li>remove the <code>basic_</code> prefix</li>
</ul>
<p>in <b>-21.2.1- Internet protocol requirements [internet.reqmts.protocol]</b>:</em></p>
</div>

<p>-1- A type <code>X</code> meets the <code>InternetProtocol</code> requirements if it satisfies the requirements of <code>AcceptableProtocol</code> ([socket.reqmts.acceptableprotocol]), as well as the additional requirements listed below.</p>

<p>-2- In the table below,
<code>a</code> and <code>b</code> denote (possibly const) values of type <code>X</code><ins >, and <code>E</code> is a type that models <code>execution&#x200b;::&#x200b;executor</code> (P0443R13)</ins>.<div class='numberedTable' id='tab:internet.reqmts.protocol.requirements'>Table 35: InternetProtocol requirements<br><table ><tr class='rowsep'><td class='center'><b>expression</b></td><td class='center'><b>return type</b></td><td class='center'><b>assertion/note pre/post-conditions</b></td></tr><tr class='capsep'><td class='left'><div style='height:0.6em;display:block'></div><code>X&#x200b;::&#x200b;resolver<ins ><code>_&shy;for&lt;E&gt;</code></ins></code></td><td class='left'><code>ip&#x200b;::&#x200b;<del >basic_&shy;</del>resolver&lt;X<ins >, E</ins>&gt;</code></td><td class='left'>The type of a resolver for the protocol<ins > and executor</ins>.</td></tr><tr class='rowsep'><td class='left'><code>X&#x200b;::&#x200b;v4()</code></td><td class='left'><code>X</code></td><td class='left'>Returns an object representing the IP version 4 protocol.</td></tr><tr class='rowsep'><td class='left'><code>X&#x200b;::&#x200b;v6()</code></td><td class='left'><code>X</code></td><td class='left'>Returns an object representing the IP version 6 protocol.</td></tr><tr class='rowsep'><td class='left'><code>a == b</code></td><td class='left'>convertible to <code>bool</code></td><td class='left'>Returns <code>true</code> if <code>a</code> and <code>b</code> represent the same IP protocol version, otherwise <code>false</code>.</td></tr><tr class='rowsep'><td class='left'><code>a != b</code></td><td class='left'>convertible to <code>bool</code></td><td class='left'>Returns <code>!(a == b)</code>.</td></tr></table></div></p>

<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,</p>
<ul>
<li>remove the <code>basic_</code> prefix, and</li>
<li>do a drive-by fix on the operation names <code>resolve</code> and <code>async_resolve</code></li>
</ul>
<p>in <b>-21.15- Class template <code>ip&#x200b;::&#x200b;basic_&shy;resolver_&shy;results</code> [internet.resolver.results]</b>:</em></p>
</div>

<p><em>[...]</em></p>

<p>-3- A default-constructed <code>basic_&shy;resolver_&shy;results</code> object is empty. A non-empty results object is obtained only by calling a <code><del ><code>basic_&shy;</code></del>resolver</code> object's <del ><code>wait</code></del><ins ><code>resolve</code></ins> or <code>async_&shy;<del ><code>wait</code></del><ins ><code>resolve</code></ins></code> operations, or otherwise by copy construction, move construction, assignment, or swap from another non-empty results object.</p>

<div class="instructions">
<p><em>Assuming the changes in P1322 have been applied,</p>
<ul>
<li>remove <code>executor</code> as the default for the <code>Executor</code> template parameter,</li>
<li>remove the <code>basic_</code> prefix</li>
</ul>
<p>in <b>-21.17- Class template <code>ip&#x200b;::&#x200b;basic_&shy;resolver</code> [internet.resolver]</b>:</em></p>
</div>

<h4>21.17 Class template <code>ip&#x200b;::&#x200b;<del >basic_&shy;</del>resolver</code> [internet.resolver]</h4>

<p>-1- Objects of type <code><del ><code>basic_&shy;</code></del>resolver&lt;InternetProtocol, Executor&gt;</code> are used to perform name resolution. Name resolution is the translation of a host name and service name into a sequence of endpoints, or the translation of an endpoint into its corresponding host name and service name.<pre class='codeblock'>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {
namespace ip {

  template&lt;class InternetProtocol, class Executor<del > = executor</del>&gt;
  class <del >basic_&shy;</del>resolver : public resolver_base
  {
  public:
    // types:

    using executor_type = Executor;
    using protocol_type = InternetProtocol;
    using endpoint_type = typename InternetProtocol::endpoint;
    using results_type = basic_resolver_results&lt;InternetProtocol&gt;;

    template&lt;class OtherExecutor&gt;
    using rebind_executor =
      <del >basic_&shy;</del>resolver&lt;InternetProtocol, OtherExecutor&gt;;

    // [internet.resolver.cons], construct / copy / destroy:

    explicit <del >basic_&shy;</del>resolver(const executor_type&amp; ex);
    template&lt;class ExecutionContext&gt; explicit <del >basic_&shy;</del>resolver(ExecutionContext&amp; ctx);
    <del >basic_&shy;</del>resolver(const <del >basic_&shy;</del>resolver&amp;) = delete;
    <del >basic_&shy;</del>resolver(<del >basic_&shy;</del>resolver&amp;&amp; rhs) noexcept;

    ~<del >basic_&shy;</del>resolver();

    <del >basic_&shy;</del>resolver&amp; operator=(const <del >basic_&shy;</del>resolver&amp;) = delete;
    <del >basic_&shy;</del>resolver&amp; operator=(<del >basic_&shy;</del>resolver&amp;&amp; rhs);

    // [internet.resolver.ops], <del >basic_&shy;</del>resolver operations:

    executor_type get_executor() noexcept;

    void cancel();

    results_type resolve(string_view host_name, string_view service_name);
    results_type resolve(string_view host_name, string_view service_name,
                         error_code&amp; ec);
    results_type resolve(string_view host_name, string_view service_name,
                         flags f);
    results_type resolve(string_view host_name, string_view service_name,
                         flags f, error_code&amp; ec);

    template&lt;class CompletionToken&gt;
      <em>DEDUCED</em> async_resolve(string_view host_name, string_view service_name,
                            CompletionToken&amp;&amp; token);
    template&lt;class CompletionToken&gt;
      <em>DEDUCED</em> async_resolve(string_view host_name, string_view service_name,
                            flags f, CompletionToken&amp;&amp; token);

    results_type resolve(const protocol_type&amp; protocol,
                         string_view host_name, string_view service_name);
    results_type resolve(const protocol_type&amp; protocol,
                         string_view host_name, string_view service_name,
                         error_code&amp; ec);
    results_type resolve(const protocol_type&amp; protocol,
                         string_view host_name, string_view service_name,
                         flags f);
    results_type resolve(const protocol_type&amp; protocol,
                         string_view host_name, string_view service_name,
                         flags f, error_code&amp; ec);

    template&lt;class CompletionToken&gt;
      <em>DEDUCED</em> async_resolve(const protocol_type&amp; protocol,
                            string_view host_name, string_view service_name,
                            CompletionToken&amp;&amp; token);
    template&lt;class CompletionToken&gt;
      <em>DEDUCED</em> async_resolve(const protocol_type&amp; protocol,
                            string_view host_name, string_view service_name,
                            flags f, CompletionToken&amp;&amp; token);

    results_type resolve(const endpoint_type&amp; e);
    results_type resolve(const endpoint_type&amp; e, error_code&amp; ec);

    template&lt;class CompletionToken&gt;
      <em>DEDUCED</em> async_resolve(const endpoint_type&amp; e,
                            CompletionToken&amp;&amp; token);
  };

} // namespace ip
} // inline namespace v1
} // namespace net
} // namespace experimental
} // namespace std
</pre></p>
<h4 >21.17.1 <code>ip&#x200b;::&#x200b;<del ><code>basic_&shy;</code></del>resolver</code> constructors [internet.resolver.cons]</h4>

<p><pre class='itemdeclcode'>explicit <del ><code>basic_&shy;</code></del>resolver(const executor_type&amp; ex);
</pre></p><p></p>
<p>-1- <em>Postconditions:</em><code>get_&shy;executor() == ex</code>.</p>
<p><pre class='itemdeclcode'>template&lt;class ExecutionContext&gt; explicit <del ><code>basic_&shy;</code></del>resolver(ExecutionContext&amp; ctx);
</pre></p><p></p><p><em>Postconditions:</em><code>get_&shy;executor() == ctx.get_&shy;executor().</code></p><p><em>Remarks:</em>This function shall not participate in overload resolution unless
<code>is_&shy;convertible&lt;ExecutionContext&amp;, execution_&shy;context&amp;&gt;&#x200b;::&#x200b;value</code> is <code>true</code>
and <code>is_&shy;constructible&lt;executor_&shy;type, typename ExecutionContext&#x200b;::&#x200b;executor_&shy;type&gt;&#x200b;::&#x200b;value</code> is <code>true</code>.</p><p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>resolver(<del ><code>basic_&shy;</code></del>resolver&amp;&amp; rhs) noexcept;
</pre></p><p></p>
<p>-2- <em>Effects:</em>Move constructs an object of class <code><del ><code>basic_&shy;</code></del>resolver&lt;InternetProtocol<ins ><code>, Executor</code></ins>&gt;</code> that refers to the state originally represented by <code>rhs</code>.</p>

<p>-3- <em>Postconditions:</em><code>get_&shy;executor() == rhs.get_&shy;executor()</code>.</p>


<h4 >21.17.2 <code>ip&#x200b;::&#x200b;<del ><code>basic_&shy;</code></del>resolver</code> destructor [internet.resolver.dtor]</h4>

<p><pre class='itemdeclcode'>~<del ><code>basic_&shy;</code></del>resolver();
</pre></p><p></p>
<p>-1- <em>Effects:</em>Destroys the resolver, canceling all asynchronous operations associated with this resolver as if by calling <code>cancel()</code>.</p>


<h4 >21.17.3 <code>ip&#x200b;::&#x200b;<del ><code>basic_&shy;</code></del>resolver</code> assignment [internet.resolver.assign]</h4>

<p><pre class='itemdeclcode'><del ><code>basic_&shy;</code></del>resolver&amp; operator=(<del ><code>basic_&shy;</code></del>resolver&amp;&amp; rhs);
</pre></p><p></p>
<p>-1- <em>Effects:</em>Cancels all outstanding asynchronous operations associated with <code>*this</code> as if by calling <code>cancel()</code>, then moves into <code>*this</code> the state originally represented by <code>rhs</code>.</p>

<p>-2- <em>Postconditions:</em><code>get_&shy;executor() == rhs.get_&shy;executor()</code>.</p>

<p>-3- <em>Returns:</em><code>*this</code>.</p>


<h4 >21.17.4 <code>ip&#x200b;::&#x200b;<del ><code>basic_&shy;</code></del>resolver</code> operations [internet.resolver.ops]</h4>

<p><em>[...]</em></p>

<p class="instructions"><em>Assuming the changes in P1322 have been applied, update <b>-21.19- Class <code>ip::tcp</code></b> as follows:</em></p>

<em>[ ... ]</em>

<pre>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {
namespace ip {

 class tcp
 {
 public:
   // types:
   using endpoint = basic_endpoint&lt;tcp&gt;;
   <del>using resolver = basic_resolver&lt;tcp&gt;;</del>
   <ins>template&lt;class Executor&gt;</ins>
   <ins>  using resolver_for = resolver&lt;tcp, Executor&gt;;</ins>
   <del>using socket = basic_stream_socket&lt;tcp&gt;;</del>
   template&lt;class Executor&gt;
     using socket_for = <del>basic_</del>stream_socket&lt;tcp, Executor&gt;;
   <del>using acceptor = basic_socket_acceptor&lt;tcp&gt;;</del>
   <ins>template&lt;class Executor&gt;</ins>
   <ins>  using acceptor_for = socket_acceptor&lt;tcp, Executor&gt;;</ins>
   using iostream = <del>basic_</del>socket_iostream&lt;tcp&gt;;
</pre>

<p class="instructions"><em>Assuming the changes in P1322 have been applied, update <b>-21.20- Class <code>ip::udp</code></b> as follows:</em></p>

<em>[ ... ]</em>

<pre>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {
namespace ip {

 class udp
 {
 public:
   // types:
   using endpoint = basic_endpoint&lt;udp&gt;;
   <del>using resolver = basic_resolver&lt;udp&gt;;</del>
   <ins>template&lt;class Executor&gt;</ins>
   <ins>  using resolver_for = resolver&lt;udp, Executor&gt;;</ins>
   <del>using socket = basic_stream_socket&lt;udp&gt;;</del>
   template&lt;class Executor&gt;
     using socket_for = <del>basic_</del>datagram_socket&lt;udp, Executor&gt;;
</pre>

</div>

<h3 id="specify.free.functions">Specify the free functions <code>dispatch</code>, <code>post</code>, and <code>defer</code> in terms of the new executors model</h3>

<p class="instructions"><em>Modify section <b>-13.22- Function dispatch [async.dispatch]</b> as follows:</em></p>

<p>-1- [<em>Note:</em> The function <code>dispatch</code> satisfies the requirements for an asynchronous operation (13.2.7), except for the requirement that the operation uses <del><code>post</code></del><ins>the <code>execution::blocking.never</code> property</ins> if it completes immediately. <em>--end note</em>]</p>

<p><em>[...]</em></p>

<p>-3- <b>Effects:</b>
<ul>
<li>Constructs an object <code>completion</code> of type <code>async_completion&lt;CompletionToken, void()&gt;</code>, initialized with <code>token</code>.</li>
<del><li>
Performs <code>ex.dispatch(std::move(completion.completion_handler), alloc)</code>, where <code>ex</code> is the result of <code>get_associated_executor(completion.completion_handler)</code>, and <code>alloc</code> is the result of <code>get_associated_allocator(completion.completion_handler)</code>.</li></del>
<ins><li>Performs:
<pre>
  execution::execute(
    std::prefer(ex, execution::blocking.possibly,
      execution::allocator(alloc)),
    std::move(completion.completion_handler));
</pre>
where <code>ex</code> is the result of <code>get_associated_executor(completion.completion_handler)</code>, and <code>alloc</code> is the result of <code>get_associated_allocator(completion.completion_handler)</code>.</li></ins>
</ul>

<p><em>[...]</em></p>

<p>-6- <b>Effects:</b>
<ul>
<li>Constructs an object <code>completion</code> of type <code>async_completion&lt;CompletionToken, void()&gt;</code>, initialized with <code>token</code>.</li>
<li>Constructs a function object <code>f</code> containing as members:
<ul>
<ins><li>an executor object <code>w</code> for the completion handler's associated executor, initialized with <code>std::prefer(get_associated_executor(h), execution::outstanding_work)</code>,</li></ins>
<li>a copy of the completion handler <code>h</code>, initialized with <code>std::move(completion.completion_handler)</code>,</li>
<del><li>an <code>executor_work_guard</code> object <code>w</code> for the completion handler's associated executor, initialized with <code>make_work_guard(h)</code>,</li></del>
</ul>
and where the effect of <code>f()</code> is:
<del><ul>
<li><code>w.get_executor().dispatch(std::move(h), alloc)</code>, where <code>alloc</code> is the result of <code>get_associated_allocator(h)</code>, followed by</li>
<li><code>w.reset()</code>.</li>
</ul></del>
<ins><pre>
  execution::execute(
    std::prefer(w, execution::blocking.possibly,
      execution::allocator(alloc)),
    std::move(h));
</pre></ins>
where <code>alloc</code> is the result of <code>get_associated_allocator(h)</code>.</li>
<del><li>Performs <code>ex.dispatch(std::move(f), alloc)</code>, where <code>alloc</code> is the result of <code>get_associated_allocator(completion.completion_handler)</code> prior to the construction of <code>f</code>.</li></del>
<ins><li>Performs:
<pre>
  execution::execute(
    std::prefer(ex, execution::blocking.possibly,
      execution::allocator(alloc)),
    std::move(f));
</pre>
</li></ins>
</ul>

<p class="instructions"><em>Modify section <b>-13.23- Function post [async.post]</b> as follows:</em></p>

<p>-3- <b>Effects:</b>
<ul>
<li>Constructs an object <code>completion</code> of type <code>async_completion&lt;CompletionToken, void()&gt;</code>, initialized with <code>token</code>.</li>
<del><li>
Performs <code>ex.post(std::move(completion.completion_handler), alloc)</code>, where <code>ex</code> is the result of <code>get_associated_executor(completion.completion_handler)</code>, and <code>alloc</code> is the result of <code>get_associated_allocator(completion.completion_handler)</code>.</li></del>
<ins><li>Performs:
<pre>
  execution::execute(
    std::prefer(
      std::require(ex, execution::blocking.never),
        execution::relationship.fork, execution::allocator(alloc)),
    std::move(completion.completion_handler));
</pre>
where <code>ex</code> is the result of <code>get_associated_executor(completion.completion_handler)</code>, and <code>alloc</code> is the result of <code>get_associated_allocator(completion.completion_handler)</code>.</li></ins>
</ul>

<p><em>[...]</em></p>

<p>-6- <b>Effects:</b>
<ul>
<li>Constructs an object <code>completion</code> of type <code>async_completion&lt;CompletionToken, void()&gt;</code>, initialized with <code>token</code>.</li>
<li>Constructs a function object <code>f</code> containing as members:
<ul>
<ins><li>an executor object <code>w</code> for the completion handler's associated executor, initialized with <code>std::prefer(get_associated_executor(h), execution::outstanding_work)</code>,</li></ins>
<li>a copy of the completion handler <code>h</code>, initialized with <code>std::move(completion.completion_handler)</code>,</li>
<del><li>an <code>executor_work_guard</code> object <code>w</code> for the completion handler's associated executor, initialized with <code>make_work_guard(h)</code>,</li></del>
</ul>
and where the effect of <code>f()</code> is:
<del><ul>
<li><code>w.get_executor().dispatch(std::move(h), alloc)</code>, where <code>alloc</code> is the result of <code>get_associated_allocator(h)</code>, followed by</li>
<li><code>w.reset()</code>.</li>
</ul></del>
<ins><pre>
  execution::execute(
    std::prefer(w, execution::blocking.possibly,
      execution::allocator(alloc)),
    std::move(h));
</pre></ins>
where <code>alloc</code> is the result of <code>get_associated_allocator(h)</code>.</li>
<del><li>Performs <code>ex.dispatch(std::move(f), alloc)</code>, where <code>alloc</code> is the result of <code>get_associated_allocator(completion.completion_handler)</code> prior to the construction of <code>f</code>.</li></del>
<ins><li>Performs:
<pre>
  execution::execute(
    std::prefer(
      std::require(ex, execution::blocking.never),
        execution::relationship.fork, execution::allocator(alloc)),
    std::move(f));
</pre>
</li></ins>
</ul>

<p class="instructions"><em>Modify section <b>-13.24- Function defer [async.defer]</b> as follows:</em></p>

<p>-1- [<em>Note:</em> The function <code>defer</code> satisfies the requirements for an asynchronous operation (13.2.7)<del>, except for the requirement that the operation uses <code>post</code> if it completes immediately</del>. <em>--end note</em>]</p>

<p><em>[...]</em></p>

<p>-3- <b>Effects:</b>
<ul>
<li>Constructs an object <code>completion</code> of type <code>async_completion&lt;CompletionToken, void()&gt;</code>, initialized with <code>token</code>.</li>
<del><li>
Performs <code>ex.defer(std::move(completion.completion_handler), alloc)</code>, where <code>ex</code> is the result of <code>get_associated_executor(completion.completion_handler)</code>, and <code>alloc</code> is the result of <code>get_associated_allocator(completion.completion_handler)</code>.</li></del>
<ins><li>Performs:
<pre>
  execution::execute(
    std::prefer(
      std::require(ex, execution::blocking.never),
        execution::relationship.continuation, execution::allocator(alloc)),
    std::move(completion.completion_handler));
</pre>
where <code>ex</code> is the result of <code>get_associated_executor(completion.completion_handler)</code>, and <code>alloc</code> is the result of <code>get_associated_allocator(completion.completion_handler)</code>.</li></ins>
</ul>

<p><em>[...]</em></p>

<p>-6- <b>Effects:</b>
<ul>
<li>Constructs an object <code>completion</code> of type <code>async_completion&lt;CompletionToken, void()&gt;</code>, initialized with <code>token</code>.</li>
<li>Constructs a function object <code>f</code> containing as members:
<ul>
<ins><li>an executor object <code>w</code> for the completion handler's associated executor, initialized with <code>std::prefer(get_associated_executor(h), execution::outstanding_work)</code>,</li></ins>
<li>a copy of the completion handler <code>h</code>, initialized with <code>std::move(completion.completion_handler)</code>,</li>
<del><li>an <code>executor_work_guard</code> object <code>w</code> for the completion handler's associated executor, initialized with <code>make_work_guard(h)</code>,</li></del>
</ul>
and where the effect of <code>f()</code> is:
<del><ul>
<li><code>w.get_executor().dispatch(std::move(h), alloc)</code>, where <code>alloc</code> is the result of <code>get_associated_allocator(h)</code>, followed by</li>
<li><code>w.reset()</code>.</li>
</ul></del>
<ins><pre>
  execution::execute(
    std::prefer(w, execution::blocking.possibly,
      execution::allocator(alloc)),
    std::move(h));
</pre></ins>
where <code>alloc</code> is the result of <code>get_associated_allocator(h)</code>.</li>
<del><li>Performs <code>ex.dispatch(std::move(f), alloc)</code>, where <code>alloc</code> is the result of <code>get_associated_allocator(completion.completion_handler)</code> prior to the construction of <code>f</code>.</li></del>
<ins><li>Performs:
<pre>
  execution::execute(
    std::prefer(
      std::require(ex, execution::blocking.never),
        execution::relationship.continuation, execution::allocator(alloc)),
    std::move(f));
</pre>
</li></ins>
</ul>

<h3 id="update.strand">Update the <code>strand</code> adapter to conform to the new executors model</h3>

<p class="instructions"><em>Modify section <b>-13.25- Class template strand [async.strand]</b> as follows:</em></p>

<pre>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {

  template&lt;class Executor&gt;
  class strand
  {
  public:
</pre>

<p><em>[...]</em></p>

<pre>
    <del>execution_context&amp; context() const noexcept;

    void on_work_started() const noexcept;
    void on_work_finished() const noexcept;

    template&lt;class Func, class ProtoAllocator&gt;
      void dispatch(Func&amp;&amp; f, const ProtoAllocator&amp; a) const;
    template&lt;class Func, class ProtoAllocator&gt;
      void post(Func&amp;&amp; f, const ProtoAllocator&amp; a) const;
    template&lt;class Func, class ProtoAllocator&gt;
      void defer(Func&amp;&amp; f, const ProtoAllocator&amp; a) const;</del>

    <ins>template&lt;class Property&gt;
      <em>see below</em> query(const Property&amp; p) const;

    template&lt;class Property&gt;
      <em>see below</em> require(const Property&amp; p) const;

    template&lt;class Property&gt;
      <em>see below</em> prefer(const Property&amp; p) const;

    template&lt;class Function&gt;
      void execute(Function&amp;&amp; f) const;</ins>
</pre>

<p><em>[...]</em></p>

<p>-3- A strand provides guarantees of ordering and non-concurrency. Given:</p>

<ul>
<li>strand objects <code>s1</code> and <code>s2</code> such that <code>s1 == s2</code></li>
<li>a function object <code>f1</code> <del>added</del><ins>submitted</ins> to the strand <code>s1</code> <del>using <code>post</code> or <code>defer</code>, or using <code>dispatch</code></del><ins>when the <code>execution::blocking.never</code> property is established in <code>s1</code>, or</ins> when <code>s1.running_in_this_thread()</code> is <code>false</code></li>
<li>a function object <code>f2</code> <del>added</del><ins>submitted</ins> to the strand <code>s2</code> <del>using <code>post</code> or <code>defer</code>, or using <code>dispatch</code></del><ins>when the <code>execution::blocking.never</code> property is established in <code>s2</code>, or</ins> when <code>s2.running_in_this_thread()</code> is <code>false</code></li>
</ul>

<p class="instructions"><em>Modify section <b>-13.25.4- strand operations [async.strand.ops]</b> as follows:</em></p>

<pre>
bool running_in_this_thread() const noexcept;
</pre>

<p>-2- <b>Returns:</b> <code>true</code> if the current thread of execution is running a function that was submitted to the strand, or to any other strand object <del><code>s</code> such that <code>s == *this</code>, using <code>dispatch</code>, <code>post</code> or <code>defer</code></del><ins>that shares the same ordered, non-concurrent state, using <code>execute</code></ins>; otherwise <code>false</code>. [<em>Note:</em> That is, the current thread of execution's call chain includes a function that was submitted to the strand. <em>--end note</em>]</p>

<del>
<pre>
void on_work_started() const noexcept;
</pre>

<p>-4- <b>Effects:</b> Calls <code>inner_ex_.on_work_started()</code>.</p>

<pre>
void on_work_finished() const noexcept;
</pre>

<p>-5- <b>Effects:</b> Calls <code>inner_ex_.on_work_finished()</code>.</p>

<pre>
template&lt;class Func, class ProtoAllocator&gt;
  void dispatch(Func&amp;&amp; f, const ProtoAllocator&amp; a) const;
</pre>

<p>-6- <b>Effects:</b> If <code>running_in_this_thread()</code> is true, calls <code><em>DECAY_COPY</em>(forward&lt;Func&gt;(f))()</code> (C++ 2014 [thread.decaycopy]). [<em>Note:</em> If <code>f</code> exits via an exception, the exception propagates to the caller of <code>dispatch()</code>. <em>--end note</em>] Otherwise, requests invocation of <code>f</code>, as if by forwarding the function object <code>f</code> and allocator <code>a</code> to the executor <code>inner_ex_</code>, such that the guarantees of ordering and non-concurrency are met.</p>

<pre>
template&lt;class Func, class ProtoAllocator&gt;
  void post(Func&amp;&amp; f, const ProtoAllocator&amp; a) const;
</pre>

<p>-7- <b>Effects:</b> Requests invocation of <code>f</code>, as if by forwarding the function object <code>f</code> and allocator <code>a</code> to the executor <code>inner_ex_</code>, such that the guarantees of ordering and non-concurrency are met.</p>

template&lt;class Func, class ProtoAllocator&gt;
  void defer(Func&amp;&amp; f, const ProtoAllocator&amp; a) const;

<p>-8- <b>Effects:</b> Requests invocation of <code>f</code>, as if by forwarding the function object <code>f</code> and allocator <code>a</code> to the executor <code>inner_ex_</code>, such that the guarantees of ordering and non-concurrency are met.</p>
</del>

<ins>
<pre>
template&lt;class Property&gt;
  <em>see below</em> query(const Property&amp; p) const;
</pre>

<p>-?- <b>Returns:</b> <code>std::query(inner_ex_, p)</code>.</p>

<p>-?- <b>Remarks:</b> Shall not participate in overload resolution unless <code>can_query_v&lt;const Executor&amp;, const Property&amp;></code> is <code>true</code>.</p>

<pre>
template&lt;class Property&gt;
  <em>see below</em> require(const Property&amp; p) const;
</pre>

<p>-?- <b>Returns:</b> A strand <code>s</code> of type <code>strand&lt;decay_t&lt;decltype(std::require(inner_ex_, p))&gt;&gt;</code>, where <code>s.inner_ex_</code> is initialized with <code>std::require(inner_ex_, p)</code>, and sharing the same ordered, non-concurrent state as <code>*this</code>.</p>

<p>-?- <b>Remarks:</b> Shall not participate in overload resolution unless <code>can_require_v&lt;const Executor&amp;, const Property&amp;></code> is <code>true</code>.</p>

<pre>
template&lt;class Property&gt;
  <em>see below</em> prefer(const Property&amp; p) const;
</pre>

<p>-?- <b>Returns:</b> A strand <code>s</code> of type <code>strand&lt;decay_t&lt;decltype(std::prefer(inner_ex_, p))&gt;&gt;</code>, where <code>s.inner_ex_</code> is initialized with <code>std::prefer(inner_ex_, p)</code>, and sharing the same ordered, non-concurrent state as <code>*this</code>.</p>

<p>-?- <b>Remarks:</b> Shall not participate in overload resolution unless <code>can_prefer_v&lt;const Executor&amp;, const Property&amp;></code> is <code>true</code>.</p>

<pre>
template&lt;class Function&gt;
  void execute(Function&amp;&amp; f) const;
</pre>

<p>-?- <b>Effects:</b> Submits <code>f</code> to the executor <code>inner_ex_</code>, such that the guarantees of ordering and non-concurrency are met.</p>
</ins>

<h3 id="update.use_future">Update the <code>use_future</code> completion token to conform to the new executors model</h3>

<p class="instructions"><em>Modify section <b>-13.26.2- use_future_t members [async.use.future.members]</b> as follows:</em></p>

<p>-8- For any executor type <code>E</code>, the associated object for the associator <code>associated_executor&lt;H, E&gt;</code> is an executor where, for function objects executed using the executor's <del><code>dispatch()</code>, <code>post()</code> or <code>defer()</code> functions</del><ins><code>execute()</code></ins> function, any exception thrown is caught by a function object and stored in the associated shared state.</p>

<p class="instructions"><em>Modify section <b>-13.26.3- Partial class template specialization async_result for use_future_t [async.use.future.result]</b> as follows:</em></p>

<p>-3- The implementation specializes <code>associated_executor</code> for <code>F</code>. For function objects executed using the associated executor's <del><code>dispatch()</code>, <code>post()</code> or <code>defer()</code> functions</del><ins><code>execute()</code> function</ins>, any exception thrown is caught by the executor and stored in the associated shared state.</p>

<p>-4- For any executor type <code>E</code>, the associated object for the associator <code>associated_executor&lt;F, E&gt;</code> is an executor where, for function objects executed using the executor's <del><code>dispatch()</code>, <code>post()</code> or <code>defer()</code> functions</del><ins><code>execute()</code> function</ins>, any exception thrown by a function object is caught by the executor and stored in the associated shared state.</p>

<h3 id="update.io_context">Update <code>io_context</code> to conform to the new executors model</h3>

<p class="instructions"><em>Modify section <b>-14.2- Class io_context [io_context.io_context]</b> as follows:</em></p>

<pre>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {

  class io_context : public execution_context
  {
  public:
    // types:

    <del>class executor_type;</del>
    <ins>using executor_type = <em>see below</em>;</ins>
</pre>

<p><em>[...]</em></p>

<p>-1- The class <code>io_context</code> satisfies the ExecutionContext type requirements (13.2.3).</p>

<ins><p>-?- <code>executor_type</code> is an executor type conforming to the specification for <code>io_context</code> executor types described below.</p></ins>

<p><em>[...]</em></p>

<p>-4- For an object of type <code>io_context</code>, <em>outstanding work</em> is defined as the sum of:</p>
<ul>
<del><li>the total number of calls to the <code>on_work_started</code> function, less the total number of calls to the <code>on_work_finished</code> function, to any executor of the <code>io_context</code>.</li></del>
<ins><li>the number of existing executor objects associated with the <code>io_context</code> for which the <code>execution::outstanding_work.tracked</code> property is established;</li></ins>
<li>the number of function objects that have been added to the <code>io_context</code> via any executor of the <code>io_context</code>, but not yet executed; and</li>
<li>the number of function objects that are currently being executed by the <code>io_context</code>.</li>
</ul>

<p><em>[...]</em></p>

<pre>
executor_type get_executor() noexcept;
</pre>

<p>-3- <b>Returns:</b> An executor that may be used for submitting function objects to the <code>io_context</code>. <ins>The returned executor has the following properties already established:</ins></p>
<ins><ul>
<li><code>execution::blocking.possibly</code></li>
<li><code>execution::relationship.fork</code></li>
<li><code>execution::outstanding_work.untracked</code></li>
<li><code>execution::mapping.thread</code></li>
<li><code>execution::allocator(std::allocator&lt;void&gt;())</code></li>
</ul>

<p>-?- <code>io_context</code> executors having a different set of established properties may be represented by distinct, unspecified types.</p></ins>

<p><em>[...]</em></p>

<p>-13- <b>Remarks:</b> This function may invoke additional function objects through nested calls to the <code>io_context</code> executor's <del><code>dispatch</code></del><ins><code>execute</code></ins> member function. These do not count towards the return value.</p>

<p><em>[...]</em></p>

<p>-19- <b>Remarks:</b> This function may invoke additional function objects through nested calls to the <code>io_context</code> executor's <del><code>dispatch</code></del><ins><code>execute</code></ins> member function. These do not count towards the return value.</p>

<p><em>[...]</em></p>

<p>-25- <b>Remarks:</b> This function may invoke additional function objects through nested calls to the <code>io_context</code> executor's <del><code>dispatch</code></del><ins><code>execute</code></ins> member function. These do not count towards the return value.</p>

<p class="instructions"><em>Remove section <b>-14.3- Class io_context::executor_type [io_context.exec]</b> in its entirety.</em></p>

<p class="instructions"><em>After section <b>-14.2- Class io_context [io_context.io_context]</b> insert a new section as follows:</em></p>

<ins><h3>-14.?- <code>io_context</code> executor types</h3>

<p class="changed">-1- Class <em>io-context-executor</em> is for exposition only. It is used to specify a bounded set of types that model <code>execution::executor</code> (P0443R13). All executor types accessible through <code>io_context::get_executor()</code>, and subsequent calls to the member function <code>require</code>, are members of this set and conform to the specification of <em>io-context-executor</em>.</p> [<em>Note:</em> An implementation may provide distinct types for executors that have different properties established. <em>--end note</em>]</p>

<pre>
namespace std {
namespace experimental {
namespace net {
inline namespace v1 {

  class <em>io-context-executor</em>
  {
  public:
    // construct / copy / destroy:

    <em>io-context-executor</em>(const <em>io-context-executor</em>&amp; other) noexcept;
    <em>io-context-executor</em>(<em>io-context-executor</em>&amp;&amp; other) noexcept;

    <em>io-context-executor</em>&amp; operator=(const <em>io-context-executor</em>&amp; other) noexcept;
    <em>io-context-executor</em>&amp; operator=(<em>io-context-executor</em>&amp;&amp; other) noexcept;

    // executor operations:

    <em>see below</em> require(execution::blocking_t::possibly_t) const;
    <em>see below</em> require(execution::blocking_t::never_t) const;
    <em>see below</em> require(execution::relationship_t::fork_t) const;
    <em>see below</em> require(execution::relationship_t::continuation_t) const;
    <em>see below</em> require(execution::outstanding_work_t::untracked_t) const;
    <em>see below</em> require(execution::outstanding_work_t::tracked_t) const;
    <em>see below</em> require(execution::allocator_t&lt;void&gt;) const;
    template&lt;class ProtoAllocator&gt;
      <em>see below</em> require(const execution::allocator_t&lt;ProtoAllocator&gt;&amp; a) const;

    static constexpr execution::mapping_t query(execution::mapping_t) noexcept;
    io_context&amp; query(execution::context_t) const noexcept;
    execution::blocking_t query(execution::blocking_t) const noexcept;
    execution::relationship_t query(execution::relationship_t) const noexcept;
    execution::outstanding_work_t query(execution::outstanding_work_t) const noexcept;
    <em>see below</em> query(execution::allocator_t&lt;void&gt;) const noexcept;
    template&lt;class ProtoAllocator&gt;
      <em>see below</em> query(const execution::allocator_t&lt;ProtoAllocator&gt;&amp;) const noexcept;

    bool running_in_this_thread() const noexcept;

    template&lt;class Function&gt;
      void execute(Function&amp;&amp; f) const;
  };

  bool operator==(const <em>io-context-executor</em>&amp; a, const <em>io-context-executor</em>&amp; b) noexcept;
  bool operator!=(const <em>io-context-executor</em>&amp; a, const <em>io-context-executor</em>&amp; b) noexcept;

} // inline namespace v1
} // namespace net
} // namespace experimental
} // namespace std
</pre>

<p class="changed">-2- Objects of type <code><em>io-context-executor</em></code> are associated with an <code>io_context</code>, and function objects submitted using the <code>execute</code> member function will be executed by the <code>io_context</code> from within a run function.</p>

<h4>-14.?.1- <code>io_context</code> executor constructors</h4>

<pre>
<em>io-context-executor</em>(const <em>io-context-executor</em>&amp; other) noexcept;
</pre>

<p>-1- <b>Postconditions:</b> <code>*this == other</code>.</p>

<pre>
<em>io-context-executor</em>(<em>io-context-executor</em>&amp;&amp; other) noexcept;
</pre>

<p>-2- <b>Postconditions:</b> <code>*this</code> is equal to the prior value of <code>other</code>.</p>

<h4>-14.?.2- <code>io_context</code> executor assignment</h4>

<pre>
<em>io-context-executor</em>&amp; operator=(const <em>io-context-executor</em>&amp; other) noexcept;
</pre>

<p>-1- <b>Postconditions:</b> <code>*this == other</code>.</p>

<p>-2- <b>Returns:</b> <code>*this</code>.</p>

<pre>
<em>io-context-executor</em>&amp; operator=(<em>io-context-executor</em>&amp;&amp; other) noexcept;
</pre>

<p>-3- <b>Postconditions:</b> <code>*this</code> is equal to the prior value of <code>other</code>.</p>

<p>-4- <b>Returns:</b> <code>*this</code>.</p>

<h4>-14.?.3- <code>io_context</code> executor operations</h4>

<pre>
<em>see below</em> require(execution::blocking_t::possibly_t) const;
<em>see below</em> require(execution::blocking_t::never_t) const;
<em>see below</em> require(execution::relationship_t::fork_t) const;
<em>see below</em> require(execution::relationship_t::continuation_t) const;
<em>see below</em> require(execution::outstanding_work_t::untracked_t) const;
<em>see below</em> require(execution::outstanding_work_t::tracked_t) const;
</pre>

<p class="changed">-1- <b>Returns:</b> An object of an <em><code>io-context-executor</code></em> class, associated with the same <code>io_context</code> as <code>*this</code>, and having the requested property established. When the requested property is part of a group that is defined as a mutually exclusive set, any other properties in the group are removed from the returned executor object. All other properties of the returned executor object are identical to those of <code>*this</code>.</p>

<pre>
<em>see below</em> require(execution::allocator_t&lt;void&gt;) const;
</pre>

<p>-2- <b>Returns:</b> <code>require(execution::allocator(std::allocator&lt;void&gt;()))</code>.

<pre>
template&lt;class ProtoAllocator&gt;
  <em>see below</em> require(const execution::allocator_t&lt;ProtoAllocator&gt;&amp; a) const;
</pre>

<p class="changed">-3- <b>Returns:</b> An object of an <em><code>io-context-executor</code></em> class, associated with the same <code>io_context</code> as <code>*this</code>, with the <code>execution::allocator_t&lt;ProtoAllocator&gt;</code> property established such that allocation and deallocation associated with function submission will be performed using a copy of <code>a.value()</code>. All other properties of the returned executor object are identical to those of <code>*this</code>.</p>

<pre>
static constexpr execution::mapping_t query(execution::execution::mapping_t) noexcept;
</pre>

<p>-4- <b>Returns:</b> <code>true</code>.</p>

<pre>
io_context&amp; query(execution::context_t) const noexcept;
</pre>

<p>-5- <b>Returns:</b> A reference to the associated <code>io_context</code> object.</p>

<pre>
execution::blocking_t query(execution::blocking_t) const noexcept;
execution::relationship_t query(execution::relationship_t) const noexcept;
execution::outstanding_work_t query(execution::outstanding_work_t) const noexcept;
</pre>

<p>-6- <b>Returns:</b> The established value of the property for the executor object <em>*this</em>.</p>

<pre>
<em>see below</em> query(execution::allocator_t&lt;void&gt;) const noexcept;
template&lt;class ProtoAllocator&gt;
  <em>see below</em> query(const execution::allocator_t&lt;ProtoAllocator&gt;&amp;) const noexcept;
</pre>

<p>-7- <b>Returns:</b> The allocator object associated with the executor, with type and value as previously established by the <code>execution::allocator_t&lt;ProtoAllocator&gt;</code> property.</p>

<pre>
bool running_in_this_thread() const noexcept;
</pre>

<p>-8- <b>Returns:</b> <code>true</code> if the current thread of execution is calling a run function of the associated <code>io_context</code> object. [<em>Note:</em> That is, the current thread of execution's call chain includes a run function. <em>--end note</em>]</p>

<pre>
template&lt;class Function&gt;
  void execute(Function&amp;&amp; f) const
</pre>

<p>-9- <b>Effects:</b> Submits the function <code>f</code> for execution on the <code>io_context</code> according to the <code>execution::executor</code> concept and the properties established for <code>*this</code>. If <code>f</code> exits via an exception, the exception does not propagate to the caller of <code>execute()</code>, but is instead subsequently propagated to a caller of a run function for the <code>io_context</code> object.</p>

<h4>-14.?.4- <code>io_context</code> executor comparisons</h4>

<pre>
bool operator==(const <em>io-context-executor</em>&amp; a, const <em>io-context-executor</em>&amp; b) noexcept;
</pre>

<p>-1- <b>Returns:</b> <code>true</code> if <code>addressof(a.query(execution::context_t)) == addressof(b.query(execution::context_t))</code>, and <code>a</code> and <code>b</code> have identical properties, otherwise <code>false</code>.</p>

<pre>
bool operator!=(const <em>io-context-executor</em>&amp; a, const <em>io-context-executor</em>&amp; b) noexcept;
</pre>

<p>-2- <b>Returns:</b> <code>!(a == b)</code>.</p>
</ins>

<h2>Revision History</h2>

<div class="changed">

<p>The following changes were made in revision 3 of this paper:</p>
<em>Note: changed sections in R3 are indicated by a pale blue background with a dark blue line on the right margin.</em>

<ul>
<li>Use "models" rather than "satisfies" when referring to the <code>execution::executor</code> concept.
<li>Clean up specifications of <em><code>system-context-executor</code></em> and <em><code>io-context-executor</code></em>.
<li>Remove <code>any_io_executor</code> type alias and all uses of polymorphic executors.</li>
<li>Remove defaults for <code>Executor</code> template parameters.</li>
<li>Removed the <code>basic_</code> prefixes from timer, socket, and resolver class templates.</li>
<li>Removed proposed extensions to P0443.</li>
</ul>

</div>

<p>The following changes were made in revision 2 of this paper:</p>

<ul>
<li>Updated to match the unified executor facilities as described in P0443R13.</li>
<li>Updated to use property facilities from namespace <code>std</code> rather than <code>std::execution</code>.</li>
<li>No longer propose the addition of the <code>context()</code> member function to I/O objects.</li>
<li>Renamed the polymorphic wrapper type alias to <code>any_io_executor</code>.</li>
<li>Added <code>any_io_executor</code> to the forward declaration header <code>&lt;netfwd&gt;</code>.</li>
<li>Added changes to use <code>any_io_executor</code> as the default, assuming P1322 changes have been applied.</li>
<li>Renamed <code>context_as</code> to <code>context_as_t</code>, and added template variable <code>context_as</code>.</li>
<li>Updated <code>system_context</code> executor specification based on implementation experience.</li>
<li>Updated <code>io_context</code> executor specification based on implementation experience.</li>
</ul>

<p>The following changes were made in revision 1 of this paper:</p>

<ul>
<li>Updated to match the unified executor facilities as described in P0443R7.</li>
<li>Added a section on deployment experience.</li>
<li>Specify that <code>system_context</code> executors use distinct types when different properties are established.</li>
<li>Added missing property queries on <code>system_context</code> executors.</li>
<li>Changed <code>strand</code> to conditionally forward static <code>query()</code> calls to the adapted executor.</li>
<li>Specify that <code>io_context</code> executors use distinct types when different properties are established.</li>
<li>Added missing property queries on <code>io_context</code> executors.</li>
<li>Added modifications to P0443R7 executors, including the <code>execution::context_as&lt;&gt;</code> property adapter.</li>
</ul>

</body>
</html>
