Flatten outstanding diffs and replace namespace v1 with v2

Author: jaredhoberock

algorithms.html

@@ -365,7 +365,7 @@ <h1>Header <code>&lt;experimental/algorithm&gt;</code> synopsis</h1>
 namespace std {
 namespace experimental {
 namespace parallel {
-inline namespace v1 {
+inline namespace <ins>v2</ins><del>v1</del> {
   template&lt;class ExecutionPolicy,
            class InputIterator, class Function&gt;
     void for_each(ExecutionPolicy&amp;&amp; exec,
@@ -499,7 +499,7 @@ <h1>Header <code>&lt;experimental/numeric&gt;</code> synopsis</h1>
 namespace std {
 namespace experimental {
 namespace parallel {
-inline namespace v1 {
+inline namespace <ins>v2</ins><del>v1</del> {
   template&lt;class InputIterator&gt;
     typename iterator_traits&lt;InputIterator&gt;::value_type
       reduce(InputIterator first, InputIterator last);

exceptions.html

@@ -9,7 +9,7 @@ <h1>Exception reporting behavior</h1>
         </p>
         <p>
           During the execution of a standard parallel algorithm, if the invocation of an element access function
-          <ins>exits via</ins><del>terminates with</del> an uncaught exception, the behavior of the program is determined by the type of
+          exits via an uncaught exception, the behavior of the program is determined by the type of
           execution policy used to invoke the algorithm:
 
           <ul>
@@ -19,30 +19,27 @@ <h1>Exception reporting behavior</h1>
             </li>
             <li>
               If the execution policy object is of type <code>sequential_execution_policy</code> or
-              <code>parallel_execution_policy</code>, the execution of the algorithm <ins>exits via</ins><del>terminates with</del> an
-              <del><code>exception_list</code></del> exception. <ins>The exception shall be an <code>exception_list</code> containing all</ins><del>All</del> uncaught exceptions thrown during
-              the invocations of element access functions<ins>, or optionally the uncaught exception if there was only one</ins><del>shall be contained in the
-              <code>exception_list</code></del>.<pre>
+              <code>parallel_execution_policy</code>, the execution of the algorithm exits via an
+               exception. The exception shall be an <code>exception_list</code> containing all uncaught exceptions thrown during
+              the invocations of element access functions, or optionally the uncaught exception if there was only one.<pre>
 </pre>
 
               <cxx-note>
-                For example, <del>the number of invocations of the user-provided function object in
-                <code>for_each</code> is unspecified. W</del><ins>w</ins>hen <code>for_each</code> is executed sequentially,
-                <ins>if an invocation of the user-provided function object throws an exception, <code>for_each</code> can exit via the uncaught exception, or throw an <code>exception_list</code> containing the original exception.
-                <del>only one exception will be contained in the <code>exception_list</code> object.</del>
+                For example, when <code>for_each</code> is executed sequentially,
+                if an invocation of the user-provided function object throws an exception, <code>for_each</code> can exit via the uncaught exception, or throw an <code>exception_list</code> containing the original exception.
               </cxx-note><pre>
 </pre>
 
               <cxx-note>
                 These guarantees imply that, unless the algorithm has failed to allocate memory and
-                <ins>exits via</ins><del>terminated with</del> <code>std::bad_alloc</code>, all exceptions thrown during the execution of
+                exits via <code>std::bad_alloc</code>, all exceptions thrown during the execution of
                 the algorithm are communicated to the caller. It is unspecified whether an algorithm implementation will "forge ahead" after 
                 encountering and capturing a user exception.
               </cxx-note><pre>
 </pre>
               <cxx-note>
-                The algorithm may <ins>exit via</ins><del>terminate with</del> the <code>std::bad_alloc</code> exception even if one or more
-                user-provided function objects have <ins>exited via</ins><del>terminated with</del> an exception. For example, this can happen when an algorithm fails to allocate memory while
+                The algorithm may exit via the <code>std::bad_alloc</code> exception even if one or more
+                user-provided function objects have exited via an exception. For example, this can happen when an algorithm fails to allocate memory while
                 creating or adding elements to the <code>exception_list</code> object.
               </cxx-note>
             </li>
@@ -60,7 +57,7 @@ <h1>Header <code>&lt;experimental/exception_list&gt;</code> synopsis</h1>
 namespace std {
 namespace experimental {
 namespace parallel {
-inline namespace v1 {
+inline namespace <ins>v2</ins><del>v1</del> {
 
   class exception_list : public exception
   {

execution_policies.html

@@ -52,7 +52,7 @@ <h1>Header <code>&lt;experimental/execution_policy&gt;</code> synopsis</h1>
 namespace std {
 namespace experimental {
 namespace parallel {
-inline namespace v1 {
+inline namespace <ins>v2</ins><del>v1</del> {
   <cxx-ref insynopsis="" to="parallel.execpol.type"></cxx-ref>
   template&lt;class T&gt; struct is_execution_policy;
   template&lt;class T&gt; constexpr bool is_execution_policy_v = is_execution_policy&lt;T&gt;::value;

general.html

@@ -52,15 +52,15 @@ <h1>Namespaces and headers</h1>
     experimental and not part of the C++ Standard Library, they should not be
     declared directly within namespace <code>std</code>. Unless otherwise specified, all
     components described in this Technical Specification are declared in namespace 
-    <code>std::experimental::parallel::v1</code>.</p>
+    <code>std::experimental::parallel::<ins>v2</ins><del>v1</del></code>.</p>
 
     <cxx-note>
     Once standardized, the components described by this Technical Specification are expected to be promoted to namespace <code>std</code>. 
     </cxx-note>
 
     <p>Unless otherwise specified, references to such entities described in this
     Technical Specification are assumed to be qualified with
-    <code>std::experimental::parallel::v1</code>, and references to entities described in the C++
+    <code>std::experimental::parallel::<ins>v2</ins><del>v1</del></code>, and references to entities described in the C++
     Standard Library are assumed to be qualified with <code>std::</code>.</p>
 
     <p>Extensions that are expected to eventually be added to an existing header
@@ -77,7 +77,7 @@ <h1>Terms and definitions</h1>
 
     <p>For the purposes of this document, the terms and definitions given in the C++ Standard and the following apply.</p>
 
-    <p>A <dfn>parallel algorithm</dfn> is a function template described by this Technical Specification declared in namespace <code>std::experimental::parallel::v1</code> with a formal template parameter named <code>ExecutionPolicy</code>.</p>
+    <p>A <dfn>parallel algorithm</dfn> is a function template described by this Technical Specification declared in namespace <code>std::experimental::parallel::<ins>v2</ins><del>v1</del></code> with a formal template parameter named <code>ExecutionPolicy</code>.</p>
 
     <p>
       Parallel algorithms access objects indirectly accessible via their arguments by invoking the following functions:
@@ -95,13 +95,13 @@ <h1>Terms and definitions</h1>
           User-provided function objects to be applied during the execution of the algorithm, if required by the specification.
         </li>
 
-        <ins><li>
+        <li>
           Operations on those function objects required by the specification.
 
           <cxx-note>
             See clause 25.1 of <em>C++ Standard Algorithms Library</em>.
           </cxx-note>
-        </li></ins>
+        </li>
       </ul>
 
       These functions are herein called <em>element access functions</em>.
@@ -127,7 +127,6 @@ <h1>Terms and definitions</h1>
   </cxx-section>
 
   <cxx-section id="parallel.general.features">
-  <ins>
     <h1>Feature-testing recommendations</h1>     
     <p>An implementation that provides support for this Technical Specification shall define the feature test macro(s) in Table 1.</p>
 
@@ -152,7 +151,6 @@ <h1>Feature-testing recommendations</h1>
         </tr>
       </thead>
     </table>
-  </ins>
   </cxx-section>
 </cxx-clause>