<html><head>
<style>
body { font-family: "Book Antiqua", "Times New Roman", "Times", serif; padding: 2em; }
.programlisting, .computeroutput, .literal { font-family: "Consolas", monospace; font-size: 90%; }
blockquote pre.programlisting { margin-left: 1em; padding-left: 1em; }
div.table { text-align: center; }
.sidebar { background-color: #e0e0e0; font-style: italic; }
p { text-align: justify; }
p.tablecaption { font-weight: bold; text-align: center; }
p.title { font-weight: bold; text-align: center; }
table { margin: auto; border: 1px solid gray; border-collapse: collapse; }
th { border: 1px solid gray; padding: 0.5em; }
td { border: 1px solid gray; padding: 0.5em; }
h1, h2, h3, h4, h5, div.titlepage { page-break-after: avoid; }
dl { margin-top: 0px; margin-bottom: 0px; }
</style>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"><title>Executors and Asynchronous Operations, Revision 1</title><meta name="generator" content="DocBook XSL Stylesheets V1.75.2"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<pre>Doc. no:  N4242 
Date:     2014-10-13
Revises:  N4046
Reply-To: Christopher Kohlhoff &lt;chris@kohlhoff.com&gt;
</pre>
<div class="chapter" title="Executors and Asynchronous Operations, Revision 1"><div class="titlepage"><div><div><h2 class="title"><a name="executors"></a>Executors and Asynchronous Operations, Revision 1</h2></div></div></div><div class="section" title="1.&#160;Introduction"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="executors.introduction"></a>1.&#160;Introduction</h2></div></div></div><p>
      N3785 <span class="emphasis"><em>Executors and schedulers, revision 3</em></span> describes a
      framework for executors. Unfortunately, this framework is built around some
      deliberate design choices that make it unsuited to the execution of fine grained
      tasks and, in particular, asynchronous operations. Primary among these choices
      is the use of abstract base classes and type erasure, but it is not the only
      such issue. The sum effect of these choices is that the framework is unable
      to exploit the full potential of the C++ language.
    </p><p>
      In this document, we will look at an alternative executors design that uses
      a lightweight, template-based policy approach. To describe the approach in
      a nutshell:
    </p><div class="blockquote"><blockquote class="blockquote"><p>
        <span class="emphasis"><em>An executor is to function execution as an allocator is to allocation.</em></span>
      </p></blockquote></div><p>
      This proposal builds on the type traits described in N4045 <span class="emphasis"><em>Library
      Foundations for Asynchronous Operations, Revision 2</em></span> to outline a
      design that unifies the following areas:
    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
          Executors and schedulers.
        </li><li class="listitem">
          Support for resumable functions or coroutines.
        </li><li class="listitem">
          A model for asynchronous operations.
        </li><li class="listitem">
          A flexible alternative to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">async</span><span class="special">()</span></code>.
        </li></ul></div><p>
      In doing so, it takes concepts from Boost.Asio, many of which have been unchanged
      since its inclusion in Boost, and repackages them in a way that is more suited
      to C++14 language facilities.
    </p></div><div class="section" title="2.&#160;Changes in this revision"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="executors.changes_in_this_revision"></a>2.&#160;Changes in this revision</h2></div></div></div><p>
      N4046 introduced a comprehensive library that covered included support for
      composition and coordination of chains of operations. In this revision we present
      a minimal subset of the proposal. This includes the facilities required to
      support a model for asynchronous operations, as required by the networking
      proposal. It also includes features that enable the use cases supported by
      N3785.
    </p></div><div class="section" title="3.&#160;Reference implementation"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="executors.reference_implementation"></a>3.&#160;Reference implementation</h2></div></div></div><p>
      A standalone reference implementation of the proposed library can be found
      at <span class="emphasis"><em><a href="http://github.com/chriskohlhoff/executors" target="_top">http://github.com/chriskohlhoff/executors</a></em></span>.
      This implementation requires a C++14 compiler.
    </p><p>
      To better illustrate how the executors library interacts with asynchronous
      operations, and to allow the facility to be used in production code, the library
      has been backported into the variant of Asio that stands alone from Boost.
      This variant is available at <span class="emphasis"><em><a href="https://github.com/chriskohlhoff/asio/tree/master" target="_top">https://github.com/chriskohlhoff/asio/tree/master</a></em></span>.
    </p></div><div class="section" title="4.&#160;A two minute introduction to the library"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="executors.a_two_minute_introduction_to_the_library"></a>4.&#160;A two minute introduction to the library</h2></div></div></div><p>
      Run a function asynchronously:
    </p><pre class="programlisting"><span class="identifier">post</span><span class="special">([]{</span>
    <span class="comment">// ...</span>
  <span class="special">});</span>
</pre><p>
      Run a function asynchronously, on your own thread pool:
    </p><pre class="programlisting"><span class="identifier">thread_pool</span> <span class="identifier">pool</span><span class="special">;</span>

<span class="identifier">post</span><span class="special">(</span><span class="identifier">pool</span><span class="special">,</span> <span class="special">[]{</span>
    <span class="comment">// ...</span>
  <span class="special">});</span>

<span class="identifier">pool</span><span class="special">.</span><span class="identifier">join</span><span class="special">();</span>
</pre><p>
      Run a function asynchronously and wait for the result:
    </p><pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">future</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">f</span> <span class="special">=</span>
  <span class="identifier">post</span><span class="special">(</span><span class="identifier">package</span><span class="special">([]{</span>
    <span class="comment">// ...</span>
    <span class="keyword">return</span> <span class="number">42</span><span class="special">;</span>
  <span class="special">}));</span>

<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">f</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre><p>
      Run a function asynchronously, on your own thread pool, and wait for the result:
    </p><pre class="programlisting"><span class="identifier">thread_pool</span> <span class="identifier">pool</span><span class="special">;</span>

<span class="identifier">std</span><span class="special">::</span><span class="identifier">future</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">f</span> <span class="special">=</span>
  <span class="identifier">post</span><span class="special">(</span><span class="identifier">pool</span><span class="special">,</span> <span class="identifier">package</span><span class="special">([]{</span>
    <span class="comment">// ...</span>
    <span class="keyword">return</span> <span class="number">42</span><span class="special">;</span>
  <span class="special">}));</span>

<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">f</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre><p>
      Run a function in the future and wait for the result:
    </p><pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">future</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">f</span> <span class="special">=</span>
  <span class="identifier">post_after</span><span class="special">(</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">seconds</span><span class="special">(</span><span class="number">1</span><span class="special">),</span>
    <span class="identifier">package</span><span class="special">([]{</span>
      <span class="comment">// ...</span>
      <span class="keyword">return</span> <span class="number">42</span><span class="special">;</span>
    <span class="special">}));</span>

<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">f</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre></div><div class="section" title="5.&#160;Library vocabulary"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="executors.library_vocabulary"></a>5.&#160;Library vocabulary</h2></div></div></div><p>
      The central concept of this library is the <span class="emphasis"><em>executor</em></span> as
      a policy. An executor embodies a set of rules about where, when and how to
      run a function object. For example:
    </p><div class="informaltable"><table class="table"><colgroup><col><col></colgroup><thead><tr><th>
              <p>
                Executor type
              </p>
            </th><th>
              <p>
                Executor rules
              </p>
            </th></tr></thead><tbody><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">system_executor</span></code>
              </p>
            </td><td>
              <p>
                Function objects are allowed to run on any thread in the process.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span></code>
              </p>
            </td><td>
              <p>
                Function objects are allowed to run on any thread in the pool, and
                nowhere else.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span></code>
              </p>
            </td><td>
              <p>
                Run function objects according to the underlying executor's rules,
                but also run them in FIFO order and not concurrently.
              </p>
            </td></tr></tbody></table></div><p>
      Executors are ultimately defined by a set of type requirements, so the set
      of executors isn't limited to those listed here. Like allocators, library users
      can develop custom executor types to implement their own rules. Executors allow
      us to encapsulate all sorts of additional information and behaviour on a fine-grained
      basis, such as:
    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
          Priority.
        </li><li class="listitem">
          Preferred CPU affinity.
        </li><li class="listitem">
          Security credentials or impersonation context.
        </li><li class="listitem">
          How exceptions should be handled.
        </li></ul></div><p>
      Certain objects may have an <span class="emphasis"><em>associated executor</em></span>, which
      specifies how any function objects related to the object should be executed.
      For example, we may want to say that all event callbacks associated with a
      network protocol implementation should execute on a particular thread, or that
      a task should run at a particular priority. The notion of an associated executor
      allows us to decouple the specification of execution behaviour from the actual
      point of execution.
    </p><p>
      An <span class="emphasis"><em>execution context</em></span> is a place where function objects
      are executed. Where executors are lightweight and cheap to copy, an execution
      context is typically long-lived and non-copyable. It may contain additional
      state such as timer queues, socket reactors, or hidden threads to emulate asynchronous
      functionality. Examples of execution contexts include <code class="computeroutput"><span class="identifier">thread_pool</span></code>,
      <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>, a Boost.Asio
      <code class="computeroutput"><span class="identifier">io_service</span></code>, and the set of
      all threads in the process.
    </p><p>
      We say that a <code class="computeroutput"><span class="identifier">thread_pool</span></code>
      <span class="emphasis"><em>is</em></span> an execution context, and that it <span class="emphasis"><em>has</em></span>
      an executor. The thread pool contains long-lived state, namely the threads
      that persist until the pool is shut down. The thread pool's executor embodies
      the rule: <span class="emphasis"><em>run functions in the pool and nowhere else</em></span>.
      The thread pool's executor may be obtained by calling its <code class="computeroutput"><span class="identifier">get_executor</span><span class="special">()</span></code> member function.
    </p><p>
      To submit a function object to an executor or execution context, we can choose
      from one of three fundamental operations: <span class="emphasis"><em>dispatch</em></span>, <span class="emphasis"><em>post</em></span>
      and <span class="emphasis"><em>defer</em></span>. These operations differ in the eagerness with
      which they run the submitted function.
    </p><p>
      A dispatch operation is the most eager.
    </p><pre class="programlisting"><span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">ex</span><span class="special">,</span> <span class="special">[]{</span> <span class="special">...</span> <span class="special">});</span>
</pre><p>
      It means: <span class="emphasis"><em>run the function immediately, in the calling thread, if
      the rules allow it; otherwise, submit for later execution</em></span>.
    </p><div class="informaltable"><table class="table"><colgroup><col><col><col></colgroup><thead><tr><th>
              <p>
                Executor type
              </p>
            </th><th>
              <p>
                Executor rules
              </p>
            </th><th>
              <p>
                Behaviour of dispatch
              </p>
            </th></tr></thead><tbody><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">system_executor</span></code>
              </p>
            </td><td>
              <p>
                Function objects are allowed to run on any thread in the process.
              </p>
            </td><td>
              <p>
                Always runs the function object before returning from <code class="computeroutput"><span class="identifier">dispatch</span><span class="special">()</span></code>.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span></code>
              </p>
            </td><td>
              <p>
                Function objects are allowed to run on any thread in the pool, and
                nowhere else.
              </p>
            </td><td>
              <p>
                If we are inside the thread pool, runs the function object before
                returning from <code class="computeroutput"><span class="identifier">dispatch</span><span class="special">()</span></code>. Otherwise, adds to the thread
                pool's work queue.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span></code>
              </p>
            </td><td>
              <p>
                Run function objects according to the underlying executor's rules,
                but also run them in FIFO order and not concurrently.
              </p>
            </td><td>
              <p>
                If we are inside the strand, or if the strand queue is empty, runs
                the function object before returning from <code class="computeroutput"><span class="identifier">dispatch</span><span class="special">()</span></code>. Otherwise, adds to the strand's
                work queue.
              </p>
            </td></tr></tbody></table></div><p>
      A consequence of calling <code class="computeroutput"><span class="identifier">dispatch</span><span class="special">()</span></code> is that, if the executor&#8217;s rules allow
      it, the compiler is able to inline the function object call.
    </p><p>
      A post operation, on the other hand, is not permitted to run the function object
      itself.
    </p><pre class="programlisting"><span class="identifier">post</span><span class="special">(</span><span class="identifier">ex</span><span class="special">,</span> <span class="special">[]{</span> <span class="special">...</span> <span class="special">});</span>
</pre><p>
      It means: <span class="emphasis"><em>submit the function for later execution; never run the
      function object immediately</em></span>. A posted function is scheduled for
      execution as soon as possible, according to the rules of the executor.
    </p><div class="informaltable"><table class="table"><colgroup><col><col><col></colgroup><thead><tr><th>
              <p>
                Executor type
              </p>
            </th><th>
              <p>
                Executor rules
              </p>
            </th><th>
              <p>
                Behaviour of post
              </p>
            </th></tr></thead><tbody><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">system_executor</span></code>
              </p>
            </td><td>
              <p>
                Function objects are allowed to run on any thread in the process.
              </p>
            </td><td>
              <p>
                Like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">async</span><span class="special">()</span></code>,
                the system executor may allocate <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">thread</span></code>
                objects to run the submitted function objects. A typical implementation
                may be to use a hidden system-wide thread pool.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span></code>
              </p>
            </td><td>
              <p>
                Function objects are allowed to run on any thread in the pool, and
                nowhere else.
              </p>
            </td><td>
              <p>
                Adds the function object to the thread pool's work queue.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span></code>
              </p>
            </td><td>
              <p>
                Run function objects according to the underlying executor's rules,
                but also run them in FIFO order and not concurrently.
              </p>
            </td><td>
              <p>
                Adds the function object to the strand's work queue.
              </p>
            </td></tr></tbody></table></div><p>
      Finally, the defer operation is the least eager of the three.
    </p><pre class="programlisting"><span class="identifier">defer</span><span class="special">(</span><span class="identifier">ex</span><span class="special">,</span> <span class="special">[]{</span> <span class="special">...</span> <span class="special">});</span>
</pre><p>
      A defer operation is similar to a post operation, in that it means: <span class="emphasis"><em>submit
      the function for later execution; never run the function object immediately</em></span>.
      However, a defer operation also <span class="emphasis"><em>implies a relationship between the
      caller and the function object being submitted</em></span>. It is intended for
      use when submitting a function object that represents a continuation of the
      caller.
    </p><div class="informaltable"><table class="table"><colgroup><col><col><col></colgroup><thead><tr><th>
              <p>
                Executor type
              </p>
            </th><th>
              <p>
                Executor rules
              </p>
            </th><th>
              <p>
                Behaviour of defer
              </p>
            </th></tr></thead><tbody><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">system_executor</span></code>
              </p>
            </td><td>
              <p>
                Function objects are allowed to run on any thread in the process.
              </p>
            </td><td>
              <p>
                If the caller is executing within the system-wide thread pool, saves
                the function object to a thread-local queue. Once control returns
                to the system thread pool, the function object is scheduled for execution
                as soon as possible.<br> <br> If the caller is not inside the
                system thread pool, behaves as a post operation.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span></code>
              </p>
            </td><td>
              <p>
                Function objects are allowed to run on any thread in the pool, and
                nowhere else.
              </p>
            </td><td>
              <p>
                If the caller is executing within the thread pool, saves the function
                object to a thread-local queue. Once control returns to the thread
                pool, the function object is scheduled for execution as soon as possible.<br>
                <br> If the caller is not inside the specified thread pool, behaves
                as a post operation.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span></code>
              </p>
            </td><td>
              <p>
                Run function objects according to the underlying executor's rules,
                but also run them in FIFO order and not concurrently.
              </p>
            </td><td>
              <p>
                Adds the function object to the strand's work queue.
              </p>
            </td></tr></tbody></table></div></div><div class="section" title="6.&#160;Library examples"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="executors.library_examples"></a>6.&#160;Library examples</h2></div></div></div><div class="toc"><dl><dt><span class="section"><a href="#executors.emulating___std__async___">6.1. Emulating <code class="literal">std::async()</code></a></span></dt><dt><span class="section"><a href="#executors.active_objects">6.2. Active objects</a></span></dt><dt><span class="section"><a href="#executors.activatable_objects">6.3. Activatable objects</a></span></dt><dt><span class="section"><a href="#executors.leader_followers_pattern">6.4. Leader/Followers pattern</a></span></dt><dt><span class="section"><a href="#executors.asynchronous_operations">6.5. Asynchronous operations</a></span></dt><dt><span class="section"><a href="#executors.pipelines">6.6. Pipelines</a></span></dt><dt><span class="section"><a href="#executors.actors">6.7. Actors</a></span></dt><dt><span class="section"><a href="#executors.priority_scheduler">6.8. Priority scheduler</a></span></dt></dl></div><p>
      In this section we will examine a selection of examples, to see how the proposed
      executors library supports a range of use cases.
    </p><div class="section" title="6.1.&#160;Emulating std::async()"><div class="titlepage"><div><div><h3 class="title"><a name="executors.emulating___std__async___"></a>6.1.&#160;Emulating <code class="literal">std::async()</code></h3></div></div></div><p>
        The behaviour of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">async</span><span class="special">()</span></code>
        function, when used with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">launch</span><span class="special">::</span><span class="identifier">async</span></code>,
        may be trivially emulated as follows:
      </p><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
<span class="keyword">auto</span> <span class="identifier">async</span><span class="special">(</span><span class="identifier">F</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">&amp;&amp;...</span> <span class="identifier">args</span><span class="special">)</span>
<span class="special">{</span>
  <span class="keyword">return</span> <span class="identifier">post</span><span class="special">(</span>
    <span class="identifier">package</span><span class="special">(</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">),</span>
        <span class="identifier">std</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">&gt;(</span><span class="identifier">args</span><span class="special">)...)));</span>
<span class="special">}</span>
</pre><p>
        Starting from the inside out, the expression:
      </p><pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">),</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">&gt;(</span><span class="identifier">args</span><span class="special">)...)</span>
</pre><p>
        creates a function object that will invoke <code class="computeroutput"><span class="identifier">f</span></code>
        with the specified arguments. Next:
      </p><pre class="programlisting"><span class="identifier">package</span><span class="special">(...)</span>
</pre><p>
        returns an object that will be lazily converted into a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">packaged_task</span><span class="special">&lt;&gt;</span></code>. We could also have used <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">packaged_task</span><span class="special">&lt;&gt;</span></code> directly, as in:
      </p><pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">packaged_task</span><span class="special">&lt;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">result_of_t</span><span class="special">&lt;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">decay_t</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">decay_t</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">&gt;...)&gt;&gt;(...)</span>
</pre><p>
        In this example, the <code class="computeroutput"><span class="identifier">package</span><span class="special">()</span></code> function saves on typing by determining
        the return type of <code class="computeroutput"><span class="identifier">F</span></code> for
        us. Finally:
      </p><pre class="programlisting"><span class="identifier">post</span><span class="special">(...)</span>
</pre><p>
        submits the function object for execution on another thread, and then returns
        immediately. When we submit a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">packaged_task</span><span class="special">&lt;&gt;</span></code>, <code class="computeroutput"><span class="identifier">post</span><span class="special">()</span></code> automatically deduces its return type to
        be the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">future</span><span class="special">&lt;&gt;</span></code>
        type produced by the task. This future object is then returned from our version
        of <code class="computeroutput"><span class="identifier">async</span><span class="special">()</span></code>.
        Note that, unlike <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">async</span><span class="special">()</span></code>,
        the returned future object's destructor will not block.
      </p><div class="sidebar"><p class="title"><b></b></p><p>
        See complete example at:<br> <a href="https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/async_1.cpp" target="_top">https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/async_1.cpp</a>
      </p></div></div><div class="section" title="6.2.&#160;Active objects"><div class="titlepage"><div><div><h3 class="title"><a name="executors.active_objects"></a>6.2.&#160;Active objects</h3></div></div></div><p>
        In the Active Object design pattern, all operations associated with an object
        are run in its own private thread.
      </p><p>
        To implement an active object, we begin by defining a class member that is
        a thread pool containing a single thread.
      </p><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">bank_account</span>
<span class="special">{</span>
  <span class="keyword">int</span> <span class="identifier">balance_</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
  <span class="keyword">mutable</span> <span class="identifier">thread_pool</span> <span class="identifier">pool_</span><span class="special">{</span><span class="number">1</span><span class="special">};</span>
  <span class="comment">// ...</span>
<span class="special">};</span>
</pre><p>
        We then define each public member function so that it posts its implementation
        to the thread pool.
      </p><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">bank_account</span>
<span class="special">{</span>
  <span class="comment">// ...</span>
  <span class="keyword">void</span> <span class="identifier">deposit</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">amount</span><span class="special">)</span>
  <span class="special">{</span>
    <span class="identifier">post</span><span class="special">(</span><span class="identifier">pool_</span><span class="special">,</span>
      <span class="identifier">package</span><span class="special">([=]</span>
        <span class="special">{</span>
          <span class="identifier">balance_</span> <span class="special">+=</span> <span class="identifier">amount</span><span class="special">;</span>
        <span class="special">})).</span><span class="identifier">get</span><span class="special">();</span>
  <span class="special">}</span>
  <span class="comment">// ...</span>
<span class="special">};</span>
</pre><p>
        In more detail, to implement an active object operation we begin by defining
        the body of the function:
      </p><pre class="programlisting"><span class="special">[=]</span>
<span class="special">{</span>
  <span class="identifier">balance_</span> <span class="special">+=</span> <span class="identifier">amount</span><span class="special">;</span>
<span class="special">}</span>
</pre><p>
        which we then wrap in a lazily created <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">packaged_task</span><span class="special">&lt;&gt;</span></code>:
      </p><pre class="programlisting"><span class="identifier">package</span><span class="special">(...)</span>
</pre><p>
        Finally, we submit the packaged task to the pool and wait for it to complete.
        When we submit a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">packaged_task</span><span class="special">&lt;&gt;</span></code>,
        <code class="computeroutput"><span class="identifier">post</span><span class="special">()</span></code>
        automatically deduces its return type to be the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">future</span><span class="special">&lt;&gt;</span></code> type produced by the task. We can
        use this future to block until the operation is complete.
      </p><pre class="programlisting"><span class="identifier">post</span><span class="special">(...).</span><span class="identifier">get</span><span class="special">();</span>
</pre><div class="sidebar"><p class="title"><b></b></p><p>
        See complete example at:<br> <a href="https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/bank_account_2.cpp" target="_top">https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/bank_account_2.cpp</a>
      </p></div></div><div class="section" title="6.3.&#160;Activatable objects"><div class="titlepage"><div><div><h3 class="title"><a name="executors.activatable_objects"></a>6.3.&#160;Activatable objects</h3></div></div></div><p>
        An Activatable object is a variant of the Active Object pattern where the
        object does not have a private thread of its own. Instead, it can borrow
        one of the calling threads to process operations<sup>[<a name="executors.library_examples.activatable_objects.f0" href="#ftn.executors.library_examples.activatable_objects.f0" class="footnote">1</a>]</sup>. However, like Active Object, it ensures that all member state
        changes do not occur on more than one thread at a time.
      </p><p>
        To implement an activatable object, we create a strand on the system executor.
      </p><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">bank_account</span>
<span class="special">{</span>
  <span class="keyword">int</span> <span class="identifier">balance_</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
  <span class="keyword">mutable</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">system_executor</span><span class="special">&gt;</span> <span class="identifier">strand_</span><span class="special">;</span>
  <span class="comment">// ...</span>
<span class="special">};</span>
</pre><p>
        We then define each public member function so that it dispatches its implementation
        to the strand.
      </p><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">bank_account</span>
<span class="special">{</span>
  <span class="comment">// ...</span>
  <span class="keyword">void</span> <span class="identifier">deposit</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">amount</span><span class="special">)</span>
  <span class="special">{</span>
    <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">strand_</span><span class="special">,</span>
      <span class="identifier">package</span><span class="special">([=]</span>
        <span class="special">{</span>
          <span class="identifier">balance_</span> <span class="special">+=</span> <span class="identifier">amount</span><span class="special">;</span>
        <span class="special">})).</span><span class="identifier">get</span><span class="special">();</span>
  <span class="special">}</span>
  <span class="comment">// ...</span>
<span class="special">};</span>
</pre><p>
        Recall that a <code class="computeroutput"><span class="identifier">system_executor</span></code>
        object embodies this rule:
      </p><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Function objects are allowed to run on any thread in the process.</em></span>
        </p></blockquote></div><p>
        while a strand embodies this rule:
      </p><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Run function objects according to the underlying executor's rules,
          but also run them in FIFO order and not concurrently.</em></span>
        </p></blockquote></div><p>
        Finally, the call to <code class="computeroutput"><span class="identifier">dispatch</span><span class="special">()</span></code> means:
      </p><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Run the function immediately, in the calling thread, if the rules
          allow it; otherwise, submit for later execution.</em></span>
        </p></blockquote></div><p>
        Thus, when we combine <code class="computeroutput"><span class="identifier">system_executor</span></code>,
        <code class="computeroutput"><span class="identifier">strand</span></code> and <code class="computeroutput"><span class="identifier">dispatch</span><span class="special">()</span></code>:
      </p><pre class="programlisting"><span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">strand_</span><span class="special">,</span> <span class="special">[]{</span> <span class="special">...</span> <span class="special">});</span>
</pre><p>
        we are effectively saying: <span class="emphasis"><em>if the strand is not busy, run the function
        object immediately</em></span>. If there is no contention on the strand, latency
        is minimised. If there is contention, the strand still ensures that the function
        object never runs concurrently with any other function object submitted through
        the same strand.
      </p><div class="sidebar"><p class="title"><b></b></p><p>
        See complete example at:<br> <a href="https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/bank_account_3.cpp" target="_top">https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/bank_account_3.cpp</a>
      </p></div></div><div class="section" title="6.4.&#160;Leader/Followers pattern"><div class="titlepage"><div><div><h3 class="title"><a name="executors.leader_followers_pattern"></a>6.4.&#160;Leader/Followers pattern</h3></div></div></div><p>
        The Leader/Followers design pattern is a model where multiple threads take
        turns to wait on event sources in order to dispatch and process incoming
        events.
      </p><p>
        Consider an example where a connection handler is responsible for receiving
        messages from a client via UDP. The Leader/Followers pattern is implemented
        using a <code class="computeroutput"><span class="identifier">thread_pool</span></code> object:
      </p><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">connection_handler</span>
<span class="special">{</span>
  <span class="comment">// ...</span>
<span class="keyword">private</span><span class="special">:</span>
  <span class="identifier">udp_socket</span> <span class="identifier">socket_</span><span class="special">;</span>
  <span class="identifier">thread_pool</span> <span class="identifier">thread_pool_</span><span class="special">;</span>
  <span class="comment">// ...</span>
<span class="special">};</span>
</pre><p>
        and involves the sequence of operations below.
      </p><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">connection_handler</span><span class="special">::</span><span class="identifier">receive_and_dispatch</span><span class="special">()</span>
<span class="special">{</span>
</pre><p>
        The leader thread waits for the next message to arrive.
      </p><pre class="programlisting">  <span class="keyword">char</span> <span class="identifier">buffer</span><span class="special">[</span><span class="number">1024</span><span class="special">];</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">length</span> <span class="special">=</span> <span class="identifier">socket_</span><span class="special">.</span><span class="identifier">receive</span><span class="special">(</span><span class="identifier">buffer</span><span class="special">,</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">buffer</span><span class="special">));</span>
</pre><p>
        A new message has arrived. The leader thread promotes a follower to become
        the new leader.
      </p><pre class="programlisting">  <span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span><span class="identifier">post</span><span class="special">(</span><span class="identifier">thread_pool_</span><span class="special">,</span>
      <span class="special">[</span><span class="keyword">this</span><span class="special">]{</span> <span class="identifier">receive_and_dispatch</span><span class="special">();</span> <span class="special">});</span>
</pre><p>
        The now former leader processes the message.
      </p><pre class="programlisting">  <span class="comment">// Process the new message and pass it to the order management bus.</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">istringstream</span> <span class="identifier">is</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">(</span><span class="identifier">buffer</span><span class="special">,</span> <span class="identifier">length</span><span class="special">));</span>
  <span class="identifier">order_management</span><span class="special">::</span><span class="identifier">new_order</span> <span class="identifier">event</span><span class="special">;</span>
  <span class="keyword">if</span> <span class="special">(</span><span class="identifier">is</span> <span class="special">&gt;&gt;</span> <span class="identifier">event</span><span class="special">)</span>
    <span class="identifier">order_management_bus_</span><span class="special">.</span><span class="identifier">dispatch_event</span><span class="special">(</span><span class="identifier">event</span><span class="special">);</span>
<span class="special">}</span>
</pre><p>
        When the function returns, the former leader automatically returns to the
        pool as a follower thread.
      </p><div class="sidebar"><p class="title"><b></b></p><p>
        See complete example at:<br> <a href="https://github.com/chriskohlhoff/executors/blob/master/src/examples/trading/server/" target="_top">https://github.com/chriskohlhoff/executors/blob/master/src/examples/trading/server/</a>
      </p></div></div><div class="section" title="6.5.&#160;Asynchronous operations"><div class="titlepage"><div><div><h3 class="title"><a name="executors.asynchronous_operations"></a>6.5.&#160;Asynchronous operations</h3></div></div></div><p>
        Asynchronous operations are often chained, and in many cases an object may
        be associated with two or more chains. For example, an object to manage a
        connection may contain one chain to do the writing, and another to do the
        reading:
      </p><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">connection</span>
<span class="special">{</span>
  <span class="identifier">tcp</span><span class="special">::</span><span class="identifier">socket</span> <span class="identifier">socket_</span><span class="special">;</span>
  <span class="identifier">mutable_buffers_1</span> <span class="identifier">in_buffer_</span><span class="special">;</span>
  <span class="identifier">mutable_buffers_1</span> <span class="identifier">out_buffer_</span><span class="special">;</span>

  <span class="comment">// ...</span>

  <span class="keyword">void</span> <span class="identifier">do_read</span><span class="special">()</span>
  <span class="special">{</span>
    <span class="identifier">socket_</span><span class="special">.</span><span class="identifier">async_read_some</span><span class="special">(</span><span class="identifier">in_buffer_</span><span class="special">,</span>
      <span class="special">[</span><span class="keyword">this</span><span class="special">](</span><span class="identifier">error_code</span> <span class="identifier">ec</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">n</span><span class="special">)</span>
      <span class="special">{</span>
        <span class="comment">// ... process input data ...</span>
        <span class="keyword">if</span> <span class="special">(!</span><span class="identifier">ec</span><span class="special">)</span> <span class="identifier">do_read</span><span class="special">();</span>
      <span class="special">});</span>
  <span class="special">}</span>

  <span class="keyword">void</span> <span class="identifier">do_write</span><span class="special">()</span>
  <span class="special">{</span>
    <span class="comment">// ... generate output data ...</span>
    <span class="identifier">async_write</span><span class="special">(</span><span class="identifier">socket_</span><span class="special">,</span> <span class="identifier">out_buffer_</span><span class="special">,</span>
      <span class="special">[</span><span class="keyword">this</span><span class="special">](</span><span class="identifier">error_code</span> <span class="identifier">ec</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">n</span><span class="special">)</span>
      <span class="special">{</span>
        <span class="keyword">if</span> <span class="special">(!</span><span class="identifier">ec</span><span class="special">)</span> <span class="identifier">do_write</span><span class="special">();</span>
      <span class="special">});</span>
  <span class="special">}</span>
<span class="special">};</span>
</pre><p>
        When these chains are run on a single-threaded event loop, it is not possible
        for more than one completion handler to run at any given time. This means
        that no synchronisation is required to protected shared data. However, if
        handlers are executed on a thread pool then some form of synchronisation
        will be required to avoid introducing data races.
      </p><p>
        The proposed library provides the <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;&gt;</span></code> template to synchronise handlers.
        A strand ensures that completion handlers never run concurrently, and explicit
        synchronisation (such as a mutex) is still not required to protect shared
        data. To implement this, we use the one strand for all asynchronous operations
        associated with the object.
      </p><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">connection</span>
<span class="special">{</span>
  <span class="identifier">tcp</span><span class="special">::</span><span class="identifier">socket</span> <span class="identifier">socket_</span><span class="special">;</span>
  <span class="identifier">mutable_buffers_1</span> <span class="identifier">in_buffer_</span><span class="special">;</span>
  <span class="identifier">mutable_buffers_1</span> <span class="identifier">out_buffer_</span><span class="special">;</span>
  <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">io_service</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;</span> <span class="identifier">strand_</span><span class="special">;</span>

  <span class="comment">// ...</span>

  <span class="keyword">void</span> <span class="identifier">do_read</span><span class="special">()</span>
  <span class="special">{</span>
    <span class="identifier">socket_</span><span class="special">.</span><span class="identifier">async_read_some</span><span class="special">(</span><span class="identifier">in_buffer_</span><span class="special">,</span>
      <span class="identifier">wrap</span><span class="special">(</span><span class="identifier">strand_</span><span class="special">,</span> <span class="special">[</span><span class="keyword">this</span><span class="special">](</span><span class="identifier">error_code</span> <span class="identifier">ec</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">n</span><span class="special">)</span>
        <span class="special">{</span>
          <span class="comment">// ... process input data ...</span>
          <span class="keyword">if</span> <span class="special">(!</span><span class="identifier">ec</span><span class="special">)</span> <span class="identifier">do_read</span><span class="special">();</span>
        <span class="special">}));</span>
  <span class="special">}</span>

  <span class="keyword">void</span> <span class="identifier">do_write</span><span class="special">()</span>
  <span class="special">{</span>
    <span class="comment">// ... generate output data ...</span>
    <span class="identifier">async_write</span><span class="special">(</span><span class="identifier">socket_</span><span class="special">,</span> <span class="identifier">out_buffer_</span><span class="special">,</span>
      <span class="identifier">wrap</span><span class="special">(</span><span class="identifier">strand_</span><span class="special">,</span> <span class="special">[</span><span class="keyword">this</span><span class="special">](</span><span class="identifier">error_code</span> <span class="identifier">ec</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">n</span><span class="special">)</span>
        <span class="special">{</span>
          <span class="keyword">if</span> <span class="special">(!</span><span class="identifier">ec</span><span class="special">)</span> <span class="identifier">do_write</span><span class="special">();</span>
        <span class="special">}));</span>
  <span class="special">}</span>
<span class="special">};</span>
</pre><p>
        The <code class="computeroutput"><span class="identifier">wrap</span></code> function is used
        to associated an executor with an object. In this example, we used <code class="computeroutput"><span class="identifier">wrap</span></code> to associated the strand with each
        of the lambdas. The <code class="computeroutput"><span class="identifier">wrap</span></code>
        function works with any executor or execution context. For example, here
        we associate a thread pool with a lamdba:
      </p><pre class="programlisting"><span class="identifier">async_getline</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cin</span><span class="special">,</span>
    <span class="identifier">wrap</span><span class="special">(</span><span class="identifier">pool</span><span class="special">,</span> <span class="special">[](</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">line</span><span class="special">)</span>
      <span class="special">{</span>
        <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Line: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">line</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
      <span class="special">}));</span>
</pre><p>
        Rather than using the <code class="computeroutput"><span class="identifier">wrap</span></code>
        function, the associated executor may be manually specified by providing
        a nested <code class="computeroutput"><span class="identifier">executor_type</span></code> typedef
        and <code class="computeroutput"><span class="identifier">get_executor</span><span class="special">()</span></code>
        member function.
      </p><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">line_printer</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
  <span class="keyword">typedef</span> <span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span> <span class="identifier">executor_type</span><span class="special">;</span>

  <span class="keyword">explicit</span> <span class="identifier">line_printer</span><span class="special">(</span><span class="identifier">loop_scheduler</span><span class="special">&amp;</span> <span class="identifier">s</span><span class="special">)</span>
    <span class="special">:</span> <span class="identifier">executor_</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">())</span>
  <span class="special">{</span>
  <span class="special">}</span>

  <span class="identifier">executor_type</span> <span class="identifier">get_executor</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span>
  <span class="special">{</span>
    <span class="keyword">return</span> <span class="identifier">executor_</span><span class="special">;</span>
  <span class="special">}</span>

  <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">line</span><span class="special">)</span>
  <span class="special">{</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Line: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">line</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
  <span class="special">}</span>

<span class="keyword">private</span><span class="special">:</span>
  <span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span> <span class="identifier">executor_</span><span class="special">;</span>
<span class="special">};</span>

<span class="comment">// ...</span>

<span class="identifier">async_getline</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cin</span><span class="special">,</span> <span class="identifier">line_printer</span><span class="special">(</span><span class="identifier">scheduler</span><span class="special">));</span>
</pre><p>
        For this to work correctly, the <code class="computeroutput"><span class="identifier">async_getline</span></code>
        asynchronous operation must participate in an executor-aware model. To be
        executor-aware, an asynchronous operation must:
      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
            Ask the completion handler for its associated executor, by calling <code class="computeroutput"><span class="identifier">get_associated_executor</span></code>.
          </li><li class="listitem">
            While pending, maintain an <code class="computeroutput"><span class="identifier">executor_work</span></code>
            object for the associated executor. This tells the executor to expect
            a function object to be submitted in the future. A thread pool, for example,
            will know that it still has work to do and needs to keep running.
          </li><li class="listitem">
            Dispatch, post or defer any intermediate handlers, and the final completion
            handler, through the associated executor. This ensures that all handlers
            are executed according to the executors rules.
          </li></ul></div><p>
        Our <code class="computeroutput"><span class="identifier">async_getline</span></code> operation
        can then be written as follows:
      </p><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Handler</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">async_getline</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">&amp;</span> <span class="identifier">is</span><span class="special">,</span> <span class="identifier">Handler</span> <span class="identifier">handler</span><span class="special">)</span>
<span class="special">{</span>
</pre><p>
        The <code class="computeroutput"><span class="identifier">make_work</span></code> function automatically
        obtains the associated executor and creates an <code class="computeroutput"><span class="identifier">executor_work</span></code>
        object for it.
      </p><pre class="programlisting">  <span class="keyword">auto</span> <span class="identifier">work</span> <span class="special">=</span> <span class="identifier">make_work</span><span class="special">(</span><span class="identifier">handler</span><span class="special">);</span>
</pre><p>
        The asynchronous operation itself is posted outside of the associated executor.
        This is because we want the line reading to be performed asynchronously with
        respect to the caller.
      </p><pre class="programlisting">  <span class="identifier">post</span><span class="special">([&amp;</span><span class="identifier">is</span><span class="special">,</span> <span class="identifier">work</span><span class="special">,</span> <span class="identifier">handler</span><span class="special">=</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)]()</span> <span class="keyword">mutable</span>
      <span class="special">{</span>
        <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">line</span><span class="special">;</span>
        <span class="identifier">std</span><span class="special">::</span><span class="identifier">getline</span><span class="special">(</span><span class="identifier">is</span><span class="special">,</span> <span class="identifier">line</span><span class="special">);</span>
</pre><p>
        Once the asynchronous work is complete, we execute the completion handler
        via its associated executor.
      </p><pre class="programlisting">        <span class="comment">// Pass the result to the handler, via the associated executor.</span>
        <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">work</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">(),</span>
            <span class="special">[</span><span class="identifier">line</span><span class="special">=</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">line</span><span class="special">),</span> <span class="identifier">handler</span><span class="special">=</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)]()</span> <span class="keyword">mutable</span>
            <span class="special">{</span>
              <span class="identifier">handler</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">line</span><span class="special">));</span>
            <span class="special">});</span>
      <span class="special">});</span>
<span class="special">}</span>
</pre><div class="sidebar"><p class="title"><b></b></p><p>
        See complete example at:<br> <a href="https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/async_op_1.cpp" target="_top">https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/async_op_1.cpp</a>
      </p></div><p>
        When composing asynchronous operations, intermediate operations can simply
        reuse the associated executor of the final handler.
      </p><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Handler</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">async_getlines</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">&amp;</span> <span class="identifier">is</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">init</span><span class="special">,</span> <span class="identifier">Handler</span> <span class="identifier">handler</span><span class="special">)</span>
<span class="special">{</span>
  <span class="comment">// Get the final handler's associated executor.</span>
  <span class="keyword">auto</span> <span class="identifier">ex</span> <span class="special">=</span> <span class="identifier">get_associated_executor</span><span class="special">(</span><span class="identifier">handler</span><span class="special">);</span>

  <span class="comment">// Use the associated executor for each operation in the composition.</span>
  <span class="identifier">async_getline</span><span class="special">(</span><span class="identifier">is</span><span class="special">,</span>
      <span class="identifier">wrap</span><span class="special">(</span><span class="identifier">ex</span><span class="special">,</span> <span class="special">[&amp;</span><span class="identifier">is</span><span class="special">,</span> <span class="identifier">lines</span><span class="special">=</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">init</span><span class="special">),</span> <span class="identifier">handler</span><span class="special">=</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)]</span>
        <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">line</span><span class="special">)</span> <span class="keyword">mutable</span>
        <span class="special">{</span>
          <span class="keyword">if</span> <span class="special">(</span><span class="identifier">line</span><span class="special">.</span><span class="identifier">empty</span><span class="special">())</span>
            <span class="identifier">handler</span><span class="special">(</span><span class="identifier">lines</span><span class="special">);</span>
          <span class="keyword">else</span>
            <span class="identifier">async_getlines</span><span class="special">(</span><span class="identifier">is</span><span class="special">,</span> <span class="identifier">lines</span> <span class="special">+</span> <span class="identifier">line</span> <span class="special">+</span> <span class="string">"\n"</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">));</span>
        <span class="special">}));</span>
<span class="special">}</span>
</pre><p>
        This ensures that all intermediate completion handlers are correctly executed
        according to the caller's executor's rules.
      </p><div class="sidebar"><p class="title"><b></b></p><p>
        See complete example at:<br> <a href="https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/async_op_2.cpp" target="_top">https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/async_op_2.cpp</a>
      </p></div></div><div class="section" title="6.6.&#160;Pipelines"><div class="titlepage"><div><div><h3 class="title"><a name="executors.pipelines"></a>6.6.&#160;Pipelines</h3></div></div></div><p>
        A pipeline is a sequence of two or more long-running functions, known as
        stages, with each stage passing data to the next via a queue. The initial
        stage acts as a source of data, the intermediate stages act as filters, and
        the final stage as a sink.
      </p><p>
        As an example, let us consider a small framework for implementing pipelines.
        The function used to construct a pipeline is declared as:
      </p><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Tail</span><span class="special">&gt;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">future</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;</span> <span class="identifier">pipeline</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">Tail</span><span class="special">...</span> <span class="identifier">t</span><span class="special">);</span>
</pre><p>
        This function returns a <code class="computeroutput"><span class="identifier">future</span></code>
        that can be used to wait until the pipeline is complete. The initial stage
        of the pipeline must be a function with signature:
      </p><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">initial</span><span class="special">(</span><span class="identifier">queue_front</span><span class="special">&lt;</span><span class="identifier">T</span><sub><span class="emphasis"><em>0</em></span></sub><span class="special">&gt;</span> <span class="identifier">out</span><span class="special">);</span>
</pre><p>
        The intermediate stages have signature:
      </p><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">intermediate</span><span class="special">(</span><span class="identifier">queue_back</span><span class="special">&lt;</span><span class="identifier">T</span><sub><span class="emphasis"><em>n</em></span></sub><span class="special">&gt;</span> <span class="identifier">in</span><span class="special">,</span> <span class="identifier">queue_front</span><span class="special">&lt;</span><span class="identifier">T</span><sub><span class="emphasis"><em>n+1</em></span></sub><span class="special">&gt;</span> <span class="identifier">out</span><span class="special">);</span>
</pre><p>
        The pipeline's final stage has the signature:
      </p><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">final</span><span class="special">(</span><span class="identifier">queue_back</span><span class="special">&lt;</span><span class="identifier">T</span><sub><span class="emphasis"><em>N</em></span></sub><span class="special">&gt;</span> <span class="identifier">in</span><span class="special">);</span>
</pre><p>
        By default, we want each stage of a pipeline to have its own thread. The
        pipeline framework achieves this by calling <code class="computeroutput"><span class="identifier">get_associated_executor</span></code>
        with two arguments:
      </p><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Tail</span><span class="special">&gt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">future</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;</span> <span class="identifier">pipeline</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">Tail</span><span class="special">...</span> <span class="identifier">t</span><span class="special">)</span>
<span class="special">{</span>
  <span class="comment">// ...</span>
  <span class="keyword">auto</span> <span class="identifier">ex</span> <span class="special">=</span> <span class="identifier">get_associated_executor</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">thread_executor</span><span class="special">());</span>
  <span class="comment">// ...</span>
<span class="special">}</span>
</pre><p>
        The <code class="computeroutput"><span class="identifier">thread_executor</span></code> class
        is a custom executor type defined for the example. It starts a new thread
        for every function passed to <code class="computeroutput"><span class="identifier">dispatch</span></code>,
        <code class="computeroutput"><span class="identifier">post</span></code> or <code class="computeroutput"><span class="identifier">defer</span></code>.
        If the function object type <code class="computeroutput"><span class="identifier">F</span></code>
        already has an associated executor then that executor will be used. The
        <code class="computeroutput"><span class="identifier">thread_executor</span></code> is used for
        types that do not specify an associated executor.
      </p><p>
        So, when we construct and run a pipeline like this:
      </p><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">reader</span><span class="special">(</span><span class="identifier">queue_front</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;</span> <span class="identifier">out</span><span class="special">);</span>
<span class="keyword">void</span> <span class="identifier">filter</span><span class="special">(</span><span class="identifier">queue_back</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;</span> <span class="identifier">in</span><span class="special">,</span> <span class="identifier">queue_front</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;</span> <span class="identifier">out</span><span class="special">);</span>
<span class="keyword">void</span> <span class="identifier">upper</span><span class="special">(</span><span class="identifier">queue_back</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;</span> <span class="identifier">in</span><span class="special">,</span> <span class="identifier">queue_front</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;</span> <span class="identifier">out</span><span class="special">);</span>
<span class="keyword">void</span> <span class="identifier">writer</span><span class="special">(</span><span class="identifier">queue_back</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;</span> <span class="identifier">in</span><span class="special">);</span>

<span class="comment">// ...</span>

<span class="identifier">thread_pool</span> <span class="identifier">pool</span><span class="special">;</span>
<span class="keyword">auto</span> <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">pipeline</span><span class="special">(</span><span class="identifier">reader</span><span class="special">,</span> <span class="identifier">filter</span><span class="special">,</span> <span class="identifier">wrap</span><span class="special">(</span><span class="identifier">pool</span><span class="special">,</span> <span class="identifier">upper</span><span class="special">),</span> <span class="identifier">writer</span><span class="special">);</span>
<span class="identifier">f</span><span class="special">.</span><span class="identifier">wait</span><span class="special">();</span>
</pre><p>
        we are specifying that the the <code class="computeroutput"><span class="identifier">upper</span></code>
        stage should run on the thread pool, while <code class="computeroutput"><span class="identifier">reader</span></code>,
        <code class="computeroutput"><span class="identifier">filter</span></code> and <code class="computeroutput"><span class="identifier">writer</span></code> should use the default behaviour
        of launching a new thread.
      </p><div class="sidebar"><p class="title"><b></b></p><p>
        See complete example at:<br> <a href="https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/pipeline.cpp" target="_top">https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/pipeline.cpp</a>
      </p></div></div><div class="section" title="6.7.&#160;Actors"><div class="titlepage"><div><div><h3 class="title"><a name="executors.actors"></a>6.7.&#160;Actors</h3></div></div></div><p>
        The Actor model is a model for concurrency where objects, known as actors,
        communicate only by sending and receiving messages. Each actor's state is
        accessed only by its own internal thread or strand. This means that actors
        are inherently thread-safe.
      </p><p>
        To illustrate how executors may be used to facilitate actors, a tiny actor
        framework is included with the executors reference implementation. This framework
        is loosely based on the Theron library<sup>[<a name="executors.library_examples.actors.f0" href="#ftn.executors.library_examples.actors.f0" class="footnote">2</a>]</sup>.
      </p><p>
        To implement an actor using this framework, we start by deriving a class
        from <code class="computeroutput"><span class="identifier">actor</span></code>:
      </p><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">member</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">actor</span>
<span class="special">{</span>
  <span class="comment">// ...</span>
</pre><p>
        When constructing an actor, we specify the executor to be used:
      </p><pre class="programlisting">  <span class="keyword">explicit</span> <span class="identifier">member</span><span class="special">(</span><span class="identifier">executor</span> <span class="identifier">e</span><span class="special">)</span>
    <span class="special">:</span> <span class="identifier">actor</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">e</span><span class="special">))</span>
  <span class="special">{</span>
    <span class="comment">// ...</span>
  <span class="special">}</span>
</pre><p>
        The polymorphic type <code class="computeroutput"><span class="identifier">executor</span></code>
        is used to allow the selection of an actor's executor to be delayed until
        runtime. All of an actor's message handlers are executed according to that
        policy. This could be a thread pool executor, but we may equally construct
        actors with an executor that <a class="link" href="#executors.priority_scheduler" title="6.8.&#160;Priority scheduler">knows
        about priorities</a>.
      </p><p>
        The actor's message handlers are member functions, identified by argument
        type, and may be arbitrarily registered or deregistered:
      </p><pre class="programlisting">  <span class="keyword">void</span> <span class="identifier">init_handler</span><span class="special">(</span><span class="identifier">actor_address</span> <span class="identifier">next</span><span class="special">,</span> <span class="identifier">actor_address</span> <span class="identifier">from</span><span class="special">)</span>
  <span class="special">{</span>
    <span class="comment">// ...</span>
    <span class="identifier">register_handler</span><span class="special">(&amp;</span><span class="identifier">member</span><span class="special">::</span><span class="identifier">token_handler</span><span class="special">);</span>
    <span class="identifier">deregister_handler</span><span class="special">(&amp;</span><span class="identifier">member</span><span class="special">::</span><span class="identifier">init_handler</span><span class="special">);</span>
  <span class="special">}</span>
</pre><p>
        Internally, the actor framework uses a per-actor <code class="computeroutput"><span class="identifier">strand</span></code>
        to ensure that the member functions are never called concurrently.
      </p><p>
        To send a message between actors we use either <code class="computeroutput"><span class="identifier">actor</span><span class="special">::</span><span class="identifier">send</span><span class="special">()</span></code> or <code class="computeroutput"><span class="identifier">actor</span><span class="special">::</span><span class="identifier">tail_send</span><span class="special">()</span></code>. The <code class="computeroutput"><span class="identifier">send</span><span class="special">()</span></code> operation is implemented in terms of the
        actor's executor's <code class="computeroutput"><span class="identifier">post</span><span class="special">()</span></code>
        member function. The <code class="computeroutput"><span class="identifier">tail_send</span><span class="special">()</span></code> function is a distinct operation and conveys
        additional information about the caller's intent which may be used to optimise
        inter-actor messaging. It is implemented in terms of <code class="computeroutput"><span class="identifier">defer</span><span class="special">()</span></code>.
      </p><pre class="programlisting">  <span class="keyword">void</span> <span class="identifier">token_handler</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">token</span><span class="special">,</span> <span class="identifier">actor_address</span> <span class="comment">/*from*/</span><span class="special">)</span>
  <span class="special">{</span>
    <span class="comment">// ...</span>
    <span class="identifier">tail_send</span><span class="special">(</span><span class="identifier">msg</span><span class="special">,</span> <span class="identifier">to</span><span class="special">);</span>
  <span class="special">}</span>

  <span class="comment">// ...</span>
<span class="special">};</span>
</pre><div class="sidebar"><p class="title"><b></b></p><p>
        See complete example at:<br> <a href="https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/actor.cpp" target="_top">https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/actor.cpp</a>
      </p></div></div><div class="section" title="6.8.&#160;Priority scheduler"><div class="titlepage"><div><div><h3 class="title"><a name="executors.priority_scheduler"></a>6.8.&#160;Priority scheduler</h3></div></div></div><p>
        Executor objects are lightweight and copyable to allow us to encapsulate
        all sorts of additional information and behaviour on a fine-grained basis.
        One use case for this is attaching priorities to function objects or tasks.
      </p><p>
        We begin by defining our priority scheduler class as an execution context.
        Internally, this class uses a priority queue to store pending function objects.
      </p><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">priority_scheduler</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">execution_context</span>
<span class="special">{</span>
  <span class="comment">// ...</span>

<span class="keyword">private</span><span class="special">:</span>

  <span class="comment">// ...</span>

  <span class="keyword">struct</span> <span class="identifier">item_comp</span>
  <span class="special">{</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">()(</span>
        <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">item_base</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span>
        <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">item_base</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">)</span>
    <span class="special">{</span>
      <span class="keyword">return</span> <span class="identifier">a</span><span class="special">-&gt;</span><span class="identifier">priority_</span> <span class="special">&lt;</span> <span class="identifier">b</span><span class="special">-&gt;</span><span class="identifier">priority_</span><span class="special">;</span>
    <span class="special">}</span>
  <span class="special">};</span>

  <span class="identifier">std</span><span class="special">::</span><span class="identifier">mutex</span> <span class="identifier">mutex_</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">condition_variable</span> <span class="identifier">condition_</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">priority_queue</span><span class="special">&lt;</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">item_base</span><span class="special">&gt;,</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">item_base</span><span class="special">&gt;&gt;,</span>
    <span class="identifier">item_comp</span><span class="special">&gt;</span> <span class="identifier">queue_</span><span class="special">;</span>
  <span class="keyword">bool</span> <span class="identifier">stopped_</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
        The <code class="computeroutput"><span class="identifier">priority_scheduler</span></code> class
        provides a nested class <code class="computeroutput"><span class="identifier">executor_type</span></code>
        which satisfies the executor type requirements, and a member function <code class="computeroutput"><span class="identifier">get_executor</span><span class="special">()</span></code>
        to obtain an executor object. On construction, an <code class="computeroutput"><span class="identifier">executor_type</span></code>
        object captures a reference to the priority scheduler, as well as the specified
        priority value.
      </p><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">priority_scheduler</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">execution_context</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
  <span class="keyword">class</span> <span class="identifier">executor_type</span>
  <span class="special">{</span>
  <span class="keyword">public</span><span class="special">:</span>
    <span class="identifier">executor_type</span><span class="special">(</span><span class="identifier">priority_scheduler</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">pri</span><span class="special">)</span> <span class="keyword">noexcept</span>
      <span class="special">:</span> <span class="identifier">context_</span><span class="special">(</span><span class="identifier">ctx</span><span class="special">),</span> <span class="identifier">priority_</span><span class="special">(</span><span class="identifier">pri</span><span class="special">)</span>
    <span class="special">{</span>
    <span class="special">}</span>

    <span class="comment">// ...</span>

  <span class="keyword">private</span><span class="special">:</span>
    <span class="identifier">priority_scheduler</span><span class="special">&amp;</span> <span class="identifier">context_</span><span class="special">;</span>
    <span class="keyword">int</span> <span class="identifier">priority_</span><span class="special">;</span>
  <span class="special">};</span>

  <span class="identifier">executor_type</span> <span class="identifier">get_executor</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">pri</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">noexcept</span>
  <span class="special">{</span>
    <span class="keyword">return</span> <span class="identifier">executor_type</span><span class="special">(*</span><span class="keyword">this</span><span class="special">,</span> <span class="identifier">pri</span><span class="special">);</span>
  <span class="special">}</span>

  <span class="comment">// ...</span>
<span class="special">};</span>
</pre><p>
        When a function object is submitted, the executor uses its stored priority
        to insert the function into the correct position in the priority queue:
      </p><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">priority_scheduler</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">execution_context</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
  <span class="keyword">class</span> <span class="identifier">executor_type</span>
  <span class="special">{</span>
  <span class="keyword">public</span><span class="special">:</span>

    <span class="comment">// ...</span>

    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">Func</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">)</span>
    <span class="special">{</span>
      <span class="keyword">auto</span> <span class="identifier">p</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">allocate_shared</span><span class="special">&lt;</span><span class="identifier">item</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;&gt;(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">priority_</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">)));</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">lock_guard</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">mutex</span><span class="special">&gt;</span> <span class="identifier">lock</span><span class="special">(</span><span class="identifier">context_</span><span class="special">.</span><span class="identifier">mutex_</span><span class="special">);</span>
      <span class="identifier">context_</span><span class="special">.</span><span class="identifier">queue_</span><span class="special">.</span><span class="identifier">push</span><span class="special">(</span><span class="identifier">p</span><span class="special">);</span>
      <span class="identifier">context_</span><span class="special">.</span><span class="identifier">condition_</span><span class="special">.</span><span class="identifier">notify_one</span><span class="special">();</span>
    <span class="special">}</span>

    <span class="comment">// ...</span>
  <span class="special">};</span>

  <span class="comment">// ...</span>
<span class="special">};</span>
</pre><p>
        The priority scheduler's executors can then be used like any other:
      </p><pre class="programlisting"><span class="identifier">priority_scheduler</span> <span class="identifier">sched</span><span class="special">;</span>
<span class="keyword">auto</span> <span class="identifier">low</span> <span class="special">=</span> <span class="identifier">sched</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">(</span><span class="number">0</span><span class="special">);</span>
<span class="keyword">auto</span> <span class="identifier">med</span> <span class="special">=</span> <span class="identifier">sched</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>
<span class="keyword">auto</span> <span class="identifier">high</span> <span class="special">=</span> <span class="identifier">sched</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
<span class="comment">// ...</span>
<span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">low</span><span class="special">,</span> <span class="special">[]{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"1\n"</span><span class="special">;</span> <span class="special">});</span>
<span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">med</span><span class="special">,</span> <span class="special">[]{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"2\n"</span><span class="special">;</span> <span class="special">});</span>
<span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">high</span><span class="special">,</span> <span class="special">[]{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"3\n"</span><span class="special">;</span> <span class="special">});</span>
</pre><div class="sidebar"><p class="title"><b></b></p><p>
        See complete example at:<br> <a href="https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/priority_scheduler.cpp" target="_top">https://github.com/chriskohlhoff/executors/blob/master/src/examples/executor/priority_scheduler.cpp</a>
      </p></div></div></div><div class="section" title="7.&#160;Summary of library facilities"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="executors.summary_of_library_facilities"></a>7.&#160;Summary of library facilities</h2></div></div></div><div class="informaltable"><table class="table"><colgroup><col><col><col></colgroup><thead><tr><th>
              <p>
                Header
              </p>
            </th><th>
              <p>
                Name
              </p>
            </th><th>
              <p>
                Description
              </p>
            </th></tr></thead><tbody><tr><td>
              <p>
                <code class="literal">type_traits</code>
              </p>
            </td><td>
              <p>
                Class template <code class="literal">handler_type</code>
              </p>
            </td><td>
              <p>
                Transforms a completion token into a completion handler.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">type_traits</code>
              </p>
            </td><td>
              <p>
                Class template <code class="literal">async_result</code>
              </p>
            </td><td>
              <p>
                Determines the result of an asynchronous operation&#8217;s initiating
                function.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">type_traits</code>
              </p>
            </td><td>
              <p>
                Class template <code class="literal">async_completion</code>
              </p>
            </td><td>
              <p>
                Helper to simplify implementation of an asynchronous operation.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">memory</code>
              </p>
            </td><td>
              <p>
                Class template <code class="literal">associated_allocator</code>
              </p>
            </td><td>
              <p>
                Used to determine a handler&#8217;s associated allocator.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">memory</code>
              </p>
            </td><td>
              <p>
                Function <code class="literal">get_associated_allocator</code>
              </p>
            </td><td>
              <p>
                Obtain a handler&#8217;s associated allocator.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">executor</code>
              </p>
            </td><td>
              <p>
                Class template <code class="literal">execution_context</code>
              </p>
            </td><td>
              <p>
                Base class for execution context types.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">executor</code>
              </p>
            </td><td>
              <p>
                Class template <code class="literal">associated_executor</code>
              </p>
            </td><td>
              <p>
                Used to determine a handler&#8217;s associated executor.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">executor</code>
              </p>
            </td><td>
              <p>
                Function <code class="literal">get_associated_executor</code>
              </p>
            </td><td>
              <p>
                Obtain a handler&#8217;s associated executor.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">executor</code>
              </p>
            </td><td>
              <p>
                Class template <code class="literal">executor_wrapper</code>
              </p>
            </td><td>
              <p>
                Associates an executor with an object.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">executor</code>
              </p>
            </td><td>
              <p>
                Function <code class="literal">wrap</code>
              </p>
            </td><td>
              <p>
                Associate an executor with an object.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">executor</code>
              </p>
            </td><td>
              <p>
                Class template <code class="literal">executor_work</code>
              </p>
            </td><td>
              <p>
                Tracks outstanding work against an executor.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">executor</code>
              </p>
            </td><td>
              <p>
                Function <code class="literal">make_work</code>
              </p>
            </td><td>
              <p>
                Create work to track an outstanding operation.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">executor</code>
              </p>
            </td><td>
              <p>
                Class <code class="literal">system_executor</code>
              </p>
            </td><td>
              <p>
                Executor representing all threads in system.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">executor</code>
              </p>
            </td><td>
              <p>
                Class <code class="literal">executor</code>
              </p>
            </td><td>
              <p>
                Polymorphic wrapper for executors.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">executor</code>
              </p>
            </td><td>
              <p>
                Functions <code class="literal">dispatch</code>, <code class="literal">post</code> and
                <code class="literal">defer</code>
              </p>
            </td><td>
              <p>
                Execute a function object.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">strand</code>
              </p>
            </td><td>
              <p>
                Class template <code class="literal">strand</code>
              </p>
            </td><td>
              <p>
                Executor adapter than runs function objects non-concurrently and
                in FIFO order.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">timer</code>
              </p>
            </td><td>
              <p>
                Functions <code class="literal">dispatch_at</code>, <code class="literal">post_at</code>
                and <code class="literal">defer_at</code>
              </p>
            </td><td>
              <p>
                Execute a function object at an absolute time.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">timer</code>
              </p>
            </td><td>
              <p>
                Functions <code class="literal">dispatch_after</code>, <code class="literal">post_after</code>
                and <code class="literal">defer_after</code>
              </p>
            </td><td>
              <p>
                Execute a function object after a relative time.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">future</code>
              </p>
            </td><td>
              <p>
                Class template <code class="literal">use_future_t</code>
              </p>
            </td><td>
              <p>
                Completion token to enable futures with asynchronous operations.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">future</code>
              </p>
            </td><td>
              <p>
                Class template specialization of <code class="literal">async_result</code>
                for <code class="literal">packaged_task</code>
              </p>
            </td><td>
              <p>
                Supports use of packaged_task with dispatch, post, defer, and asynchronous
                operations.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">future</code>
              </p>
            </td><td>
              <p>
                Class templates <code class="literal">packaged_token</code> and <code class="literal">packaged_handler</code>
              </p>
            </td><td>
              <p>
                Implements lazy creation of a packaged_task.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">future</code>
              </p>
            </td><td>
              <p>
                Function <code class="literal">package</code>
              </p>
            </td><td>
              <p>
                Return a <code class="literal">packaged_token</code> for use with dispatch,
                post, defer, and asynchronous operations.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">thread_pool</code>
              </p>
            </td><td>
              <p>
                Class <code class="literal">thread_pool</code>
              </p>
            </td><td>
              <p>
                A fixed size thread pool.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">loop_scheduler</code>
              </p>
            </td><td>
              <p>
                Class <code class="literal">loop_scheduler</code>
              </p>
            </td><td>
              <p>
                A thread pool where threads are explicitly donated by the caller.
              </p>
            </td></tr></tbody></table></div></div><div class="section" title="8.&#160;On the naming of executors"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="executors.on_the_naming_of_executors"></a>8.&#160;On the naming of executors</h2></div></div></div><p>
      There has been some confusion due to the reuse of the term <span class="emphasis"><em>executor</em></span>
      in N3785 and this proposal, but with slightly different meanings. In N3785,
      an "executor" refers to a heavyweight, non-copyable object, such
      as a thread pool. In this proposal, an "executor" is a lightweight,
      copyable policy object. This is distinct from a heavyweight object such as
      a thread pool, which is known as an "execution context".
    </p><p>
      N3785's API is superficially similar to Java executors, so it is interesting
      to examine the Java prior art in this area. What we find is that N3785 misses
      a key concept: the separation of <code class="computeroutput"><span class="identifier">Executor</span></code>
      and <code class="computeroutput"><span class="identifier">ExecutorService</span></code>. On the
      other hand, it turns out that this proposal's "executor" mirrors
      the concept <span class="emphasis"><em>and</em></span> terminology of Java executors.
    </p><p>
      Let us start by reviewing a couple of the core interfaces of the Java executor
      framework: <span class="emphasis"><em><a href="http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html" target="_top">http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html</a></em></span>
    </p><p>
      First, we have interface <code class="computeroutput"><span class="identifier">Executor</span></code>.
      This interface provides a way of submitting a <code class="computeroutput"><span class="identifier">Runnable</span></code>
      (i.e. the equivalent of a function object) for execution, and it decouples
      the submission from the concrete mechanism which runs the function.
    </p><p>
      Second, we have interface <code class="computeroutput"><span class="identifier">ExecutorService</span></code>.
      This extends <code class="computeroutput"><span class="identifier">Executor</span></code>, i.e.
      <code class="computeroutput"><span class="identifier">ExecutorService</span></code> <span class="emphasis"><em>is-a</em></span>
      Executor. It adds some additional functionality, such as the ability to request
      that it be shut down.
    </p><p>
      A thread pool <span class="emphasis"><em>is-a</em></span> <code class="computeroutput"><span class="identifier">ExecutorService</span></code>.
      A fork/join pool <span class="emphasis"><em>is-a</em></span> <code class="computeroutput"><span class="identifier">ExecutorService</span></code>.
      An <code class="computeroutput"><span class="identifier">ExecutorService</span></code> represents
      a heavyweight entity where <code class="computeroutput"><span class="identifier">Runnable</span></code>
      items are run.
    </p><p>
      A <code class="computeroutput"><span class="identifier">SerialExecutor</span></code> <span class="emphasis"><em>is-a</em></span>
      <code class="computeroutput"><span class="identifier">Executor</span></code>. A thread-per-task
      executor <span class="emphasis"><em>is-a</em></span> <code class="computeroutput"><span class="identifier">Executor</span></code>.
      An executor represents a policy. Where there is a customisation point (as in
      the <code class="computeroutput"><span class="identifier">ExecutorCompletionService</span></code>
      class) it is specified as an <code class="computeroutput"><span class="identifier">Executor</span></code>.
    </p><p>
      When we want to create our own policy, we do it by implementing the <code class="computeroutput"><span class="identifier">Executor</span></code> interface. Our <code class="computeroutput"><span class="identifier">Executor</span></code>
      policy object can be short lived, or it can be long lived. As we are using
      Java, the object is newed and we let the garbage collector take care of it.
      In fact, we don't really have a choice.
    </p><p>
      Java is not C++. Java references are not C++ references, nor are they C++ pointers.
      We do not have the garbage collector to clean up after us. Yet, and this is
      especially true of concurrent code, correctly managing object lifetime is critical.
      How do we address this in C++? The idiomatic approach is to use value semantics.
    </p><p>
      Thus our <code class="computeroutput"><span class="identifier">Executor</span></code> policy object
      should use value semantics. We should be able to copy it and move it freely.
      Where a particular concrete <code class="computeroutput"><span class="identifier">Executor</span></code>
      uses some allocated resource, the constructors and destructors can manage the
      resource lifetime, just as we do in other standard library components.
    </p><p>
      Of course, we do want to be able to use a heavyweight thread pool as an <code class="computeroutput"><span class="identifier">Executor</span></code>. In Java, the thread pool <span class="emphasis"><em>is-a</em></span>
      <code class="computeroutput"><span class="identifier">ExecutorService</span></code> which <span class="emphasis"><em>is-a</em></span>
      <code class="computeroutput"><span class="identifier">Executor</span></code>, so we are able to
      use the heavyweight object in the same way as a lightweight one. Once again,
      this is because of Java's reference semantics, where basically all objects
      are treated the same, whether light or heavy.
    </p><p>
      In C++, however, our heavyweight thread pool may be best represented by a non-copyable
      type. This presents a challenge: how do we establish a pattern where we can
      pass either a noncopyable type or a type with value semantics? That is, how
      can we have an interface where we can pass either a heavyweight <code class="computeroutput"><span class="identifier">ExecutorService</span></code> or a lightweight <code class="computeroutput"><span class="identifier">Executor</span></code>?
    </p><p>
      The solution is to change the relationship between <code class="computeroutput"><span class="identifier">ExecutorService</span></code>
      and <code class="computeroutput"><span class="identifier">Executor</span></code>. Rather than saying
      an <code class="computeroutput"><span class="identifier">ExecutorService</span></code> <span class="emphasis"><em>is-a</em></span>
      <code class="computeroutput"><span class="identifier">Executor</span></code>, we instead say an
      <code class="computeroutput"><span class="identifier">ExecutorService</span></code> <span class="bold"><strong><span class="emphasis"><em>has-a</em></span></strong></span>
      <code class="computeroutput"><span class="identifier">Executor</span></code>. Every <code class="computeroutput"><span class="identifier">ExecutorService</span></code> has an associated lightweight
      <code class="computeroutput"><span class="identifier">Executor</span></code> policy which encapsulates
      the submission logic. This lightweight <code class="computeroutput"><span class="identifier">Executor</span></code>
      provides the necessary value semantics.
    </p><p>
      Thus we can see that this proposal's "executor" is in fact the same
      concept as the Java <code class="computeroutput"><span class="identifier">Executor</span></code>.
      It is just that it is packaged in a way that is more idiomatic C++, i.e. it
      uses value semantics. This proposal's "execution context" concept
      is the equivalent of Java's <code class="computeroutput"><span class="identifier">ExecutorService</span></code>.
      The executor is the "how", a policy, and it logically performs the
      execution. The execution context or <code class="computeroutput"><span class="identifier">ExecutorService</span></code>
      is the "where", a venue if you like.
    </p><p>
      As we are using C++, and not Java, we get the same level of abstraction but
      with the benefits of compile time polymorphism, inlining, control over memory
      use, and using fewer allocations (i.e. we create less garbage). The reasons
      we are using C++ in the first place.
    </p><p>
      As we can see, the separation of executor from execution context clearly exists
      in the prior art represented by Java. However, this proposal's design is derived
      from Boost.Asio, and is very much driven by what is required to make asynchronous
      operations work, but with a desire to have a clean separation of concerns.
      The Java executors framework did not inform the design, yet it is not surprising
      that Java represents an example of convergent evolution, once we make a deeper
      analysis of the library.
    </p></div><div class="section" title="9.&#160;On the need for dispatch, post and defer"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="executors.on_the_need_for_dispatch__post_and_defer"></a>9.&#160;On the need for dispatch, post and defer</h2></div></div></div><p>
      Let us take another look at the specification of the Java <code class="computeroutput"><span class="identifier">Executor</span></code>
      class and its <code class="computeroutput"><span class="identifier">execute</span></code> method:
      <span class="emphasis"><em><a href="http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executor.html" target="_top">http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executor.html</a></em></span>
    </p><p>
      It says:
    </p><div class="blockquote"><blockquote class="blockquote"><p>
        <code class="computeroutput"><span class="keyword">void</span> <span class="identifier">execute</span><span class="special">(</span><span class="identifier">Runnable</span> <span class="identifier">command</span><span class="special">)</span></code><br>
        <br> <span class="emphasis"><em>Executes the given command at some time in the future. The
        command may execute in a new thread, in a pooled thread, or in the calling
        thread, at the discretion of the Executor implementation.</em></span>
      </p></blockquote></div><p>
      Note that the wording includes "in the calling thread". In fact,
      the specification of the execute method is essentially the same as the <code class="computeroutput"><span class="identifier">dispatch</span></code> function of this proposal.
    </p><p>
      As it is the only available <code class="computeroutput"><span class="identifier">Executor</span></code>
      method, this specification of <code class="computeroutput"><span class="identifier">execute</span></code>
      is a problem. Clearly there are times when we want to guarantee that a function
      will <span class="emphasis"><em>not</em></span> run in the calling thread, such as when we want
      launch a long running function. Unfortunately, if we are using an <code class="computeroutput"><span class="identifier">Executor</span></code> in a polymorphic context we have
      no way of knowing what behaviour we will get. We have to know the concrete
      executor type to ensure that it doesn't run in the calling thread.
    </p><p>
      Thus, we wish to introduce a function with slightly different semantics:
    </p><div class="blockquote"><blockquote class="blockquote"><p>
        <span class="emphasis"><em>Executes the given command at some time in the future. The command
        may execute in a new thread, in a pooled thread, at the discretion of the
        Executor implementation.</em></span>
      </p></blockquote></div><p>
      This is the <code class="computeroutput"><span class="identifier">post</span></code> function of
      this proposal, and it lets us as the caller ensure that a function does not
      run in the calling thread.
    </p><p>
      However, this does not obviate the need for the original semantics (i.e. the
      current Java semantics). There are times when it is to our advantage to allow
      a function to run in the calling thread. Some examples:
    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
          When using a strand (or a serial executor, in Java terminology) to ensure
          non-concurrent function execution. If the strand is not contended, we want
          to execute the function in the current thread. This will minimise latency
          and avoid the cost of a context switch.
        </li><li class="listitem">
          At the end of an asynchronous operation. We are unwrapping layers of composition
          and handing the result back through a stack of callbacks. A callback needs
          to run on its correct executor, but we do not want to unnecessarily incur
          a context switch or a cycle through the scheduler, as doing so significantly
          adds to the latency in processing the event.
        </li></ul></div><p>
      Interestingly, the specification of <code class="computeroutput"><span class="identifier">future</span><span class="special">::</span><span class="identifier">then</span></code> (now
      removed from the concurrency TS) that took an executor would also suffer from
      this extra cost unless it had access to dispatch semantics.
    </p><p>
      The <code class="computeroutput"><span class="identifier">defer</span></code> operation, like
      <code class="computeroutput"><span class="identifier">post</span></code>, does not allow the function
      to run in the calling thread. Where it differs is in the expression of the
      intent of the caller. Using <code class="computeroutput"><span class="identifier">defer</span></code>
      states that there is a relationship between the caller and callee, such as
      being consecutive links in a chain of function objects. An executor can make
      use of this to do smarter, more efficient scheduling.
    </p><p>
      For example, consider a chain of asynchronous read operations on a socket:
    </p><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">read_loop</span><span class="special">(</span><span class="identifier">Socket</span> <span class="identifier">socket</span><span class="special">,</span> <span class="identifier">Buffer</span> <span class="identifier">buffer</span><span class="special">)</span>
<span class="special">{</span>
  <span class="identifier">async_read</span><span class="special">(</span><span class="identifier">socket</span><span class="special">,</span> <span class="identifier">buffer</span><span class="special">,</span>
    <span class="special">[&amp;](</span><span class="identifier">error_code</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span>
      <span class="identifier">process_data</span><span class="special">(</span><span class="identifier">buffer</span><span class="special">,</span> <span class="identifier">n</span><span class="special">);</span>
      <span class="identifier">read_loop</span><span class="special">(</span><span class="identifier">socket</span><span class="special">,</span> <span class="identifier">buffer</span><span class="special">);</span>
    <span class="special">});</span>
<span class="special">}</span>
</pre><p>
      where an individual read operation is implemented something like this:
    </p><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Handler</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">async_read</span><span class="special">(</span><span class="identifier">Socket</span> <span class="identifier">socket</span><span class="special">,</span> <span class="identifier">Buffer</span> <span class="identifier">buffer</span><span class="special">,</span> <span class="identifier">Handler</span> <span class="identifier">handler</span><span class="special">)</span>
<span class="special">{</span>
  <span class="comment">// Perform a speculative read first.</span>
  <span class="identifier">error_code</span> <span class="identifier">ec</span><span class="special">;</span>
  <span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="identifier">non_blocking_read</span><span class="special">(</span><span class="identifier">socket</span><span class="special">,</span> <span class="identifier">buffer</span><span class="special">,</span> <span class="identifier">ec</span><span class="special">);</span>
  <span class="keyword">if</span> <span class="special">(</span><span class="identifier">ec</span> <span class="special">!=</span> <span class="identifier">would_block</span><span class="special">)</span>
  <span class="special">{</span>
    <span class="comment">// Read completed immediately, post handler.</span>
    <span class="identifier">ex</span> <span class="special">=</span> <span class="identifier">get_associated_executor</span><span class="special">(</span><span class="identifier">handler</span><span class="special">);</span>
    <span class="identifier">post</span><span class="special">(</span><span class="identifier">ex</span><span class="special">,</span> <span class="special">[=]{</span> <span class="identifier">handler</span><span class="special">(</span><span class="identifier">ec</span><span class="special">,</span> <span class="identifier">n</span><span class="special">);</span> <span class="special">});</span>
  <span class="special">}</span>
  <span class="keyword">else</span>
  <span class="special">{</span>
    <span class="comment">// Wait for socket to become readable.</span>
    <span class="comment">// ...</span>
  <span class="special">}</span>
<span class="special">}</span>
</pre><p>
      In certain circumstances the read operation will always complete immediately,
      such as when the data is already available in the kernel buffers. When this
      occurs, the sequence of operations is essentially equivalent to:
    </p><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">read_loop</span><span class="special">(</span><span class="identifier">socket</span><span class="special">,</span> <span class="identifier">buffer</span><span class="special">)</span>
<span class="special">{</span>
  <span class="comment">// ...</span>
  <span class="identifier">ex</span><span class="special">.</span><span class="identifier">post</span><span class="special">([&amp;]{</span> <span class="comment">// #1 <a name="post1"></a></span>
      <span class="identifier">read_loop</span><span class="special">(</span><span class="identifier">socket</span><span class="special">,</span> <span class="identifier">buffer</span><span class="special">);</span>
    <span class="special">});</span>
  <span class="comment">// ...</span>
<span class="special">}</span>
</pre><p>
      Let us assume that our executor <code class="computeroutput"><span class="identifier">ex</span></code>
      uses a thread pool with a mutex-protected queue:
    </p><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">my_thread_pool</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
  <span class="keyword">class</span> <span class="identifier">executor_type</span>
  <span class="special">{</span>
  <span class="keyword">public</span><span class="special">:</span>
    <span class="comment">// ...</span>

    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">Func</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">)</span>
    <span class="special">{</span>
      <span class="keyword">auto</span> <span class="identifier">p</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">allocate_shared</span><span class="special">&lt;</span><span class="identifier">item</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;&gt;(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">)));</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">lock_guard</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">mutex</span><span class="special">&gt;</span> <span class="identifier">lock</span><span class="special">(</span><span class="identifier">pool_</span><span class="special">.</span><span class="identifier">mutex_</span><span class="special">);</span> <span class="comment">// #2 <a name="post2"></a></span>
      <span class="identifier">pool_</span><span class="special">.</span><span class="identifier">queue_</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">p</span><span class="special">));</span> <span class="comment">// #3 <a name="post3"></a></span>
      <span class="identifier">pool_</span><span class="special">.</span><span class="identifier">condition_</span><span class="special">.</span><span class="identifier">notify_one</span><span class="special">();</span> <span class="comment">// #4 <a name="post4"></a></span>
      <span class="comment">// #5 <a name="post5"></a></span>
    <span class="special">}</span>

    <span class="comment">// ...</span>
  <span class="special">};</span>

  <span class="comment">// ...</span>

  <span class="keyword">void</span> <span class="identifier">run</span><span class="special">()</span>
  <span class="special">{</span>
    <span class="keyword">for</span> <span class="special">(;;)</span>
    <span class="special">{</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">unique_lock</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">mutex</span><span class="special">&gt;</span> <span class="identifier">lock</span><span class="special">(</span><span class="identifier">mutex_</span><span class="special">);</span> <span class="comment">// #6 <a name="post6"></a></span>
      <span class="identifier">condition_</span><span class="special">.</span><span class="identifier">wait</span><span class="special">(</span><span class="identifier">lock</span><span class="special">,</span> <span class="special">[&amp;]{</span> <span class="special">!</span><span class="identifier">queue_</span><span class="special">.</span><span class="identifier">empty</span><span class="special">();</span> <span class="special">});</span>
      <span class="keyword">auto</span> <span class="identifier">p</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">queue_</span><span class="special">.</span><span class="identifier">front</span><span class="special">()));</span> <span class="comment">// #7 <a name="post7"></a></span>
      <span class="identifier">queue_</span><span class="special">.</span><span class="identifier">pop_front</span><span class="special">();</span>
      <span class="identifier">lock</span><span class="special">.</span><span class="identifier">unlock</span><span class="special">();</span> <span class="comment">// #8 <a name="post8"></a></span>
      <span class="identifier">p</span><span class="special">-&gt;</span><span class="identifier">execute_</span><span class="special">(</span><span class="identifier">p</span><span class="special">);</span> <span class="comment">// #9 <a name="post9"></a></span>
    <span class="special">}</span>
  <span class="special">}</span>

<span class="keyword">private</span><span class="special">:</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">mutex</span> <span class="identifier">mutex_</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">condition_variable</span> <span class="identifier">condition_</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">deque</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">item_base</span><span class="special">&gt;&gt;</span> <span class="identifier">queue_</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
      There are two performance issues at play here. First, each "cycle"
      of <code class="computeroutput"><span class="identifier">read_loop</span></code> involves two lock/unlock
      pairs. Second, a condition variable may be used to wake a sleeping thread when
      the queue is non-empty. If we step through the code we will see the following:
    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
          <a class="link" href="#post6">#6</a> &#8212; lock
        </li><li class="listitem">
          <a class="link" href="#post7">#7</a> &#8212; dequeue <code class="computeroutput"><span class="identifier">read_loop</span></code>
        </li><li class="listitem">
          <a class="link" href="#post8">#8</a> &#8212; unlock
        </li><li class="listitem">
          <a class="link" href="#post9">#9</a> &#8212; call <code class="computeroutput"><span class="identifier">read_loop</span></code>
          <div class="itemizedlist"><ul class="itemizedlist" type="circle"><li class="listitem">
                <a class="link" href="#post1">#1</a> &#8212; call <code class="computeroutput"><span class="identifier">post</span></code>
                <div class="itemizedlist"><ul class="itemizedlist" type="square"><li class="listitem">
                      <a class="link" href="#post2">#2</a> &#8212; lock
                    </li><li class="listitem">
                      <a class="link" href="#post3">#3</a> &#8212; enqueue <code class="computeroutput"><span class="identifier">read_loop</span></code>
                    </li><li class="listitem">
                      <a class="link" href="#post4">#4</a> &#8212; notify
                    </li><li class="listitem">
                      <a class="link" href="#post5">#5</a> &#8212; unlock
                    </li></ul></div>
              </li></ul></div>
        </li><li class="listitem">
          <span class="emphasis"><em>(start of next cycle)</em></span>
        </li><li class="listitem">
          <a class="link" href="#post6">#6</a> &#8212; lock
        </li><li class="listitem">
          <a class="link" href="#post7">#7</a> &#8212; dequeue <code class="computeroutput"><span class="identifier">read_loop</span></code>
        </li><li class="listitem">
          <a class="link" href="#post8">#8</a> &#8212; unlock
        </li><li class="listitem">
          <a class="link" href="#post9">#9</a> &#8212; call <code class="computeroutput"><span class="identifier">read_loop</span></code>
        </li><li class="listitem">
          ...
        </li></ul></div><p>
      On the other hand, with <code class="computeroutput"><span class="identifier">defer</span></code>
      we are telling the executor that the submitted function is a continuation of
      the current one. That is, the executor does not have to eagerly schedule the
      function because we have told it that one function follows the other.
    </p><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">read_loop</span><span class="special">(</span><span class="identifier">socket</span><span class="special">,</span> <span class="identifier">buffer</span><span class="special">)</span>
<span class="special">{</span>
  <span class="comment">// ...</span>
  <span class="identifier">ex</span><span class="special">.</span><span class="identifier">defer</span><span class="special">([&amp;]{</span> <span class="comment">// #1 <a name="defer1"></a></span>
      <span class="identifier">read_loop</span><span class="special">(</span><span class="identifier">socket</span><span class="special">,</span> <span class="identifier">buffer</span><span class="special">);</span>
    <span class="special">});</span>
  <span class="comment">// ...</span>
<span class="special">}</span>

<span class="keyword">class</span> <span class="identifier">my_thread_pool</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
  <span class="keyword">class</span> <span class="identifier">executor_type</span>
  <span class="special">{</span>
  <span class="keyword">public</span><span class="special">:</span>
    <span class="comment">// ...</span>

    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">defer</span><span class="special">(</span><span class="identifier">Func</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">)</span>
    <span class="special">{</span>
      <span class="keyword">if</span> <span class="special">(</span><span class="identifier">pool_</span><span class="special">.</span><span class="identifier">thread_local_queue_</span><span class="special">)</span>
      <span class="special">{</span>
        <span class="keyword">auto</span> <span class="identifier">p</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">allocate_shared</span><span class="special">&lt;</span><span class="identifier">item</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;&gt;(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">)));</span>
        <span class="identifier">pool_</span><span class="special">.</span><span class="identifier">thread_local_queue_</span><span class="special">-&gt;</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">p</span><span class="special">));</span> <span class="comment">// #2 <a name="defer2"></a></span>
      <span class="special">}</span>
      <span class="keyword">else</span>
        <span class="identifier">post</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">),</span> <span class="identifier">a</span><span class="special">);</span>
    <span class="special">}</span>

    <span class="comment">// ...</span>
  <span class="special">};</span>

  <span class="comment">// ...</span>

  <span class="keyword">void</span> <span class="identifier">run</span><span class="special">()</span>
  <span class="special">{</span>
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">deque</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">item_base</span><span class="special">&gt;&gt;</span> <span class="identifier">local_queue</span><span class="special">;</span>
    <span class="identifier">thread_local_queue_</span> <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">local_queue</span><span class="special">;</span>
    <span class="keyword">for</span> <span class="special">(;;)</span>
    <span class="special">{</span>
      <span class="identifier">std</span><span class="special">::</span><span class="identifier">unique_lock</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">mutex</span><span class="special">&gt;</span> <span class="identifier">lock</span><span class="special">(</span><span class="identifier">mutex_</span><span class="special">);</span> <span class="comment">// #3 <a name="defer3"></a></span>
      <span class="keyword">while</span> <span class="special">(!</span><span class="identifier">local_queue</span><span class="special">.</span><span class="identifier">empty</span><span class="special">())</span> <span class="comment">// #4 <a name="defer4"></a></span>
      <span class="special">{</span>
        <span class="identifier">queue_</span><span class="special">.</span><span class="identifier">push</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">local_queue</span><span class="special">.</span><span class="identifier">front</span><span class="special">()));</span>
        <span class="identifier">local_queue</span><span class="special">.</span><span class="identifier">pop_front</span><span class="special">();</span>
      <span class="special">}</span>
      <span class="identifier">condition_</span><span class="special">.</span><span class="identifier">wait</span><span class="special">(</span><span class="identifier">lock</span><span class="special">,</span> <span class="special">[&amp;]{</span> <span class="special">!</span><span class="identifier">queue_</span><span class="special">.</span><span class="identifier">empty</span><span class="special">();</span> <span class="special">});</span>
      <span class="keyword">auto</span> <span class="identifier">p</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">queue_</span><span class="special">.</span><span class="identifier">front</span><span class="special">()));</span> <span class="comment">// #5 <a name="defer5"></a></span>
      <span class="identifier">queue_</span><span class="special">.</span><span class="identifier">pop_front</span><span class="special">();</span>
      <span class="identifier">lock</span><span class="special">.</span><span class="identifier">unlock</span><span class="special">();</span> <span class="comment">// #6 <a name="defer6"></a></span>
      <span class="identifier">p</span><span class="special">-&gt;</span><span class="identifier">execute_</span><span class="special">(</span><span class="identifier">p</span><span class="special">);</span> <span class="comment">// #7 <a name="defer7"></a></span>
    <span class="special">}</span>
  <span class="special">}</span>

<span class="keyword">private</span><span class="special">:</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">mutex</span> <span class="identifier">mutex_</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">condition_variable</span> <span class="identifier">condition_</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">deque</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">item_base</span><span class="special">&gt;&gt;</span> <span class="identifier">queue_</span><span class="special">;</span>
  <span class="keyword">static</span> <span class="keyword">thread_local</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">deque</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">item_base</span><span class="special">&gt;&gt;*</span> <span class="identifier">thread_local_queue_</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
      Now when we step through the code:
    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
          <a class="link" href="#defer3">#3</a> &#8212; lock
        </li><li class="listitem">
          <a class="link" href="#defer4">#4</a> &#8212; copy contents of thread-local queue to
          main queue
        </li><li class="listitem">
          <a class="link" href="#defer5">#5</a> &#8212; dequeue <code class="computeroutput"><span class="identifier">read_loop</span></code>
        </li><li class="listitem">
          <a class="link" href="#defer6">#6</a> &#8212; unlock
        </li><li class="listitem">
          <a class="link" href="#defer7">#7</a> &#8212; call <code class="computeroutput"><span class="identifier">read_loop</span></code>
          <div class="itemizedlist"><ul class="itemizedlist" type="circle"><li class="listitem">
                <a class="link" href="#defer1">#1</a> &#8212; call <code class="computeroutput"><span class="identifier">defer</span></code>
                <div class="itemizedlist"><ul class="itemizedlist" type="square"><li class="listitem">
                      <a class="link" href="#defer2">#2</a> &#8212; enqueue <code class="computeroutput"><span class="identifier">read_loop</span></code>
                      to thread-local queue
                    </li></ul></div>
              </li></ul></div>
        </li><li class="listitem">
          <span class="emphasis"><em>(start of next cycle)</em></span>
        </li><li class="listitem">
          <a class="link" href="#defer3">#3</a> &#8212; lock
        </li><li class="listitem">
          <a class="link" href="#defer4">#4</a> &#8212; copy contents of thread-local queue to
          main queue
        </li><li class="listitem">
          <a class="link" href="#defer5">#5</a> &#8212; dequeue <code class="computeroutput"><span class="identifier">read_loop</span></code>
        </li><li class="listitem">
          <a class="link" href="#defer6">#6</a> &#8212; unlock
        </li><li class="listitem">
          <a class="link" href="#defer7">#7</a> &#8212; call <code class="computeroutput"><span class="identifier">read_loop</span></code>
        </li><li class="listitem">
          ...
        </li></ul></div><p>
      we see that we have eliminated one lock/unlock pair, and we also no longer
      need to wake another thread. We are able to do this because of the additional
      information imparted by <code class="computeroutput"><span class="identifier">defer</span></code>.
    </p><p>
      On recent hardware we can observe an uncontended lock/unlock cost of some 10
      to 15 nanoseconds, compared with 1 to 2 nanoseconds for accessing a thread-local
      queue. There is also a significant (and often larger) benefit in avoiding the
      unnecessary thread wakeup and the ensuing lock contention, particularly when
      dealing with bursty traffic profiles. Either way, this is a latency win.
    </p><p>
      With asynchronous operations, the rules are that if an operation completes
      immediately it posts the result (rather than dispatch, which may result in
      unfairness, starvation or stack overflow). If it finishes later, it dispatches
      the result (to minimise latency).
    </p><p>
      By default, an individual low-level asynchronous operation, such as <code class="computeroutput"><span class="identifier">async_read</span></code> shown above, doesn't know if the
      operation represents a continuation of the current function, or a new fork
      in the control flow. Either one is possible, so we conservatively assume that
      every operation represents a new fork and use <code class="computeroutput"><span class="identifier">post</span></code>.
    </p><p>
      However, once we move to a higher layer of abstraction, like a composed operation
      to read a message frame, we can start to make certain assertions. We know that
      within the operation it consists of a single chain of asynchronous reads.
    </p><p>
      As an example, let us consider a hypothetical composed operation to read a
      message frame, implemented in terms of <code class="computeroutput"><span class="identifier">async_read</span></code>
      above. Each message frame consists of a header, a body in several chunks, and
      a trailer. In this scenario, the header and body are immediately available
      in the kernel buffers, but we have to wait for the trailer to arrive. The sequence
      of executor operations used by the asynchronous chain looks like this:
    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
          header available immediately &#8594; <code class="computeroutput"><span class="identifier">post</span><span class="special">()</span></code>
        </li><li class="listitem">
          first body chunk available immediately &#8594; <code class="computeroutput"><span class="identifier">post</span><span class="special">()</span></code>
        </li><li class="listitem">
          second body chunk available immediately &#8594; <code class="computeroutput"><span class="identifier">post</span><span class="special">()</span></code>
        </li><li class="listitem">
          <span class="emphasis"><em>... waiting for trailer ...</em></span>
        </li><li class="listitem">
          trailer available &#8594; <code class="computeroutput"><span class="identifier">dispatch</span><span class="special">()</span></code>
        </li></ul></div><p>
      One of the motivating reasons for having lightweight, copyable executors, distinct
      from the execution context, is that they let us remap the executor operations
      as required. Thus, within the composed operation we can remap <code class="computeroutput"><span class="identifier">post</span></code> to <code class="computeroutput"><span class="identifier">defer</span></code>.
      We can do this with a lightweight wrapper around the composed operation's handler's
      associated executor:
    </p><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">remap_post_to_defer</span>
<span class="special">{</span>
  <span class="special">...</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">A</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">)</span>
  <span class="special">{</span>
    <span class="identifier">ex_</span><span class="special">.</span><span class="identifier">defer</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">),</span> <span class="identifier">a</span><span class="special">);</span>
  <span class="special">}</span>
  <span class="special">...</span>
  <span class="identifier">Executor</span> <span class="identifier">ex_</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
      We can then apply this wrapper to optimise the intermediate steps of the chain:
    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
          header available immediately &#8594; <code class="computeroutput"><span class="identifier">post</span><span class="special">()</span></code>
        </li><li class="listitem">
          first body chunk available immediately &#8594; <code class="computeroutput"><span class="identifier">defer</span><span class="special">()</span></code>
        </li><li class="listitem">
          second body chunk available immediately &#8594; <code class="computeroutput"><span class="identifier">defer</span><span class="special">()</span></code>
        </li><li class="listitem">
          <span class="emphasis"><em>... waiting for trailer ...</em></span>
        </li><li class="listitem">
          trailer available &#8594; <code class="computeroutput"><span class="identifier">dispatch</span><span class="special">()</span></code>
        </li></ul></div><p>
      If we had a limited vocabulary that only consisted of dispatch:
    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
          header available immediately &#8594; <code class="computeroutput"><span class="identifier">dispatch</span><span class="special">()</span></code>
        </li><li class="listitem">
          first body chunk available immediately &#8594; <code class="computeroutput"><span class="identifier">dispatch</span><span class="special">()</span></code>
        </li><li class="listitem">
          second body chunk available immediately &#8594; <code class="computeroutput"><span class="identifier">dispatch</span><span class="special">()</span></code>
        </li><li class="listitem">
          <span class="emphasis"><em>... waiting for trailer ...</em></span>
        </li><li class="listitem">
          trailer available &#8594; <code class="computeroutput"><span class="identifier">dispatch</span><span class="special">()</span></code>
        </li></ul></div><p>
      then traffic bursts can lead to unfairness and starvation. We are susceptible
      to denial of service attacks.
    </p><p>
      If our vocabulary only consisted of post:
    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
          header available immediately &#8594; <code class="computeroutput"><span class="identifier">post</span><span class="special">()</span></code>
        </li><li class="listitem">
          first body chunk available immediately &#8594; <code class="computeroutput"><span class="identifier">post</span><span class="special">()</span></code>
        </li><li class="listitem">
          second body chunk available immediately &#8594; <code class="computeroutput"><span class="identifier">post</span><span class="special">()</span></code>
        </li><li class="listitem">
          <span class="emphasis"><em>... waiting for trailer ...</em></span>
        </li><li class="listitem">
          trailer available &#8594; <code class="computeroutput"><span class="identifier">post</span><span class="special">()</span></code>
        </li></ul></div><p>
      then every operation in the chain can incur otherwise avoidable synchronisation
      costs, context switches, and cycles through the scheduler, resulting in higher
      latency.
    </p><p>
      If our vocabulary only consisted of defer:
    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
          header available immediately &#8594; <code class="computeroutput"><span class="identifier">defer</span><span class="special">()</span></code>
        </li><li class="listitem">
          first body chunk available immediately &#8594; <code class="computeroutput"><span class="identifier">defer</span><span class="special">()</span></code>
        </li><li class="listitem">
          second body chunk available immediately &#8594; <code class="computeroutput"><span class="identifier">defer</span><span class="special">()</span></code>
        </li><li class="listitem">
          <span class="emphasis"><em>... waiting for trailer ...</em></span>
        </li><li class="listitem">
          trailer available &#8594; <code class="computeroutput"><span class="identifier">defer</span><span class="special">()</span></code>
        </li></ul></div><p>
      then we almost get away with it, apart from the additional latency introduced
      by <code class="computeroutput"><span class="identifier">defer</span></code> at the end of the
      operation. However, we are also limiting the opportunities for concurrency.
      This may not be an issue in this example with a single chain of operations,
      but can be a problem where your asynchronous control flow really does fork,
      such as in a typical accept "loop":
    </p><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">handle_accept</span><span class="special">()</span>
<span class="special">{</span>
  <span class="identifier">new_socket</span><span class="special">-&gt;</span><span class="identifier">start</span><span class="special">();</span> <span class="comment">// starts asynchronous reads and writes</span>
  <span class="identifier">async_accept</span><span class="special">(...,</span> <span class="special">&amp;</span><span class="identifier">handle_accept</span><span class="special">);</span> <span class="comment">// accepts next connection</span>
<span class="special">}</span>
</pre><p>
      Thus we need all three operations to complete the set:
    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
          <code class="computeroutput"><span class="identifier">post</span></code> &#8212; the default choice,
          guaranteeing non-blocking calls and maximising concurrency
        </li><li class="listitem">
          <code class="computeroutput"><span class="identifier">dispatch</span></code> &#8212; for minimising
          latency when we are prepared to accept blocking
        </li><li class="listitem">
          <code class="computeroutput"><span class="identifier">defer</span></code> &#8212; to link sequences
          of related operations
        </li></ul></div><p>
      Note that, when implementing the executor type requirements, it is perfectly
      fine to start by implementing <code class="computeroutput"><span class="identifier">dispatch</span></code>
      and <code class="computeroutput"><span class="identifier">defer</span></code> in terms of <code class="computeroutput"><span class="identifier">post</span></code>. This is in keeping with the specified
      semantics. Then, we can optimise the implementation of these functions as we
      are able to.
    </p><p>
      However, are these three operations sufficient? Might there be more things
      that a user wants to communicate to the executor, about how a function or task
      should be launched? For example, a priority or a hard real-time deadline.
    </p><p>
      The proposed library meets these needs by giving a function object or task
      an associated executor. As lightweight, copyable objects, executors allow us
      to encapsulate all sorts of additional information and behaviour on a fine-grained
      basis, such as priority. The associated executor determines how it should be
      executed, and the point of association may be distant in time and space from
      the point where a function is submitted using <code class="computeroutput"><span class="identifier">dispatch</span></code>,
      <code class="computeroutput"><span class="identifier">post</span></code> and <code class="computeroutput"><span class="identifier">defer</span></code>.
    </p></div><div class="section" title="10.&#160;Impact on the standard"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="executors.impact_on_the_standard"></a>10.&#160;Impact on the standard</h2></div></div></div><p>
      This is a pure library proposal. It does not add any new language features,
      nor does it alter any existing standard library headers. It makes additions
      to experimental headers that may also be modified by other Technical Specifications.
    </p><p>
      This library can be implemented using compilers that conform to the C++14 standard.
      An implementation of this library requires operating system-specific functions
      that lie outside the C++14 standard.
    </p></div><div class="section" title="11.&#160;Relationship to other proposals"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="executors.relationship_to_other_proposals"></a>11.&#160;Relationship to other proposals</h2></div></div></div><p>
      This proposal builds on the type traits defined in N4045 <span class="emphasis"><em>Library
      Foundations for Asynchronous Operations</em></span>. This paper is intended
      as an alternative proposal to N3785 <span class="emphasis"><em>Executors and schedulers</em></span>.
    </p><p>
      A substantial subset of the executors library specified below is a prerequisite
      for the networking library. For this reason, the networking library's proposed
      text also incorporates a specification of these facilities.
    </p></div><div class="section" title="12.&#160;Conclusion"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="executors.conclusion"></a>12.&#160;Conclusion</h2></div></div></div><p>
      The type traits introduced in N4045 <span class="emphasis"><em>Library Foundations for Asynchronous
      Operations</em></span> define an extensible asynchronous model that can support
      a variety of composition methods, including:
    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
          Callbacks, where minimal runtime penalty is desirable.
        </li><li class="listitem">
          Futures, and not just <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">future</span></code>
          but also future classes supplied by other libraries.
        </li><li class="listitem">
          Coroutines or resumable functions, without adding new keywords to the language.
        </li></ul></div><p>
      The library introduced in this paper applies this asynchronous model, and its
      design philosophy, to executors. Rather than a design that is restricted to
      runtime polymorphism, we can allow users to choose the approach that is appropriate
      to their use case.
    </p></div><div class="section" title="13.&#160;Acknowledgements"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="executors.acknowledgements"></a>13.&#160;Acknowledgements</h2></div></div></div><p>
      The author would like to thank Jamie Allsop, Arash Partow and Dietmar K&#252;hl for
      providing feedback, corrections and suggestions on both the library implementation
      and this proposal.
    </p></div><div class="section" title="14.&#160;Appendix: Design issues in N3785"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="executors.appendix__design_issues_in_n3785"></a>14.&#160;Appendix: Design issues in N3785</h2></div></div></div><div class="toc"><dl><dt><span class="section"><a href="#executors.use_of_inheritance_and_polymorphism">14.1. Use of inheritance and polymorphism</a></span></dt><dt><span class="section"><a href="#executors.use_of_std__function_void___">14.2. Use of std::function&lt;void()&gt;</a></span></dt><dt><span class="section"><a href="#executors.scheduled_work">14.3. Scheduled work</a></span></dt><dt><span class="section"><a href="#executors.exception_handling">14.4. Exception handling</a></span></dt><dt><span class="section"><a href="#executors.inline_executors_and_the_single_add_function">14.5. Inline executors and the single add function</a></span></dt></dl></div><div class="section" title="14.1.&#160;Use of inheritance and polymorphism"><div class="titlepage"><div><div><h3 class="title"><a name="executors.use_of_inheritance_and_polymorphism"></a>14.1.&#160;Use of inheritance and polymorphism</h3></div></div></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>The interface is based on inheritance and polymorphism, rather
          than on templates, for two reasons. First, executors are often passed as
          function arguments, often to functions that have no other reason to be
          templates, so this makes it possible to change executor type without code
          restructuring. Second, a non-template design makes it possible to pass
          executors across a binary interface: a precompiled library can export a
          function one of whose parameters is an executor.</em></span>
        </p></blockquote></div><p>
        As we will see in this proposal, a template-based design does not preclude
        the inclusion of a runtime polymorphic wrapper. Such a wrapper still allows
        users to write non-template code for use with executors, and makes it possible
        to pass executors across a binary interface. On the other hand, it is not
        possible to undo the performance impact of a type-erased interface.
      </p><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>The cost of an additional virtual dispatch is almost certainly
          negligible compared to the other operations involved.</em></span>
        </p></blockquote></div><p>
        This claim might be true when passing coarse-grained tasks across threads.
        However, use cases for executors are not limited to this. As outlined in
        N4045, composition of asynchronous operations may entail multiple layers
        of abstraction. The ability to leverage function inlining is a key part of
        delivering a low abstraction penalty, but the compiler is unable to see through
        a virtual interface.
      </p></div><div class="section" title="14.2.&#160;Use of std::function&lt;void()&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="executors.use_of_std__function_void___"></a>14.2.&#160;Use of std::function&lt;void()&gt;</h3></div></div></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Most fundamentally, of course, executor is an abstract base class
          and add() is a virtual member function, and function templates can&#8217;t
          be virtual. Another reason is that a template parameter would complicate
          the interface without adding any real generality. In the end an executor
          class is going to need some kind of type erasure to handle all the different
          kinds of function objects with void() signature, and that&#8217;s exactly what
          std::function already does.</em></span>
        </p></blockquote></div><p>
        By forcing type erasure at the executor interface, an executor implementer
        is denied the opportunity to choose a more appropriate form of type erasure.
        For example, an implementer may wish to store pending work items in a linked
        list. With a template-based approach, the function object and the &#8220;next
        pointer&#8221; can be stored in the same object. This is not possible if type
        erasure has already occurred<sup>[<a name="executors.appendix__design_issues_in_n3785.use_of_std__function_void___.f0" href="#ftn.executors.appendix__design_issues_in_n3785.use_of_std__function_void___.f0" class="footnote">3</a>]</sup>.
      </p><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>One theoretical advantage of a template-based interface is that
          the executor might sometimes decide to execute the work item inline, rather
          than enqueueing it for asynchronous, in which case it could avoid the expense
          of converting it to a closure. In practice this would be very difficult,
          however: the executor would somehow have to know which work items would
          execute quickly enough for this to be worthwhile.</em></span>
        </p></blockquote></div><p>
        There is a key use case for wanting to execute work items inline: delivering
        the result of an asynchronous operation, possibly across multiple layers
        of abstraction. Rather than relying on the executor to &#8220;somehow have to
        know&#8221;, we can allow the user to choose. This is the approach taken in this
        proposal.
      </p><p>
        Finally, another disadvantage of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">function</span></code>
        is that it prevents the use of move-only function objects.
      </p><p>
        Of course, as N3785 states, the need for a type-erased function object is
        itself a consequence of the use of inheritance and polymorphism.
      </p></div><div class="section" title="14.3.&#160;Scheduled work"><div class="titlepage"><div><div><h3 class="title"><a name="executors.scheduled_work"></a>14.3.&#160;Scheduled work</h3></div></div></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>There are several important design decisions involving that time-based
          functionality. First: how do we handle executors that aren&#8217;t able to
          provide it? The issue is that add_at and add_after involve significant
          implementation complexity. In Microsoft&#8217;s experience it&#8217;s important
          to allow very simple and lightweight executor classes that don&#8217;t need
          such complicated functionality.</em></span>
        </p></blockquote></div><p>
        N3785 couples timer-based operations to executors via the <code class="computeroutput"><span class="identifier">scheduled_executor</span></code>
        base class. This proposal avoids this coupling by distinguishing between
        the executor as a lightweight policy object, and an execution context where
        the &#8220;implementation complexity&#8221; of timers can be housed in a reusable
        way. Thus, timer operations are independent of executor types, and can be
        used with any executor.
      </p><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Second, how should we specify time? [...] Some standard functionality,
          like sleep_until and sleep_for, is templatized to deal with arbitrary duration
          and time_point specializations. That&#8217;s not an option for an executor
          library that uses virtual functions, however, since virtual member functions
          can&#8217;t be function templates. There are a number of possible options:<br>
          <br> 1. Redesign the library to make executor a concept rather than an
          abstract base class. We believe that this would be invention rather than
          existing practice, and that it would make the library more complicated,
          and less convenient for users, for little gain.<br> <br> 2. Make executor
          a class template, parameterized on the clock. As discussed above, we believe
          that a template-based design would be less convenient than one based on
          inheritance and runtime polymorphism.<br> <br> 3. Pick a single clock
          and use its duration and time_point.<br> <br> We chose the last of
          those options, largely for simplicity.</em></span>
        </p></blockquote></div><p>
        Unfortunately, N3785 chooses <code class="computeroutput"><span class="identifier">system_clock</span></code>
        as that single clock. As the system clock is susceptible to clock changes
        it may be inappropriate for use cases that require a periodic timer. In those
        instances, <code class="computeroutput"><span class="identifier">steady_clock</span></code> is
        the better choice.
      </p><p>
        In any case, by decoupling timers from executors, this proposal provides
        timer operations that are indeed templates, and can work with arbitrary clock
        types.
      </p></div><div class="section" title="14.4.&#160;Exception handling"><div class="titlepage"><div><div><h3 class="title"><a name="executors.exception_handling"></a>14.4.&#160;Exception handling</h3></div></div></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>A more interesting question is what happens if a user closure
          throws an exception. The exception will in general be thrown by a different
          thread than the one that added the closure or the thread that started the
          executor, and may be far separated from it in time and in code location.
          As such, unhandled exceptions are considered a program error because they
          are difficult to signal to the caller. The decision we made is that an
          exception from a closure is ill-formed and the implementation must call
          std::terminate.</em></span>
        </p></blockquote></div><p>
        Rather than apply a blanket rule, this proposal includes exception handling
        as part of an executor&#8217;s policy. While <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">terminate</span></code>
        is likely to be the best choice for unhandled exceptions inside a thread
        pool, users may prefer greater control when using something like <code class="computeroutput"><span class="identifier">loop_executor</span></code>. For example, the approach
        taken by Boost.Asio&#8217;s <code class="computeroutput"><span class="identifier">io_service</span></code>
        and this proposal&#8217;s <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
        is to allow exceptions to escape from the &#8220;event loop&#8221;, where the user
        can handle them as appropriate.
      </p></div><div class="section" title="14.5.&#160;Inline executors and the single add function"><div class="titlepage"><div><div><h3 class="title"><a name="executors.inline_executors_and_the_single_add_function"></a>14.5.&#160;Inline executors and the single add function</h3></div></div></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>[...] Inline executors, which execute inline to the thread which
          calls add(). This has no queuing and behaves like a normal executor, but
          always uses the caller&#8217;s thread to execute.</em></span>
        </p></blockquote></div><p>
        Since the executor interface is defined by an abstract base class, code that
        calls the <code class="computeroutput"><span class="identifier">add</span><span class="special">()</span></code>
        function has to assume that the underlying executor may execute the function
        object inline. As a consequence, extra care must be taken in situations such
        as:
      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
            If using mutexes, avoiding calls to <code class="computeroutput"><span class="identifier">add</span><span class="special">()</span></code> while holding the lock.
          </li><li class="listitem">
            If iterating over a container and calling <code class="computeroutput"><span class="identifier">add</span><span class="special">()</span></code> for each element, ensuring the added
            function object cannot invalidate the iterators.
          </li></ul></div><p>
        This proposal instead makes an explicit distinction between operations that
        can execute inline, and those that cannot. The library user is then able
        to choose the appropriate operation for their use case.
      </p></div></div><div class="section" title="15.&#160;Appendix: Proposed text"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="executors.appendix__proposed_text"></a>15.&#160;Appendix: Proposed text</h2></div></div></div><div class="toc"><dl><dt><span class="section"><a href="#headers.header____experimental_type_traits___synopsis">15.1. Header <code class="literal">&lt;experimental/type_traits&gt;</code> synopsis</a></span></dt><dt><span class="section"><a href="#classes.handler_type">15.2. Class template <code class="literal">handler_type</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__handler_type__members">15.2.1. <code class="literal">handler_type</code> members</a></span></dt></dl></dd><dt><span class="section"><a href="#classes.async_result">15.3. Class template <code class="literal">async_result</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__async_result__members">15.3.1. <code class="literal">async_result</code> members</a></span></dt></dl></dd><dt><span class="section"><a href="#classes.async_completion">15.4. Class template <code class="literal">async_completion</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__async_completion__members">15.4.1. <code class="literal">async_completion</code> members</a></span></dt></dl></dd><dt><span class="section"><a href="#headers.header____experimental_memory___synopsis">15.5. Header <code class="literal">&lt;experimental/memory&gt;</code> synopsis</a></span></dt><dt><span class="section"><a href="#classes.associated_allocator">15.6. Class template <code class="literal">associated_allocator</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__associated_allocator__members">15.6.1. <code class="literal">associated_allocator</code> members</a></span></dt></dl></dd><dt><span class="section"><a href="#functions.get_associated_allocator">15.7. Function <code class="literal">get_associated_allocator</code></a></span></dt><dt><span class="section"><a href="#headers.header____experimental_executor___synopsis">15.8. Header <code class="literal">&lt;experimental/executor&gt;</code> synopsis</a></span></dt><dt><span class="section"><a href="#executors.async_requirements">15.9. Requirements</a></span></dt><dd><dl><dt><span class="section"><a href="#requirements.executor">15.9.1. Executor requirements</a></span></dt><dt><span class="section"><a href="#requirements.service">15.9.2. Service requirements</a></span></dt></dl></dd><dt><span class="section"><a href="#classes.execution_context">15.10. Class <code class="literal">execution_context</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__execution_context__constructor">15.10.1. <code class="literal">execution_context</code> constructor</a></span></dt><dt><span class="section"><a href="#classes.__execution_context__destructor">15.10.2. <code class="literal">execution_context</code> destructor</a></span></dt><dt><span class="section"><a href="#classes.__execution_context__operations">15.10.3. <code class="literal">execution_context</code> operations</a></span></dt><dt><span class="section"><a href="#classes.__execution_context__protected_operations">15.10.4. <code class="literal">execution_context</code> protected operations</a></span></dt><dt><span class="section"><a href="#classes.__execution_context__globals">15.10.5. <code class="literal">execution_context</code> globals</a></span></dt></dl></dd><dt><span class="section"><a href="#classes.execution_context__service">15.11. Class <code class="literal">execution_context::service</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__execution_context__service__constructors">15.11.1. <code class="literal">execution_context::service</code> constructors</a></span></dt><dt><span class="section"><a href="#classes.__execution_context__service__observers">15.11.2. <code class="literal">execution_context::service</code> observers</a></span></dt><dt><span class="section"><a href="#classes.__execution_context__service__operations">15.11.3. <code class="literal">execution_context::service</code> operations</a></span></dt></dl></dd><dt><span class="section"><a href="#classes.is_executor">15.12. Class template <code class="literal">is_executor</code></a></span></dt><dt><span class="section"><a href="#classes.executor_arg_t">15.13. Executor argument tag</a></span></dt><dt><span class="section"><a href="#classes.uses_executor">15.14. <code class="literal">uses_executor</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__uses_executor__trait">15.14.1. <code class="literal">uses_executor</code> trait</a></span></dt><dt><span class="section"><a href="#classes.uses_executor_construction">15.14.2. uses-executor construction</a></span></dt></dl></dd><dt><span class="section"><a href="#classes.associated_executor">15.15. Class template <code class="literal">associated_executor</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__associated_executor__members">15.15.1. <code class="literal">associated_executor</code> members</a></span></dt></dl></dd><dt><span class="section"><a href="#functions.get_associated_executor">15.16. Function <code class="literal">get_associated_executor</code></a></span></dt><dt><span class="section"><a href="#classes.executor_wrapper">15.17. Class template <code class="literal">executor_wrapper</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__executor_wrapper__constructors">15.17.1. <code class="literal">executor_wrapper</code> constructors</a></span></dt><dt><span class="section"><a href="#classes.__executor_wrapper__access">15.17.2. <code class="literal">executor_wrapper</code> access</a></span></dt><dt><span class="section"><a href="#classes.__executor_wrapper__invocation">15.17.3. <code class="literal">executor_wrapper</code> invocation</a></span></dt><dt><span class="section"><a href="#classes.class_template_specialization___async_result_">15.17.4. Class template specialization <code class="literal">async_result</code></a></span></dt><dt><span class="section"><a href="#classes.class_template_specialization___associated_allocator_">15.17.5. Class template specialization <code class="literal">associated_allocator</code></a></span></dt><dt><span class="section"><a href="#classes.class_template_specialization___associated_executor_">15.17.6. Class template specialization <code class="literal">associated_executor</code></a></span></dt></dl></dd><dt><span class="section"><a href="#functions.wrap">15.18. Function <code class="literal">wrap</code></a></span></dt><dt><span class="section"><a href="#classes.executor_work">15.19. Class template <code class="literal">executor_work</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__executor_work__constructors">15.19.1. <code class="literal">executor_work</code> constructors</a></span></dt><dt><span class="section"><a href="#classes.__executor_work__destructor">15.19.2. <code class="literal">executor_work</code> destructor</a></span></dt><dt><span class="section"><a href="#classes.__executor_work__observers">15.19.3. <code class="literal">executor_work</code> observers</a></span></dt><dt><span class="section"><a href="#classes.__executor_work__modifiers">15.19.4. <code class="literal">executor_work</code> modifiers</a></span></dt></dl></dd><dt><span class="section"><a href="#functions.make_work">15.20. Function <code class="literal">make_work</code></a></span></dt><dt><span class="section"><a href="#classes.system_executor">15.21. Class <code class="literal">system_executor</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__system_executor__operations">15.21.1. <code class="literal">system_executor</code> operations</a></span></dt><dt><span class="section"><a href="#classes.__system_executor__comparisons">15.21.2. <code class="literal">system_executor</code> comparisons</a></span></dt></dl></dd><dt><span class="section"><a href="#classes.bad_executor">15.22. Class <code class="literal">bad_executor</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__bad_executor__constructor">15.22.1. <code class="literal">bad_executor</code> constructor</a></span></dt></dl></dd><dt><span class="section"><a href="#classes.executor">15.23. Class <code class="literal">executor</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__executor__constructors">15.23.1. <code class="literal">executor</code> constructors</a></span></dt><dt><span class="section"><a href="#classes.__executor__assignment">15.23.2. <code class="literal">executor</code> assignment</a></span></dt><dt><span class="section"><a href="#classes.__executor__destructor">15.23.3. <code class="literal">executor</code> destructor</a></span></dt><dt><span class="section"><a href="#classes.__executor__modifiers">15.23.4. <code class="literal">executor</code> modifiers</a></span></dt><dt><span class="section"><a href="#classes.__executor__operations">15.23.5. <code class="literal">executor</code> operations</a></span></dt><dt><span class="section"><a href="#classes.__executor__capacity">15.23.6. <code class="literal">executor</code> capacity</a></span></dt><dt><span class="section"><a href="#classes.__executor__target_access">15.23.7. <code class="literal">executor</code> target access</a></span></dt><dt><span class="section"><a href="#classes.__executor__comparisons">15.23.8. <code class="literal">executor</code> comparisons</a></span></dt><dt><span class="section"><a href="#classes.__executor__specialized_algorithms">15.23.9. <code class="literal">executor</code> specialized algorithms</a></span></dt></dl></dd><dt><span class="section"><a href="#functions.dispatch">15.24. Function <code class="literal">dispatch</code></a></span></dt><dt><span class="section"><a href="#functions.post">15.25. Function <code class="literal">post</code></a></span></dt><dt><span class="section"><a href="#functions.defer">15.26. Function <code class="literal">defer</code></a></span></dt><dt><span class="section"><a href="#headers.header____experimental_strand___synopsis">15.27. Header <code class="literal">&lt;experimental/strand&gt;</code> synopsis</a></span></dt><dt><span class="section"><a href="#classes.strand">15.28. Class template <code class="literal">strand</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__strand__constructors">15.28.1. <code class="literal">strand</code> constructors</a></span></dt><dt><span class="section"><a href="#classes.__strand__assignment">15.28.2. <code class="literal">strand</code> assignment</a></span></dt><dt><span class="section"><a href="#classes.__strand__destructor">15.28.3. <code class="literal">strand</code> destructor</a></span></dt><dt><span class="section"><a href="#classes.__strand__operations">15.28.4. <code class="literal">strand</code> operations</a></span></dt><dt><span class="section"><a href="#classes.__strand__comparisons">15.28.5. <code class="literal">strand</code> comparisons</a></span></dt></dl></dd><dt><span class="section"><a href="#headers.header____experimental_timer___synopsis">15.29. Header <code class="literal">&lt;experimental/timer&gt;</code> synopsis</a></span></dt><dt><span class="section"><a href="#functions.dispatch_at">15.30. Function <code class="literal">dispatch_at</code></a></span></dt><dt><span class="section"><a href="#functions.post_at">15.31. Function <code class="literal">post_at</code></a></span></dt><dt><span class="section"><a href="#functions.defer_at">15.32. Function <code class="literal">defer_at</code></a></span></dt><dt><span class="section"><a href="#functions.dispatch_after">15.33. Function <code class="literal">dispatch_after</code></a></span></dt><dt><span class="section"><a href="#functions.post_after">15.34. Function <code class="literal">post_after</code></a></span></dt><dt><span class="section"><a href="#functions.defer_after">15.35. Function <code class="literal">defer_after</code></a></span></dt><dt><span class="section"><a href="#headers.header____experimental_future___synopsis">15.36. Header <code class="literal">&lt;experimental/future&gt;</code> synopsis</a></span></dt><dt><span class="section"><a href="#classes.use_future_t">15.37. Class template <code class="literal">use_future_t</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__use_future_t__constructors">15.37.1. <code class="literal">use_future_t</code> constructors</a></span></dt><dt><span class="section"><a href="#classes.__use_future_t__members">15.37.2. <code class="literal">use_future_t</code> members</a></span></dt><dt><span class="section"><a href="#classes.use_future_t_traits">15.37.3. <code class="literal">use_future_t</code> traits</a></span></dt></dl></dd><dt><span class="section"><a href="#classes.async_result_packaged_task">15.38. Class template specialization <code class="literal">async_result</code> for <code class="literal">packaged_task</code></a></span></dt><dt><span class="section"><a href="#classes.packaged_handler">15.39. Class template <code class="literal">packaged_handler</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__packaged_handler__constructors">15.39.1. <code class="literal">packaged_handler</code> constructors</a></span></dt><dt><span class="section"><a href="#classes.__packaged_handler__operations">15.39.2. <code class="literal">packaged_handler</code> operations</a></span></dt><dt><span class="section"><a href="#classes.async_result_packaged_handler">15.39.3. Class template specialization <code class="literal">async_result</code></a></span></dt></dl></dd><dt><span class="section"><a href="#classes.packaged_token">15.40. Class template <code class="literal">packaged_token</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__packaged_token__constructors">15.40.1. <code class="literal">packaged_token</code> constructors</a></span></dt><dt><span class="section"><a href="#classes.__packaged_token__operations">15.40.2. <code class="literal">packaged_token</code> operations</a></span></dt></dl></dd><dt><span class="section"><a href="#functions.package">15.41. Function <code class="literal">package</code></a></span></dt><dt><span class="section"><a href="#headers.header____experimental_thread_pool___synopsis">15.42. Header <code class="literal">&lt;experimental/thread_pool&gt;</code> synopsis</a></span></dt><dt><span class="section"><a href="#classes.thread_pool">15.43. Class <code class="literal">thread_pool</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__thread_pool__constructors_destructor">15.43.1. <code class="literal">thread_pool</code> constructors/destructor</a></span></dt><dt><span class="section"><a href="#classes.__thread_pool__members">15.43.2. <code class="literal">thread_pool</code> members</a></span></dt></dl></dd><dt><span class="section"><a href="#classes.thread_pool__executor_type">15.44. Class <code class="literal">thread_pool::executor_type</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__thread_pool__executor_type__constructors">15.44.1. <code class="literal">thread_pool::executor_type</code> constructors</a></span></dt><dt><span class="section"><a href="#classes.__thread_pool__executor_type__assignment">15.44.2. <code class="literal">thread_pool::executor_type</code> assignment</a></span></dt><dt><span class="section"><a href="#classes.__thread_pool__executor_type__operations">15.44.3. <code class="literal">thread_pool::executor_type</code> operations</a></span></dt><dt><span class="section"><a href="#classes.__thread_pool__executor_type__comparisons">15.44.4. <code class="literal">thread_pool::executor_type</code> comparisons</a></span></dt></dl></dd><dt><span class="section"><a href="#headers.header____experimental_loop_scheduler___synopsis">15.45. Header <code class="literal">&lt;experimental/loop_scheduler&gt;</code> synopsis</a></span></dt><dt><span class="section"><a href="#classes.loop_scheduler">15.46. Class <code class="literal">loop_scheduler</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__loop_scheduler__constructors_destructor">15.46.1. <code class="literal">loop_scheduler</code> constructors/destructor</a></span></dt><dt><span class="section"><a href="#classes.__loop_scheduler__members">15.46.2. <code class="literal">loop_scheduler</code> members</a></span></dt></dl></dd><dt><span class="section"><a href="#classes.loop_scheduler__executor_type">15.47. Class <code class="literal">loop_scheduler::executor_type</code></a></span></dt><dd><dl><dt><span class="section"><a href="#classes.__loop_scheduler__executor_type__constructors">15.47.1. <code class="literal">loop_scheduler::executor_type</code> constructors</a></span></dt><dt><span class="section"><a href="#classes.__loop_scheduler__executor_type__assignment">15.47.2. <code class="literal">loop_scheduler::executor_type</code> assignment</a></span></dt><dt><span class="section"><a href="#classes.__loop_scheduler__executor_type__operations">15.47.3. <code class="literal">loop_scheduler::executor_type</code> operations</a></span></dt><dt><span class="section"><a href="#classes.__loop_scheduler__executor_type__comparisons">15.47.4. <code class="literal">loop_scheduler::executor_type</code> comparisons</a></span></dt></dl></dd></dl></div><div class="section" title="15.1.&#160;Header &lt;experimental/type_traits&gt; synopsis"><div class="titlepage"><div><div><h3 class="title"><a name="headers.header____experimental_type_traits___synopsis"></a>15.1.&#160;Header <code class="literal">&lt;experimental/type_traits&gt;</code> synopsis</h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Signature</span><span class="special">,</span> <span class="keyword">class</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span>
        <span class="keyword">struct</span> <a class="link" href="#classes.handler_type" title="15.2.&#160;Class template handler_type">handler_type</a><span class="special">;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Signature</span><span class="special">&gt;</span>
        <span class="keyword">using</span> <span class="identifier">handler_type_t</span> <span class="special">=</span>
          <span class="keyword">typename</span> <span class="identifier">handler_type</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">,</span> <span class="identifier">Signature</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Handler</span><span class="special">&gt;</span> <span class="keyword">class</span> <a class="link" href="#classes.async_result" title="15.3.&#160;Class template async_result">async_result</a><span class="special">;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Signature</span><span class="special">&gt;</span>
        <span class="keyword">struct</span> <a class="link" href="#classes.async_completion" title="15.4.&#160;Class template async_completion">async_completion</a><span class="special">;</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" title="15.2.&#160;Class template handler_type"><div class="titlepage"><div><div><h3 class="title"><a name="classes.handler_type"></a>15.2.&#160;Class template <code class="literal">handler_type</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Signature</span><span class="special">,</span> <span class="keyword">class</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span>
      <span class="keyword">struct</span> <span class="identifier">handler_type</span>
      <span class="special">{</span>
        <span class="keyword">typedef</span> <span class="emphasis"><em>see below</em></span> <span class="identifier">type</span><span class="special">;</span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        Template parameter <code class="computeroutput"><span class="identifier">CompletionToken</span></code>
        specifies the model used to obtain the result of the asynchronous operation.
        Template parameter <code class="computeroutput"><span class="identifier">Signature</span></code>
        is the call signature (C++ Std, [func.def]) for the handler type invoked
        on completion of the asynchronous operation.
      </p><p>
        A program may specialize this trait if the <code class="computeroutput"><span class="identifier">CompletionToken</span></code>
        template parameter in the specialization is a user-defined type.
      </p><p>
        Specializations of <code class="computeroutput"><span class="identifier">handler_type</span></code>
        shall define a nested handler type <code class="computeroutput"><span class="identifier">type</span></code>
        that satisfies the <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>
        requirements, and objects of type <code class="computeroutput"><span class="identifier">type</span></code>
        shall be constructible from an lvalue or rvalue of the type specified by
        the <code class="computeroutput"><span class="identifier">CompletionToken</span></code> template
        parameter.
      </p><div class="section" title="15.2.1.&#160;handler_type members"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__handler_type__members"></a>15.2.1.&#160;<code class="literal">handler_type</code> members</h4></div></div></div><pre class="programlisting"><span class="keyword">typedef</span> <span class="emphasis"><em>see below</em></span> <span class="identifier">type</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Type:</em></span> <code class="computeroutput"><span class="identifier">CompletionToken</span></code>
            if <code class="computeroutput"><span class="identifier">CompletionToken</span></code> and
            <code class="computeroutput"><span class="identifier">decay_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;</span></code>
            are the same type; otherwise, <code class="computeroutput"><span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">decay_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;,</span> <span class="identifier">Signature</span><span class="special">&gt;</span></code>.
          </p></blockquote></div></div></div><div class="section" title="15.3.&#160;Class template async_result"><div class="titlepage"><div><div><h3 class="title"><a name="classes.async_result"></a>15.3.&#160;Class template <code class="literal">async_result</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Handler</span><span class="special">&gt;</span>
      <span class="keyword">class</span> <span class="identifier">async_result</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="keyword">typedef</span> <span class="keyword">void</span> <span class="identifier">type</span><span class="special">;</span>

        <span class="keyword">explicit</span> <span class="identifier">async_result</span><span class="special">(</span><span class="identifier">Handler</span><span class="special">&amp;);</span>
        <span class="identifier">async_result</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">async_result</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
        <span class="identifier">async_result</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">async_result</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>

        <span class="identifier">type</span> <span class="identifier">get</span><span class="special">();</span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        Template argument <code class="computeroutput"><span class="identifier">Handler</span></code>
        is a handler type produced by <code class="computeroutput"><span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span>
        <span class="identifier">S</span><span class="special">&gt;</span></code>
        for some completion token type <code class="computeroutput"><span class="identifier">T</span></code>
        and call signature <code class="computeroutput"><span class="identifier">S</span></code>.
      </p><p>
        A program may specialize this template if the <code class="computeroutput"><span class="identifier">Handler</span></code>
        template parameter in the specialization is a user-defined type.
      </p><p>
        Specializations of <code class="computeroutput"><span class="identifier">async_result</span></code>
        shall satisfy the <code class="computeroutput"><span class="identifier">Destructible</span></code>
        requirements (C++ Std, [destructible]) in addition to the requirements in
        the table below. In this table, <code class="computeroutput"><span class="identifier">R</span></code>
        is a specialization of <code class="computeroutput"><span class="identifier">async_result</span></code>
        for the template parameter <code class="computeroutput"><span class="identifier">Handler</span></code>;
        <code class="computeroutput"><span class="identifier">r</span></code> is a modifiable lvalue
        of type <code class="computeroutput"><span class="identifier">R</span></code>; and <code class="computeroutput"><span class="identifier">h</span></code> is a modifiable lvalue of type <code class="computeroutput"><span class="identifier">Handler</span></code>.
      </p><div class="table"><a name="classes.appendix__proposed_text.async_result.t0"></a><p class="title"><b>Table&#160;1.&#160;async_result specialization requirements</b></p><div class="table-contents"><table class="table" summary="async_result specialization requirements"><colgroup><col><col><col></colgroup><thead><tr><th>
                <p>
                  Expression
                </p>
              </th><th>
                <p>
                  Return type
                </p>
              </th><th>
                <p>
                  Note
                </p>
              </th></tr></thead><tbody><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">R</span><span class="special">::</span><span class="identifier">type</span></code>
                </p>
              </td><td>
              </td><td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>; or a type satisfying
                  <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>
                  requirements (C++ Std, [moveconstructible])
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">R</span> <span class="identifier">r</span><span class="special">(</span><span class="identifier">h</span><span class="special">);</span></code>
                </p>
              </td><td>
              </td><td>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">r</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code>
                </p>
              </td><td>
                <p>
                  <code class="computeroutput"><span class="identifier">R</span><span class="special">::</span><span class="identifier">type</span></code>
                </p>
              </td><td>
                <p>
                  The <code class="computeroutput"><span class="identifier">get</span><span class="special">()</span></code>
                  member function shall be used only as a return expression.
                </p>
              </td></tr></tbody></table></div></div><br class="table-break"><div class="section" title="15.3.1.&#160;async_result members"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__async_result__members"></a>15.3.1.&#160;<code class="literal">async_result</code> members</h4></div></div></div><pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">async_result</span><span class="special">(</span><span class="identifier">Handler</span><span class="special">&amp;);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Does nothing.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">type</span> <span class="identifier">get</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Does nothing.
          </p></blockquote></div></div></div><div class="section" title="15.4.&#160;Class template async_completion"><div class="titlepage"><div><div><h3 class="title"><a name="classes.async_completion"></a>15.4.&#160;Class template <code class="literal">async_completion</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Signature</span><span class="special">&gt;</span>
      <span class="keyword">struct</span> <span class="identifier">async_completion</span>
      <span class="special">{</span>
        <span class="keyword">typedef</span> <span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">,</span> <span class="identifier">Signature</span><span class="special">&gt;</span> <span class="identifier">handler_type</span><span class="special">;</span>

        <span class="keyword">explicit</span> <span class="identifier">async_completion</span><span class="special">(</span><span class="identifier">remove_reference_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;&amp;</span> <span class="identifier">t</span><span class="special">);</span>
        <span class="identifier">async_completion</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">async_completion</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
        <span class="identifier">async_completion</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">async_completion</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>

        <span class="emphasis"><em>see below</em></span> <span class="identifier">handler</span><span class="special">;</span>
        <span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">handler_type</span><span class="special">&gt;</span> <span class="identifier">result</span><span class="special">;</span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        Template parameter <code class="computeroutput"><span class="identifier">CompletionToken</span></code>
        specifies the model used to obtain the result of the asynchronous operation.
        Template parameter <code class="computeroutput"><span class="identifier">Signature</span></code>
        is the call signature (C++ Std, [func.def]) for the handler type invoked
        on completion of the asynchronous operation.
      </p><div class="section" title="15.4.1.&#160;async_completion members"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__async_completion__members"></a>15.4.1.&#160;<code class="literal">async_completion</code> members</h4></div></div></div><pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">async_completion</span><span class="special">(</span><span class="identifier">remove_reference_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;&amp;</span> <span class="identifier">t</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> If <code class="computeroutput"><span class="identifier">CompletionToken</span></code>
            and <code class="computeroutput"><span class="identifier">handler_type</span></code> are
            the same type, binds <code class="computeroutput"><span class="identifier">handler</span></code>
            to <code class="computeroutput"><span class="identifier">t</span></code>; otherwise, initializes
            <code class="computeroutput"><span class="identifier">handler</span></code> with the result
            of <code class="computeroutput"><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">t</span><span class="special">)</span></code>.
            Initializes <code class="computeroutput"><span class="identifier">result</span></code> with
            <code class="computeroutput"><span class="identifier">handler</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="emphasis"><em>see below</em></span> <span class="identifier">handler</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Type:</em></span> <code class="computeroutput"><span class="identifier">handler_type</span><span class="special">&amp;</span></code> if <code class="computeroutput"><span class="identifier">CompletionToken</span></code>
            and <code class="computeroutput"><span class="identifier">handler_type</span></code> are
            the same type; otherwise, <code class="computeroutput"><span class="identifier">handler_type</span></code>.
          </p></blockquote></div></div></div><div class="section" title="15.5.&#160;Header &lt;experimental/memory&gt; synopsis"><div class="titlepage"><div><div><h3 class="title"><a name="headers.header____experimental_memory___synopsis"></a>15.5.&#160;Header <code class="literal">&lt;experimental/memory&gt;</code> synopsis</h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span> <span class="special">=</span> <span class="identifier">allocator</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;&gt;</span>
        <span class="keyword">struct</span> <a class="link" href="#classes.associated_allocator" title="15.6.&#160;Class template associated_allocator">associated_allocator</a><span class="special">;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span> <span class="special">=</span> <span class="identifier">allocator</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;&gt;</span>
        <span class="keyword">using</span> <span class="identifier">associated_allocator_t</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">associated_allocator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">;</span>

      // <a class="link" href="#functions.get_associated_allocator" title="15.7.&#160;Function get_associated_allocator">get_associated_allocator</a>:

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
        <span class="identifier">associated_allocator_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
        <span class="identifier">associated_allocator_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" title="15.6.&#160;Class template associated_allocator"><div class="titlepage"><div><div><h3 class="title"><a name="classes.associated_allocator"></a>15.6.&#160;Class template <code class="literal">associated_allocator</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span> <span class="special">=</span> <span class="identifier">allocator</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;&gt;</span>
      <span class="keyword">struct</span> <span class="identifier">associated_allocator</span>
      <span class="special">{</span>
        <span class="keyword">typedef</span> <span class="emphasis"><em>see below</em></span> <span class="identifier">type</span><span class="special">;</span>

        <span class="keyword">static</span> <span class="identifier">type</span> <span class="identifier">get</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span> <span class="special">=</span> <span class="identifier">Alloc</span><span class="special">())</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        A program may specialize this traits type if the <code class="computeroutput"><span class="identifier">T</span></code>
        template parameter in the specialization is a user-defined type. The template
        parameter <code class="computeroutput"><span class="identifier">Alloc</span></code> shall be
        a type meeting <code class="computeroutput"><span class="identifier">Allocator</span></code>
        requirements (C++ Std, [allocator.requirements]).
      </p><p>
        Specializations of <code class="computeroutput"><span class="identifier">associated_allocator</span></code>
        shall satisfy the requirements in the table below. In this table, <code class="computeroutput"><span class="identifier">X</span></code> is a specialization of <code class="computeroutput"><span class="identifier">associated_allocator</span></code> for the template parameter
        <code class="computeroutput"><span class="identifier">T</span></code>; <code class="computeroutput"><span class="identifier">t</span></code>
        is a const reference to an object of type <code class="computeroutput"><span class="identifier">T</span></code>;
        and <code class="computeroutput"><span class="identifier">a</span></code> is an object of type
        <code class="computeroutput"><span class="identifier">Alloc</span></code>.
      </p><div class="table"><a name="classes.appendix__proposed_text.associated_allocator.t0"></a><p class="title"><b>Table&#160;2.&#160;associated_allocator specialization requirements</b></p><div class="table-contents"><table class="table" summary="associated_allocator specialization requirements"><colgroup><col><col><col></colgroup><thead><tr><th>
                <p>
                  Expression
                </p>
              </th><th>
                <p>
                  Return type
                </p>
              </th><th>
                <p>
                  Note
                </p>
              </th></tr></thead><tbody><tr><td>
                <p>
                  <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">X</span><span class="special">::</span><span class="identifier">type</span></code>
                </p>
              </td><td>
                <p>
                  A type meeting <code class="computeroutput"><span class="identifier">Allocator</span></code>
                  requirements (C++ Std, [allocator.requirements]).
                </p>
              </td><td>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">t</span><span class="special">)</span></code>
                </p>
              </td><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">type</span></code>
                </p>
              </td><td>
                <p>
                  Shall not exit via an exception.<br> Equivalent to <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">t</span><span class="special">,</span>
                  <span class="identifier">Alloc</span><span class="special">())</span></code>.
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">t</span><span class="special">,</span>
                  <span class="identifier">a</span><span class="special">)</span></code>
                </p>
              </td><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">type</span></code>
                </p>
              </td><td>
                <p>
                  Shall not exit via an exception.
                </p>
              </td></tr></tbody></table></div></div><br class="table-break"><div class="section" title="15.6.1.&#160;associated_allocator members"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__associated_allocator__members"></a>15.6.1.&#160;<code class="literal">associated_allocator</code> members</h4></div></div></div><pre class="programlisting"><span class="keyword">typedef</span> <span class="emphasis"><em>see below</em></span> <span class="identifier">type</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Type:</em></span> If <code class="computeroutput"><span class="identifier">T</span></code>
            has a nested type <code class="computeroutput"><span class="identifier">allocator_type</span></code>,
            <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">::</span><span class="identifier">allocator_type</span></code>.
            Otherwise <code class="computeroutput"><span class="identifier">Alloc</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">type</span> <span class="identifier">get</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span> <span class="special">=</span> <span class="identifier">Alloc</span><span class="special">())</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> If <code class="computeroutput"><span class="identifier">T</span></code>
            has a nested type <code class="computeroutput"><span class="identifier">allocator_type</span></code>,
            <code class="computeroutput"><span class="identifier">t</span><span class="special">.</span><span class="identifier">get_allocator</span><span class="special">()</span></code>.
            Otherwise <code class="computeroutput"><span class="identifier">a</span></code>.
          </p></blockquote></div></div></div><div class="section" title="15.7.&#160;Function get_associated_allocator"><div class="titlepage"><div><div><h3 class="title"><a name="functions.get_associated_allocator"></a>15.7.&#160;Function <code class="literal">get_associated_allocator</code></h3></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
  <span class="identifier">associated_allocator_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">associated_allocator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">t</span><span class="special">)</span></code>.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="identifier">associated_allocator_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
    <span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">associated_allocator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">t</span><span class="special">,</span>
          <span class="identifier">a</span><span class="special">)</span></code>.
        </p></blockquote></div></div><div class="section" title="15.8.&#160;Header &lt;experimental/executor&gt; synopsis"><div class="titlepage"><div><div><h3 class="title"><a name="headers.header____experimental_executor___synopsis"></a>15.8.&#160;Header <code class="literal">&lt;experimental/executor&gt;</code> synopsis</h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">enum</span> <span class="keyword">class</span> <span class="identifier">fork_event</span> <span class="special">{</span>
        <span class="identifier">prepare</span><span class="special">,</span>
        <span class="identifier">parent</span><span class="special">,</span>
        <span class="identifier">child</span>
      <span class="special">};</span>

      <span class="keyword">class</span> <a class="link" href="#classes.execution_context" title="15.10.&#160;Class execution_context">execution_context</a><span class="special">;</span>

      <span class="keyword">class</span> <span class="identifier">service_already_exists</span><span class="special">;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Service</span><span class="special">&gt;</span> <span class="identifier">Service</span><span class="special">&amp;</span> <span class="identifier">use_service</span><span class="special">(</span><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Service</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span> <span class="identifier">Service</span><span class="special">&amp;</span>
        <span class="identifier">make_service</span><span class="special">(</span><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">&amp;&amp;...</span> <span class="identifier">args</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Service</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">has_service</span><span class="special">(</span><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="#classes.is_executor" title="15.12.&#160;Class template is_executor">is_executor</a> <span class="special">:</span> <span class="identifier">false_type</span> <span class="special">{};</span>

      <span class="keyword">struct</span> <a class="link" href="#classes.executor_arg_t" title="15.13.&#160;Executor argument tag">executor_arg_t</a> <span class="special">{</span> <span class="special">};</span>
      <span class="keyword">constexpr</span> <span class="identifier">executor_arg_t</span> <span class="identifier">executor_arg</span> <span class="special">=</span> <span class="identifier">executor_arg_t</span><span class="special">();</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="#classes.uses_executor" title="15.14.&#160;uses_executor">uses_executor</a><span class="special">;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span> <span class="special">=</span> <span class="identifier">system_executor</span><span class="special">&gt;</span>
        <span class="keyword">struct</span> <a class="link" href="#classes.associated_executor" title="15.15.&#160;Class template associated_executor">associated_executor</a><span class="special">;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span> <span class="special">=</span> <span class="identifier">system_executor</span><span class="special">&gt;</span>
        <span class="keyword">using</span> <span class="identifier">associated_executor_t</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">associated_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">;</span>

      // <a class="link" href="#functions.get_associated_executor" title="15.16.&#160;Function get_associated_executor">get_associated_executor</a>:

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
        <span class="identifier">associated_executor_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">get_associated_executor</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
        <span class="identifier">associated_executor_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
          <span class="identifier">get_associated_executor</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">&gt;</span>
        <span class="identifier">associated_executor_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">ExecutionContext</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;</span>
          <span class="identifier">get_associated_executor</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">);</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="#classes.executor_wrapper" title="15.17.&#160;Class template executor_wrapper">executor_wrapper</a><span class="special">;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Signature</span><span class="special">&gt;</span>
        <span class="keyword">struct</span> <span class="identifier">handler_type</span><span class="special">&lt;</span><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;,</span> <span class="identifier">Signature</span><span class="special">&gt;;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
        <span class="keyword">class</span> <span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;&gt;;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
        <span class="keyword">struct</span> <span class="identifier">associated_allocator</span><span class="special">&lt;</span><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;,</span> <span class="identifier">Allocator</span><span class="special">&gt;;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor1</span><span class="special">&gt;</span>
        <span class="keyword">struct</span> <span class="identifier">associated_executor</span><span class="special">&lt;</span><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;,</span> <span class="identifier">Executor1</span><span class="special">&gt;;</span>

      // <a class="link" href="#functions.wrap" title="15.18.&#160;Function wrap">wrap</a>:

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
        <span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">decay_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">Executor</span><span class="special">&gt;</span> <span class="identifier">wrap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="identifier">t</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
        <span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">decay_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="keyword">typename</span> <span class="identifier">ExecutionContext</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;</span>
          <span class="identifier">wrap</span><span class="special">(</span><span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="identifier">t</span><span class="special">);</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="#classes.executor_work" title="15.19.&#160;Class template executor_work">executor_work</a><span class="special">;</span>

      // <a class="link" href="#functions.make_work" title="15.20.&#160;Function make_work">make_work</a>:

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
        <span class="identifier">executor_work</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span>
          <span class="identifier">make_work</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">&gt;</span>
        <span class="identifier">executor_work</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">ExecutionContext</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;</span>
          <span class="identifier">make_work</span><span class="special">(</span><span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
        <span class="identifier">executor_work</span><span class="special">&lt;</span><span class="identifier">associated_executor_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&gt;</span>
          <span class="identifier">make_work</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
        <span class="identifier">executor_work</span><span class="special">&lt;</span><span class="identifier">associated_executor_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;&gt;</span>
          <span class="identifier">make_work</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">&gt;</span>
        <span class="identifier">executor_work</span><span class="special">&lt;</span><span class="identifier">associated_executor_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">ExecutionContext</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;&gt;</span>
          <span class="identifier">make_work</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">);</span>

      <span class="keyword">class</span> <a class="link" href="#classes.system_executor" title="15.21.&#160;Class system_executor">system_executor</a><span class="special">;</span>

      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">system_executor</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">system_executor</span><span class="special">&amp;);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">system_executor</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">system_executor</span><span class="special">&amp;);</span>

      <span class="keyword">template</span><span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">system_executor</span><span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">true_type</span> <span class="special">{};</span>

      <span class="keyword">class</span> <a class="link" href="#classes.bad_executor" title="15.22.&#160;Class bad_executor">bad_executor</a><span class="special">;</span>

      <span class="keyword">class</span> <a class="link" href="#classes.executor" title="15.23.&#160;Class executor">executor</a><span class="special">;</span>

      <span class="keyword">template</span> <span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">executor</span><span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">true_type</span> <span class="special">{};</span>

      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">nullptr_t</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="identifier">nullptr_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">nullptr_t</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="identifier">nullptr_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>

      // <a class="link" href="#functions.dispatch" title="15.24.&#160;Function dispatch">dispatch</a>:

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
        <span class="keyword">auto</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
        <span class="keyword">auto</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
        <span class="keyword">auto</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>

      // <a class="link" href="#functions.post" title="15.25.&#160;Function post">post</a>:

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
        <span class="keyword">auto</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
        <span class="keyword">auto</span> <span class="identifier">post</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
        <span class="keyword">auto</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>

      // <a class="link" href="#functions.defer" title="15.26.&#160;Function defer">defer</a>:

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
        <span class="keyword">auto</span> <span class="identifier">defer</span><span class="special">(</span><span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
        <span class="keyword">auto</span> <span class="identifier">defer</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
        <span class="keyword">auto</span> <span class="identifier">defer</span><span class="special">(</span><span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>

  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
    <span class="keyword">struct</span> <span class="identifier">uses_allocator</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">executor</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
      <span class="special">:</span> <span class="identifier">true_type</span> <span class="special">{};</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" title="15.9.&#160;Requirements"><div class="titlepage"><div><div><h3 class="title"><a name="executors.async_requirements"></a>15.9.&#160;Requirements</h3></div></div></div><div class="section" title="15.9.1.&#160;Executor requirements"><div class="titlepage"><div><div><h4 class="title"><a name="requirements.executor"></a>15.9.1.&#160;Executor requirements</h4></div></div></div><p>
          The library describes a standard set of requirements for <span class="emphasis"><em>executors</em></span>.
          A type meeting Executor requirements shall embody a set of rules for determining
          how submitted function objects are to be executed.
        </p><p>
          An executor type <code class="computeroutput"><span class="identifier">X</span></code> shall
          satisfy the requirements of <code class="computeroutput"><span class="identifier">CopyConstructible</span></code>
          (C++ Std, [copyconstructible]) types. No constructor, comparison operator,
          copy operation, move operation, swap operation, or member functions <code class="computeroutput"><span class="identifier">context</span></code>, <code class="computeroutput"><span class="identifier">on_work_started</span></code>
          and <code class="computeroutput"><span class="identifier">on_work_finished</span></code> on
          these types shall exit via an exception.
        </p><p>
          The executor copy constructor, comparison operators, and member functions
          defined in these requirements shall not introduce data races as a result
          of concurrent calls to those functions from different threads.
        </p><p>
          In the table below, <code class="computeroutput"><span class="identifier">X</span></code> denotes
          an executor class, <code class="computeroutput"><span class="identifier">x</span></code> denotes
          a value of type <code class="computeroutput"><span class="identifier">X</span><span class="special">&amp;</span></code>,
          <code class="computeroutput"><span class="identifier">x1</span></code> and <code class="computeroutput"><span class="identifier">x2</span></code>
          denote values of type <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">X</span><span class="special">&amp;</span></code>,
          <code class="computeroutput"><span class="identifier">x3</span></code> denotes a value of type
          <code class="computeroutput"><span class="identifier">X</span><span class="special">&amp;&amp;</span></code>,
          <code class="computeroutput"><span class="identifier">f</span></code> denotes a <code class="computeroutput"><span class="identifier">MoveConstructible</span></code> (C++ Std, [moveconstructible])
          function object callable with zero arguments, <code class="computeroutput"><span class="identifier">a</span></code>
          denotes a value of type <code class="computeroutput"><span class="identifier">A</span></code>
          meeting <code class="computeroutput"><span class="identifier">Allocator</span></code> requirements
          (C++ Std, [allocator.requirements]), <code class="computeroutput"><span class="identifier">t</span></code>
          denotes an object of type <code class="computeroutput"><span class="identifier">T</span></code>,
          and <code class="computeroutput"><span class="identifier">u</span></code> denotes an identifier.
        </p><div class="table"><a name="requirements.appendix__proposed_text.async_requirements.executor.t0"></a><p class="title"><b>Table&#160;3.&#160;Executor requirements</b></p><div class="table-contents"><table class="table" summary="Executor requirements"><colgroup><col><col><col></colgroup><thead><tr><th>
                  <p>
                    expression
                  </p>
                </th><th>
                  <p>
                    type
                  </p>
                </th><th>
                  <p>
                    assertion/note<br> pre/post-conditions
                  </p>
                </th></tr></thead><tbody><tr><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">X</span> <span class="identifier">u</span><span class="special">(</span><span class="identifier">x1</span><span class="special">);</span></code>
                  </p>
                </td><td>
                </td><td>
                  <p>
                    Shall not exit via an exception.<br> <br> post: <code class="computeroutput"><span class="identifier">u</span> <span class="special">==</span>
                    <span class="identifier">x1</span></code>
                  </p>
                </td></tr><tr><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">X</span> <span class="identifier">u</span><span class="special">(</span><span class="identifier">x3</span><span class="special">);</span></code>
                  </p>
                </td><td>
                </td><td>
                  <p>
                    Shall not exit via an exception.<br> <br> post: <code class="computeroutput"><span class="identifier">u</span></code> equals the prior value of
                    <code class="computeroutput"><span class="identifier">x3</span></code>.
                  </p>
                </td></tr><tr><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">x1</span> <span class="special">==</span>
                    <span class="identifier">x2</span></code>
                  </p>
                </td><td>
                  <p>
                    <code class="computeroutput"><span class="keyword">bool</span></code>
                  </p>
                </td><td>
                  <p>
                    Shall not exit via an exception.<br> <br> Returns <code class="computeroutput"><span class="keyword">true</span></code> only if <code class="computeroutput"><span class="identifier">x1</span></code>
                    and <code class="computeroutput"><span class="identifier">x2</span></code> can be
                    interchanged with identical effects in any of the expressions
                    defined in these type requirements. [<span class="emphasis"><em>Note:</em></span>
                    <code class="computeroutput"><span class="keyword">false</span></code> does not necessarily
                    imply that the effects are not identical. &#8212;<span class="emphasis"><em>end note</em></span>]
                    <br> <br> <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> shall be reflexive, symmetric,
                    and transitive, and shall not exit via an exception.
                  </p>
                </td></tr><tr><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">x1</span> <span class="special">!=</span>
                    <span class="identifier">x2</span></code>
                  </p>
                </td><td>
                  <p>
                    <code class="computeroutput"><span class="keyword">bool</span></code>
                  </p>
                </td><td>
                  <p>
                    Shall not exit via an exception.<br> <br> Same as <code class="computeroutput"><span class="special">!(</span><span class="identifier">x1</span>
                    <span class="special">==</span> <span class="identifier">x2</span><span class="special">)</span></code>.
                  </p>
                </td></tr><tr><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">x</span><span class="special">.</span><span class="identifier">context</span><span class="special">()</span></code>
                  </p>
                </td><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">execution_context</span><span class="special">&amp;</span></code>, or a type that is convertible
                    to <code class="computeroutput"><span class="identifier">execution_context</span><span class="special">&amp;</span></code>.
                  </p>
                </td><td>
                  <p>
                    Shall not exit via an exception.
                  </p>
                </td></tr><tr><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">x</span><span class="special">.</span><span class="identifier">on_work_started</span><span class="special">()</span></code>
                  </p>
                </td><td>
                </td><td>
                  <p>
                    Shall not exit via an exception.
                  </p>
                </td></tr><tr><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">x</span><span class="special">.</span><span class="identifier">on_work_finished</span><span class="special">()</span></code>
                  </p>
                </td><td>
                </td><td>
                  <p>
                    Shall not exit via an exception.<br> <br> Requires: A preceding
                    call <code class="computeroutput"><span class="identifier">x1</span><span class="special">.</span><span class="identifier">on_work_started</span><span class="special">()</span></code>
                    where <code class="computeroutput"><span class="identifier">x</span> <span class="special">==</span>
                    <span class="identifier">x1</span></code>.
                  </p>
                </td></tr><tr><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">x</span><span class="special">.</span><span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">),</span><span class="identifier">a</span><span class="special">)</span></code>
                  </p>
                </td><td>
                </td><td>
                  <p>
                    Effects: Calls <code class="literal"><span class="emphasis"><em>DECAY_COPY</em></span></code><code class="computeroutput"><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">))()</span></code> at most once. The executor
                    may invoke <code class="computeroutput"><span class="identifier">f</span></code>
                    in the current thread, prior to returning from <code class="computeroutput"><span class="identifier">dispatch</span></code>. The call to <code class="computeroutput"><span class="identifier">DECAY_COPY</span><span class="special">()</span></code>
                    is evaluated in the thread that called <code class="computeroutput"><span class="identifier">dispatch</span></code>.<br>
                    <br> Executor implementations are encouraged to use the supplied
                    allocator to allocate any memory required to store the function
                    object. The executor shall deallocate all memory prior to invoking
                    the function object.<br> <br> Synchronization: The invocation
                    of <code class="computeroutput"><span class="identifier">dispatch</span></code> synchronizes
                    with (C++ Std, [intro.multithread]) the invocation of <code class="computeroutput"><span class="identifier">f</span></code>.
                  </p>
                </td></tr><tr><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">x</span><span class="special">.</span><span class="identifier">post</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">),</span><span class="identifier">a</span><span class="special">)</span></code>
                  </p>
                </td><td>
                </td><td>
                  <p>
                    Effects: Calls <code class="literal"><span class="emphasis"><em>DECAY_COPY</em></span></code><code class="computeroutput"><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">))()</span></code> at most once. The executor
                    may not invoke <code class="computeroutput"><span class="identifier">f</span></code>
                    in the current thread, prior to returning from <code class="computeroutput"><span class="identifier">post</span></code>. The call to <code class="computeroutput"><span class="identifier">DECAY_COPY</span><span class="special">()</span></code>
                    is evaluated in the thread that called <code class="computeroutput"><span class="identifier">post</span></code>.<br>
                    <br> Executor implementations are encouraged to use the supplied
                    allocator to allocate any memory required to store the function
                    object. The executor shall deallocate all memory prior to invoking
                    the function object.<br> <br> Synchronization: The invocation
                    of <code class="computeroutput"><span class="identifier">post</span></code> synchronizes
                    with (C++ Std, [intro.multithread]) the invocation of <code class="computeroutput"><span class="identifier">f</span></code>.
                  </p>
                </td></tr><tr><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">x</span><span class="special">.</span><span class="identifier">defer</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">),</span><span class="identifier">a</span><span class="special">)</span></code>
                  </p>
                </td><td>
                </td><td>
                  <p>
                    Effects: Calls <code class="literal"><span class="emphasis"><em>DECAY_COPY</em></span></code><code class="computeroutput"><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">))()</span></code> at most once. The executor
                    may not invoke <code class="computeroutput"><span class="identifier">f</span></code>
                    in the current thread, prior to returning from <code class="computeroutput"><span class="identifier">defer</span></code>. The call to <code class="computeroutput"><span class="identifier">DECAY_COPY</span><span class="special">()</span></code>
                    is evaluated in the thread that called <code class="computeroutput"><span class="identifier">defer</span></code>.<br>
                    <br> Executor implementations are encouraged to use the supplied
                    allocator to allocate any memory required to store the function
                    object. The executor shall deallocate all memory prior to invoking
                    the function object.<br> <br> Synchronization: The invocation
                    of <code class="computeroutput"><span class="identifier">defer</span></code> synchronizes
                    with (C++ Std, [intro.multithread]) the invocation of <code class="computeroutput"><span class="identifier">f</span></code>.<br> <br> Note: Although
                    the requirements placed on <code class="computeroutput"><span class="identifier">defer</span></code>
                    are identical to <code class="computeroutput"><span class="identifier">post</span></code>,
                    a separate function is used to convey the intention of the caller
                    that the submitted function is a continuation of the current
                    call context. The executor may use this information to optimize
                    or otherwise adjust the way in which <code class="computeroutput"><span class="identifier">f</span></code>
                    is invoked.
                  </p>
                </td></tr></tbody></table></div></div><br class="table-break"></div><div class="section" title="15.9.2.&#160;Service requirements"><div class="titlepage"><div><div><h4 class="title"><a name="requirements.service"></a>15.9.2.&#160;Service requirements</h4></div></div></div><p>
          A class is a service if it is publicly derived from another service, or
          if it is a class publicly derived from <code class="computeroutput"><span class="identifier">execution_context</span><span class="special">::</span><span class="identifier">service</span></code>.
        </p><p>
          A service may contain a publicly-accessible nested typedef named <code class="computeroutput"><span class="identifier">key_type</span></code>. If the nested typedef <code class="computeroutput"><span class="identifier">key_type</span></code> exists, the service class shall
          be the same type as <code class="computeroutput"><span class="identifier">key_type</span></code>,
          or otherwise publicly and unambiguously derived from <code class="computeroutput"><span class="identifier">key_type</span></code>.
        </p><p>
          All services define a one-argument constructor that takes a reference to
          the <code class="computeroutput"><span class="identifier">execution_context</span></code> object
          that owns the service. This constructor is <span class="emphasis"><em>explicit</em></span>,
          preventing its participation in automatic conversions.
        </p><p>
          A service may provide additional constructors with two or more arguments,
          where the first argument is a reference to the <code class="computeroutput"><span class="identifier">execution_context</span></code>
          object that owns the service. [<span class="emphasis"><em>Note:</em></span> These constructors
          may be called by the <code class="computeroutput"><span class="identifier">make_service</span></code>
          function. &#8212;<span class="emphasis"><em>end note</em></span>]
        </p><p>
          [<span class="emphasis"><em>Example:</em></span> <br>
        </p><p>
</p><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">my_service</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">execution_context</span><span class="special">::</span><span class="identifier">service</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
  <span class="keyword">typedef</span> <span class="identifier">my_service</span> <span class="identifier">key_type</span><span class="special">;</span>
  <span class="keyword">explicit</span> <span class="identifier">my_service</span><span class="special">(</span><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">);</span>
<span class="keyword">private</span><span class="special">:</span>
  <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="identifier">shutdown_service</span><span class="special">();</span>
  ...
<span class="special">};</span>
</pre><p>
        </p><p>
          &#8212;<span class="emphasis"><em>end example</em></span>]
        </p><p>
          A service's <code class="computeroutput"><span class="identifier">shutdown_service</span></code>
          member function must cause all copies of user-defined function objects
          that are held by the service to be destroyed.
        </p></div></div><div class="section" title="15.10.&#160;Class execution_context"><div class="titlepage"><div><div><h3 class="title"><a name="classes.execution_context"></a>15.10.&#160;Class <code class="literal">execution_context</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">class</span> <span class="identifier">execution_context</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="keyword">class</span> <a class="link" href="#classes.execution_context__service" title="15.11.&#160;Class execution_context::service">service</a><span class="special">;</span>

        <span class="comment">// construct / copy / destroy:</span>

        <span class="identifier">execution_context</span><span class="special">();</span>
        <span class="identifier">execution_context</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">execution_context</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
        <span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">execution_context</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
        <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">execution_context</span><span class="special">();</span>

        <span class="comment">// execution context operations:</span>

        <span class="keyword">void</span> <span class="identifier">notify_fork</span><span class="special">(</span><span class="identifier">fork_event</span> <span class="identifier">e</span><span class="special">);</span>

      <span class="keyword">protected</span><span class="special">:</span>

        <span class="comment">// execution context protected operations:</span>

        <span class="keyword">void</span> <span class="identifier">shutdown_context</span><span class="special">();</span>
        <span class="keyword">void</span> <span class="identifier">destroy_context</span><span class="special">();</span>
      <span class="special">};</span>

      <span class="comment">// service access:</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Service</span><span class="special">&gt;</span> <span class="identifier">Service</span><span class="special">&amp;</span> <span class="identifier">use_service</span><span class="special">(</span><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Service</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span> <span class="identifier">Service</span><span class="special">&amp;</span>
        <span class="identifier">make_service</span><span class="special">(</span><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">&amp;&amp;...</span> <span class="identifier">args</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Service</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">has_service</span><span class="special">(</span><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="keyword">class</span> <span class="identifier">service_already_exists</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">logic_error</span> <span class="special">{</span> <span class="special">...</span> <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        Class <code class="computeroutput"><span class="identifier">execution_context</span></code> implements
        an extensible, type-safe, polymorphic set of services, indexed by service
        <span class="emphasis"><em>type</em></span>.
      </p><p>
        Access to the services of an <code class="computeroutput"><span class="identifier">execution_context</span></code>
        is via three function templates, <code class="computeroutput"><span class="identifier">use_service</span><span class="special">&lt;&gt;</span></code>, <code class="computeroutput"><span class="identifier">make_service</span><span class="special">&lt;&gt;</span></code> and <code class="computeroutput"><span class="identifier">has_service</span><span class="special">&lt;&gt;</span></code>.
      </p><p>
        In a call to <code class="computeroutput"><span class="identifier">use_service</span><span class="special">&lt;</span><span class="identifier">Service</span><span class="special">&gt;()</span></code>, the type argument chooses a service,
        making available all members of the named type. If the service is not present
        in an <code class="computeroutput"><span class="identifier">execution_context</span></code>,
        an object of type <code class="computeroutput"><span class="identifier">Service</span></code>
        is created and added to the <code class="computeroutput"><span class="identifier">execution_context</span></code>.
        A C++ program can check if an <code class="computeroutput"><span class="identifier">execution_context</span></code>
        implements a particular service with the function template <code class="computeroutput"><span class="identifier">has_service</span><span class="special">&lt;</span><span class="identifier">Service</span><span class="special">&gt;()</span></code>.
      </p><p>
        Service objects may be explicitly added to an <code class="computeroutput"><span class="identifier">execution_context</span></code>
        using the function template <code class="computeroutput"><span class="identifier">make_service</span><span class="special">&lt;</span><span class="identifier">Service</span><span class="special">&gt;()</span></code>. If the service is already present,
        the <code class="computeroutput"><span class="identifier">service_already_exists</span></code>
        exception is thrown.
      </p><p>
        Once a service reference is obtained from an <code class="computeroutput"><span class="identifier">execution_context</span></code>
        object by calling <code class="computeroutput"><span class="identifier">use_service</span><span class="special">&lt;&gt;</span></code>, that reference remains usable until
        a call to <code class="computeroutput"><span class="identifier">destroy_context</span><span class="special">()</span></code>.
      </p><div class="section" title="15.10.1.&#160;execution_context constructor"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__execution_context__constructor"></a>15.10.1.&#160;<code class="literal">execution_context</code> constructor</h4></div></div></div><pre class="programlisting"><span class="identifier">execution_context</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Creates an object of class <code class="computeroutput"><span class="identifier">execution_context</span></code>.
          </p></blockquote></div></div><div class="section" title="15.10.2.&#160;execution_context destructor"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__execution_context__destructor"></a>15.10.2.&#160;<code class="literal">execution_context</code> destructor</h4></div></div></div><pre class="programlisting"><span class="special">~</span><span class="identifier">execution_context</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Destroys an object of class <code class="computeroutput"><span class="identifier">execution_context</span></code>. Performs <code class="computeroutput"><span class="identifier">shutdown_context</span><span class="special">()</span></code>
            followed by <code class="computeroutput"><span class="identifier">destroy_context</span><span class="special">()</span></code>.
          </p></blockquote></div></div><div class="section" title="15.10.3.&#160;execution_context operations"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__execution_context__operations"></a>15.10.3.&#160;<code class="literal">execution_context</code> operations</h4></div></div></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">notify_fork</span><span class="special">(</span><span class="identifier">fork_event</span> <span class="identifier">e</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> For each service object <code class="computeroutput"><span class="identifier">svc</span></code>
            in the set:<br> &#8212; If <code class="computeroutput"><span class="identifier">e</span> <span class="special">==</span> <span class="identifier">fork_event</span><span class="special">::</span><span class="identifier">prepare</span></code>,
            performs <code class="computeroutput"><span class="identifier">svc</span><span class="special">-&gt;</span><span class="identifier">notify_fork</span><span class="special">(</span><span class="identifier">e</span><span class="special">)</span></code>
            in reverse order of the beginning of service object lifetime (C++ Std,
            [basic.life]).<br> &#8212; Otherwise, performs <code class="computeroutput"><span class="identifier">svc</span><span class="special">-&gt;</span><span class="identifier">notify_fork</span><span class="special">(</span><span class="identifier">e</span><span class="special">)</span></code> in order of the beginning of service
            object lifetime.
          </p></blockquote></div></div><div class="section" title="15.10.4.&#160;execution_context protected operations"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__execution_context__protected_operations"></a>15.10.4.&#160;<code class="literal">execution_context</code> protected operations</h4></div></div></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">shutdown_context</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> For each service object <code class="computeroutput"><span class="identifier">svc</span></code>
            in the <code class="computeroutput"><span class="identifier">execution_context</span></code>
            set, in reverse order of the beginning of service object lifetime (C++
            Std, [basic.life]), performs <code class="computeroutput"><span class="identifier">svc</span><span class="special">-&gt;</span><span class="identifier">shutdown_service</span><span class="special">()</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            [<span class="emphasis"><em>Note:</em></span> <code class="computeroutput"><span class="identifier">shutdown_context</span></code>
            is an idempotent operation. &#8212;<span class="emphasis"><em>end note</em></span>]
          </p></blockquote></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">destroy_context</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Destroys each service object in the <code class="computeroutput"><span class="identifier">execution_context</span></code> set, in reverse order
            of the beginning of service object lifetime (C++ Std, [basic.life]).
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            [<span class="emphasis"><em>Note:</em></span> <code class="computeroutput"><span class="identifier">destroy_context</span></code>
            is an idempotent operation. &#8212;<span class="emphasis"><em>end note</em></span>]
          </p></blockquote></div></div><div class="section" title="15.10.5.&#160;execution_context globals"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__execution_context__globals"></a>15.10.5.&#160;<code class="literal">execution_context</code> globals</h4></div></div></div><p>
          The functions <code class="computeroutput"><span class="identifier">use_service</span></code>,
          <code class="computeroutput"><span class="identifier">make_service</span></code> and <code class="computeroutput"><span class="identifier">has_service</span></code> shall not introduce data
          races as a result of concurrent calls to those functions from different
          threads.
        </p><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Service</span><span class="special">&gt;</span> <span class="identifier">Service</span><span class="special">&amp;</span> <span class="identifier">use_service</span><span class="special">(</span><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            Let <code class="computeroutput"><span class="identifier">Key</span></code> be <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code> if the nested typedef <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code> exists; otherwise, let <code class="computeroutput"><span class="identifier">Key</span></code> be <code class="computeroutput"><span class="identifier">Service</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">Service</span></code>
            is a service class that is publicly and unambiguously derived from <a class="link" href="#classes.execution_context__service" title="15.11.&#160;Class execution_context::service"><code class="computeroutput"><span class="identifier">execution_context</span><span class="special">::</span><span class="identifier">service</span></code></a>.
            If the nested typedef <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code>
            exists, <code class="computeroutput"><span class="identifier">Service</span></code> is the
            same type as <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code>,
            or <code class="computeroutput"><span class="identifier">Service</span></code> is publicly
            and unambiguously derived from <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code>,
            and <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code> is publicly and unambiguously
            derived from <code class="computeroutput"><span class="identifier">execution_context</span><span class="special">::</span><span class="identifier">service</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> If an object of type <code class="computeroutput"><span class="identifier">Key</span></code>
            does not already exist in the <code class="computeroutput"><span class="identifier">execution_context</span></code>
            set identified by <code class="computeroutput"><span class="identifier">ctx</span></code>,
            creates an object of type <code class="computeroutput"><span class="identifier">Service</span></code>,
            initializing it with <code class="computeroutput"><span class="identifier">Service</span><span class="special">(</span><span class="identifier">ctx</span><span class="special">)</span></code>, and adds it to the set.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> A reference to the corresponding service
            of <code class="computeroutput"><span class="identifier">ctx</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Notes:</em></span> The reference returned remains valid until
            a call to <code class="computeroutput"><span class="identifier">destroy_context</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Service</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span> <span class="identifier">Service</span><span class="special">&amp;</span>
  <span class="identifier">make_service</span><span class="special">(</span><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">&amp;&amp;...</span> <span class="identifier">args</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            Let <code class="computeroutput"><span class="identifier">Key</span></code> be <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code> if the nested typedef <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code> exists; otherwise, let <code class="computeroutput"><span class="identifier">Key</span></code> be <code class="computeroutput"><span class="identifier">Service</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">Service</span></code>
            is a service class that is publicly and unambiguously derived from <a class="link" href="#classes.execution_context__service" title="15.11.&#160;Class execution_context::service"><code class="computeroutput"><span class="identifier">execution_context</span><span class="special">::</span><span class="identifier">service</span></code></a>.
            If the nested typedef <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code>
            exists, <code class="computeroutput"><span class="identifier">Service</span></code> is the
            same type as <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code>,
            or <code class="computeroutput"><span class="identifier">Service</span></code> is publicly
            and unambiguously derived from <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code>,
            and <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code> is publicly and unambiguously
            derived from <code class="computeroutput"><span class="identifier">execution_context</span><span class="special">::</span><span class="identifier">service</span></code>.
            A service object of type <code class="computeroutput"><span class="identifier">Key</span></code>
            does not already exist in the <code class="computeroutput"><span class="identifier">execution_context</span></code>
            set identified by <code class="computeroutput"><span class="identifier">ctx</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Creates an object of type <code class="computeroutput"><span class="identifier">Service</span></code>, initializing it with <code class="computeroutput"><span class="identifier">Service</span><span class="special">(</span><span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">&gt;(</span><span class="identifier">args</span><span class="special">)</span>...<span class="special">)</span></code>, and adds it to the <code class="computeroutput"><span class="identifier">execution_context</span></code>
            set identified by <code class="computeroutput"><span class="identifier">ctx</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Throws:</em></span> <code class="computeroutput"><span class="identifier">service_already_exists</span></code>
            if a corresponding service object of type <code class="computeroutput"><span class="identifier">Key</span></code>
            is already present in the set.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Notes:</em></span> The reference returned remains valid until
            a call to <code class="computeroutput"><span class="identifier">destroy_context</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Service</span><span class="special">&gt;</span> <span class="keyword">bool</span> <span class="identifier">has_service</span><span class="special">(</span><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            Let <code class="computeroutput"><span class="identifier">Key</span></code> be <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code> if the nested typedef <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code> exists; otherwise, let <code class="computeroutput"><span class="identifier">Key</span></code> be <code class="computeroutput"><span class="identifier">Service</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">Service</span></code>
            is a service class that is publicly and unambiguously derived from <a class="link" href="#classes.execution_context__service" title="15.11.&#160;Class execution_context::service"><code class="computeroutput"><span class="identifier">execution_context</span><span class="special">::</span><span class="identifier">service</span></code></a>.
            If the nested typedef <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code>
            exists, <code class="computeroutput"><span class="identifier">Service</span></code> is the
            same type as <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code>,
            or <code class="computeroutput"><span class="identifier">Service</span></code> is publicly
            and unambiguously derived from <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code>,
            and <code class="computeroutput"><span class="identifier">Service</span><span class="special">::</span><span class="identifier">key_type</span></code> is publicly and unambiguously
            derived from <code class="computeroutput"><span class="identifier">execution_context</span><span class="special">::</span><span class="identifier">service</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> If an object of type <code class="computeroutput"><span class="identifier">Key</span></code>
            is present in <code class="computeroutput"><span class="identifier">ctx</span></code>, <code class="computeroutput"><span class="keyword">true</span></code>; otherwise, <code class="computeroutput"><span class="keyword">false</span></code>.
          </p></blockquote></div></div></div><div class="section" title="15.11.&#160;Class execution_context::service"><div class="titlepage"><div><div><h3 class="title"><a name="classes.execution_context__service"></a>15.11.&#160;Class <code class="literal">execution_context::service</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">class</span> <span class="identifier">execution_context</span><span class="special">::</span><span class="identifier">service</span>
      <span class="special">{</span>
      <span class="keyword">protected</span><span class="special">:</span>
        <span class="comment">// construct / copy / destroy:</span>

        <span class="identifier">service</span><span class="special">(</span><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">owner</span><span class="special">);</span>
        <span class="identifier">service</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">service</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
        <span class="identifier">service</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">service</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
        <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">service</span><span class="special">();</span>

        <span class="comment">// service observers:</span>

        <span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">context</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>

      <span class="keyword">private</span><span class="special">:</span>
        <span class="keyword">friend</span> <span class="keyword">class</span> <span class="identifier">execution_context</span><span class="special">;</span> <span class="comment">// <span class="emphasis"><em>exposition only</em></span></span>

        <span class="comment">// service operations:</span>

        <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="identifier">shutdown_service</span><span class="special">()</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
        <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="identifier">notify_fork</span><span class="special">(</span><span class="identifier">fork_event</span> <span class="identifier">e</span><span class="special">);</span>

        <span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">context_</span><span class="special">;</span> <span class="comment">// <span class="emphasis"><em>exposition only</em></span></span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><div class="section" title="15.11.1.&#160;execution_context::service constructors"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__execution_context__service__constructors"></a>15.11.1.&#160;<code class="literal">execution_context::service</code> constructors</h4></div></div></div><pre class="programlisting"><span class="identifier">service</span><span class="special">(</span><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">owner</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">context_</span> <span class="special">==</span>
            <span class="special">&amp;</span><span class="identifier">owner</span></code>.
          </p></blockquote></div></div><div class="section" title="15.11.2.&#160;execution_context::service observers"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__execution_context__service__observers"></a>15.11.2.&#160;<code class="literal">execution_context::service</code> observers</h4></div></div></div><pre class="programlisting"><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">context</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">context_</span></code>.
          </p></blockquote></div></div><div class="section" title="15.11.3.&#160;execution_context::service operations"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__execution_context__service__operations"></a>15.11.3.&#160;<code class="literal">execution_context::service</code> operations</h4></div></div></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">notify_fork</span><span class="special">(</span><span class="identifier">fork_event</span> <span class="identifier">e</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Does nothing.
          </p></blockquote></div></div></div><div class="section" title="15.12.&#160;Class template is_executor"><div class="titlepage"><div><div><h3 class="title"><a name="classes.is_executor"></a>15.12.&#160;Class template <code class="literal">is_executor</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_executor</span> <span class="special">:</span> <span class="identifier">false_type</span> <span class="special">{};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        <code class="computeroutput"><span class="identifier">is_executor</span></code> can be used to
        detect executor types satisfying the <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor
        type requirements</a>.
      </p><p>
        Instantiations of the <code class="computeroutput"><span class="identifier">is_executor</span></code>
        template shall meet the UnaryTypeTrait requirements (C++ Std, [meta.rqmts]).
        A program may specialize this template for a user-defined type <code class="computeroutput"><span class="identifier">T</span></code> to have a BaseCharacteristic of <code class="computeroutput"><span class="identifier">integral_constant</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> </code><code class="literal"><span class="emphasis"><em>N</em></span></code><code class="computeroutput"><span class="special">&gt;</span></code> with <code class="literal"><span class="emphasis"><em>N</em></span>
        &gt; 0</code> to indicate that <code class="computeroutput"><span class="identifier">T</span></code>
        should be treated as an executor type.
      </p></div><div class="section" title="15.13.&#160;Executor argument tag"><div class="titlepage"><div><div><h3 class="title"><a name="classes.executor_arg_t"></a>15.13.&#160;Executor argument tag</h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">struct</span> <span class="identifier">executor_arg_t</span> <span class="special">{</span> <span class="special">};</span>
      <span class="keyword">constexpr</span> <span class="identifier">executor_arg_t</span> <span class="identifier">executor_arg</span> <span class="special">=</span> <span class="identifier">executor_arg_t</span><span class="special">();</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        The <code class="computeroutput"><span class="identifier">executor_arg_t</span></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 class="computeroutput"><span class="identifier">executor_arg_t</span></code> as the first
        argument, immediately followed by an argument of a type that satisfies the
        <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor requirements</a>.
      </p></div><div class="section" title="15.14.&#160;uses_executor"><div class="titlepage"><div><div><h3 class="title"><a name="classes.uses_executor"></a>15.14.&#160;<code class="literal">uses_executor</code></h3></div></div></div><div class="section" title="15.14.1.&#160;uses_executor trait"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__uses_executor__trait"></a>15.14.1.&#160;<code class="literal">uses_executor</code> trait</h4></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">uses_executor</span><span class="special">;</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
          <span class="emphasis"><em>Remark:</em></span> Detects whether <code class="computeroutput"><span class="identifier">T</span></code>
          has a nested <code class="computeroutput"><span class="identifier">executor_type</span></code>
          that is convertible from <code class="computeroutput"><span class="identifier">Executor</span></code>.
          Meets the <code class="computeroutput"><span class="identifier">BinaryTypeTrait</span></code>
          requirements (C++ Std, [meta.rqmts]). The implementation shall provide
          a definition that is derived from <code class="computeroutput"><span class="identifier">false_type</span></code>.
          A program may specialize this template to derive from <code class="computeroutput"><span class="identifier">true_type</span></code>
          for a user-defined type <code class="computeroutput"><span class="identifier">T</span></code>
          that does not have a nested <code class="computeroutput"><span class="identifier">executor_type</span></code>
          but nonetheless can be constructed with an executor where either:
        </p><p>
          &#8212; the first argument of a constructor has type <code class="computeroutput"><span class="identifier">executor_type</span></code>
          and the second argument has type <code class="computeroutput"><span class="identifier">Executor</span></code>;
          or
        </p><p>
          &#8212; the last argument of a constructor has type <code class="computeroutput"><span class="identifier">Executor</span></code>.
        </p></div><div class="section" title="15.14.2.&#160;uses-executor construction"><div class="titlepage"><div><div><h4 class="title"><a name="classes.uses_executor_construction"></a>15.14.2.&#160;uses-executor construction</h4></div></div></div><p>
          <span class="emphasis"><em>Uses-executor construction</em></span> with executor <code class="computeroutput"><span class="identifier">Executor</span></code> refers to the construction of
          an object <code class="computeroutput"><span class="identifier">obj</span></code> of type
          <code class="computeroutput"><span class="identifier">T</span></code>, using constructor arguments
          <code class="computeroutput"><span class="identifier">v1</span><span class="special">,</span>
          <span class="identifier">v2</span><span class="special">,</span>
          <span class="special">...,</span> <span class="identifier">vN</span></code>
          of types <code class="computeroutput"><span class="identifier">V1</span><span class="special">,</span>
          <span class="identifier">V2</span><span class="special">,</span>
          <span class="special">...,</span> <span class="identifier">VN</span></code>,
          respectively, and an executor <code class="computeroutput"><span class="identifier">ex</span></code>
          of type <code class="computeroutput"><span class="identifier">Executor</span></code>, according
          to the following rules:
        </p><p>
          &#8212; if <code class="computeroutput"><span class="identifier">uses_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is false and <code class="computeroutput"><span class="identifier">is_constructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">V1</span><span class="special">,</span> <span class="identifier">V2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">VN</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is true, then <code class="computeroutput"><span class="identifier">obj</span></code>
          is initialized as <code class="computeroutput"><span class="identifier">obj</span><span class="special">(</span><span class="identifier">v1</span><span class="special">,</span> <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vN</span><span class="special">)</span></code>;
        </p><p>
          &#8212; otherwise, if <code class="computeroutput"><span class="identifier">uses_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true and <code class="computeroutput"><span class="identifier">is_constructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">executor_arg_t</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="identifier">V1</span><span class="special">,</span> <span class="identifier">V2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">VN</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is true, then <code class="computeroutput"><span class="identifier">obj</span></code>
          is initialized as <code class="computeroutput"><span class="identifier">obj</span><span class="special">(</span><span class="identifier">executor_arg</span><span class="special">,</span>
          <span class="identifier">ex</span><span class="special">,</span>
          <span class="identifier">v1</span><span class="special">,</span>
          <span class="identifier">v2</span><span class="special">,</span>
          <span class="special">...,</span> <span class="identifier">vN</span><span class="special">)</span></code>;
        </p><p>
          &#8212; otherwise, if <code class="computeroutput"><span class="identifier">uses_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true and <code class="computeroutput"><span class="identifier">is_constructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">V1</span><span class="special">,</span> <span class="identifier">V2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">VN</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is true, then <code class="computeroutput"><span class="identifier">obj</span></code>
          is initialized as <code class="computeroutput"><span class="identifier">obj</span><span class="special">(</span><span class="identifier">v1</span><span class="special">,</span> <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vN</span><span class="special">,</span> <span class="identifier">ex</span><span class="special">)</span></code>;
        </p><p>
          &#8212; otherwise, the request for uses-executor construction is ill-formed. [<span class="emphasis"><em>Note:</em></span>
          An error will result if <code class="computeroutput"><span class="identifier">uses_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true but the specific constructor does not take an executor. This definition
          prevents a silent failure to pass the executor to an element. &#8212;<span class="emphasis"><em>end
          note</em></span>]
        </p></div></div><div class="section" title="15.15.&#160;Class template associated_executor"><div class="titlepage"><div><div><h3 class="title"><a name="classes.associated_executor"></a>15.15.&#160;Class template <code class="literal">associated_executor</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span> <span class="special">=</span> <span class="identifier">system_executor</span><span class="special">&gt;</span>
      <span class="keyword">struct</span> <span class="identifier">associated_executor</span>
      <span class="special">{</span>
        <span class="keyword">typedef</span> <span class="emphasis"><em>see below</em></span> <span class="identifier">type</span><span class="special">;</span>

        <span class="keyword">static</span> <span class="identifier">type</span> <span class="identifier">get</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">e</span> <span class="special">=</span> <span class="identifier">Executor</span><span class="special">())</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        A program may specialize this traits type if the <code class="computeroutput"><span class="identifier">T</span></code>
        template parameter in the specialization is a user-defined type. The template
        parameter <code class="computeroutput"><span class="identifier">Executor</span></code> shall
        be a type meeting <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor requirements</a>.
      </p><p>
        Specializations of <code class="computeroutput"><span class="identifier">associated_executor</span></code>
        shall satisfy the requirements in the table below. In this table, <code class="computeroutput"><span class="identifier">X</span></code> is a specialization of <code class="computeroutput"><span class="identifier">associated_executor</span></code> for the template parameter
        <code class="computeroutput"><span class="identifier">T</span></code>; <code class="computeroutput"><span class="identifier">t</span></code>
        is a const reference to an object of type <code class="computeroutput"><span class="identifier">T</span></code>;
        and <code class="computeroutput"><span class="identifier">e</span></code> is an object of type
        <code class="computeroutput"><span class="identifier">Executor</span></code>.
      </p><div class="table"><a name="classes.appendix__proposed_text.associated_executor.t0"></a><p class="title"><b>Table&#160;4.&#160;associated_executor specialization requirements</b></p><div class="table-contents"><table class="table" summary="associated_executor specialization requirements"><colgroup><col><col><col></colgroup><thead><tr><th>
                <p>
                  Expression
                </p>
              </th><th>
                <p>
                  Return type
                </p>
              </th><th>
                <p>
                  Note
                </p>
              </th></tr></thead><tbody><tr><td>
                <p>
                  <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">X</span><span class="special">::</span><span class="identifier">type</span></code>
                </p>
              </td><td>
                <p>
                  A type meeting <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor requirements</a>.
                </p>
              </td><td>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">t</span><span class="special">)</span></code>
                </p>
              </td><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">type</span></code>
                </p>
              </td><td>
                <p>
                  Shall not exit via an exception.<br> Equivalent to <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">t</span><span class="special">,</span>
                  <span class="identifier">Executor</span><span class="special">())</span></code>.
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">t</span><span class="special">,</span>
                  <span class="identifier">e</span><span class="special">)</span></code>
                </p>
              </td><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">type</span></code>
                </p>
              </td><td>
                <p>
                  Shall not exit via an exception.
                </p>
              </td></tr></tbody></table></div></div><br class="table-break"><div class="section" title="15.15.1.&#160;associated_executor members"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__associated_executor__members"></a>15.15.1.&#160;<code class="literal">associated_executor</code> members</h4></div></div></div><pre class="programlisting"><span class="keyword">typedef</span> <span class="emphasis"><em>see below</em></span> <span class="identifier">type</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Type:</em></span> If <code class="computeroutput"><span class="identifier">T</span></code>
            has a nested type <code class="computeroutput"><span class="identifier">executor_type</span></code>,
            <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">::</span><span class="identifier">executor_type</span></code>.
            Otherwise <code class="computeroutput"><span class="identifier">Executor</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">type</span> <span class="identifier">get</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">e</span> <span class="special">=</span> <span class="identifier">Executor</span><span class="special">())</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> If <code class="computeroutput"><span class="identifier">T</span></code>
            has a nested type <code class="computeroutput"><span class="identifier">executor_type</span></code>,
            <code class="computeroutput"><span class="identifier">t</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">()</span></code>.
            Otherwise <code class="computeroutput"><span class="identifier">e</span></code>.
          </p></blockquote></div></div></div><div class="section" title="15.16.&#160;Function get_associated_executor"><div class="titlepage"><div><div><h3 class="title"><a name="functions.get_associated_executor"></a>15.16.&#160;Function <code class="literal">get_associated_executor</code></h3></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
  <span class="identifier">associated_executor_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">get_associated_executor</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">associated_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">t</span><span class="special">)</span></code>.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
  <span class="identifier">associated_executor_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
    <span class="identifier">get_associated_executor</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">associated_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">t</span><span class="special">,</span>
          <span class="identifier">ex</span><span class="special">)</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">&gt;</span>
  <span class="identifier">associated_executor_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">ExecutionContext</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;</span>
    <span class="identifier">get_associated_executor</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">associated_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">ExecutionContext</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">t</span><span class="special">,</span> <span class="identifier">ctx</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">())</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">ExecutionContext</span><span class="special">&amp;,</span> <span class="identifier">execution_context</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div></div><div class="section" title="15.17.&#160;Class template executor_wrapper"><div class="titlepage"><div><div><h3 class="title"><a name="classes.executor_wrapper"></a>15.17.&#160;Class template <code class="literal">executor_wrapper</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
      <span class="keyword">class</span> <span class="identifier">executor_wrapper</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="comment">// types:</span>

        <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">wrapped_type</span><span class="special">;</span>
        <span class="keyword">typedef</span> <span class="identifier">Executor</span> <span class="identifier">executor_type</span><span class="special">;</span>
        <span class="keyword">typedef</span> <span class="emphasis"><em>see below</em></span> <span class="identifier">result_type</span><span class="special">;</span>          <span class="comment">// <span class="emphasis"><em>not always defined</em></span></span>
        <span class="keyword">typedef</span> <span class="emphasis"><em>see below</em></span> <span class="identifier">argument_type</span><span class="special">;</span>        <span class="comment">// <span class="emphasis"><em>not always defined</em></span></span>
        <span class="keyword">typedef</span> <span class="emphasis"><em>see below</em></span> <span class="identifier">first_argument_type</span><span class="special">;</span>  <span class="comment">// <span class="emphasis"><em>not always defined</em></span></span>
        <span class="keyword">typedef</span> <span class="emphasis"><em>see below</em></span> <span class="identifier">second_argument_type</span><span class="special">;</span> <span class="comment">// <span class="emphasis"><em>not always defined</em></span></span>

        <span class="comment">// construct / copy / destroy:</span>

        <span class="identifier">executor_wrapper</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">);</span>
        <span class="identifier">executor_wrapper</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor_wrapper</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="special">=</span> <span class="keyword">default</span><span class="special">;</span>
        <span class="identifier">executor_wrapper</span><span class="special">(</span><span class="identifier">executor_wrapper</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="special">=</span> <span class="keyword">default</span><span class="special">;</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span>
          <span class="identifier">executor_wrapper</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">,</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span>
          <span class="identifier">executor_wrapper</span><span class="special">(</span><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">,</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span>
          <span class="identifier">executor_wrapper</span><span class="special">(</span><span class="identifier">executor_arg_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span>
            <span class="keyword">const</span> <span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">,</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span>
          <span class="identifier">executor_wrapper</span><span class="special">(</span><span class="identifier">executor_arg_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span>
            <span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">,</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">other</span><span class="special">);</span>

        <span class="special">~</span><span class="identifier">executor_wrapper</span><span class="special">();</span>

        <span class="comment">// executor wrapper access:</span>

        <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">unwrap</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">unwrap</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="identifier">executor_type</span> <span class="identifier">get_executor</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="comment">// executor wrapper invocation:</span>

        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
          <span class="identifier">result_of_t</span><span class="special">&lt;</span><span class="emphasis"><em>cv</em></span> <span class="identifier">T</span><span class="special">&amp;(</span><span class="identifier">Args</span><span class="special">&amp;&amp;...)&gt;</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">Args</span><span class="special">&amp;&amp;...</span> <span class="identifier">args</span><span class="special">)</span> <span class="emphasis"><em>cv</em></span><span class="special">;</span>

      <span class="keyword">private</span><span class="special">:</span>
        <span class="identifier">Executor</span> <span class="identifier">ex_</span><span class="special">;</span> <span class="comment">// <span class="emphasis"><em>exposition only</em></span></span>
        <span class="identifier">T</span> <span class="identifier">wrapped_</span><span class="special">;</span> <span class="comment">// <span class="emphasis"><em>exposition only</em></span></span>
      <span class="special">};</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Signature</span><span class="special">&gt;</span>
      <span class="keyword">struct</span> <span class="identifier">handler_type</span><span class="special">&lt;</span><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;,</span> <span class="identifier">Signature</span><span class="special">&gt;</span>
      <span class="special">{</span>
        <span class="keyword">typedef</span> <span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Signature</span><span class="special">&gt;,</span> <span class="identifier">Executor</span><span class="special">&gt;</span> <span class="identifier">type</span><span class="special">;</span>
      <span class="special">};</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
        <span class="keyword">class</span> <span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;&gt;;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
        <span class="keyword">struct</span> <span class="identifier">associated_allocator</span><span class="special">&lt;</span><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;,</span> <span class="identifier">Alloc</span><span class="special">&gt;;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor1</span><span class="special">&gt;</span>
        <span class="keyword">struct</span> <span class="identifier">associated_executor</span><span class="special">&lt;</span><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;,</span> <span class="identifier">Executor1</span><span class="special">&gt;;</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        <code class="computeroutput"><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;</span></code> is a wrapper around an object or function
        of type <code class="computeroutput"><span class="identifier">T</span></code>, and an executor
        object of type <code class="computeroutput"><span class="identifier">Executor</span></code> satisfying
        <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor requirements</a>.
      </p><p>
        <code class="computeroutput"><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;</span></code> has a weak result type (C++ Std, [func.require]).
        If <code class="computeroutput"><span class="identifier">T</span></code> is a function type,
        <code class="computeroutput"><span class="identifier">result_type</span></code> shall be a synonym
        for the return type of <code class="computeroutput"><span class="identifier">T</span></code>.
      </p><p>
        The template instantiation <code class="computeroutput"><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span>
        <span class="identifier">Executor</span><span class="special">&gt;</span></code>
        shall define a nested type named <code class="computeroutput"><span class="identifier">argument_type</span></code>
        as a synonym for <code class="computeroutput"><span class="identifier">T1</span></code> only
        if the type <code class="computeroutput"><span class="identifier">T</span></code> is any of the
        following:
      </p><p>
        &#8212; a function type or a pointer to function type taking one argument of type
        <code class="computeroutput"><span class="identifier">T1</span></code>
      </p><p>
        &#8212; a pointer to member function <code class="computeroutput"><span class="identifier">R</span>
        <span class="identifier">T0</span><span class="special">::</span><span class="identifier">f</span></code> <code class="literal"><span class="emphasis"><em>cv</em></span></code>
        (where <code class="literal"><span class="emphasis"><em>cv</em></span></code> represents the member function&#8217;s
        cv-qualifiers); the type <code class="computeroutput"><span class="identifier">T1</span></code>
        is <code class="literal"><span class="emphasis"><em>cv</em></span></code> <code class="computeroutput"><span class="identifier">T0</span><span class="special">*</span></code>
      </p><p>
        &#8212; a class type with a member type <code class="computeroutput"><span class="identifier">argument_type</span></code>;
        the type <code class="computeroutput"><span class="identifier">T1</span></code> is <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">argument_type</span></code>.
      </p><p>
        The template instantiation <code class="computeroutput"><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span>
        <span class="identifier">Executor</span><span class="special">&gt;</span></code>
        shall define two nested types named <code class="computeroutput"><span class="identifier">first_argument_type</span></code>
        and <code class="computeroutput"><span class="identifier">second_argument_type</span></code>
        as synonyms for <code class="computeroutput"><span class="identifier">T1</span></code> and <code class="computeroutput"><span class="identifier">T2</span></code>, respectively, only if the type <code class="computeroutput"><span class="identifier">T</span></code> is any of the following:
      </p><p>
        &#8212; a function type or a pointer to function type taking two arguments of types
        <code class="computeroutput"><span class="identifier">T1</span></code> and <code class="computeroutput"><span class="identifier">T2</span></code>
      </p><p>
        &#8212; a pointer to member function <code class="computeroutput"><span class="identifier">R</span>
        <span class="identifier">T0</span><span class="special">::</span><span class="identifier">f</span><span class="special">(</span><span class="identifier">T2</span><span class="special">)</span></code> <code class="literal"><span class="emphasis"><em>cv</em></span></code>
        (where <code class="literal"><span class="emphasis"><em>cv</em></span></code> represents the member function&#8217;s
        cv-qualifiers); the type <code class="computeroutput"><span class="identifier">T1</span></code>
        is <code class="literal"><span class="emphasis"><em>cv</em></span></code> <code class="computeroutput"><span class="identifier">T0</span><span class="special">*</span></code>
      </p><p>
        &#8212; a class type with member types <code class="computeroutput"><span class="identifier">first_argument_type</span></code>
        and <code class="computeroutput"><span class="identifier">second_argument_type</span></code>;
        the type <code class="computeroutput"><span class="identifier">T1</span></code> is <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">first_argument_type</span></code>.
        and the type <code class="computeroutput"><span class="identifier">T2</span></code> is <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="identifier">second_argument_type</span></code>.
      </p><div class="section" title="15.17.1.&#160;executor_wrapper constructors"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor_wrapper__constructors"></a>15.17.1.&#160;<code class="literal">executor_wrapper</code> constructors</h4></div></div></div><pre class="programlisting"><span class="identifier">executor_wrapper</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of type <code class="computeroutput"><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;</span></code>.
            Initializes <code class="computeroutput"><span class="identifier">ex_</span></code> with
            the value <code class="computeroutput"><span class="identifier">ex</span></code>. If <code class="computeroutput"><span class="identifier">uses_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is true, performs uses-executor
            construction to initialize <code class="computeroutput"><span class="identifier">wrapped_</span></code>
            with <code class="computeroutput"><span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">executor_arg</span><span class="special">,</span>
            <span class="identifier">ex_</span><span class="special">,</span>
            <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">t</span><span class="special">))</span></code>;
            otherwise, initializes <code class="computeroutput"><span class="identifier">wrapped_</span></code>
            with <code class="computeroutput"><span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">t</span><span class="special">))</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span>
  <span class="identifier">executor_wrapper</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">,</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">U</span></code>
            is <code class="computeroutput"><span class="identifier">T</span></code> or convertible to
            <code class="computeroutput"><span class="identifier">T</span></code>. <code class="computeroutput"><span class="identifier">OtherExecutor</span></code>
            is <code class="computeroutput"><span class="identifier">Executor</span></code> or convertible
            to <code class="computeroutput"><span class="identifier">Executor</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of type <code class="computeroutput"><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;</span></code>.
            Initializes <code class="computeroutput"><span class="identifier">ex_</span></code> with
            <code class="computeroutput"><span class="identifier">other</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">()</span></code>.
            If <code class="computeroutput"><span class="identifier">uses_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is true, performs uses-executor
            construction to initialize <code class="computeroutput"><span class="identifier">wrapped_</span></code>
            with <code class="computeroutput"><span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">executor_arg</span><span class="special">,</span>
            <span class="identifier">ex_</span><span class="special">,</span>
            <span class="identifier">other</span><span class="special">.</span><span class="identifier">unwrap</span><span class="special">())</span></code>;
            otherwise, initializes <code class="computeroutput"><span class="identifier">wrapped_</span></code>
            with <code class="computeroutput"><span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">other</span><span class="special">.</span><span class="identifier">unwrap</span><span class="special">())</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span>
  <span class="identifier">executor_wrapper</span><span class="special">(</span><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">,</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">U</span></code>
            is <code class="computeroutput"><span class="identifier">T</span></code> or convertible to
            <code class="computeroutput"><span class="identifier">T</span></code>. <code class="computeroutput"><span class="identifier">OtherExecutor</span></code>
            is <code class="computeroutput"><span class="identifier">Executor</span></code> or convertible
            to <code class="computeroutput"><span class="identifier">Executor</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of type <code class="computeroutput"><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;</span></code>.
            Initializes <code class="computeroutput"><span class="identifier">ex_</span></code> with
            <code class="computeroutput"><span class="identifier">other</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">()</span></code>.
            If <code class="computeroutput"><span class="identifier">uses_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is true, performs uses-executor
            construction to initialize <code class="computeroutput"><span class="identifier">wrapped_</span></code>
            with <code class="computeroutput"><span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">executor_arg</span><span class="special">,</span>
            <span class="identifier">ex_</span><span class="special">,</span>
            <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">other</span><span class="special">.</span><span class="identifier">unwrap</span><span class="special">()))</span></code>;
            otherwise, initializes <code class="computeroutput"><span class="identifier">wrapped_</span></code>
            with <code class="computeroutput"><span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">other</span><span class="special">.</span><span class="identifier">unwrap</span><span class="special">()))</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span>
  <span class="identifier">executor_wrapper</span><span class="special">(</span><span class="identifier">executor_arg_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span>
    <span class="keyword">const</span> <span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">,</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">U</span></code>
            is <code class="computeroutput"><span class="identifier">T</span></code> or convertible to
            <code class="computeroutput"><span class="identifier">T</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of type <code class="computeroutput"><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;</span></code>.
            Initializes <code class="computeroutput"><span class="identifier">ex_</span></code> with
            <code class="computeroutput"><span class="identifier">ex</span></code>. If <code class="computeroutput"><span class="identifier">uses_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is true, performs uses-executor
            construction to initialize <code class="computeroutput"><span class="identifier">wrapped_</span></code>
            with <code class="computeroutput"><span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">executor_arg</span><span class="special">,</span>
            <span class="identifier">ex_</span><span class="special">,</span>
            <span class="identifier">other</span><span class="special">.</span><span class="identifier">unwrap</span><span class="special">())</span></code>;
            otherwise, initializes <code class="computeroutput"><span class="identifier">wrapped_</span></code>
            with <code class="computeroutput"><span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">other</span><span class="special">.</span><span class="identifier">unwrap</span><span class="special">())</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span>
  <span class="identifier">executor_wrapper</span><span class="special">(</span><span class="identifier">executor_arg_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span>
    <span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">,</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">U</span></code>
            is <code class="computeroutput"><span class="identifier">T</span></code> or convertible to
            <code class="computeroutput"><span class="identifier">T</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of type <code class="computeroutput"><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;</span></code>.
            Initializes <code class="computeroutput"><span class="identifier">ex_</span></code> with
            <code class="computeroutput"><span class="identifier">ex</span></code>. If <code class="computeroutput"><span class="identifier">uses_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is true, performs uses-executor
            construction to initialize <code class="computeroutput"><span class="identifier">wrapped_</span></code>
            with <code class="computeroutput"><span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">executor_arg</span><span class="special">,</span>
            <span class="identifier">ex_</span><span class="special">,</span>
            <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">other</span><span class="special">.</span><span class="identifier">unwrap</span><span class="special">()))</span></code>;
            otherwise, initializes <code class="computeroutput"><span class="identifier">wrapped_</span></code>
            with <code class="computeroutput"><span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">other</span><span class="special">.</span><span class="identifier">unwrap</span><span class="special">()))</span></code>.
          </p></blockquote></div></div><div class="section" title="15.17.2.&#160;executor_wrapper access"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor_wrapper__access"></a>15.17.2.&#160;<code class="literal">executor_wrapper</code> access</h4></div></div></div><pre class="programlisting"><span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">unwrap</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">unwrap</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">wrapped_</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">executor_type</span> <span class="identifier">get_executor</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">executor_</span></code>.
          </p></blockquote></div></div><div class="section" title="15.17.3.&#160;executor_wrapper invocation"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor_wrapper__invocation"></a>15.17.3.&#160;<code class="literal">executor_wrapper</code> invocation</h4></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
  <span class="identifier">result_of_t</span><span class="special">&lt;</span><span class="emphasis"><em>cv</em></span> <span class="identifier">T</span><span class="special">&amp;(</span><span class="identifier">Args</span><span class="special">&amp;&amp;...)&gt;</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">Args</span><span class="special">&amp;&amp;...</span> <span class="identifier">args</span><span class="special">)</span> <span class="emphasis"><em>cv</em></span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="literal"><span class="emphasis"><em>INVOKE</em></span></code><code class="computeroutput"><span class="special">(</span><span class="identifier">unwrap</span><span class="special">(),</span> <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">&gt;(</span><span class="identifier">args</span><span class="special">)</span>...<span class="special">)</span></code>
            (C++ Std, [func.require]).
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Remarks:</em></span> <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> is described for exposition only. Implementations
            are not required to provide an actual <code class="computeroutput"><span class="identifier">executor_wrapper</span><span class="special">::</span><span class="keyword">operator</span><span class="special">()</span></code>. Implementations are permitted to support
            <code class="computeroutput"><span class="identifier">executor_wrapper</span></code> function
            invocation through multiple overloaded operators or through other means.
          </p></blockquote></div></div><div class="section" title="15.17.4.&#160;Class template specialization async_result"><div class="titlepage"><div><div><h4 class="title"><a name="classes.class_template_specialization___async_result_"></a>15.17.4.&#160;Class template specialization <code class="literal">async_result</code></h4></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
      <span class="keyword">class</span> <span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;&gt;</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">type</span><span class="special">;</span>

        <span class="keyword">explicit</span> <span class="identifier">async_result</span><span class="special">(</span><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">wrapper</span><span class="special">);</span>
        <span class="identifier">async_result</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">async_result</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
        <span class="identifier">async_result</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">async_result</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>

        <span class="identifier">type</span> <span class="identifier">get</span><span class="special">();</span>

      <span class="keyword">private</span><span class="special">:</span>
        <span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">wrapped_</span><span class="special">;</span> <span class="comment">// <span class="emphasis"><em>exposition only</em></span></span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
          The implementation shall provide a specialization of <code class="computeroutput"><span class="identifier">async_result</span></code>
          that meets the <a class="link" href="#classes.async_result" title="15.3.&#160;Class template async_result"><code class="computeroutput"><span class="identifier">async_result</span></code>
          specialization requirements</a>.
        </p><pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">async_result</span><span class="special">(</span><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">wrapper</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Initializes <code class="computeroutput"><span class="identifier">wrapped_</span></code>
            with <code class="computeroutput"><span class="identifier">wrapped_</span><span class="special">(</span><span class="identifier">wrapper</span><span class="special">.</span><span class="identifier">unwrap</span><span class="special">())</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">type</span> <span class="identifier">get</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">wrapped_</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code>.
          </p></blockquote></div></div><div class="section" title="15.17.5.&#160;Class template specialization associated_allocator"><div class="titlepage"><div><div><h4 class="title"><a name="classes.class_template_specialization___associated_allocator_"></a>15.17.5.&#160;Class template specialization <code class="literal">associated_allocator</code></h4></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
        <span class="keyword">struct</span> <span class="identifier">associated_allocator</span><span class="special">&lt;</span><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
      <span class="special">{</span>
        <span class="keyword">typedef</span> <span class="identifier">associated_allocator_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="identifier">type</span><span class="special">;</span>

        <span class="keyword">static</span> <span class="identifier">type</span> <span class="identifier">get</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">w</span><span class="special">,</span>
                        <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span> <span class="special">=</span> <span class="identifier">Alloc</span><span class="special">())</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
          The implementation shall provide a specialization of <code class="computeroutput"><span class="identifier">associated_allocator</span></code>
          that meets the <a class="link" href="#classes.associated_allocator" title="15.6.&#160;Class template associated_allocator"><code class="computeroutput"><span class="identifier">associated_allocator</span></code> specialization requirements</a>.
        </p><pre class="programlisting"><span class="keyword">static</span> <span class="identifier">type</span> <span class="identifier">get</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">w</span><span class="special">,</span>
                <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span> <span class="special">=</span> <span class="identifier">Alloc</span><span class="special">())</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">associated_allocator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">w</span><span class="special">.</span><span class="identifier">unwrap</span><span class="special">(),</span> <span class="identifier">a</span><span class="special">)</span></code>.
          </p></blockquote></div></div><div class="section" title="15.17.6.&#160;Class template specialization associated_executor"><div class="titlepage"><div><div><h4 class="title"><a name="classes.class_template_specialization___associated_executor_"></a>15.17.6.&#160;Class template specialization <code class="literal">associated_executor</code></h4></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor1</span><span class="special">&gt;</span>
        <span class="keyword">struct</span> <span class="identifier">associated_executor</span><span class="special">&lt;</span><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;,</span> <span class="identifier">Executor1</span><span class="special">&gt;</span>
      <span class="special">{</span>
        <span class="keyword">typedef</span> <span class="identifier">Executor</span> <span class="identifier">type</span><span class="special">;</span>

        <span class="keyword">static</span> <span class="identifier">type</span> <span class="identifier">get</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">w</span><span class="special">,</span>
                        <span class="keyword">const</span> <span class="identifier">Executor1</span><span class="special">&amp;</span> <span class="identifier">e</span> <span class="special">=</span> <span class="identifier">Executor1</span><span class="special">())</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
          The implementation shall provide a specialization of <code class="computeroutput"><span class="identifier">associated_executor</span></code>
          that meets the <a class="link" href="#classes.associated_executor" title="15.15.&#160;Class template associated_executor"><code class="computeroutput"><span class="identifier">associated_executor</span></code> specialization requirements</a>.
        </p><pre class="programlisting"><span class="keyword">static</span> <span class="identifier">type</span> <span class="identifier">get</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">w</span><span class="special">,</span>
                <span class="keyword">const</span> <span class="identifier">Executor1</span><span class="special">&amp;</span> <span class="identifier">e</span> <span class="special">=</span> <span class="identifier">Executor1</span><span class="special">())</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">w</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">()</span></code>.
          </p></blockquote></div></div></div><div class="section" title="15.18.&#160;Function wrap"><div class="titlepage"><div><div><h3 class="title"><a name="functions.wrap"></a>15.18.&#160;Function <code class="literal">wrap</code></h3></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
  <span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">decay_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">Executor</span><span class="special">&gt;</span> <span class="identifier">wrap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="identifier">t</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">decay_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">Executor</span><span class="special">&gt;(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">t</span><span class="special">),</span> <span class="identifier">ex</span><span class="special">)</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
  <span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">decay_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="keyword">typename</span> <span class="identifier">ExecutionContext</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;</span>
    <span class="identifier">wrap</span><span class="special">(</span><span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="identifier">t</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">executor_wrapper</span><span class="special">&lt;</span><span class="identifier">decay_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="keyword">typename</span>
          <span class="identifier">ExecutionContext</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">t</span><span class="special">),</span> <span class="identifier">ctx</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">())</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">ExecutionContext</span><span class="special">&amp;,</span> <span class="identifier">execution_context</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div></div><div class="section" title="15.19.&#160;Class template executor_work"><div class="titlepage"><div><div><h3 class="title"><a name="classes.executor_work"></a>15.19.&#160;Class template <code class="literal">executor_work</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
      <span class="keyword">class</span> <span class="identifier">executor_work</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="comment">// types:</span>

        <span class="keyword">typedef</span> <span class="identifier">Executor</span> <span class="identifier">executor_type</span><span class="special">;</span>

        <span class="comment">// construct / copy / destroy:</span>

        <span class="keyword">explicit</span> <span class="identifier">executor_work</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="identifier">executor_work</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor_work</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="identifier">executor_work</span><span class="special">(</span><span class="identifier">executor_work</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="identifier">executor_work</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">executor_type</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>

        <span class="special">~</span><span class="identifier">executor_work</span><span class="special">();</span>

        <span class="comment">// executor work observers:</span>

        <span class="identifier">executor_type</span> <span class="identifier">get_executor</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="keyword">bool</span> <span class="identifier">owns_work</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="comment">// executor work modifiers:</span>

        <span class="keyword">void</span> <span class="identifier">reset</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>

      <span class="keyword">private</span><span class="special">:</span>
        <span class="identifier">Executor</span> <span class="identifier">ex_</span><span class="special">;</span> <span class="comment">// <span class="emphasis"><em>exposition only</em></span></span>
        <span class="keyword">bool</span> <span class="identifier">owns_</span><span class="special">;</span> <span class="comment">// <span class="emphasis"><em>exposition only</em></span></span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><div class="section" title="15.19.1.&#160;executor_work constructors"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor_work__constructors"></a>15.19.1.&#160;<code class="literal">executor_work</code> constructors</h4></div></div></div><pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">executor_work</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">executor_work</span></code>, initializing <code class="computeroutput"><span class="identifier">ex_</span></code> with <code class="computeroutput"><span class="identifier">ex</span></code>,
            and then performing <code class="computeroutput"><span class="identifier">ex_</span><span class="special">.</span><span class="identifier">on_work_started</span><span class="special">()</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="identifier">ex</span>
            <span class="special">==</span> <span class="identifier">ex_</span></code>
            and <code class="computeroutput"><span class="identifier">owns_</span> <span class="special">==</span>
            <span class="keyword">true</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">executor_work</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor_work</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">executor_work</span></code>, initializing <code class="computeroutput"><span class="identifier">ex_</span></code> with <code class="computeroutput"><span class="identifier">other</span><span class="special">.</span><span class="identifier">ex</span></code>.
            If <code class="computeroutput"><span class="identifier">other</span><span class="special">.</span><span class="identifier">owns_</span> <span class="special">==</span>
            <span class="keyword">true</span></code>, performs <code class="computeroutput"><span class="identifier">ex_</span><span class="special">.</span><span class="identifier">on_work_started</span><span class="special">()</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="identifier">ex</span>
            <span class="special">==</span> <span class="identifier">other</span><span class="special">.</span><span class="identifier">ex_</span></code>
            and <code class="computeroutput"><span class="identifier">owns_</span> <span class="special">==</span>
            <span class="identifier">other</span><span class="special">.</span><span class="identifier">owns_</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">executor_work</span><span class="special">(</span><span class="identifier">executor_work</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">executor_work</span></code>, initializing <code class="computeroutput"><span class="identifier">ex_</span></code> with <code class="computeroutput"><span class="identifier">other</span><span class="special">.</span><span class="identifier">ex</span></code>
            and <code class="computeroutput"><span class="identifier">owns_</span></code> with <code class="computeroutput"><span class="identifier">other</span><span class="special">.</span><span class="identifier">owns_</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="identifier">ex</span></code>
            is equal to the prior value of <code class="computeroutput"><span class="identifier">other</span><span class="special">.</span><span class="identifier">ex_</span></code>,
            <code class="computeroutput"><span class="identifier">owns_</span></code> is equal to the
            prior value of <code class="computeroutput"><span class="identifier">other</span><span class="special">.</span><span class="identifier">owns_</span></code>,
            and <code class="computeroutput"><span class="identifier">other</span><span class="special">.</span><span class="identifier">owns_</span> <span class="special">==</span>
            <span class="keyword">false</span></code>.
          </p></blockquote></div></div><div class="section" title="15.19.2.&#160;executor_work destructor"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor_work__destructor"></a>15.19.2.&#160;<code class="literal">executor_work</code> destructor</h4></div></div></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> If <code class="computeroutput"><span class="identifier">owns_</span></code>
            is true, performs <code class="computeroutput"><span class="identifier">ex</span><span class="special">.</span><span class="identifier">on_work_finished</span><span class="special">()</span></code>.
          </p></blockquote></div></div><div class="section" title="15.19.3.&#160;executor_work observers"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor_work__observers"></a>15.19.3.&#160;<code class="literal">executor_work</code> observers</h4></div></div></div><pre class="programlisting"><span class="identifier">executor_type</span> <span class="identifier">get_executor</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">ex_</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">owns_work</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">owns_</span></code>.
          </p></blockquote></div></div><div class="section" title="15.19.4.&#160;executor_work modifiers"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor_work__modifiers"></a>15.19.4.&#160;<code class="literal">executor_work</code> modifiers</h4></div></div></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">reset</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> If <code class="computeroutput"><span class="identifier">owns_</span></code>
            is true, performs <code class="computeroutput"><span class="identifier">ex</span><span class="special">.</span><span class="identifier">on_work_finished</span><span class="special">()</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="identifier">owns_</span>
            <span class="special">==</span> <span class="keyword">false</span></code>.
          </p></blockquote></div></div></div><div class="section" title="15.20.&#160;Function make_work"><div class="titlepage"><div><div><h3 class="title"><a name="functions.make_work"></a>15.20.&#160;Function <code class="literal">make_work</code></h3></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
  <span class="identifier">executor_work</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span>
    <span class="identifier">make_work</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">executor_work</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;(</span><span class="identifier">ex</span><span class="special">)</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">&gt;</span>
  <span class="identifier">executor_work</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">ExecutionContext</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;</span>
    <span class="identifier">make_work</span><span class="special">(</span><span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> An object of type <code class="computeroutput"><span class="identifier">executor_work</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">ExecutionContext</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;</span></code>
          initialized with the result of <code class="computeroutput"><span class="identifier">ctx</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">()</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">ExecutionContext</span><span class="special">&amp;,</span> <span class="identifier">execution_context</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
  <span class="identifier">executor_work</span><span class="special">&lt;</span><span class="identifier">associated_executor_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&gt;</span>
    <span class="identifier">make_work</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> An object of type <code class="computeroutput"><span class="identifier">executor_work</span><span class="special">&lt;</span><span class="identifier">associated_executor_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&gt;</span></code> initialized with the result of
          <code class="computeroutput"><span class="identifier">associated_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">t</span><span class="special">)</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is false and <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&amp;,</span> <span class="identifier">execution_context</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code>
          is false.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
  <span class="identifier">executor_work</span><span class="special">&lt;</span><span class="identifier">associated_executor_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;&gt;</span>
    <span class="identifier">make_work</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> An object of type <code class="computeroutput"><span class="identifier">executor_work</span><span class="special">&lt;</span><span class="identifier">associated_executor_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;&gt;</span></code> initialized with the result of
          <code class="computeroutput"><span class="identifier">associated_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">t</span><span class="special">,</span>
          <span class="identifier">ex</span><span class="special">)</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">&gt;</span>
  <span class="identifier">executor_work</span><span class="special">&lt;</span><span class="identifier">associated_executor_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">ExecutionContext</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;&gt;</span>
    <span class="identifier">make_work</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">t</span><span class="special">,</span> <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> An object of type <code class="computeroutput"><span class="identifier">executor_work</span><span class="special">&lt;</span><span class="identifier">associated_executor_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">ExecutionContext</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;&gt;</span></code>
          initialized with the result of <code class="computeroutput"><span class="identifier">associated_executor</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">ExecutionContext</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">t</span><span class="special">,</span> <span class="identifier">ctx</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">())</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">ExecutionContext</span><span class="special">&amp;,</span> <span class="identifier">execution_context</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div></div><div class="section" title="15.21.&#160;Class system_executor"><div class="titlepage"><div><div><h3 class="title"><a name="classes.system_executor"></a>15.21.&#160;Class <code class="literal">system_executor</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">class</span> <span class="identifier">system_executor</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>

        <span class="comment">// executor operations:</span>

        <span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">context</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="keyword">void</span> <span class="identifier">on_work_started</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="keyword">void</span> <span class="identifier">on_work_finished</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">defer</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
      <span class="special">};</span>

      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">system_executor</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">system_executor</span><span class="special">&amp;)</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">system_executor</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">system_executor</span><span class="special">&amp;)</span> <span class="keyword">noexcept</span><span class="special">;</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        Class <code class="computeroutput"><span class="identifier">system_executor</span></code> is
        a <code class="computeroutput"><span class="identifier">DefaultConstructible</span></code> type
        (C++ Std, [defaultconstructible]) satisfying <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor
        requirements</a>. It represents a set of rules where function objects
        are permitted to execute on any thread.
      </p><p>
        To satisfy the executor requirements for the <code class="computeroutput"><span class="identifier">post</span></code>
        and <code class="computeroutput"><span class="identifier">defer</span></code> member functions,
        the system executor may allocate <code class="computeroutput"><span class="identifier">thread</span></code>
        objects to run the submitted function objects. If <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">exit</span></code>
        is called, and there remain unexecuted functions objects that have been submitted
        using <code class="computeroutput"><span class="identifier">post</span></code> or <code class="computeroutput"><span class="identifier">defer</span></code>, the implementation shall discard
        these function objects without calling them.
      </p><div class="section" title="15.21.1.&#160;system_executor operations"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__system_executor__operations"></a>15.21.1.&#160;<code class="literal">system_executor</code> operations</h4></div></div></div><pre class="programlisting"><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">context</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> A reference to a static-duration object
            of a type derived from <code class="computeroutput"><span class="identifier">execution_context</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">on_work_started</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Does nothing.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">on_work_finished</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Does nothing.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Calls <code class="literal"><span class="emphasis"><em>DECAY_COPY</em></span></code><code class="computeroutput"><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">))()</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Calls <code class="literal"><span class="emphasis"><em>DECAY_COPY</em></span></code><code class="computeroutput"><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">))()</span></code> as if in a thread of execution represented
            by a <code class="computeroutput"><span class="identifier">thread</span></code> object, with
            the call to <code class="computeroutput"><span class="identifier">DECAY_COPY</span><span class="special">()</span></code> being evaluated in the thread that
            called <code class="computeroutput"><span class="identifier">post</span></code>. Any exception
            propagated from the execution of <code class="literal"><span class="emphasis"><em>DECAY_COPY</em></span></code><code class="computeroutput"><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">))()</span></code> shall result in a call to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">terminate</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">defer</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Calls <code class="literal"><span class="emphasis"><em>DECAY_COPY</em></span></code><code class="computeroutput"><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">))()</span></code> as if in a thread of execution represented
            by a <code class="computeroutput"><span class="identifier">thread</span></code> object, with
            the call to <code class="computeroutput"><span class="identifier">DECAY_COPY</span><span class="special">()</span></code> being evaluated in the thread that
            called <code class="computeroutput"><span class="identifier">defer</span></code>. Any exception
            propagated from the execution of <code class="literal"><span class="emphasis"><em>DECAY_COPY</em></span></code><code class="computeroutput"><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">))()</span></code> shall result in a call to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">terminate</span></code>.
          </p></blockquote></div></div><div class="section" title="15.21.2.&#160;system_executor comparisons"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__system_executor__comparisons"></a>15.21.2.&#160;<code class="literal">system_executor</code> comparisons</h4></div></div></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">system_executor</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">system_executor</span><span class="special">&amp;)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="keyword">true</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">system_executor</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">system_executor</span><span class="special">&amp;)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="keyword">false</span></code>.
          </p></blockquote></div></div></div><div class="section" title="15.22.&#160;Class bad_executor"><div class="titlepage"><div><div><h3 class="title"><a name="classes.bad_executor"></a>15.22.&#160;Class <code class="literal">bad_executor</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">class</span> <span class="identifier">bad_executor</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">exception</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="comment">// constructor:</span>
        <span class="identifier">bad_executor</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        An exception of type <code class="computeroutput"><span class="identifier">bad_executor</span></code>
        is thrown by <code class="computeroutput"><span class="identifier">executor</span></code> member
        functions <code class="computeroutput"><span class="identifier">dispatch</span></code>, <code class="computeroutput"><span class="identifier">post</span></code> and <code class="computeroutput"><span class="identifier">defer</span></code>
        when the executor object has no target.
      </p><div class="section" title="15.22.1.&#160;bad_executor constructor"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__bad_executor__constructor"></a>15.22.1.&#160;<code class="literal">bad_executor</code> constructor</h4></div></div></div><pre class="programlisting"><span class="identifier">bad_executor</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs a <code class="computeroutput"><span class="identifier">bad_executor</span></code>
            object.
          </p></blockquote></div></div></div><div class="section" title="15.23.&#160;Class executor"><div class="titlepage"><div><div><h3 class="title"><a name="classes.executor"></a>15.23.&#160;Class <code class="literal">executor</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">class</span> <span class="identifier">executor</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="comment">// construct / copy / destroy:</span>

        <span class="identifier">executor</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="identifier">executor</span><span class="special">(</span><span class="identifier">nullptr_t</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="identifier">executor</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="identifier">executor</span><span class="special">(</span><span class="identifier">executor</span><span class="special">&amp;&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span> <span class="identifier">executor</span><span class="special">(</span><span class="identifier">Executor</span> <span class="identifier">e</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="identifier">executor</span><span class="special">(</span><span class="identifier">allocator_arg_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">Executor</span> <span class="identifier">e</span><span class="special">);</span>

        <span class="identifier">executor</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="identifier">executor</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">executor</span><span class="special">&amp;&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="identifier">executor</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">nullptr_t</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">Executor</span> <span class="identifier">e</span><span class="special">);</span>

        <span class="special">~</span><span class="identifier">executor</span><span class="special">();</span>

        <span class="comment">// executor modifiers:</span>

        <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">Executor</span> <span class="identifier">e</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">);</span>

        <span class="comment">// executor operations:</span>

        <span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">context</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="keyword">void</span> <span class="identifier">on_work_started</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="keyword">void</span> <span class="identifier">on_work_finished</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">defer</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>

        <span class="comment">// executor capacity:</span>

        <span class="keyword">explicit</span> <span class="keyword">operator</span> <span class="keyword">bool</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="comment">// executor target access:</span>

        <span class="keyword">const</span> <span class="identifier">type_info</span><span class="special">&amp;</span> <span class="identifier">target_type</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span> <span class="identifier">Executor</span><span class="special">*</span> <span class="identifier">target</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span> <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">*</span> <span class="identifier">target</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="special">};</span>

      <span class="keyword">template</span><span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">executor</span><span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">true_type</span> <span class="special">{};</span>

      <span class="comment">// executor comparisons:</span>

      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">nullptr_t</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="identifier">nullptr_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">nullptr_t</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="identifier">nullptr_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>

      <span class="comment">// executor specialized algorithms:</span>

      <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>

  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
    <span class="keyword">struct</span> <span class="identifier">uses_allocator</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">executor</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
      <span class="special">:</span> <span class="identifier">true_type</span> <span class="special">{};</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        The <code class="computeroutput"><span class="identifier">executor</span></code> class provides
        a polymorphic wrapper for types that satisfy the <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor
        requirements</a>. The <span class="emphasis"><em>target object</em></span> is the executor
        object that is held by the wrapper. The <code class="computeroutput"><span class="identifier">executor</span></code>
        type itself meets the requirements for an <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor</a>.
      </p><p>
        [<span class="emphasis"><em>Note:</em></span> To meet the <code class="computeroutput"><span class="keyword">noexcept</span></code>
        requirements for executor copy constructors and move constructors, implementations
        may share a target between two or more <code class="computeroutput"><span class="identifier">executor</span></code>
        objects. &#8212;<span class="emphasis"><em>end note</em></span>]
      </p><div class="section" title="15.23.1.&#160;executor constructors"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor__constructors"></a>15.23.1.&#160;<code class="literal">executor</code> constructors</h4></div></div></div><pre class="programlisting"><span class="identifier">executor</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="special">!*</span><span class="keyword">this</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">executor</span><span class="special">(</span><span class="identifier">nullptr_t</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="special">!*</span><span class="keyword">this</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">executor</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="special">!*</span><span class="keyword">this</span></code> if <code class="computeroutput"><span class="special">!</span><span class="identifier">e</span></code>; otherwise, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> targets <code class="computeroutput"><span class="identifier">e</span><span class="special">.</span><span class="identifier">target</span><span class="special">()</span></code> or a copy of <code class="computeroutput"><span class="identifier">e</span><span class="special">.</span><span class="identifier">target</span><span class="special">()</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">executor</span><span class="special">(</span><span class="identifier">executor</span><span class="special">&amp;&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> If <code class="computeroutput"><span class="special">!</span><span class="identifier">e</span></code>, <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> has no target; otherwise, moves
            <code class="computeroutput"><span class="identifier">e</span><span class="special">.</span><span class="identifier">target</span><span class="special">()</span></code>
            or move-constructs the target of <code class="computeroutput"><span class="identifier">e</span></code>
            into the target of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>,
            leaving <code class="computeroutput"><span class="identifier">e</span></code> in a valid
            state with an unspecified value.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span> <span class="identifier">executor</span><span class="special">(</span><span class="identifier">Executor</span> <span class="identifier">e</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">Executor</span></code>
            shall satisfy the <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor requirements</a>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> targets a copy of <code class="computeroutput"><span class="identifier">e</span></code>
            initialized with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">e</span><span class="special">)</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in
            overload resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
            is true.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="identifier">executor</span><span class="special">(</span><span class="identifier">allocator_arg_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">Executor</span> <span class="identifier">e</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">Executor</span></code>
            shall satisfy the <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor requirements</a>.
            <code class="computeroutput"><span class="identifier">Allocator</span></code> conforms to
            the <code class="computeroutput"><span class="identifier">Allocator</span></code> requirements
            (C++ Std, [allocator.requirements]).
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> targets a copy of <code class="computeroutput"><span class="identifier">e</span></code>
            initialized with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">e</span><span class="special">)</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            A copy of the allocator argument is used to allocate memory, if necessary,
            for the internal data structures of the constructed <code class="computeroutput"><span class="identifier">executor</span></code>
            object.
          </p></blockquote></div></div><div class="section" title="15.23.2.&#160;executor assignment"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor__assignment"></a>15.23.2.&#160;<code class="literal">executor</code> assignment</h4></div></div></div><pre class="programlisting"><span class="identifier">executor</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="identifier">executor</span><span class="special">(</span><span class="identifier">e</span><span class="special">).</span><span class="identifier">swap</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">executor</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">executor</span><span class="special">&amp;&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Replaces the target of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> with the target of <code class="computeroutput"><span class="identifier">e</span></code>, leaving <code class="computeroutput"><span class="identifier">e</span></code>
            in a valid state with an unspecified value.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">executor</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">nullptr_t</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="identifier">executor</span><span class="special">(</span><span class="keyword">nullptr</span><span class="special">).</span><span class="identifier">swap</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">Executor</span> <span class="identifier">e</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="identifier">executor</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">e</span><span class="special">)).</span><span class="identifier">swap</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in
            overload resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
            is true.
          </p></blockquote></div></div><div class="section" title="15.23.3.&#160;executor destructor"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor__destructor"></a>15.23.3.&#160;<code class="literal">executor</code> destructor</h4></div></div></div><pre class="programlisting"><span class="special">~</span><span class="identifier">executor</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span> <span class="special">!=</span> <span class="keyword">nullptr</span></code>, releases shared ownership of,
            or destroys, the target of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div></div><div class="section" title="15.23.4.&#160;executor modifiers"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor__modifiers"></a>15.23.4.&#160;<code class="literal">executor</code> modifiers</h4></div></div></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Interchanges the targets of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
            and <code class="computeroutput"><span class="identifier">other</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">Executor</span> <span class="identifier">e</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="identifier">executor</span><span class="special">(</span><span class="identifier">allocator_arg</span><span class="special">,</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">e</span><span class="special">)).</span><span class="identifier">swap</span><span class="special">(*</span><span class="keyword">this</span><span class="special">)</span></code>.
          </p></blockquote></div></div><div class="section" title="15.23.5.&#160;executor operations"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor__operations"></a>15.23.5.&#160;<code class="literal">executor</code> operations</h4></div></div></div><pre class="programlisting"><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">context</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">e</span><span class="special">.</span><span class="identifier">context</span><span class="special">()</span></code>, where <code class="computeroutput"><span class="identifier">e</span></code>
            is the target object of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">on_work_started</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="identifier">e</span><span class="special">.</span><span class="identifier">on_work_started</span><span class="special">()</span></code>, where <code class="computeroutput"><span class="identifier">e</span></code>
            is the target object of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">on_work_finished</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="identifier">e</span><span class="special">.</span><span class="identifier">on_work_finished</span><span class="special">()</span></code>, where <code class="computeroutput"><span class="identifier">e</span></code>
            is the target object of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="identifier">e</span><span class="special">.</span><span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>, where <code class="computeroutput"><span class="identifier">e</span></code>
            is the target object of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>, and <code class="computeroutput"><span class="identifier">g</span></code>
            is a function object of unspecified type that, when called as <code class="computeroutput"><span class="identifier">g</span><span class="special">()</span></code>,
            performs <code class="computeroutput"><span class="identifier">DECAY_COPY</span><span class="special">(</span><span class="identifier">f</span><span class="special">)()</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="identifier">e</span><span class="special">.</span><span class="identifier">post</span><span class="special">(</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>, where <code class="computeroutput"><span class="identifier">e</span></code>
            is the target object of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>, and <code class="computeroutput"><span class="identifier">g</span></code>
            is a function object of unspecified type that, when called as <code class="computeroutput"><span class="identifier">g</span><span class="special">()</span></code>,
            performs <code class="computeroutput"><span class="identifier">DECAY_COPY</span><span class="special">(</span><span class="identifier">f</span><span class="special">)()</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">defer</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="identifier">e</span><span class="special">.</span><span class="identifier">defer</span><span class="special">(</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>, where <code class="computeroutput"><span class="identifier">e</span></code>
            is the target object of <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>, and <code class="computeroutput"><span class="identifier">g</span></code>
            is a function object of unspecified type that, when called as <code class="computeroutput"><span class="identifier">g</span><span class="special">()</span></code>,
            performs <code class="computeroutput"><span class="identifier">DECAY_COPY</span><span class="special">(</span><span class="identifier">f</span><span class="special">)()</span></code>.
          </p></blockquote></div></div><div class="section" title="15.23.6.&#160;executor capacity"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor__capacity"></a>15.23.6.&#160;<code class="literal">executor</code> capacity</h4></div></div></div><pre class="programlisting"><span class="keyword">explicit</span> <span class="keyword">operator</span> <span class="keyword">bool</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="keyword">true</span></code>
            if <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
            has a target, otherwise <code class="computeroutput"><span class="keyword">false</span></code>,
          </p></blockquote></div></div><div class="section" title="15.23.7.&#160;executor target access"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor__target_access"></a>15.23.7.&#160;<code class="literal">executor</code> target access</h4></div></div></div><pre class="programlisting"><span class="keyword">const</span> <span class="identifier">type_info</span><span class="special">&amp;</span> <span class="identifier">target_type</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> If <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> has a target of type <code class="computeroutput"><span class="identifier">T</span></code>, <code class="computeroutput"><span class="keyword">typeid</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span></code>; otherwise, <code class="computeroutput"><span class="keyword">typeid</span><span class="special">(</span><span class="keyword">void</span><span class="special">)</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span> <span class="identifier">Executor</span><span class="special">*</span> <span class="identifier">target</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span> <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">*</span> <span class="identifier">target</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">Executor</span></code>
            shall satisfy the <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor requirements</a>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> If <code class="computeroutput"><span class="identifier">target_type</span><span class="special">()</span> <span class="special">==</span> <span class="keyword">typeid</span><span class="special">(</span><span class="identifier">Executor</span><span class="special">)</span></code>
            a pointer to the stored executor target; otherwise a null pointer.
          </p></blockquote></div></div><div class="section" title="15.23.8.&#160;executor comparisons"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor__comparisons"></a>15.23.8.&#160;<code class="literal">executor</code> comparisons</h4></div></div></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <br> &#8212; <code class="computeroutput"><span class="keyword">true</span></code>
            if <code class="computeroutput"><span class="special">!</span><span class="identifier">a</span></code>
            and <code class="computeroutput"><span class="special">!</span><span class="identifier">b</span></code>;<br>
            &#8212; <code class="computeroutput"><span class="keyword">true</span></code> if <code class="computeroutput"><span class="identifier">a</span></code>
            and <code class="computeroutput"><span class="identifier">b</span></code> share a target;<br>
            &#8212; <code class="computeroutput"><span class="keyword">true</span></code> if <code class="computeroutput"><span class="identifier">e</span></code>
            and <code class="computeroutput"><span class="identifier">f</span></code> are the same type
            and <code class="computeroutput"><span class="identifier">e</span> <span class="special">==</span>
            <span class="identifier">f</span></code>, where <code class="computeroutput"><span class="identifier">e</span></code>
            is the target object of <code class="computeroutput"><span class="identifier">a</span></code>
            and <code class="computeroutput"><span class="identifier">f</span></code> is the target object
            of <code class="computeroutput"><span class="identifier">b</span></code>;<br> &#8212; otherwise
            <code class="computeroutput"><span class="keyword">false</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">nullptr_t</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="identifier">nullptr_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">!</span><span class="identifier">e</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">!(</span><span class="identifier">a</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">)</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">nullptr_t</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="identifier">nullptr_t</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">(</span><span class="keyword">bool</span><span class="special">)</span> <span class="identifier">e</span></code>.
          </p></blockquote></div></div><div class="section" title="15.23.9.&#160;executor specialized algorithms"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__executor__specialized_algorithms"></a>15.23.9.&#160;<code class="literal">executor</code> specialized algorithms</h4></div></div></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">executor</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span></code>.
          </p></blockquote></div></div></div><div class="section" title="15.24.&#160;Function dispatch"><div class="titlepage"><div><div><h3 class="title"><a name="functions.dispatch"></a>15.24.&#160;Function <code class="literal">dispatch</code></h3></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          Let the type <code class="computeroutput"><span class="identifier">Handler</span></code> be
          the handler function object type determined by performing <code class="computeroutput"><span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">,</span>
          <span class="keyword">void</span><span class="special">()&gt;</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Requires:</em></span> The type <code class="computeroutput"><span class="identifier">Handler</span></code>
          must satisfy the <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>
          requirements (C++ Std, [moveconstructible]) and be callable with zero arguments.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Effects:</em></span> <br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">handler</span></code> of type <code class="computeroutput"><span class="identifier">Handler</span></code>,
          initialized with <code class="computeroutput"><span class="identifier">handler</span><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.<br> &#8212; Constructs an object <code class="computeroutput"><span class="identifier">result</span></code> of type <code class="computeroutput"><span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">Handler</span><span class="special">&gt;</span></code>, initializing the object as <code class="computeroutput"><span class="identifier">result</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br>
          &#8212; Obtains the handler's associated executor object <code class="computeroutput"><span class="identifier">ex</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_executor</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Obtains the handler's associated
          allocator object <code class="computeroutput"><span class="identifier">alloc</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Performs <code class="computeroutput"><span class="identifier">ex</span><span class="special">.</span><span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">result</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code>.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          Let the type <code class="computeroutput"><span class="identifier">Handler</span></code> be
          the handler function object type determined by performing <code class="computeroutput"><span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">,</span>
          <span class="keyword">void</span><span class="special">()&gt;</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Requires:</em></span> The type <code class="computeroutput"><span class="identifier">Handler</span></code>
          must satisfy the <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>
          requirements (C++ Std, [moveconstructible]) and be callable with zero arguments.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Effects:</em></span> <br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">handler</span></code> of type <code class="computeroutput"><span class="identifier">Handler</span></code>,
          initialized with <code class="computeroutput"><span class="identifier">handler</span><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.<br> &#8212; Constructs an object <code class="computeroutput"><span class="identifier">result</span></code> of type <code class="computeroutput"><span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">Handler</span><span class="special">&gt;</span></code>, initializing the object as <code class="computeroutput"><span class="identifier">result</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br>
          &#8212; Obtains the handler's associated executor object <code class="computeroutput"><span class="identifier">ex1</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_executor</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Creates a work object <code class="computeroutput"><span class="identifier">w</span></code> by performing <code class="computeroutput"><span class="identifier">make_work</span><span class="special">(</span><span class="identifier">ex1</span><span class="special">)</span></code>.<br> &#8212; Obtains the handler's associated
          allocator object <code class="computeroutput"><span class="identifier">alloc</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">f</span></code> with a function call operator that
          performs <code class="computeroutput"><span class="identifier">ex1</span><span class="special">.</span><span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code>
          followed by <code class="computeroutput"><span class="identifier">w</span><span class="special">.</span><span class="identifier">reset</span><span class="special">()</span></code>.<br>
          &#8212; Performs <code class="computeroutput"><span class="identifier">ex</span><span class="special">.</span><span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">result</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">ctx</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">(),</span>
          <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">ExecutionContext</span><span class="special">&amp;,</span> <span class="identifier">execution_context</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div></div><div class="section" title="15.25.&#160;Function post"><div class="titlepage"><div><div><h3 class="title"><a name="functions.post"></a>15.25.&#160;Function <code class="literal">post</code></h3></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          Let the type <code class="computeroutput"><span class="identifier">Handler</span></code> be
          the handler function object type determined by performing <code class="computeroutput"><span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">,</span>
          <span class="keyword">void</span><span class="special">()&gt;</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Requires:</em></span> The type <code class="computeroutput"><span class="identifier">Handler</span></code>
          must satisfy the <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>
          requirements (C++ Std, [moveconstructible]) and be callable with zero arguments.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Effects:</em></span> <br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">handler</span></code> of type <code class="computeroutput"><span class="identifier">Handler</span></code>,
          initialized with <code class="computeroutput"><span class="identifier">handler</span><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.<br> &#8212; Constructs an object <code class="computeroutput"><span class="identifier">result</span></code> of type <code class="computeroutput"><span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">Handler</span><span class="special">&gt;</span></code>, initializing the object as <code class="computeroutput"><span class="identifier">result</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br>
          &#8212; Obtains the handler's associated executor object <code class="computeroutput"><span class="identifier">ex</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_executor</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Obtains the handler's associated
          allocator object <code class="computeroutput"><span class="identifier">alloc</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Performs <code class="computeroutput"><span class="identifier">ex</span><span class="special">.</span><span class="identifier">post</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">result</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code>.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">post</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          Let the type <code class="computeroutput"><span class="identifier">Handler</span></code> be
          the handler function object type determined by performing <code class="computeroutput"><span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">,</span>
          <span class="keyword">void</span><span class="special">()&gt;</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Requires:</em></span> The type <code class="computeroutput"><span class="identifier">Handler</span></code>
          must satisfy the <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>
          requirements (C++ Std, [moveconstructible]) and be callable with zero arguments.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Effects:</em></span> <br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">handler</span></code> of type <code class="computeroutput"><span class="identifier">Handler</span></code>,
          initialized with <code class="computeroutput"><span class="identifier">handler</span><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.<br> &#8212; Constructs an object <code class="computeroutput"><span class="identifier">result</span></code> of type <code class="computeroutput"><span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">Handler</span><span class="special">&gt;</span></code>, initializing the object as <code class="computeroutput"><span class="identifier">result</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br>
          &#8212; Obtains the handler's associated executor object <code class="computeroutput"><span class="identifier">ex1</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_executor</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Creates a work object <code class="computeroutput"><span class="identifier">w</span></code> by performing <code class="computeroutput"><span class="identifier">make_work</span><span class="special">(</span><span class="identifier">ex1</span><span class="special">)</span></code>.<br> &#8212; Obtains the handler's associated
          allocator object <code class="computeroutput"><span class="identifier">alloc</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">f</span></code> with a function call operator that
          performs <code class="computeroutput"><span class="identifier">ex1</span><span class="special">.</span><span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code>
          followed by <code class="computeroutput"><span class="identifier">w</span><span class="special">.</span><span class="identifier">reset</span><span class="special">()</span></code>.<br>
          &#8212; Performs <code class="computeroutput"><span class="identifier">ex</span><span class="special">.</span><span class="identifier">post</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">result</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">post</span><span class="special">(</span><span class="identifier">ctx</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">(),</span>
          <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">ExecutionContext</span><span class="special">&amp;,</span> <span class="identifier">execution_context</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div></div><div class="section" title="15.26.&#160;Function defer"><div class="titlepage"><div><div><h3 class="title"><a name="functions.defer"></a>15.26.&#160;Function <code class="literal">defer</code></h3></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">defer</span><span class="special">(</span><span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          Let the type <code class="computeroutput"><span class="identifier">Handler</span></code> be
          the handler function object type determined by performing <code class="computeroutput"><span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">,</span>
          <span class="keyword">void</span><span class="special">()&gt;</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Requires:</em></span> The type <code class="computeroutput"><span class="identifier">Handler</span></code>
          must satisfy the <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>
          requirements (C++ Std, [moveconstructible]) and be callable with zero arguments.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Effects:</em></span> <br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">handler</span></code> of type <code class="computeroutput"><span class="identifier">Handler</span></code>,
          initialized with <code class="computeroutput"><span class="identifier">handler</span><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.<br> &#8212; Constructs an object <code class="computeroutput"><span class="identifier">result</span></code> of type <code class="computeroutput"><span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">Handler</span><span class="special">&gt;</span></code>, initializing the object as <code class="computeroutput"><span class="identifier">result</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br>
          &#8212; Obtains the handler's associated executor object <code class="computeroutput"><span class="identifier">ex</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_executor</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Obtains the handler's associated
          allocator object <code class="computeroutput"><span class="identifier">alloc</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Performs <code class="computeroutput"><span class="identifier">ex</span><span class="special">.</span><span class="identifier">defer</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">result</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code>.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">defer</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          Let the type <code class="computeroutput"><span class="identifier">Handler</span></code> be
          the handler function object type determined by performing <code class="computeroutput"><span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">,</span>
          <span class="keyword">void</span><span class="special">()&gt;</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Requires:</em></span> The type <code class="computeroutput"><span class="identifier">Handler</span></code>
          must satisfy the <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>
          requirements (C++ Std, [moveconstructible]) and be callable with zero arguments.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Effects:</em></span> <br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">handler</span></code> of type <code class="computeroutput"><span class="identifier">Handler</span></code>,
          initialized with <code class="computeroutput"><span class="identifier">handler</span><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.<br> &#8212; Constructs an object <code class="computeroutput"><span class="identifier">result</span></code> of type <code class="computeroutput"><span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">Handler</span><span class="special">&gt;</span></code>, initializing the object as <code class="computeroutput"><span class="identifier">result</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br>
          &#8212; Obtains the handler's associated executor object <code class="computeroutput"><span class="identifier">ex1</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_executor</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Creates a work object <code class="computeroutput"><span class="identifier">w</span></code> by performing <code class="computeroutput"><span class="identifier">make_work</span><span class="special">(</span><span class="identifier">ex1</span><span class="special">)</span></code>.<br> &#8212; Obtains the handler's associated
          allocator object <code class="computeroutput"><span class="identifier">alloc</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">f</span></code> with a function call operator that
          performs <code class="computeroutput"><span class="identifier">ex1</span><span class="special">.</span><span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code>
          followed by <code class="computeroutput"><span class="identifier">w</span><span class="special">.</span><span class="identifier">reset</span><span class="special">()</span></code>.<br>
          &#8212; Performs <code class="computeroutput"><span class="identifier">ex</span><span class="special">.</span><span class="identifier">defer</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">result</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">CompletionToken</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">defer</span><span class="special">(</span><span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">CompletionToken</span><span class="special">&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">defer</span><span class="special">(</span><span class="identifier">ctx</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">(),</span>
          <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">ExecutionContext</span><span class="special">&amp;,</span> <span class="identifier">execution_context</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div></div><div class="section" title="15.27.&#160;Header &lt;experimental/strand&gt; synopsis"><div class="titlepage"><div><div><h3 class="title"><a name="headers.header____experimental_strand___synopsis"></a>15.27.&#160;Header <code class="literal">&lt;experimental/strand&gt;</code> synopsis</h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
        <span class="keyword">class</span> <a class="link" href="#classes.strand" title="15.28.&#160;Class template strand">strand</a><span class="special">;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
        <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
        <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
        <span class="keyword">struct</span> <span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;&gt;</span> <span class="special">:</span> <span class="identifier">true_type</span> <span class="special">{};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" title="15.28.&#160;Class template strand"><div class="titlepage"><div><div><h3 class="title"><a name="classes.strand"></a>15.28.&#160;Class template <code class="literal">strand</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">&gt;</span>
      <span class="keyword">class</span> <span class="identifier">strand</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="comment">// types:</span>

        <span class="keyword">typedef</span> <span class="identifier">Executor</span> <span class="identifier">inner_executor_type</span><span class="special">;</span>

        <span class="comment">// construct / copy / destroy:</span>

        <span class="identifier">strand</span><span class="special">();</span>
        <span class="keyword">explicit</span> <span class="identifier">strand</span><span class="special">(</span><span class="identifier">Executor</span> <span class="identifier">ex</span><span class="special">);</span>
        <span class="identifier">strand</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">);</span>
        <span class="identifier">strand</span><span class="special">(</span><span class="identifier">strand</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span> <span class="identifier">strand</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span> <span class="identifier">strand</span><span class="special">(</span><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">other</span><span class="special">);</span>

        <span class="identifier">strand</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">);</span>
        <span class="identifier">strand</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">strand</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span> <span class="identifier">strand</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span> <span class="identifier">strand</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">other</span><span class="special">);</span>

        <span class="special">~</span><span class="identifier">strand</span><span class="special">();</span>

        <span class="comment">// strand operations:</span>

        <span class="identifier">inner_executor_type</span> <span class="identifier">get_inner_executor</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="keyword">bool</span> <span class="identifier">running_in_this_thread</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">context</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="keyword">void</span> <span class="identifier">on_work_started</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="keyword">void</span> <span class="identifier">on_work_finished</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">defer</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>

      <span class="keyword">private</span><span class="special">:</span>
        <span class="identifier">Executor</span> <span class="identifier">inner_ex_</span><span class="special">;</span> <span class="comment">// <span class="emphasis"><em>exposition only</em></span></span>
      <span class="special">};</span>

      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span></code>
        is a wrapper around an object of type <code class="computeroutput"><span class="identifier">Executor</span></code>
        satisfying <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor requirements</a>.
        <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span></code>
        satisfies the Executor requirements.
      </p><p>
        A strand provides guarantees of ordering and non-concurrency. Given:
      </p><p>
        &#8212; strand objects <code class="computeroutput"><span class="identifier">s1</span></code> and <code class="computeroutput"><span class="identifier">s2</span></code> such that <code class="computeroutput"><span class="identifier">s1</span>
        <span class="special">==</span> <span class="identifier">s2</span></code>
      </p><p>
        &#8212; a function object <code class="computeroutput"><span class="identifier">f1</span></code> added
        to the strand <code class="computeroutput"><span class="identifier">s1</span></code> using <code class="computeroutput"><span class="identifier">post</span></code> or <code class="computeroutput"><span class="identifier">defer</span></code>,
        or using <code class="computeroutput"><span class="identifier">dispatch</span></code> when <code class="computeroutput"><span class="identifier">s1</span><span class="special">.</span><span class="identifier">running_in_this_thread</span><span class="special">()</span> <span class="special">==</span> <span class="keyword">false</span></code>
      </p><p>
        &#8212; a function object <code class="computeroutput"><span class="identifier">f2</span></code> added
        to the strand <code class="computeroutput"><span class="identifier">s2</span></code> using <code class="computeroutput"><span class="identifier">post</span></code> or <code class="computeroutput"><span class="identifier">defer</span></code>,
        or using <code class="computeroutput"><span class="identifier">dispatch</span></code> when <code class="computeroutput"><span class="identifier">s2</span><span class="special">.</span><span class="identifier">running_in_this_thread</span><span class="special">()</span> <span class="special">==</span> <span class="keyword">false</span></code>
      </p><p>
        then the implementation shall invoke <code class="computeroutput"><span class="identifier">f1</span></code>
        and <code class="computeroutput"><span class="identifier">f2</span></code> such that:
      </p><p>
        &#8212; the invocation of <code class="computeroutput"><span class="identifier">f1</span></code> is not
        concurrent with the invocation of <code class="computeroutput"><span class="identifier">f2</span></code>
      </p><p>
        &#8212; the invocation of <code class="computeroutput"><span class="identifier">f1</span></code> synchronizes
        with the invocation of <code class="computeroutput"><span class="identifier">f2</span></code>.
      </p><p>
        Furthermore, if the addition of <code class="computeroutput"><span class="identifier">f1</span></code>
        happens before the addition of <code class="computeroutput"><span class="identifier">f2</span></code>,
        then the invocation of <code class="computeroutput"><span class="identifier">f1</span></code>
        happens before the invocation of <code class="computeroutput"><span class="identifier">f2</span></code>.
      </p><p>
        The strand copy constructors, comparison operators, and member functions
        shall not introduce data races as a result of concurrent calls to those functions
        from different threads.
      </p><p>
        If any function <code class="computeroutput"><span class="identifier">f</span></code> executed
        by the strand throws an exception, the subsequent strand state shall be as
        if <code class="computeroutput"><span class="identifier">f</span></code> had exited without throwing
        an exception.
      </p><div class="section" title="15.28.1.&#160;strand constructors"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__strand__constructors"></a>15.28.1.&#160;<code class="literal">strand</code> constructors</h4></div></div></div><pre class="programlisting"><span class="identifier">strand</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span></code>
            that represents a unique ordered, non-concurrent state. Initializes
            <code class="computeroutput"><span class="identifier">inner_ex_</span></code> with <code class="computeroutput"><span class="identifier">inner_ex_</span><span class="special">()</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Remarks:</em></span> This overload shall not participate in
            overload resolution unless <code class="computeroutput"><span class="identifier">Executor</span></code>
            satisfies the <code class="computeroutput"><span class="identifier">DefaultConstructible</span></code>
            requirements (C++ Std, [defaultconstructible]).
          </p></blockquote></div><pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">strand</span><span class="special">(</span><span class="identifier">Executor</span> <span class="identifier">ex</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span></code>
            that represents a unique ordered, non-concurrent state. Initializes
            <code class="computeroutput"><span class="identifier">inner_ex_</span></code> with <code class="computeroutput"><span class="identifier">inner_ex_</span><span class="special">(</span><span class="identifier">ex</span><span class="special">)</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">strand</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span></code>.
            Initalizes <code class="computeroutput"><span class="identifier">inner_ex_</span></code>
            with <code class="computeroutput"><span class="identifier">inner_ex_</span><span class="special">(</span><span class="identifier">other</span><span class="special">.</span><span class="identifier">inner_ex_</span><span class="special">)</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <br> &#8212; <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span> <span class="special">==</span> <span class="identifier">other</span></code><br> &#8212; <code class="computeroutput"><span class="identifier">get_inner_executor</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">other</span><span class="special">.</span><span class="identifier">get_inner_executor</span><span class="special">()</span></code>
          </p></blockquote></div><pre class="programlisting"><span class="identifier">strand</span><span class="special">(</span><span class="identifier">strand</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span></code>.
            Initalizes <code class="computeroutput"><span class="identifier">inner_ex_</span></code>
            with <code class="computeroutput"><span class="identifier">inner_ex_</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">other</span><span class="special">.</span><span class="identifier">inner_ex_</span><span class="special">))</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <br> &#8212; <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is equal to the prior value of <code class="computeroutput"><span class="identifier">other</span></code><br> &#8212; <code class="computeroutput"><span class="identifier">get_inner_executor</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">other</span><span class="special">.</span><span class="identifier">get_inner_executor</span><span class="special">()</span></code>
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span> <span class="identifier">strand</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">OtherExecutor</span></code>
            is convertible to <code class="computeroutput"><span class="identifier">Executor</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span></code>.
            Initalizes <code class="computeroutput"><span class="identifier">inner_ex_</span></code>
            with <code class="computeroutput"><span class="identifier">inner_ex_</span><span class="special">(</span><span class="identifier">other</span><span class="special">.</span><span class="identifier">inner_ex_</span><span class="special">)</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span> <span class="special">==</span> <span class="identifier">other</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span> <span class="identifier">strand</span><span class="special">(</span><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">OtherExecutor</span></code>
            is convertible to <code class="computeroutput"><span class="identifier">Executor</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span></code>.
            Initalizes <code class="computeroutput"><span class="identifier">inner_ex_</span></code>
            with <code class="computeroutput"><span class="identifier">inner_ex_</span><span class="special">(</span><span class="identifier">other</span><span class="special">.</span><span class="identifier">inner_ex_</span><span class="special">)</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is equal to the prior value of <code class="computeroutput"><span class="identifier">other</span></code>.
          </p></blockquote></div></div><div class="section" title="15.28.2.&#160;strand assignment"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__strand__assignment"></a>15.28.2.&#160;<code class="literal">strand</code> assignment</h4></div></div></div><pre class="programlisting"><span class="identifier">strand</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">Executor</span></code>
            is <code class="computeroutput"><span class="identifier">Assignable</span></code> (C++ Std
            [assignable]).
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <br> &#8212; <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span> <span class="special">==</span> <span class="identifier">other</span></code><br> &#8212; <code class="computeroutput"><span class="identifier">get_inner_executor</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">other</span><span class="special">.</span><span class="identifier">get_inner_executor</span><span class="special">()</span></code>
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">strand</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">strand</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">Executor</span></code>
            is <code class="computeroutput"><span class="identifier">Assignable</span></code> (C++ Std
            [assignable]).
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <br> &#8212; <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is equal to the prior value of <code class="computeroutput"><span class="identifier">other</span></code><br> &#8212; <code class="computeroutput"><span class="identifier">get_inner_executor</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">other</span><span class="special">.</span><span class="identifier">get_inner_executor</span><span class="special">()</span></code>
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span> <span class="identifier">strand</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">OtherExecutor</span></code>
            is convertible to <code class="computeroutput"><span class="identifier">Executor</span></code>.
            <code class="computeroutput"><span class="identifier">Executor</span></code> is <code class="computeroutput"><span class="identifier">Assignable</span></code> (C++ Std [assignable]).
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Equivalent to <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=(</span><span class="identifier">Executor</span><span class="special">(</span><span class="identifier">other</span><span class="special">))</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">OtherExecutor</span><span class="special">&gt;</span> <span class="identifier">strand</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">OtherExecutor</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">other</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> <code class="computeroutput"><span class="identifier">OtherExecutor</span></code>
            is convertible to <code class="computeroutput"><span class="identifier">Executor</span></code>.
            <code class="computeroutput"><span class="identifier">Executor</span></code> is <code class="computeroutput"><span class="identifier">Assignable</span></code> (C++ Std [assignable]).
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Equivalent to <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="keyword">operator</span><span class="special">=(</span><span class="identifier">Executor</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">other</span><span class="special">)))</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div></div><div class="section" title="15.28.3.&#160;strand destructor"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__strand__destructor"></a>15.28.3.&#160;<code class="literal">strand</code> destructor</h4></div></div></div><pre class="programlisting"><span class="special">~</span><span class="identifier">strand</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Destroys an object of class <code class="computeroutput"><span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;</span></code>.
            Function objects that were added to the strand but have not yet been
            executed shall still be executed in a way that meets the guarantees of
            ordering and non-concurrency.
          </p></blockquote></div></div><div class="section" title="15.28.4.&#160;strand operations"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__strand__operations"></a>15.28.4.&#160;<code class="literal">strand</code> operations</h4></div></div></div><pre class="programlisting"><span class="identifier">inner_executor_type</span> <span class="identifier">get_inner_executor</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">inner_ex_</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">running_in_this_thread</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="keyword">true</span></code>
            if the current thread of execution is invoking a function that was submitted
            to the strand, or to any other strand object <code class="computeroutput"><span class="identifier">s</span></code>
            such that <code class="computeroutput"><span class="identifier">s</span> <span class="special">==</span>
            <span class="special">*</span><span class="keyword">this</span></code>,
            using <code class="computeroutput"><span class="identifier">dispatch</span></code>, <code class="computeroutput"><span class="identifier">post</span></code> or <code class="computeroutput"><span class="identifier">defer</span></code>;
            otherwise <code class="computeroutput"><span class="keyword">false</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">execution_context</span><span class="special">&amp;</span> <span class="identifier">context</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">inner_ex_</span><span class="special">.</span><span class="identifier">context</span><span class="special">()</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">on_work_started</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Calls <code class="computeroutput"><span class="identifier">inner_ex_</span><span class="special">.</span><span class="identifier">on_work_started</span><span class="special">()</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">on_work_finished</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Calls <code class="computeroutput"><span class="identifier">inner_ex_</span><span class="special">.</span><span class="identifier">on_work_finished</span><span class="special">()</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> If <code class="computeroutput"><span class="identifier">running_in_this_thread</span><span class="special">()</span></code> is true, calls <code class="literal"><span class="emphasis"><em>DECAY_COPY</em></span></code><code class="computeroutput"><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">))()</span></code>. Otherwise, requests invocation of
            <code class="computeroutput"><span class="identifier">f</span></code>, as if by forwarding
            the function object <code class="computeroutput"><span class="identifier">f</span></code>
            and allocator <code class="computeroutput"><span class="identifier">a</span></code> to the
            executor <code class="computeroutput"><span class="identifier">inner_ex_</span></code>, such
            that the guarantees of ordering and non-concurrency are met.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            If <code class="computeroutput"><span class="identifier">f</span></code> exits via an exception,
            and the execution of <code class="computeroutput"><span class="identifier">f</span></code>
            is performed in the current thread and before <code class="computeroutput"><span class="identifier">dispatch</span></code>
            returns, the exception shall propagate to the caller of <code class="computeroutput"><span class="identifier">dispatch</span><span class="special">()</span></code>
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Requests invocation of <code class="computeroutput"><span class="identifier">f</span></code>,
            as if by forwarding the function object <code class="computeroutput"><span class="identifier">f</span></code>
            and allocator <code class="computeroutput"><span class="identifier">a</span></code> to the
            executor <code class="computeroutput"><span class="identifier">inner_ex_</span></code>, such
            that the guarantees of ordering and non-concurrency are met.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">defer</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Requests invocation of <code class="computeroutput"><span class="identifier">f</span></code>,
            as if by forwarding the function object <code class="computeroutput"><span class="identifier">f</span></code>
            and allocator <code class="computeroutput"><span class="identifier">a</span></code> to the
            executor <code class="computeroutput"><span class="identifier">inner_ex_</span></code>, such
            that the guarantees of ordering and non-concurrency are met.
          </p></blockquote></div></div><div class="section" title="15.28.5.&#160;strand comparisons"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__strand__comparisons"></a>15.28.5.&#160;<code class="literal">strand</code> comparisons</h4></div></div></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="keyword">true</span></code>,
            if the strand objects share the same ordered, non-concurrent state; otherwise
            <code class="computeroutput"><span class="keyword">false</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">strand</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;&amp;</span> <span class="identifier">b</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">!(</span><span class="identifier">a</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">)</span></code>.
          </p></blockquote></div></div></div><div class="section" title="15.29.&#160;Header &lt;experimental/timer&gt; synopsis"><div class="titlepage"><div><div><h3 class="title"><a name="headers.header____experimental_timer___synopsis"></a>15.29.&#160;Header <code class="literal">&lt;experimental/timer&gt;</code> synopsis</h3></div></div></div><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">chrono</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

    // <a class="link" href="#functions.dispatch_at" title="15.30.&#160;Function dispatch_at">dispatch_at</a>:

    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">dispatch_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
                       <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">dispatch_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
                       <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">dispatch_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
                       <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>

    // <a class="link" href="#functions.post_at" title="15.31.&#160;Function post_at">post_at</a>:

    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">post_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
                   <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">post_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
                   <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">post_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
                   <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>

    // <a class="link" href="#functions.defer_at" title="15.32.&#160;Function defer_at">defer_at</a>:

    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">defer_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
        <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">defer_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
        <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">defer_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
                    <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>

    // <a class="link" href="#functions.dispatch_after" title="15.33.&#160;Function dispatch_after">dispatch_after</a>:

    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">dispatch_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                          <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">token</span><span class="special">);</span>
    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">dispatch_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                          <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">dispatch_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                          <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>

    // <a class="link" href="#functions.post_after" title="15.34.&#160;Function post_after">post_after</a>:

    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">post_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                      <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">token</span><span class="special">);</span>
    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">post_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                      <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">post_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                      <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>

    // <a class="link" href="#functions.defer_after" title="15.35.&#160;Function defer_after">defer_after</a>:

    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">defer_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                       <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">token</span><span class="special">);</span>
    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">defer_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                       <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
      <span class="keyword">auto</span> <span class="identifier">defer_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                       <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" title="15.30.&#160;Function dispatch_at"><div class="titlepage"><div><div><h3 class="title"><a name="functions.dispatch_at"></a>15.30.&#160;Function <code class="literal">dispatch_at</code></h3></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">dispatch_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
                   <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          Let the type <code class="computeroutput"><span class="identifier">Handler</span></code> be
          the handler function object type determined by performing <code class="computeroutput"><span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">,</span>
          <span class="keyword">void</span><span class="special">()&gt;</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Requires:</em></span> The type <code class="computeroutput"><span class="identifier">Handler</span></code>
          must satisfy the <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>
          requirements (C++ Std, [moveconstructible]) and be callable with zero arguments.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Effects:</em></span> <br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">handler</span></code> of type <code class="computeroutput"><span class="identifier">Handler</span></code>,
          initialized with <code class="computeroutput"><span class="identifier">handler</span><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.<br> &#8212; Constructs an object <code class="computeroutput"><span class="identifier">result</span></code> of type <code class="computeroutput"><span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">Handler</span><span class="special">&gt;</span></code>, initializing the object as <code class="computeroutput"><span class="identifier">result</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br>
          &#8212; Obtains the handler's associated executor object <code class="computeroutput"><span class="identifier">ex</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_executor</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Creates a work object <code class="computeroutput"><span class="identifier">w</span></code> by performing <code class="computeroutput"><span class="identifier">make_work</span><span class="special">(</span><span class="identifier">ex</span><span class="special">)</span></code>.<br>
          &#8212; Obtains the handler's associated allocator object <code class="computeroutput"><span class="identifier">alloc</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Without blocking the current thread
          of execution, on expiration of the absolute timeout specified by <code class="computeroutput"><span class="identifier">abs_time</span></code> performs <code class="computeroutput"><span class="identifier">ex</span><span class="special">.</span><span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code> followed by <code class="computeroutput"><span class="identifier">w</span><span class="special">.</span><span class="identifier">reset</span><span class="special">()</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">result</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code>.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">dispatch_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
                   <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          Let the type <code class="computeroutput"><span class="identifier">Handler</span></code> be
          the handler function object type determined by performing <code class="computeroutput"><span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">,</span>
          <span class="keyword">void</span><span class="special">()&gt;</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Requires:</em></span> The type <code class="computeroutput"><span class="identifier">Handler</span></code>
          must satisfy the <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>
          requirements (C++ Std, [moveconstructible]) and be callable with zero arguments.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Effects:</em></span> <br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">handler</span></code> of type <code class="computeroutput"><span class="identifier">Handler</span></code>,
          initialized with <code class="computeroutput"><span class="identifier">handler</span><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.<br> &#8212; Constructs an object <code class="computeroutput"><span class="identifier">result</span></code> of type <code class="computeroutput"><span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">Handler</span><span class="special">&gt;</span></code>, initializing the object as <code class="computeroutput"><span class="identifier">result</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br>
          &#8212; Creates a work object <code class="computeroutput"><span class="identifier">w</span></code>
          by performing <code class="computeroutput"><span class="identifier">make_work</span><span class="special">(</span><span class="identifier">ex</span><span class="special">)</span></code>.<br>
          &#8212; Obtains the handler's associated executor object <code class="computeroutput"><span class="identifier">ex1</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_executor</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Creates a work object <code class="computeroutput"><span class="identifier">w1</span></code> by performing <code class="computeroutput"><span class="identifier">make_work</span><span class="special">(</span><span class="identifier">ex1</span><span class="special">)</span></code>.<br> &#8212; Obtains the handler's associated
          allocator object <code class="computeroutput"><span class="identifier">alloc</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">f</span></code> with a function call operator that
          performs <code class="computeroutput"><span class="identifier">ex1</span><span class="special">.</span><span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code>
          followed by <code class="computeroutput"><span class="identifier">w1</span><span class="special">.</span><span class="identifier">reset</span><span class="special">()</span></code>.<br>
          &#8212; Without blocking the current thread of execution, on expiration of the
          absolute timeout specified by <code class="computeroutput"><span class="identifier">abs_time</span></code>
          performs <code class="computeroutput"><span class="identifier">ex</span><span class="special">.</span><span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code>
          followed by <code class="computeroutput"><span class="identifier">w</span><span class="special">.</span><span class="identifier">reset</span><span class="special">()</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">result</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">dispatch_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
                   <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">dispatch_at</span><span class="special">(</span><span class="identifier">ctx</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">(),</span>
          <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">ExecutionContext</span><span class="special">&amp;,</span> <span class="identifier">execution_context</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div></div><div class="section" title="15.31.&#160;Function post_at"><div class="titlepage"><div><div><h3 class="title"><a name="functions.post_at"></a>15.31.&#160;Function <code class="literal">post_at</code></h3></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">post_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
               <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          Let the type <code class="computeroutput"><span class="identifier">Handler</span></code> be
          the handler function object type determined by performing <code class="computeroutput"><span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">,</span>
          <span class="keyword">void</span><span class="special">()&gt;</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Requires:</em></span> The type <code class="computeroutput"><span class="identifier">Handler</span></code>
          must satisfy the <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>
          requirements (C++ Std, [moveconstructible]) and be callable with zero arguments.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Effects:</em></span> <br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">handler</span></code> of type <code class="computeroutput"><span class="identifier">Handler</span></code>,
          initialized with <code class="computeroutput"><span class="identifier">handler</span><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.<br> &#8212; Constructs an object <code class="computeroutput"><span class="identifier">result</span></code> of type <code class="computeroutput"><span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">Handler</span><span class="special">&gt;</span></code>, initializing the object as <code class="computeroutput"><span class="identifier">result</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br>
          &#8212; Obtains the handler's associated executor object <code class="computeroutput"><span class="identifier">ex</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_executor</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Creates a work object <code class="computeroutput"><span class="identifier">w</span></code> by performing <code class="computeroutput"><span class="identifier">make_work</span><span class="special">(</span><span class="identifier">ex</span><span class="special">)</span></code>.<br>
          &#8212; Obtains the handler's associated allocator object <code class="computeroutput"><span class="identifier">alloc</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Without blocking the current thread
          of execution, on expiration of the absolute timeout specified by <code class="computeroutput"><span class="identifier">abs_time</span></code> performs <code class="computeroutput"><span class="identifier">ex</span><span class="special">.</span><span class="identifier">post</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code> followed by <code class="computeroutput"><span class="identifier">w</span><span class="special">.</span><span class="identifier">reset</span><span class="special">()</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">result</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code>.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">post_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
               <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          Let the type <code class="computeroutput"><span class="identifier">Handler</span></code> be
          the handler function object type determined by performing <code class="computeroutput"><span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">,</span>
          <span class="keyword">void</span><span class="special">()&gt;</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Requires:</em></span> The type <code class="computeroutput"><span class="identifier">Handler</span></code>
          must satisfy the <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>
          requirements (C++ Std, [moveconstructible]) and be callable with zero arguments.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Effects:</em></span> <br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">handler</span></code> of type <code class="computeroutput"><span class="identifier">Handler</span></code>,
          initialized with <code class="computeroutput"><span class="identifier">handler</span><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.<br> &#8212; Constructs an object <code class="computeroutput"><span class="identifier">result</span></code> of type <code class="computeroutput"><span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">Handler</span><span class="special">&gt;</span></code>, initializing the object as <code class="computeroutput"><span class="identifier">result</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br>
          &#8212; Creates a work object <code class="computeroutput"><span class="identifier">w</span></code>
          by performing <code class="computeroutput"><span class="identifier">make_work</span><span class="special">(</span><span class="identifier">ex</span><span class="special">)</span></code>.<br>
          &#8212; Obtains the handler's associated executor object <code class="computeroutput"><span class="identifier">ex1</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_executor</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Creates a work object <code class="computeroutput"><span class="identifier">w1</span></code> by performing <code class="computeroutput"><span class="identifier">make_work</span><span class="special">(</span><span class="identifier">ex1</span><span class="special">)</span></code>.<br> &#8212; Obtains the handler's associated
          allocator object <code class="computeroutput"><span class="identifier">alloc</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">f</span></code> with a function call operator that
          performs <code class="computeroutput"><span class="identifier">ex1</span><span class="special">.</span><span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code>
          followed by <code class="computeroutput"><span class="identifier">w1</span><span class="special">.</span><span class="identifier">reset</span><span class="special">()</span></code>.<br>
          &#8212; Without blocking the current thread of execution, on expiration of the
          absolute timeout specified by <code class="computeroutput"><span class="identifier">abs_time</span></code>
          performs <code class="computeroutput"><span class="identifier">ex</span><span class="special">.</span><span class="identifier">post</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code>
          followed by <code class="computeroutput"><span class="identifier">w</span><span class="special">.</span><span class="identifier">reset</span><span class="special">()</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">result</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">post_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
               <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">post_at</span><span class="special">(</span><span class="identifier">ctx</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">(),</span>
          <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">ExecutionContext</span><span class="special">&amp;,</span> <span class="identifier">execution_context</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div></div><div class="section" title="15.32.&#160;Function defer_at"><div class="titlepage"><div><div><h3 class="title"><a name="functions.defer_at"></a>15.32.&#160;Function <code class="literal">defer_at</code></h3></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">defer_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
                <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          Let the type <code class="computeroutput"><span class="identifier">Handler</span></code> be
          the handler function object type determined by performing <code class="computeroutput"><span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">,</span>
          <span class="keyword">void</span><span class="special">()&gt;</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Requires:</em></span> The type <code class="computeroutput"><span class="identifier">Handler</span></code>
          must satisfy the <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>
          requirements (C++ Std, [moveconstructible]) and be callable with zero arguments.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Effects:</em></span> <br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">handler</span></code> of type <code class="computeroutput"><span class="identifier">Handler</span></code>,
          initialized with <code class="computeroutput"><span class="identifier">handler</span><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.<br> &#8212; Constructs an object <code class="computeroutput"><span class="identifier">result</span></code> of type <code class="computeroutput"><span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">Handler</span><span class="special">&gt;</span></code>, initializing the object as <code class="computeroutput"><span class="identifier">result</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br>
          &#8212; Obtains the handler's associated executor object <code class="computeroutput"><span class="identifier">ex</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_executor</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Creates a work object <code class="computeroutput"><span class="identifier">w</span></code> by performing <code class="computeroutput"><span class="identifier">make_work</span><span class="special">(</span><span class="identifier">ex</span><span class="special">)</span></code>.<br>
          &#8212; Obtains the handler's associated allocator object <code class="computeroutput"><span class="identifier">alloc</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Without blocking the current thread
          of execution, on expiration of the absolute timeout specified by <code class="computeroutput"><span class="identifier">abs_time</span></code> performs <code class="computeroutput"><span class="identifier">ex</span><span class="special">.</span><span class="identifier">defer</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code> followed by <code class="computeroutput"><span class="identifier">w</span><span class="special">.</span><span class="identifier">reset</span><span class="special">()</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">result</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code>.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">defer_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
                <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          Let the type <code class="computeroutput"><span class="identifier">Handler</span></code> be
          the handler function object type determined by performing <code class="computeroutput"><span class="identifier">handler_type_t</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">,</span>
          <span class="keyword">void</span><span class="special">()&gt;</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Requires:</em></span> The type <code class="computeroutput"><span class="identifier">Handler</span></code>
          must satisfy the <code class="computeroutput"><span class="identifier">MoveConstructible</span></code>
          requirements (C++ Std, [moveconstructible]) and be callable with zero arguments.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Effects:</em></span> <br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">handler</span></code> of type <code class="computeroutput"><span class="identifier">Handler</span></code>,
          initialized with <code class="computeroutput"><span class="identifier">handler</span><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.<br> &#8212; Constructs an object <code class="computeroutput"><span class="identifier">result</span></code> of type <code class="computeroutput"><span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">Handler</span><span class="special">&gt;</span></code>, initializing the object as <code class="computeroutput"><span class="identifier">result</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br>
          &#8212; Creates a work object <code class="computeroutput"><span class="identifier">w</span></code>
          by performing <code class="computeroutput"><span class="identifier">make_work</span><span class="special">(</span><span class="identifier">ex</span><span class="special">)</span></code>.<br>
          &#8212; Obtains the handler's associated executor object <code class="computeroutput"><span class="identifier">ex1</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_executor</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Creates a work object <code class="computeroutput"><span class="identifier">w1</span></code> by performing <code class="computeroutput"><span class="identifier">make_work</span><span class="special">(</span><span class="identifier">ex1</span><span class="special">)</span></code>.<br> &#8212; Obtains the handler's associated
          allocator object <code class="computeroutput"><span class="identifier">alloc</span></code>
          by performing <code class="computeroutput"><span class="identifier">get_associated_allocator</span><span class="special">(</span><span class="identifier">handler</span><span class="special">)</span></code>.<br> &#8212; Constructs a function object <code class="computeroutput"><span class="identifier">f</span></code> with a function call operator that
          performs <code class="computeroutput"><span class="identifier">ex1</span><span class="special">.</span><span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">handler</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code>
          followed by <code class="computeroutput"><span class="identifier">w1</span><span class="special">.</span><span class="identifier">reset</span><span class="special">()</span></code>.<br>
          &#8212; Without blocking the current thread of execution, on expiration of the
          absolute timeout specified by <code class="computeroutput"><span class="identifier">abs_time</span></code>
          performs <code class="computeroutput"><span class="identifier">ex</span><span class="special">.</span><span class="identifier">defer</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">),</span> <span class="identifier">alloc</span><span class="special">)</span></code>
          followed by <code class="computeroutput"><span class="identifier">w</span><span class="special">.</span><span class="identifier">reset</span><span class="special">()</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">result</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">defer_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">,</span>
                <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">ctx</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">defer_at</span><span class="special">(</span><span class="identifier">ctx</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">(),</span>
          <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">ExecutionContext</span><span class="special">&amp;,</span> <span class="identifier">execution_context</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div></div><div class="section" title="15.33.&#160;Function dispatch_after"><div class="titlepage"><div><div><h3 class="title"><a name="functions.dispatch_after"></a>15.33.&#160;Function <code class="literal">dispatch_after</code></h3></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">dispatch_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                      <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">token</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">dispatch_at</span><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">steady_clock</span><span class="special">::</span><span class="identifier">now</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">rel_time</span><span class="special">,</span> <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">dispatch_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                      <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">dispatch_at</span><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">steady_clock</span><span class="special">::</span><span class="identifier">now</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">rel_time</span><span class="special">,</span> <span class="identifier">e</span><span class="special">,</span>
          <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">dispatch_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                      <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">dispatch_at</span><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">steady_clock</span><span class="special">::</span><span class="identifier">now</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">rel_time</span><span class="special">,</span> <span class="identifier">ctx</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">(),</span> <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">ExecutionContext</span><span class="special">&amp;,</span> <span class="identifier">execution_context</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div></div><div class="section" title="15.34.&#160;Function post_after"><div class="titlepage"><div><div><h3 class="title"><a name="functions.post_after"></a>15.34.&#160;Function <code class="literal">post_after</code></h3></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">post_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                  <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">token</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">post_at</span><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">steady_clock</span><span class="special">::</span><span class="identifier">now</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">rel_time</span><span class="special">,</span> <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">post_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                  <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">post_at</span><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">steady_clock</span><span class="special">::</span><span class="identifier">now</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">rel_time</span><span class="special">,</span> <span class="identifier">e</span><span class="special">,</span>
          <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">post_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                  <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">post_at</span><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">steady_clock</span><span class="special">::</span><span class="identifier">now</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">rel_time</span><span class="special">,</span> <span class="identifier">ctx</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">(),</span> <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">ExecutionContext</span><span class="special">&amp;,</span> <span class="identifier">execution_context</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div></div><div class="section" title="15.35.&#160;Function defer_after"><div class="titlepage"><div><div><h3 class="title"><a name="functions.defer_after"></a>15.35.&#160;Function <code class="literal">defer_after</code></h3></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">defer_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                   <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">token</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">defer_at</span><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">steady_clock</span><span class="special">::</span><span class="identifier">now</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">rel_time</span><span class="special">,</span> <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Executor</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">defer_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                   <span class="keyword">const</span> <span class="identifier">Executor</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">defer_at</span><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">steady_clock</span><span class="special">::</span><span class="identifier">now</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">rel_time</span><span class="special">,</span> <span class="identifier">e</span><span class="special">,</span>
          <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">Executor</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ExecutionContext</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">CompletionTokens</span><span class="special">&gt;</span>
  <span class="keyword">auto</span> <span class="identifier">defer_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">,</span>
                   <span class="identifier">ExecutionContext</span><span class="special">&amp;</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">CompletionTokens</span><span class="special">&amp;&amp;...</span> <span class="identifier">tokens</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">experimental</span><span class="special">::</span>concurrency_v1<span class="special">::</span><span class="identifier">defer_at</span><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">steady_clock</span><span class="special">::</span><span class="identifier">now</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">rel_time</span><span class="special">,</span> <span class="identifier">ctx</span><span class="special">.</span><span class="identifier">get_executor</span><span class="special">(),</span> <span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">CompletionToken</span><span class="special">&gt;(</span><span class="identifier">token</span><span class="special">))</span></code>.
        </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Remarks:</em></span> This function shall not participate in overload
          resolution unless <code class="computeroutput"><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">ExecutionContext</span><span class="special">&amp;,</span> <span class="identifier">execution_context</span><span class="special">&amp;&gt;::</span><span class="identifier">value</span></code>
          is true.
        </p></blockquote></div></div><div class="section" title="15.36.&#160;Header &lt;experimental/future&gt; synopsis"><div class="titlepage"><div><div><h3 class="title"><a name="headers.header____experimental_future___synopsis"></a>15.36.&#160;Header <code class="literal">&lt;experimental/future&gt;</code> synopsis</h3></div></div></div><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">future</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="identifier">allocator</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;&gt;</span>
        <span class="keyword">class</span> <a class="link" href="#classes.use_future_t" title="15.37.&#160;Class template use_future_t">use_future_t</a><span class="special">;</span>

      <span class="keyword">constexpr</span> <span class="identifier">use_future_t</span><span class="special">&lt;&gt;</span> <span class="identifier">use_future</span> <span class="special">=</span> <span class="identifier">use_future_t</span><span class="special">&lt;&gt;();</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
        <span class="keyword">struct</span> <span class="identifier">handler_type</span><span class="special">&lt;</span><span class="identifier">use_future_t</span><span class="special">&lt;</span><span class="identifier">Allocator</span><span class="special">&gt;,</span> <span class="identifier">R</span><span class="special">(</span><span class="identifier">Args</span><span class="special">...)&gt;;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
        <span class="keyword">class</span> <a class="link" href="#classes.async_result_packaged_task" title="15.38.&#160;Class template specialization async_result for packaged_task">async_result&lt;packaged_task&lt;R(Args...)&gt;&gt;</a><span class="special">;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Signature</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
        <span class="keyword">class</span> <a class="link" href="#classes.packaged_handler" title="15.39.&#160;Class template packaged_handler">packaged_handler</a><span class="special">;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Signature</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
        <span class="keyword">class</span> <span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">packaged_handler</span><span class="special">&lt;</span><span class="identifier">Signature</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;&gt;;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span> <span class="special">=</span> <span class="identifier">allocator</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;&gt;</span>
        <span class="keyword">class</span> <a class="link" href="#classes.packaged_token" title="15.40.&#160;Class template packaged_token">packaged_token</a><span class="special">;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
        <span class="keyword">struct</span> <span class="identifier">handler_type</span><span class="special">&lt;</span><span class="identifier">packaged_token</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;,</span> <span class="identifier">R</span><span class="special">(</span><span class="identifier">Args</span><span class="special">...)&gt;;</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span> <span class="special">=</span> <span class="identifier">allocator</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;&gt;</span>
        <span class="identifier">packaged_token</span><span class="special">&lt;</span><span class="identifier">decay_t</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <a class="link" href="#functions.package" title="15.41.&#160;Function package">package</a><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span> <span class="special">=</span> <span class="identifier">Alloc</span><span class="special">());</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" title="15.37.&#160;Class template use_future_t"><div class="titlepage"><div><div><h3 class="title"><a name="classes.use_future_t"></a>15.37.&#160;Class template <code class="literal">use_future_t</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="identifier">allocator</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;&gt;</span>
      <span class="keyword">class</span> <span class="identifier">use_future_t</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="comment">// use_future_t types:</span>
        <span class="keyword">typedef</span> <span class="identifier">Allocator</span> <span class="identifier">allocator_type</span><span class="special">;</span>

        <span class="comment">// use_future_t members:</span>
        <span class="keyword">constexpr</span> <span class="identifier">use_future_t</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="keyword">explicit</span> <span class="identifier">use_future_t</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">OtherAllocator</span><span class="special">&gt;</span> <span class="identifier">use_future_t</span><span class="special">&lt;</span><span class="identifier">OtherAllocator</span><span class="special">&gt;</span>
          <span class="keyword">operator</span><span class="special">[](</span><span class="keyword">const</span> <span class="identifier">OtherAllocator</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="identifier">allocator_type</span> <span class="identifier">get_allocator</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        The class template <code class="computeroutput"><span class="identifier">use_future_t</span></code>
        defines a set of <a class="link" href="#classes.handler_type" title="15.2.&#160;Class template handler_type">completion token types</a>
        for use with asynchronous operations.
      </p><div class="section" title="15.37.1.&#160;use_future_t constructors"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__use_future_t__constructors"></a>15.37.1.&#160;<code class="literal">use_future_t</code> constructors</h4></div></div></div><pre class="programlisting"><span class="keyword">constexpr</span> <span class="identifier">use_future_t</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs a <code class="computeroutput"><span class="identifier">use_future_t</span></code>
            with default-constructed allocator.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">use_future_t</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of type <code class="computeroutput"><span class="identifier">use_future_t</span></code> with post-condition <code class="computeroutput"><span class="identifier">get_allocator</span><span class="special">()</span>
            <span class="special">==</span> <span class="identifier">a</span></code>.
          </p></blockquote></div></div><div class="section" title="15.37.2.&#160;use_future_t members"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__use_future_t__members"></a>15.37.2.&#160;<code class="literal">use_future_t</code> members</h4></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">OtherAllocator</span><span class="special">&gt;</span> <span class="identifier">use_future_t</span><span class="special">&lt;</span><span class="identifier">OtherAllocator</span><span class="special">&gt;</span>
  <span class="keyword">operator</span><span class="special">[](</span><span class="keyword">const</span> <span class="identifier">OtherAllocator</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> A <code class="computeroutput"><span class="identifier">use_future_t</span></code>
            object where <code class="computeroutput"><span class="identifier">get_allocator</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">a</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">allocator_type</span> <span class="identifier">get_allocator</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> The associated allocator object.
          </p></blockquote></div></div><div class="section" title="15.37.3.&#160;use_future_t traits"><div class="titlepage"><div><div><h4 class="title"><a name="classes.use_future_t_traits"></a>15.37.3.&#160;<code class="literal">use_future_t</code> traits</h4></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">handler_type</span><span class="special">&lt;</span><span class="identifier">use_future_t</span><span class="special">&lt;</span><span class="identifier">Allocator</span><span class="special">&gt;,</span> <span class="identifier">R</span><span class="special">(</span><span class="identifier">Args</span><span class="special">...)&gt;</span>
<span class="special">{</span>
  <span class="keyword">typedef</span> <span class="emphasis"><em>see below</em></span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
          An object <code class="computeroutput"><span class="identifier">t1</span></code> of the nested
          function object type <code class="computeroutput"><span class="identifier">type</span></code>
          is an asynchronous provider with an associated shared state (C++Std, [futures.state]).
          The type <code class="computeroutput"><span class="identifier">type</span></code> provides
          <code class="computeroutput"><span class="identifier">type</span><span class="special">::</span><span class="keyword">operator</span><span class="special">()</span></code>
          such that the expression <code class="computeroutput"><span class="identifier">t1</span><span class="special">(</span><span class="identifier">declval</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">&gt;()...)</span></code> is well formed.
        </p><p>
          The implementation shall specialize <code class="computeroutput"><span class="identifier">associated_executor</span></code>
          for <code class="computeroutput"><span class="identifier">type</span></code>. For function
          objects executed using the associated executor's <code class="computeroutput"><span class="identifier">dispatch</span><span class="special">()</span></code>, <code class="computeroutput"><span class="identifier">post</span><span class="special">()</span></code> or <code class="computeroutput"><span class="identifier">defer</span><span class="special">()</span></code> functions, any exception thrown is caught
          by the executor and stored in the associated shared state.
        </p><p>
          The implementation shall specialize <code class="computeroutput"><span class="identifier">async_result</span></code>
          for <code class="computeroutput"><span class="identifier">type</span></code> such that, when
          an <code class="computeroutput"><span class="identifier">async_result</span></code> object
          <code class="computeroutput"><span class="identifier">r1</span></code> is constructed from
          <code class="computeroutput"><span class="identifier">t1</span></code>, the expression <code class="computeroutput"><span class="identifier">r1</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code> returns a future with the same shared
          state as <code class="computeroutput"><span class="identifier">t1</span></code>.
        </p><p>
          The semantics of <code class="computeroutput"><span class="identifier">async_result</span><span class="special">::</span><span class="identifier">type</span></code>
          and <code class="computeroutput"><span class="identifier">type</span><span class="special">::</span><span class="keyword">operator</span><span class="special">()</span></code>
          are defined in the table below. In this table, <code class="literal">N</code> is
          the value of <code class="computeroutput"><span class="keyword">sizeof</span><span class="special">...(</span><span class="identifier">Args</span><span class="special">)</span></code>;
          let <code class="literal"><span class="emphasis"><em>i</em></span></code> be in the range [<code class="literal">0</code>..<code class="literal">N</code>)
          and let <code class="literal">T<sub><span class="emphasis"><em>i</em></span></sub></code> be the <code class="literal"><span class="emphasis"><em>i</em></span></code>th
          type in <code class="computeroutput"><span class="identifier">Args</span></code>; let <code class="literal">U<sub><span class="emphasis"><em>i</em></span></sub></code>
          be <code class="literal">decay&lt;T<sub><span class="emphasis"><em>i</em></span></sub>&gt;::type</code> for each
          type <code class="literal">T<sub><span class="emphasis"><em>i</em></span></sub></code> in <code class="computeroutput"><span class="identifier">Args</span></code>;
          and let <code class="literal">a<sub><span class="emphasis"><em>i</em></span></sub></code> be the <code class="literal"><span class="emphasis"><em>i</em></span></code>th
          argument to <code class="computeroutput"><span class="identifier">type</span><span class="special">::</span><span class="keyword">operator</span><span class="special">()</span></code>.
        </p><div class="table"><a name="classes.appendix__proposed_text.use_future_t.use_future_t_traits.t0"></a><p class="title"><b>Table&#160;5.&#160;handler_type&lt;use_future_t&lt;Allocator&gt;, R(Args...)&gt;::type
          semantics</b></p><div class="table-contents"><table class="table" summary="handler_type&lt;use_future_t&lt;Allocator&gt;, R(Args...)&gt;::type
          semantics"><colgroup><col><col><col><col></colgroup><thead><tr><th>
                  <p>
                    <code class="literal">N</code>
                  </p>
                </th><th>
                  <p>
                    <code class="literal">U<sub><span class="emphasis"><em>0</em></span></sub></code>
                  </p>
                </th><th>
                  <p>
                    <code class="computeroutput"><span class="identifier">async_result</span><span class="special">::</span><span class="identifier">type</span></code>
                  </p>
                </th><th>
                  <p>
                    <code class="computeroutput"><span class="identifier">type</span><span class="special">::</span><span class="keyword">operator</span></code> effects
                  </p>
                </th></tr></thead><tbody><tr><td>
                  <p>
                    0
                  </p>
                </td><td>
                </td><td>
                  <p>
                    <code class="literal">future&lt;void&gt;</code>
                  </p>
                </td><td>
                  <p>
                    Makes the shared state ready.
                  </p>
                </td></tr><tr><td>
                  <p>
                    1
                  </p>
                </td><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">error_code</span></code>
                  </p>
                </td><td>
                  <p>
                    <code class="literal">future&lt;void&gt;</code>
                  </p>
                </td><td>
                  <p>
                    If <code class="literal">a<sub><span class="emphasis"><em>0</em></span></sub></code> evaluates to <code class="computeroutput"><span class="keyword">true</span></code>, atomically stores the exception
                    pointer produced by <code class="literal">make_exception_ptr(system_error(a<sub><span class="emphasis"><em>0</em></span></sub>))</code>
                    in the shared state. The shared state is made ready.
                  </p>
                </td></tr><tr><td>
                  <p>
                    1
                  </p>
                </td><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">exception_ptr</span></code>
                  </p>
                </td><td>
                  <p>
                    <code class="literal">future&lt;void&gt;</code>
                  </p>
                </td><td>
                  <p>
                    If <code class="literal">a<sub><span class="emphasis"><em>0</em></span></sub></code> is non-null, atomically
                    stores the exception pointer <code class="literal">a<sub><span class="emphasis"><em>0</em></span></sub></code>
                    in the shared state. The shared state is made ready.
                  </p>
                </td></tr><tr><td>
                  <p>
                    1
                  </p>
                </td><td>
                  <p>
                    all other types
                  </p>
                </td><td>
                  <p>
                    <code class="literal">future&lt;U<sub><span class="emphasis"><em>0</em></span></sub>&gt;</code>
                  </p>
                </td><td>
                  <p>
                    Atomically stores <code class="literal">a<sub><span class="emphasis"><em>0</em></span></sub></code>
                    in the shared state and makes that state ready.
                  </p>
                </td></tr><tr><td>
                  <p>
                    2
                  </p>
                </td><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">error_code</span></code>
                  </p>
                </td><td>
                  <p>
                    <code class="literal">future&lt;U<sub><span class="emphasis"><em>1</em></span></sub>&gt;</code>
                  </p>
                </td><td>
                  <p>
                    If <code class="literal">a<sub><span class="emphasis"><em>0</em></span></sub></code> evaluates to <code class="computeroutput"><span class="keyword">true</span></code>, atomically stores the exception
                    pointer produced by <code class="literal">make_exception_ptr(system_error(a<sub><span class="emphasis"><em>0</em></span></sub>))</code>
                    in the shared state; otherwise, atomically stores <code class="literal">a<sub><span class="emphasis"><em>1</em></span></sub></code>
                    in the shared state. The shared state is made ready.
                  </p>
                </td></tr><tr><td>
                  <p>
                    2
                  </p>
                </td><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">exception_ptr</span></code>
                  </p>
                </td><td>
                  <p>
                    <code class="literal">future&lt;U<sub><span class="emphasis"><em>1</em></span></sub>&gt;</code>
                  </p>
                </td><td>
                  <p>
                    If <code class="literal">a<sub><span class="emphasis"><em>0</em></span></sub></code> is non-null, atomically
                    stores the exception pointer in the shared state; otherwise,
                    atomically stores <code class="literal">a<sub><span class="emphasis"><em>1</em></span></sub></code>
                    in the shared state. The shared state is made ready.
                  </p>
                </td></tr><tr><td>
                  <p>
                    2
                  </p>
                </td><td>
                  <p>
                    all other types
                  </p>
                </td><td>
                  <p>
                    <code class="literal">future&lt;tuple&lt;U<sub><span class="emphasis"><em>0</em></span></sub>,U<sub><span class="emphasis"><em>1</em></span></sub>&gt;&gt;</code>
                  </p>
                </td><td>
                  <p>
                    Atomically stores the result of <code class="literal">make_tuple(a<sub><span class="emphasis"><em>0</em></span></sub>,a<sub><span class="emphasis"><em>1</em></span></sub>)</code>
                    in the shared state and makes that state ready.
                  </p>
                </td></tr><tr><td>
                  <p>
                    &gt;2
                  </p>
                </td><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">error_code</span></code>
                  </p>
                </td><td>
                  <p>
                    <code class="literal">future&lt;tuple&lt;U<sub><span class="emphasis"><em>1</em></span></sub>,...,U<sub><span class="emphasis"><em>N-1</em></span></sub>&gt;&gt;</code>
                  </p>
                </td><td>
                  <p>
                    If <code class="literal">a<sub><span class="emphasis"><em>0</em></span></sub></code> evaluates to <code class="computeroutput"><span class="keyword">true</span></code>, atomically stores the exception
                    pointer produced by <code class="literal">make_exception_ptr(system_error(a<sub><span class="emphasis"><em>0</em></span></sub>))</code>
                    in the shared state; otherwise, atomically stores the result
                    of <code class="literal">make_tuple(a<sub><span class="emphasis"><em>1</em></span></sub>,...,a<sub><span class="emphasis"><em>N-1</em></span></sub>)</code>
                    in the shared state. The shared state is made ready.
                  </p>
                </td></tr><tr><td>
                  <p>
                    &gt;2
                  </p>
                </td><td>
                  <p>
                    <code class="computeroutput"><span class="identifier">exception_ptr</span></code>
                  </p>
                </td><td>
                  <p>
                    <code class="literal">future&lt;tuple&lt;U<sub><span class="emphasis"><em>1</em></span></sub>,...,U<sub><span class="emphasis"><em>N-1</em></span></sub>&gt;&gt;</code>
                  </p>
                </td><td>
                  <p>
                    If <code class="literal">a<sub><span class="emphasis"><em>0</em></span></sub></code> is non-null, atomically
                    stores the exception pointer in the shared state; otherwise,
                    atomically stores the result of <code class="literal">make_tuple(a<sub><span class="emphasis"><em>1</em></span></sub>,...,a<sub><span class="emphasis"><em>N-1</em></span></sub>)</code>
                    in the shared state. The shared state is made ready.
                  </p>
                </td></tr><tr><td>
                  <p>
                    &gt;2
                  </p>
                </td><td>
                  <p>
                    all other types
                  </p>
                </td><td>
                  <p>
                    <code class="literal">future&lt;tuple&lt;U<sub><span class="emphasis"><em>0</em></span></sub>,...,U<sub><span class="emphasis"><em>N-1</em></span></sub>&gt;&gt;</code>
                  </p>
                </td><td>
                  <p>
                    Atomically stores the result of <code class="literal">make_tuple(a<sub><span class="emphasis"><em>0</em></span></sub>,...,a<sub><span class="emphasis"><em>N-1</em></span></sub>)</code>
                    in the shared state and makes that state ready.
                  </p>
                </td></tr></tbody></table></div></div><br class="table-break"></div></div><div class="section" title="15.38.&#160;Class template specialization async_result for packaged_task"><div class="titlepage"><div><div><h3 class="title"><a name="classes.async_result_packaged_task"></a>15.38.&#160;Class template specialization <code class="literal">async_result</code> for <code class="literal">packaged_task</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
      <span class="keyword">class</span> <span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">packaged_task</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">(</span><span class="identifier">Args</span><span class="special">...)&gt;&gt;</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="keyword">typedef</span> <span class="identifier">future</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;</span> <span class="identifier">type</span><span class="special">;</span>

        <span class="identifier">async_result</span><span class="special">(</span><span class="identifier">packaged_task</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">(</span><span class="identifier">Args</span><span class="special">...)&gt;&amp;</span> <span class="identifier">t</span><span class="special">);</span>
        <span class="identifier">async_result</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">async_result</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
        <span class="identifier">async_result</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">async_result</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>

        <span class="identifier">type</span> <span class="identifier">get</span><span class="special">();</span>

      <span class="keyword">private</span><span class="special">:</span>
        <span class="identifier">type</span> <span class="identifier">future_</span><span class="special">;</span> <span class="comment">// <span class="emphasis"><em>exposition only</em></span></span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        The implementation shall provide a specialization of <code class="computeroutput"><span class="identifier">async_result</span></code>
        that meets the <a class="link" href="#classes.async_result" title="15.3.&#160;Class template async_result"><code class="computeroutput"><span class="identifier">async_result</span></code>
        specialization requirements</a>.
      </p><pre class="programlisting"><span class="identifier">async_result</span><span class="special">(</span><span class="identifier">packaged_task</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">(</span><span class="identifier">Args</span><span class="special">...)&gt;&amp;</span> <span class="identifier">t</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Effects:</em></span> Initializes <code class="computeroutput"><span class="identifier">future_</span></code>
          with <code class="computeroutput"><span class="identifier">t</span><span class="special">.</span><span class="identifier">get_future</span><span class="special">()</span></code>.
        </p></blockquote></div><pre class="programlisting"><span class="identifier">type</span> <span class="identifier">get</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">future_</span><span class="special">)</span></code>.
        </p></blockquote></div></div><div class="section" title="15.39.&#160;Class template packaged_handler"><div class="titlepage"><div><div><h3 class="title"><a name="classes.packaged_handler"></a>15.39.&#160;Class template <code class="literal">packaged_handler</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Signature</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
      <span class="keyword">class</span> <span class="identifier">packaged_handler</span>
        <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">packaged_task</span><span class="special">&lt;</span><span class="identifier">Signature</span><span class="special">&gt;</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="comment">// packaged_handler types:</span>

        <span class="keyword">typedef</span> <span class="identifier">Alloc</span> <span class="identifier">allocator_type</span><span class="special">;</span>

        <span class="comment">// packaged_handler constructors:</span>

        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">&gt;</span>
          <span class="keyword">explicit</span> <span class="identifier">packaged_handler</span><span class="special">(</span><span class="identifier">packaged_token</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>

        <span class="comment">// packaged_handler operations:</span>

        <span class="identifier">allocator_type</span> <span class="identifier">get_allocator</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

      <span class="keyword">private</span><span class="special">:</span>
        <span class="identifier">Alloc</span> <span class="identifier">allocator_</span><span class="special">;</span> <span class="comment">// <span class="emphasis"><em>exposition only</em></span></span>
      <span class="special">};</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Signature</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
        <span class="keyword">class</span> <span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">packaged_handler</span><span class="special">&lt;</span><span class="identifier">Signature</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;&gt;;</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><div class="section" title="15.39.1.&#160;packaged_handler constructors"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__packaged_handler__constructors"></a>15.39.1.&#160;<code class="literal">packaged_handler</code> constructors</h4></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">&gt;</span>
  <span class="keyword">explicit</span> <span class="identifier">packaged_handler</span><span class="special">(</span><span class="identifier">packaged_token</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;&amp;&amp;</span> <span class="identifier">token</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">packaged_handler</span><span class="special">&lt;</span><span class="identifier">Signature</span><span class="special">,</span>
            <span class="identifier">Alloc</span><span class="special">&gt;</span></code>,
            initializing the base class with <code class="computeroutput"><span class="identifier">packaged_task</span><span class="special">&lt;</span><span class="identifier">Signature</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">token</span><span class="special">.</span><span class="identifier">f_</span><span class="special">))</span></code> and initializing <code class="computeroutput"><span class="identifier">allocator_</span></code>
            with <code class="computeroutput"><span class="identifier">token</span><span class="special">.</span><span class="identifier">allocator_</span></code>.
          </p></blockquote></div></div><div class="section" title="15.39.2.&#160;packaged_handler operations"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__packaged_handler__operations"></a>15.39.2.&#160;<code class="literal">packaged_handler</code> operations</h4></div></div></div><pre class="programlisting"><span class="identifier">allocator_type</span> <span class="identifier">get_allocator</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">allocator_</span></code>.
          </p></blockquote></div></div><div class="section" title="15.39.3.&#160;Class template specialization async_result"><div class="titlepage"><div><div><h4 class="title"><a name="classes.async_result_packaged_handler"></a>15.39.3.&#160;Class template specialization <code class="literal">async_result</code></h4></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Signature</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
      <span class="keyword">class</span> <span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">packaged_handler</span><span class="special">&lt;</span><span class="identifier">Signature</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;&gt;</span>
        <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">async_result</span><span class="special">&lt;</span><span class="identifier">packaged_task</span><span class="special">&lt;</span><span class="identifier">Signature</span><span class="special">&gt;&gt;</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="keyword">explicit</span> <span class="identifier">async_result</span><span class="special">(</span><span class="identifier">packaged_handler</span><span class="special">&lt;</span><span class="identifier">Signature</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;&amp;</span> <span class="identifier">h</span><span class="special">);</span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
          The implementation shall provide a specialization of <code class="computeroutput"><span class="identifier">async_result</span></code>
          that meets the <a class="link" href="#classes.async_result" title="15.3.&#160;Class template async_result"><code class="computeroutput"><span class="identifier">async_result</span></code>
          specialization requirements</a>.
        </p><pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">async_result</span><span class="special">(</span><span class="identifier">packaged_handler</span><span class="special">&lt;</span><span class="identifier">Signature</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;&amp;</span> <span class="identifier">h</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Initializes the base class with <code class="computeroutput"><span class="identifier">h</span></code>.
          </p></blockquote></div></div></div><div class="section" title="15.40.&#160;Class template packaged_token"><div class="titlepage"><div><div><h3 class="title"><a name="classes.packaged_token"></a>15.40.&#160;Class template <code class="literal">packaged_token</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span> <span class="special">=</span> <span class="identifier">allocator</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;&gt;</span>
      <span class="keyword">class</span> <span class="identifier">packaged_token</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="comment">// packaged_token types:</span>

        <span class="keyword">typedef</span> <span class="identifier">Alloc</span> <span class="identifier">allocator_type</span><span class="special">;</span>

        <span class="comment">// packaged_token constructors:</span>

        <span class="keyword">explicit</span> <span class="identifier">packaged_token</span><span class="special">(</span><span class="identifier">Func</span> <span class="identifier">f</span><span class="special">);</span>
        <span class="identifier">packaged_token</span><span class="special">(</span><span class="identifier">Func</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>

        <span class="comment">// packaged_token operations:</span>

        <span class="identifier">allocator_type</span> <span class="identifier">get_allocator</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

      <span class="keyword">private</span><span class="special">:</span>
        <span class="identifier">Func</span> <span class="identifier">f_</span><span class="special">;</span> <span class="comment">// <span class="emphasis"><em>exposition only</em></span></span>
        <span class="identifier">Alloc</span> <span class="identifier">allocator_</span><span class="special">;</span> <span class="comment">// <span class="emphasis"><em>exposition only</em></span></span>
      <span class="special">};</span>

      <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
      <span class="keyword">struct</span> <span class="identifier">handler_type</span><span class="special">&lt;</span><span class="identifier">packaged_token</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;,</span> <span class="identifier">R</span><span class="special">(</span><span class="identifier">Args</span><span class="special">...)&gt;</span>
      <span class="special">{</span>
        <span class="keyword">typedef</span> <span class="identifier">packaged_handler</span><span class="special">&lt;</span><span class="identifier">result_of_t</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">(</span><span class="identifier">Args</span><span class="special">...)&gt;(</span><span class="identifier">Args</span><span class="special">...),</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="identifier">type</span><span class="special">;</span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><div class="section" title="15.40.1.&#160;packaged_token constructors"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__packaged_token__constructors"></a>15.40.1.&#160;<code class="literal">packaged_token</code> constructors</h4></div></div></div><pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">packaged_token</span><span class="special">(</span><span class="identifier">Func</span> <span class="identifier">f</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">packaged_token</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span></code>,
            initializing <code class="computeroutput"><span class="identifier">f_</span></code> with
            <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">)</span></code>
            and default constructing <code class="computeroutput"><span class="identifier">allocator_</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">packaged_token</span><span class="special">(</span><span class="identifier">Func</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">packaged_token</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span></code>,
            initializing <code class="computeroutput"><span class="identifier">f_</span></code> with
            <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">f</span><span class="special">)</span></code>
            and <code class="computeroutput"><span class="identifier">allocator_</span></code> with
            <code class="computeroutput"><span class="identifier">a</span></code>.
          </p></blockquote></div></div><div class="section" title="15.40.2.&#160;packaged_token operations"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__packaged_token__operations"></a>15.40.2.&#160;<code class="literal">packaged_token</code> operations</h4></div></div></div><pre class="programlisting"><span class="identifier">allocator_type</span> <span class="identifier">get_allocator</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">allocator_</span></code>.
          </p></blockquote></div></div></div><div class="section" title="15.41.&#160;Function package"><div class="titlepage"><div><div><h3 class="title"><a name="functions.package"></a>15.41.&#160;Function <code class="literal">package</code></h3></div></div></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span> <span class="special">=</span> <span class="identifier">allocator</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;&gt;</span>
  <span class="identifier">packaged_token</span><span class="special">&lt;</span><span class="identifier">decay_t</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;,</span> <span class="identifier">Alloc</span><span class="special">&gt;</span> <span class="identifier">package</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span> <span class="special">=</span> <span class="identifier">Alloc</span><span class="special">());</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
          <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">packaged_token</span><span class="special">&lt;</span><span class="identifier">decay_t</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;,</span> <span class="identifier">Alloc</span><span class="special">&gt;(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">),</span> <span class="identifier">a</span><span class="special">)</span></code>.
        </p></blockquote></div></div><div class="section" title="15.42.&#160;Header &lt;experimental/thread_pool&gt; synopsis"><div class="titlepage"><div><div><h3 class="title"><a name="headers.header____experimental_thread_pool___synopsis"></a>15.42.&#160;Header <code class="literal">&lt;experimental/thread_pool&gt;</code> synopsis</h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">class</span> <a class="link" href="#classes.thread_pool" title="15.43.&#160;Class thread_pool">thread_pool</a><span class="special">;</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" title="15.43.&#160;Class thread_pool"><div class="titlepage"><div><div><h3 class="title"><a name="classes.thread_pool"></a>15.43.&#160;Class <code class="literal">thread_pool</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">class</span> <span class="identifier">thread_pool</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">execution_context</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="comment">// types:</span>

        <span class="keyword">class</span> <a class="link" href="#classes.thread_pool__executor_type" title="15.44.&#160;Class thread_pool::executor_type">executor_type</a><span class="special">;</span>

        <span class="comment">// construct / copy / destroy:</span>

        <span class="identifier">thread_pool</span><span class="special">();</span>
        <span class="keyword">explicit</span> <span class="identifier">thread_pool</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">num_threads</span><span class="special">);</span>
        <span class="identifier">thread_pool</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">thread_pool</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
        <span class="identifier">thread_pool</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">thread_pool</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
        <span class="special">~</span><span class="identifier">thread_pool</span><span class="special">();</span>

        <span class="comment">// thread_pool operations:</span>

        <span class="identifier">executor_type</span> <span class="identifier">get_executor</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="keyword">void</span> <span class="identifier">stop</span><span class="special">();</span>

        <span class="keyword">void</span> <span class="identifier">join</span><span class="special">();</span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        Class <code class="computeroutput"><span class="identifier">thread_pool</span></code> implements
        a fixed-size pool of threads.
      </p><p>
        An object of type <code class="computeroutput"><span class="identifier">thread_pool</span></code>
        has an associated executor object, meeting the <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor
        type requirements</a>, of type <code class="computeroutput"><span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span></code>
        and obtainable via the <code class="computeroutput"><span class="identifier">thread_pool</span></code>
        object's <code class="computeroutput"><span class="identifier">get_executor</span></code> member
        function.
      </p><p>
        For an object of type <code class="computeroutput"><span class="identifier">thread_pool</span></code>,
        <span class="emphasis"><em>outstanding work</em></span> is defined as the sum of:
      </p><p>
        &#8212; the total number of calls to the <code class="computeroutput"><span class="identifier">thread_pool</span></code>
        executor's <code class="computeroutput"><span class="identifier">on_work_started</span></code>
        function, less the total number of calls to the <code class="computeroutput"><span class="identifier">on_work_finished</span></code>
        function;
      </p><p>
        &#8212; the number of function objects that have been added to the <code class="computeroutput"><span class="identifier">thread_pool</span></code> via the <code class="computeroutput"><span class="identifier">thread_pool</span></code>
        executor, but not yet executed; and
      </p><p>
        &#8212; the number of function objects that are currently being executed by the
        <code class="computeroutput"><span class="identifier">thread_pool</span></code>.
      </p><p>
        The <code class="computeroutput"><span class="identifier">thread_pool</span></code> member functions
        <code class="computeroutput"><span class="identifier">get_executor</span></code>, <code class="computeroutput"><span class="identifier">stop</span></code>, and <code class="computeroutput"><span class="identifier">join</span></code>,
        and the <code class="computeroutput"><span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span></code> copy constructors, member
        functions and comparison operators, shall not introduce data races as a result
        of concurrent calls to those functions from different threads.
      </p><div class="section" title="15.43.1.&#160;thread_pool constructors/destructor"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__thread_pool__constructors_destructor"></a>15.43.1.&#160;<code class="literal">thread_pool</code> constructors/destructor</h4></div></div></div><pre class="programlisting"><span class="identifier">thread_pool</span><span class="special">();</span>
<span class="keyword">explicit</span> <span class="identifier">thread_pool</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">num_threads</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Creates an object of class <code class="computeroutput"><span class="identifier">thread_pool</span></code> containing a number of
            threads of execution, each represented by a <code class="computeroutput"><span class="identifier">thread</span></code>
            object. If specified, the number of threads in the pool is <code class="computeroutput"><span class="identifier">num_threads</span></code>. Otherwise, the number
            of threads in the pool is implementation-defined. [<span class="emphasis"><em>Note:</em></span>
            A suggested value for the implementation-defined number of threads is
            <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">thread</span><span class="special">::</span><span class="identifier">hardware_concurrency</span><span class="special">()</span>
            <span class="special">*</span> <span class="number">2</span></code>.
            &#8212;<span class="emphasis"><em>end note</em></span>]
          </p></blockquote></div><pre class="programlisting"><span class="special">~</span><span class="identifier">thread_pool</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Destroys an object of class <code class="computeroutput"><span class="identifier">thread_pool</span></code>. Performs <code class="computeroutput"><span class="identifier">stop</span><span class="special">()</span></code>
            followed by <code class="computeroutput"><span class="identifier">join</span><span class="special">()</span></code>.
          </p></blockquote></div></div><div class="section" title="15.43.2.&#160;thread_pool members"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__thread_pool__members"></a>15.43.2.&#160;<code class="literal">thread_pool</code> members</h4></div></div></div><pre class="programlisting"><span class="identifier">executor_type</span> <span class="identifier">get_executor</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> An executor that may be used for submitting
            function objects to the <code class="computeroutput"><span class="identifier">thread_pool</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">stop</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Signals the threads in the pool to complete
            as soon as possible. If a thread is currently executing a function object,
            the thread will exit only after completion of that function object. The
            call to <code class="computeroutput"><span class="identifier">stop</span><span class="special">()</span></code>
            returns without waiting for the threads to complete.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">join</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> If not already stopped, signals the threads
            in the pool to exit once the outstanding work is <code class="computeroutput"><span class="number">0</span></code>.
            Blocks until all threads in the pool have completed.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Synchronization:</em></span> The completion of each thread in
            the pool synchronizes with (C++ Std, [intro.multithread]) the corresponding
            successful <code class="computeroutput"><span class="identifier">join</span><span class="special">()</span></code>
            return.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> The threads in the pool represented
            by <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
            have completed.
          </p></blockquote></div></div></div><div class="section" title="15.44.&#160;Class thread_pool::executor_type"><div class="titlepage"><div><div><h3 class="title"><a name="classes.thread_pool__executor_type"></a>15.44.&#160;Class <code class="literal">thread_pool::executor_type</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">class</span> <span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="comment">// construct / copy / destroy:</span>

        <span class="identifier">executor_type</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="identifier">executor_type</span><span class="special">(</span><span class="identifier">executor_type</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">executor_type</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="special">~</span><span class="identifier">executor_type</span><span class="special">();</span>

        <span class="comment">// executor operations:</span>

        <span class="keyword">bool</span> <span class="identifier">running_in_this_thread</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="identifier">thread_pool</span><span class="special">&amp;</span> <span class="identifier">context</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="keyword">void</span> <span class="identifier">on_work_started</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="keyword">void</span> <span class="identifier">on_work_finished</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">defer</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
      <span class="special">};</span>

      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span>
                      <span class="keyword">const</span> <span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span>
                      <span class="keyword">const</span> <span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>

      <span class="keyword">template</span><span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">true_type</span> <span class="special">{};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        <code class="computeroutput"><span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span></code> is a type satisfying <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor requirements</a>. Objects of
        type <code class="computeroutput"><span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span></code> are associated with a <code class="computeroutput"><span class="identifier">thread_pool</span></code>, and function objects submitted
        using the <code class="computeroutput"><span class="identifier">dispatch</span></code>, <code class="computeroutput"><span class="identifier">post</span></code> or <code class="computeroutput"><span class="identifier">defer</span></code>
        member functions will be executed by the <code class="computeroutput"><span class="identifier">thread_pool</span></code>.
      </p><div class="section" title="15.44.1.&#160;thread_pool::executor_type constructors"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__thread_pool__executor_type__constructors"></a>15.44.1.&#160;<code class="literal">thread_pool::executor_type</code> constructors</h4></div></div></div><pre class="programlisting"><span class="identifier">executor_type</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span> <span class="special">==</span> <span class="identifier">other</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">executor_type</span><span class="special">(</span><span class="identifier">executor_type</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is equal to the prior value of <code class="computeroutput"><span class="identifier">other</span></code>.
          </p></blockquote></div></div><div class="section" title="15.44.2.&#160;thread_pool::executor_type assignment"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__thread_pool__executor_type__assignment"></a>15.44.2.&#160;<code class="literal">thread_pool::executor_type</code> assignment</h4></div></div></div><pre class="programlisting"><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span> <span class="special">==</span> <span class="identifier">other</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">executor_type</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is equal to the prior value of <code class="computeroutput"><span class="identifier">other</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div></div><div class="section" title="15.44.3.&#160;thread_pool::executor_type operations"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__thread_pool__executor_type__operations"></a>15.44.3.&#160;<code class="literal">thread_pool::executor_type</code> operations</h4></div></div></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">running_in_this_thread</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="keyword">true</span></code>
            if the current thread of execution is a member of the pool; otherwise
            <code class="computeroutput"><span class="keyword">false</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">thread_pool</span><span class="special">&amp;</span> <span class="identifier">context</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> A reference to the associated <code class="computeroutput"><span class="identifier">thread_pool</span></code> object.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">on_work_started</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Increases the count of outstanding work
            associated with the <code class="computeroutput"><span class="identifier">thread_pool</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">on_work_finished</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Decreases the count of outstanding work
            associated with the <code class="computeroutput"><span class="identifier">thread_pool</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> If <code class="computeroutput"><span class="identifier">running_in_this_thread</span><span class="special">()</span></code> is true, calls <code class="literal"><span class="emphasis"><em>DECAY_COPY</em></span></code><code class="computeroutput"><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">))()</span></code>. Otherwise, requests execution of
            <code class="computeroutput"><span class="identifier">f</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            If <code class="computeroutput"><span class="identifier">f</span></code> exits via an exception,
            and the execution of <code class="computeroutput"><span class="identifier">f</span></code>
            is performed in the current thread and before <code class="computeroutput"><span class="identifier">dispatch</span></code>
            returns, the exception shall propagate to the caller of <code class="computeroutput"><span class="identifier">dispatch</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Requests execution of <code class="computeroutput"><span class="identifier">f</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">defer</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Requests execution of <code class="computeroutput"><span class="identifier">f</span></code>.
          </p></blockquote></div></div><div class="section" title="15.44.4.&#160;thread_pool::executor_type comparisons"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__thread_pool__executor_type__comparisons"></a>15.44.4.&#160;<code class="literal">thread_pool::executor_type</code> comparisons</h4></div></div></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span>
                <span class="keyword">const</span> <span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">a</span><span class="special">.</span><span class="identifier">context</span><span class="special">()</span>
            <span class="special">==</span> <span class="special">&amp;</span><span class="identifier">b</span><span class="special">.</span><span class="identifier">context</span><span class="special">()</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span>
                <span class="keyword">const</span> <span class="identifier">thread_pool</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">!(</span><span class="identifier">a</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">)</span></code>.
          </p></blockquote></div></div></div><div class="section" title="15.45.&#160;Header &lt;experimental/loop_scheduler&gt; synopsis"><div class="titlepage"><div><div><h3 class="title"><a name="headers.header____experimental_loop_scheduler___synopsis"></a>15.45.&#160;Header <code class="literal">&lt;experimental/loop_scheduler&gt;</code> synopsis</h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">class</span> <a class="link" href="#classes.loop_scheduler" title="15.46.&#160;Class loop_scheduler">loop_scheduler</a><span class="special">;</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" title="15.46.&#160;Class loop_scheduler"><div class="titlepage"><div><div><h3 class="title"><a name="classes.loop_scheduler"></a>15.46.&#160;Class <code class="literal">loop_scheduler</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">class</span> <span class="identifier">loop_scheduler</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">execution_context</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="comment">// types:</span>

        <span class="keyword">class</span> <a class="link" href="#classes.loop_scheduler__executor_type" title="15.47.&#160;Class loop_scheduler::executor_type">executor_type</a><span class="special">;</span>

        <span class="comment">// construct / copy / destroy:</span>

        <span class="identifier">loop_scheduler</span><span class="special">();</span>
        <span class="keyword">explicit</span> <span class="identifier">loop_scheduler</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">concurrency_hint</span><span class="special">);</span>
        <span class="identifier">loop_scheduler</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">loop_scheduler</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
        <span class="identifier">loop_scheduler</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">loop_scheduler</span><span class="special">&amp;)</span> <span class="special">=</span> <span class="keyword">delete</span><span class="special">;</span>
        <span class="special">~</span><span class="identifier">loop_scheduler</span><span class="special">();</span>

        <span class="comment">// loop_scheduler operations:</span>

        <span class="identifier">executor_type</span> <span class="identifier">get_executor</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="identifier">size_t</span> <span class="identifier">run</span><span class="special">();</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">&gt;</span>
          <span class="identifier">size_t</span> <span class="identifier">run_for</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">&gt;</span>
          <span class="identifier">size_t</span> <span class="identifier">run_until</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">);</span>

        <span class="identifier">size_t</span> <span class="identifier">run_one</span><span class="special">();</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">&gt;</span>
          <span class="identifier">size_t</span> <span class="identifier">run_one_for</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">&gt;</span>
          <span class="identifier">size_t</span> <span class="identifier">run_one_until</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">);</span>

        <span class="identifier">size_t</span> <span class="identifier">poll</span><span class="special">();</span>

        <span class="identifier">size_t</span> <span class="identifier">poll_one</span><span class="special">();</span>

        <span class="keyword">void</span> <span class="identifier">stop</span><span class="special">();</span>

        <span class="keyword">bool</span> <span class="identifier">stopped</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>

        <span class="keyword">void</span> <span class="identifier">restart</span><span class="special">();</span>
      <span class="special">};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        An object of type <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
        has an associated executor object, meeting the <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor
        type requirements</a>, of type <code class="computeroutput"><span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span></code>
        and obtainable via the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
        object's <code class="computeroutput"><span class="identifier">get_executor</span></code> member
        function.
      </p><p>
        For an object of type <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>,
        <span class="emphasis"><em>outstanding work</em></span> is defined as the sum of:
      </p><p>
        &#8212; the total number of calls to the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
        executor's <code class="computeroutput"><span class="identifier">on_work_started</span></code>
        function, less the total number of calls to the <code class="computeroutput"><span class="identifier">on_work_finished</span></code>
        function;
      </p><p>
        &#8212; the number of function objects that have been added to the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code> via the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
        executor, but not yet executed; and
      </p><p>
        &#8212; the number of function objects that are currently being executed by the
        <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>.
      </p><p>
        If at any time the outstanding work falls to <code class="computeroutput"><span class="number">0</span></code>,
        the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code> is stopped
        as if by <code class="computeroutput"><span class="identifier">stop</span><span class="special">()</span></code>.
      </p><p>
        The <code class="computeroutput"><span class="identifier">loop_scheduler</span></code> member
        functions <code class="computeroutput"><span class="identifier">get_executor</span></code>,
        <code class="computeroutput"><span class="identifier">run</span></code>, <code class="computeroutput"><span class="identifier">run_for</span></code>,
        <code class="computeroutput"><span class="identifier">run_until</span></code>, <code class="computeroutput"><span class="identifier">run_one</span></code>, <code class="computeroutput"><span class="identifier">run_one_for</span></code>,
        <code class="computeroutput"><span class="identifier">run_one_until</span></code>, <code class="computeroutput"><span class="identifier">poll</span></code>, <code class="computeroutput"><span class="identifier">poll_one</span></code>,
        <code class="computeroutput"><span class="identifier">stop</span></code>, and <code class="computeroutput"><span class="identifier">stopped</span></code>,
        and the <code class="computeroutput"><span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span></code> copy constructors, member
        functions and comparison operators, shall not introduce data races as a result
        of concurrent calls to those functions from different threads. [<span class="emphasis"><em>Note:</em></span>
        The <code class="computeroutput"><span class="identifier">restart</span></code> member function
        is excluded from these thread safety requirements. &#8212;<span class="emphasis"><em>end note</em></span>]
      </p><div class="section" title="15.46.1.&#160;loop_scheduler constructors/destructor"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__loop_scheduler__constructors_destructor"></a>15.46.1.&#160;<code class="literal">loop_scheduler</code> constructors/destructor</h4></div></div></div><pre class="programlisting"><span class="identifier">loop_scheduler</span><span class="special">();</span>
<span class="keyword">explicit</span> <span class="identifier">loop_scheduler</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">concurrency_hint</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Creates an object of class <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Remarks:</em></span> The <code class="computeroutput"><span class="identifier">concurrency_hint</span></code>
            parameter is a suggestion to the implementation on the number of threads
            that should process asynchronous operations and execute function objects.
          </p></blockquote></div><pre class="programlisting"><span class="special">~</span><span class="identifier">loop_scheduler</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Destroys an object of class <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>.
          </p></blockquote></div></div><div class="section" title="15.46.2.&#160;loop_scheduler members"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__loop_scheduler__members"></a>15.46.2.&#160;<code class="literal">loop_scheduler</code> members</h4></div></div></div><pre class="programlisting"><span class="identifier">executor_type</span> <span class="identifier">get_executor</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> An executor that may be used for submitting
            function objects to the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">size_t</span> <span class="identifier">run</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> Must not be called from a thread that
            is currently calling one of <code class="computeroutput"><span class="identifier">run</span></code>,
            <code class="computeroutput"><span class="identifier">run_for</span></code>, <code class="computeroutput"><span class="identifier">run_until</span></code>, <code class="computeroutput"><span class="identifier">run_one</span></code>,
            <code class="computeroutput"><span class="identifier">run_one_for</span></code>, <code class="computeroutput"><span class="identifier">run_one_until</span></code>, <code class="computeroutput"><span class="identifier">poll</span></code>,
            or <code class="computeroutput"><span class="identifier">poll_one</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Equivalent to:
</p><pre class="programlisting"><span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="keyword">while</span> <span class="special">(</span><span class="identifier">run_one</span><span class="special">())</span>
  <span class="keyword">if</span> <span class="special">(</span><span class="identifier">n</span> <span class="special">!=</span> <span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">size_t</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">())</span>
    <span class="special">++</span><span class="identifier">n</span><span class="special">;</span>
</pre><p>
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">n</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">&gt;</span>
  <span class="identifier">size_t</span> <span class="identifier">run_for</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Equivalent to:
</p><pre class="programlisting"><span class="keyword">return</span> <span class="identifier">run_until</span><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">steady_clock</span><span class="special">::</span><span class="identifier">now</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">rel_time</span><span class="special">);</span>
</pre><p>
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">&gt;</span>
  <span class="identifier">size_t</span> <span class="identifier">run_until</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Equivalent to:
</p><pre class="programlisting"><span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="keyword">while</span> <span class="special">(</span><span class="identifier">run_one_until</span><span class="special">(</span><span class="identifier">abs_time</span><span class="special">))</span>
  <span class="keyword">if</span> <span class="special">(</span><span class="identifier">n</span> <span class="special">!=</span> <span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">size_t</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">())</span>
    <span class="special">++</span><span class="identifier">n</span><span class="special">;</span>
</pre><p>
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">n</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">size_t</span> <span class="identifier">run_one</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Requires:</em></span> Must not be called from a thread that
            is currently calling one of <code class="computeroutput"><span class="identifier">run</span></code>,
            <code class="computeroutput"><span class="identifier">run_for</span></code>, <code class="computeroutput"><span class="identifier">run_until</span></code>, <code class="computeroutput"><span class="identifier">run_one</span></code>,
            <code class="computeroutput"><span class="identifier">run_one_for</span></code>, <code class="computeroutput"><span class="identifier">run_one_until</span></code>, <code class="computeroutput"><span class="identifier">poll</span></code>,
            or <code class="computeroutput"><span class="identifier">poll_one</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> If the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
            object has no oustanding work, performs <code class="computeroutput"><span class="identifier">stop</span><span class="special">()</span></code>. Otherwise, blocks while the loop_scheduler
            has outstanding work, or until the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
            is stopped, or until one function object has been executed.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            If an executed function object throws an exception, the exception shall
            be allowed to propagate to the caller of <code class="computeroutput"><span class="identifier">run_one</span><span class="special">()</span></code>. The <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
            state shall be as if the function object had returned normally.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="number">1</span></code>
            if a function object was executed, otherwise <code class="computeroutput"><span class="number">0</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Notes:</em></span> This function may invoke additional handlers
            through nested calls to the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
            executor's <code class="computeroutput"><span class="identifier">dispatch</span></code> member
            function. These do not count towards the return value.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Period</span><span class="special">&gt;</span>
  <span class="identifier">size_t</span> <span class="identifier">run_one_for</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span><span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span><span class="special">&gt;&amp;</span> <span class="identifier">rel_time</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Equivalent to:
</p><pre class="programlisting"><span class="keyword">return</span> <span class="identifier">run_until</span><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">steady_clock</span><span class="special">::</span><span class="identifier">now</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">rel_time</span><span class="special">);</span>
</pre><p>
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="number">1</span></code>
            if a function object was executed, otherwise <code class="computeroutput"><span class="number">0</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">&gt;</span>
  <span class="identifier">size_t</span> <span class="identifier">run_one_until</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">abs_time</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> If the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
            object has no oustanding work, performs <code class="computeroutput"><span class="identifier">stop</span><span class="special">()</span></code>. Otherwise, blocks while the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code> has outstanding work,
            or until the expiration of the absolute timeout (C++ Std, [thread.req.timing])
            specified by <code class="computeroutput"><span class="identifier">abs_time</span></code>,
            or until the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
            is stopped, or until one function object has been executed.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            If an executed function object throws an exception, the exception shall
            be allowed to propagate to the caller of <code class="computeroutput"><span class="identifier">run_one</span><span class="special">()</span></code>. The <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
            state shall be as if the function object had returned normally.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="number">1</span></code>
            if a function object was executed, otherwise <code class="computeroutput"><span class="number">0</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Notes:</em></span> This function may invoke additional handlers
            through nested calls to the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
            executor's <code class="computeroutput"><span class="identifier">dispatch</span></code> member
            function. These do not count towards the return value.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">size_t</span> <span class="identifier">poll</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Equivalent to:
</p><pre class="programlisting"><span class="identifier">size_t</span> <span class="identifier">n</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="keyword">while</span> <span class="special">(</span><span class="identifier">poll_one</span><span class="special">())</span>
  <span class="keyword">if</span> <span class="special">(</span><span class="identifier">n</span> <span class="special">!=</span> <span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">size_t</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">())</span>
    <span class="special">++</span><span class="identifier">n</span><span class="special">;</span>
</pre><p>
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">n</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">size_t</span> <span class="identifier">poll_one</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> If the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
            object has no oustanding work, performs <code class="computeroutput"><span class="identifier">stop</span><span class="special">()</span></code>. Otherwise, if there is a function
            object ready for immediate execution, executes it.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            If an executed function object throws an exception, the exception shall
            be allowed to propagate to the caller of <code class="computeroutput"><span class="identifier">poll_one</span><span class="special">()</span></code>. The <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
            state shall be as if the function object had returned normally.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="number">1</span></code>
            if a handler was executed, otherwise <code class="computeroutput"><span class="number">0</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Notes:</em></span> This function may invoke additional handlers
            through nested calls to the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
            executor's <code class="computeroutput"><span class="identifier">dispatch</span></code> member
            function. These do not count towards the return value.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">stop</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Stops the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>.
            Concurrent calls to <code class="computeroutput"><span class="identifier">run</span></code>,
            <code class="computeroutput"><span class="identifier">run_for</span></code>, <code class="computeroutput"><span class="identifier">run_until</span></code>, <code class="computeroutput"><span class="identifier">run_one</span></code>,
            <code class="computeroutput"><span class="identifier">run_one_for</span></code>, <code class="computeroutput"><span class="identifier">run_one_until</span></code>, <code class="computeroutput"><span class="identifier">poll</span></code>
            or <code class="computeroutput"><span class="identifier">poll_one</span></code> will end
            as soon as possible. If a call to <code class="computeroutput"><span class="identifier">run</span></code>,
            <code class="computeroutput"><span class="identifier">run_for</span></code>, <code class="computeroutput"><span class="identifier">run_until</span></code>, <code class="computeroutput"><span class="identifier">run_one</span></code>,
            <code class="computeroutput"><span class="identifier">run_one_for</span></code>, <code class="computeroutput"><span class="identifier">run_one_until</span></code>, <code class="computeroutput"><span class="identifier">poll</span></code>
            or <code class="computeroutput"><span class="identifier">poll_one</span></code> is currently
            executing a function object, the call will end only after completion
            of that function object. The call to <code class="computeroutput"><span class="identifier">stop</span><span class="special">()</span></code> returns without waiting for concurrent
            calls to <code class="computeroutput"><span class="identifier">run</span></code>, <code class="computeroutput"><span class="identifier">run_for</span></code>, <code class="computeroutput"><span class="identifier">run_until</span></code>,
            <code class="computeroutput"><span class="identifier">run_one</span></code>, <code class="computeroutput"><span class="identifier">run_one_for</span></code>, <code class="computeroutput"><span class="identifier">run_one_until</span></code>,
            <code class="computeroutput"><span class="identifier">poll</span></code> or <code class="computeroutput"><span class="identifier">poll_one</span></code> to complete.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="identifier">stopped</span><span class="special">()</span> <span class="special">==</span> <span class="keyword">true</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            [<span class="emphasis"><em>Note:</em></span> When <code class="computeroutput"><span class="identifier">stopped</span><span class="special">()</span> <span class="special">==</span> <span class="keyword">true</span></code>, subsequent calls to <code class="computeroutput"><span class="identifier">run</span></code>, <code class="computeroutput"><span class="identifier">run_for</span></code>,
            <code class="computeroutput"><span class="identifier">run_until</span></code>, <code class="computeroutput"><span class="identifier">run_one</span></code>, <code class="computeroutput"><span class="identifier">run_one_for</span></code>,
            <code class="computeroutput"><span class="identifier">run_one_until</span></code>, <code class="computeroutput"><span class="identifier">poll</span></code> or <code class="computeroutput"><span class="identifier">poll_one</span></code>
            will exit immediately with a return value of <code class="computeroutput"><span class="number">0</span></code>,
            without executing any function objects. A <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
            remains in the stopped state until a call to <code class="computeroutput"><span class="identifier">restart</span><span class="special">()</span></code>. &#8212;<span class="emphasis"><em>end note</em></span>]
          </p></blockquote></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">restart</span><span class="special">();</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="identifier">stopped</span><span class="special">()</span> <span class="special">==</span> <span class="keyword">false</span></code>.
          </p></blockquote></div></div></div><div class="section" title="15.47.&#160;Class loop_scheduler::executor_type"><div class="titlepage"><div><div><h3 class="title"><a name="classes.loop_scheduler__executor_type"></a>15.47.&#160;Class <code class="literal">loop_scheduler::executor_type</code></h3></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">namespace</span> <span class="identifier">experimental</span> <span class="special">{</span>
    inline namespace concurrency_v1 {

      <span class="keyword">class</span> <span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span>
      <span class="special">{</span>
      <span class="keyword">public</span><span class="special">:</span>
        <span class="comment">// construct / copy / destroy:</span>

        <span class="identifier">executor_type</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="identifier">executor_type</span><span class="special">(</span><span class="identifier">executor_type</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">executor_type</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="special">~</span><span class="identifier">executor_type</span><span class="special">();</span>

        <span class="comment">// executor operations:</span>

        <span class="keyword">bool</span> <span class="identifier">running_in_this_thread</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="identifier">loop_scheduler</span><span class="special">&amp;</span> <span class="identifier">context</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="keyword">void</span> <span class="identifier">on_work_started</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
        <span class="keyword">void</span> <span class="identifier">on_work_finished</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>

        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
        <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
          <span class="keyword">void</span> <span class="identifier">defer</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
      <span class="special">};</span>

      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span>
                      <span class="keyword">const</span> <span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
      <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span>
                      <span class="keyword">const</span> <span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>

      <span class="keyword">template</span><span class="special">&lt;&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_executor</span><span class="special">&lt;</span><span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">true_type</span> <span class="special">{};</span>

    } // inline namespace concurrency_v1
  <span class="special">}</span> <span class="comment">// namespace experimental</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
        <code class="computeroutput"><span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span></code> is a type satisfying <a class="link" href="#requirements.executor" title="15.9.1.&#160;Executor requirements">Executor requirements</a>. Objects of
        type <code class="computeroutput"><span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span></code> are associated with a <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>, and function objects submitted
        using the <code class="computeroutput"><span class="identifier">dispatch</span></code>, <code class="computeroutput"><span class="identifier">post</span></code> or <code class="computeroutput"><span class="identifier">defer</span></code>
        member functions will be executed by the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
        from within the <code class="computeroutput"><span class="identifier">run</span></code>, <code class="computeroutput"><span class="identifier">run_for</span></code>, <code class="computeroutput"><span class="identifier">run_until</span></code>,
        <code class="computeroutput"><span class="identifier">run_one</span></code>, <code class="computeroutput"><span class="identifier">run_one_for</span></code>,
        <code class="computeroutput"><span class="identifier">run_one_until</span></code>, <code class="computeroutput"><span class="identifier">poll</span></code> or <code class="computeroutput"><span class="identifier">poll_one</span></code>
        functions.
      </p><div class="section" title="15.47.1.&#160;loop_scheduler::executor_type constructors"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__loop_scheduler__executor_type__constructors"></a>15.47.1.&#160;<code class="literal">loop_scheduler::executor_type</code> constructors</h4></div></div></div><pre class="programlisting"><span class="identifier">executor_type</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span> <span class="special">==</span> <span class="identifier">other</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">executor_type</span><span class="special">(</span><span class="identifier">executor_type</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Constructs an object of class <code class="computeroutput"><span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is equal to the prior value of <code class="computeroutput"><span class="identifier">other</span></code>.
          </p></blockquote></div></div><div class="section" title="15.47.2.&#160;loop_scheduler::executor_type assignment"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__loop_scheduler__executor_type__assignment"></a>15.47.2.&#160;<code class="literal">loop_scheduler::executor_type</code> assignment</h4></div></div></div><pre class="programlisting"><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span> <span class="special">==</span> <span class="identifier">other</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">executor_type</span><span class="special">&amp;&amp;</span> <span class="identifier">other</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Postconditions:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code> is equal to the prior value of <code class="computeroutput"><span class="identifier">other</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>.
          </p></blockquote></div></div><div class="section" title="15.47.3.&#160;loop_scheduler::executor_type operations"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__loop_scheduler__executor_type__operations"></a>15.47.3.&#160;<code class="literal">loop_scheduler::executor_type</code> operations</h4></div></div></div><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">running_in_this_thread</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="keyword">true</span></code>
            if the current thread of execution is invoking the <code class="computeroutput"><span class="identifier">run</span></code>,
            <code class="computeroutput"><span class="identifier">run_for</span></code>, <code class="computeroutput"><span class="identifier">run_until</span></code>, <code class="computeroutput"><span class="identifier">run_one</span></code>,
            <code class="computeroutput"><span class="identifier">run_one_for</span></code>, <code class="computeroutput"><span class="identifier">run_one_until</span></code>, <code class="computeroutput"><span class="identifier">poll</span></code>
            or <code class="computeroutput"><span class="identifier">poll_one</span></code> function
            of the associated <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>
            object.
          </p></blockquote></div><pre class="programlisting"><span class="identifier">loop_scheduler</span><span class="special">&amp;</span> <span class="identifier">context</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> A reference to the associated <code class="computeroutput"><span class="identifier">loop_scheduler</span></code> object.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">on_work_started</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Increases the count of outstanding work
            associated with the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">on_work_finished</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Decreases the count of outstanding work
            associated with the <code class="computeroutput"><span class="identifier">loop_scheduler</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">dispatch</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> If <code class="computeroutput"><span class="identifier">running_in_this_thread</span><span class="special">()</span></code> is true, calls <code class="literal"><span class="emphasis"><em>DECAY_COPY</em></span></code><code class="computeroutput"><span class="special">(</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Func</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">))()</span></code>. Otherwise, requests execution of
            <code class="computeroutput"><span class="identifier">f</span></code>.
          </p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
            If <code class="computeroutput"><span class="identifier">f</span></code> exits via an exception,
            and the execution of <code class="computeroutput"><span class="identifier">f</span></code>
            is performed in the current thread and before <code class="computeroutput"><span class="identifier">dispatch</span></code>
            returns, the exception shall propagate to the caller of <code class="computeroutput"><span class="identifier">dispatch</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">post</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Requests execution of <code class="computeroutput"><span class="identifier">f</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Func</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Alloc</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">defer</span><span class="special">(</span><span class="identifier">Func</span><span class="special">&amp;&amp;</span> <span class="identifier">f</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Alloc</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Effects:</em></span> Requests execution of <code class="computeroutput"><span class="identifier">f</span></code>.
          </p></blockquote></div></div><div class="section" title="15.47.4.&#160;loop_scheduler::executor_type comparisons"><div class="titlepage"><div><div><h4 class="title"><a name="classes.__loop_scheduler__executor_type__comparisons"></a>15.47.4.&#160;<code class="literal">loop_scheduler::executor_type</code> comparisons</h4></div></div></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span>
                <span class="keyword">const</span> <span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">a</span><span class="special">.</span><span class="identifier">context</span><span class="special">()</span>
            <span class="special">==</span> <span class="special">&amp;</span><span class="identifier">b</span><span class="special">.</span><span class="identifier">context</span><span class="special">()</span></code>.
          </p></blockquote></div><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">,</span>
                <span class="keyword">const</span> <span class="identifier">loop_scheduler</span><span class="special">::</span><span class="identifier">executor_type</span><span class="special">&amp;</span> <span class="identifier">b</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre><div class="blockquote"><blockquote class="blockquote"><p>
            <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">!(</span><span class="identifier">a</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">)</span></code>.
          </p></blockquote></div></div></div></div><div class="footnotes"><br><hr width="100" align="left"><div class="footnote"><p><sup>[<a name="ftn.executors.library_examples.activatable_objects.f0" href="#executors.library_examples.activatable_objects.f0" class="para">1</a>] </sup>
          The concept itself is not new, however the term is taken from <a href="http://accu.org/index.php/journals/1956" target="_top">Holgate,
          Len, <span class="emphasis"><em>Activatable Object</em></span>, ACCU Overload Journal #122,
          August 2014</a>
        </p></div><div class="footnote"><p><sup>[<a name="ftn.executors.library_examples.actors.f0" href="#executors.library_examples.actors.f0" class="para">2</a>] </sup>
          <a href="http://theron-library.com" target="_top">http://theron-library.com</a>
        </p></div><div class="footnote"><p><sup>[<a name="ftn.executors.appendix__design_issues_in_n3785.use_of_std__function_void___.f0" href="#executors.appendix__design_issues_in_n3785.use_of_std__function_void___.f0" class="para">3</a>] </sup>
          Unless a small-object optimisation is employed by <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">function</span></code>,
          but this is not guaranteed.
        </p></div></div></div></body></html>
