﻿<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
  <meta http-equiv="content-type" content="text/html; charset=UTF-8">
  <title>N3157 - More on noexcept for the General Utilities Library</title>

  <style type="text/css">
    p {text-align:justify}
    li {text-align:justify}
    ins {background-color:#A0FFA0}
    del {background-color:#FF6666}
    
    tr.TITLE_ROW {text-align: center; font-weight: bold}
    tr.DELETED {background: #FF6666; text-decoration: line-through}
    tr.INSERTED {background: #FFFF99}
  </style>

  </head>

  <body>
<address>Document number: N3157=10-0147<br/>
  Date: 2010-10-14<br/>
  J. Daniel Garcia<br/>
  Project: Programming Language C++, Library Working Group<br />
  Reply To: <a href="mailto:josedaniel.garcia@uc3m.es">josedaniel.garcia@uc3m.es</a>
</address>
 
<hr/>

<h1>N3157 - More on noexcept for the General Utilities Library</h1>

<p>During the Rapperswil meeting the Library Working Group decided to revise the library in terms of no except.
This paper presents proposed wording for some of these changes. The paper addresses National Body comments 
CH 16 and GB 60.</p>

<p>
This paper poposes additional changes to those presented in N3148 and N3149. Changes in this paper are
<b>restricted to chapter 20</b> (general utilities library).
</p>

<h2>Discussion</h2>

<h3>Allocators requirement impact</h3>

According to <em>Allocator</em> requirements, the following members should not throw:
<ul>
	<li>a.deallocate(p,n)</li>
	<li>a1==a2</li>
	<li>X a1(a)</li>
	<li>X a(b)</li>
	<li>X a1(move(b))</li>
	<li>X a(move(b))</li>
</ul>

This affects to:
<ul>
	<li>Example in 20.2.5/5.</li>
	<li>The default allocator</li>
	<li>The scoped allocator</li>
</ul>

Besides in <tt>scoped_allocator</tt> member functions <tt>inner_allocator</tt> and <tt>outer_allocator</tt> cannot throw
as they return references to allocators.

<h3>Utility components</h3>

<p>
The generic relational operators may throw only if operators they are based on (<tt>==</tt> and <tt>&lt;</tt>) may throw. 
This paper makes them conditionally <tt>noexcept</tt>.
</p>

<p>
Function <tt>swap()</tt> is not able to throw if the corresponding move construction is not able to throw. This paper makes
it conditionally <tt>noexcept</tt>. The array specialization of <tt>swap()</tt> can be made <tt>noexcept</tt> in the
cases where individual <tt>swap()</tt> does not throw.
</p>

<p>
Functions <tt>forward()</tt> and <tt>move()</tt> essentially perform type transformations and therefore cannot throw. The
same can be applied 
</p>

<p>Class <tt>pair</tt> and associated functions has been revised in detail as its <tt>noexcept</tt>specifications 
depends on its parts. The same has been done for class <tt>tuple</tt>.</p>


<h3>Bitset</h3>

Some constructors of <tt>bitset</tt> cannot throw. This is the case of the following constructors:
<pre>
constexpr bitset();
constexpr bitset(unsigned long long val);
</pre>

<p>
Many bitset members do not need to throw. For example, setting a bit should not throw. However, those member functions
did not have a <tt>throw()</tt> specification. The proposal is to make all of them <tt>noexcept</tt>. This also affects to 
some free operators (<tt>&</tt>, <tt>|</tt> and <tt>^</tt>).
</p>

<p>
However, some operators (<tt>&lt;&lt</tt>, <tt>&gt;&gt;</tt>, <tt>&lt;&lt=</tt> and <tt>&gt;&gt;=</tt>) remain
<tt>noexcept(false)</tt> as the specification does not have any requires elements, and the
intro says that generally bound violations may throw exceptions.
</p>

<h3>Function objects</h3>

<p>
Arithmetic operations, comparisons, logical operations and bitwise operations are exception free if the operator they
are based on is also exception free. As this can easily expressed with noexcept clausus of the form 
<tt>noexcept(noexcept(x op y))</tt>, those specs have been added. This has also been done for negators.
</p>

<p>For the polymorphic function wrapper the following changes have been made:</p>
<ul>
  <li>Move constructor has been made <tt>noexcept</tt>.</li>
  <li>Copy constructor has been made conditionally <tt>noexcept</tt>.</li>
  <li>Copy assignment has been made <tt>noexcept</tt> as it is base on the non-throwing <tt>swap()</tt>.</li>
  <li>Move assignment has been made <tt>noexcept</tt>.</li>
  <li>Member function <tt>assign()</tt> can be safely made <tt>noexcept</tt> as it only depends on the 
  non-throwing <tt>swap()</tt> member function.</li>
  <li>Specialized algorithm <tt>swap()</tt> can be safely made <tt>noexcept</tt> as it only depends on the 
  non-throwing <tt>swap()</tt> member function.</li>
</ul>

<h3>Memory</h3>

<p>For allocator traits, all the operations are defined in terms of the corresponding operation in the allocator.
For every operation, the <tt>noexcept</tt> spec has been defined in terms of the corresponding allocator operation
spec. However when the allocator requirements at 20.2.5 specifies an operation as non-throwing, the operation
has been made <tt>noexcept(true)</tt></p>

<p>Destroying trhough an allocator can only throw if the corresponding class has a throwing destrcutor. The
destroy member function has been made conditionally <tt>noexcept</tt>in allocator traits and allocators.</p>

<p>
Getting the address of a reference through an allocator (<tt>allocator&lt;T&gt;::address()</tt>) does not
throw. Not that it does not make use of <tt>operator&amp;</tt> which avoids the activation of a user-defined
unary <tt>operator&amp;</tt> which could throw. Thus, <tt>address()</tt> operation has been made <tt>noexcept</tt>.
</p>

<p>
Operations in class <tt>raw_storage_iterator</tt> should not throw (except assignment). All its members have 
been made <tt>noexcept</tt>. For the particular case of assignment it has been made conditionally <tt>noexcept</tt>.
This operation may throw only if <tt>T</tt>'s assignmet throws.
</p>

<p>
Temporary buffers management functions do not throw. Instead <tt>get_temporary_buffer</tt> returns a
pair of 0 values if not successful. They have been maded <tt>noexcept</tt>.
</p>

<p>
Uninitialized copy algorithms can throw only if the constructor of the iterator value type can throw. This is derived
from 29.9.9/1 (<em>the formal template parameter <tt>Input Iterator</tt> is required to 
have the property that no exceptions are thrown from increment, assignment, comparison, or dereference of
valid iterators</tt></em>. Those algorithms have been made conditionally <tt>noexcept</tt>.
</p>

<p>
Default deleters do not need to throw on construction. Besides, <tt>operator()</tt> is specified to invoke
delete on the received <tt>ptr</tt>. That could throw only if the destructor throws.
</p>

<p>
<tt>operator*</tt> for <tt>unique_ptr</tt> and <tt>operator[]</tt> for array specialization of <tt>unique_ptr</tt> both
are based on <tt>get()</tt> which does not throw. So both operators have been made <tt>noexcept</tt>. The same is applied
to sepcializations of <tt>swap()</tt> algorithm (based on non-throwing <tt>swap()</tt> member function).
</p>

<p>
Relational operators on <tt>unique_ptr</tt> may throw if the corresponding operator on pointer types may throw. Thus,
these operators have been made conditionally <tt>noexcept</tt>.
</p>

<p>
In <tt>shared_ptr</tt>, assignment operators are based on non-throwing <tt>swap()</tt>. However, only those versions
based on non-throwing constructors may be made <tt>noexcept</tt>. The same can be applied to the first version of
<tt>reset()</tt>.
</p>

<p>
For <tt>weak_ptr</tt> member function <tt>reset()</tt> does not throw as it is based on non-throwing <tt>swap()</tt>.
</p>

<p>
Some functions for atomic access to <tt>shared_ptr</tt>s (the non-explicit) ones have been made <tt>noexcept</tt>
as they rest on the <em>explicit</em> versions, which are already non-throwing.
</p>

<p>Function <tt>align</tt> does not throw because on failure it <em>does nothing</em>.</p>

<h3>Scoped allocator</h3>

<p>
Because an scoped allocator must meet allocator requirements, its constructors cannot throw. Every
constructor has been made <tt>noexcept</tt>.
</p>

<p>
Member functions for accessing inner and outer allocators all return references to the required allocator.
They have been made <tt>noexcept</tt>.
</p>

<p>
Member function <tt>deallocate()</tt> must be non-throwing because of allocator requirements. It has
been made <tt>noexcept</tt>.
</p>

<p>
Construction member functions will not throw if the corresponding constructor does not throw. That is
expressed by means of contidional <tt>noexcept</tt> spec. The same is applied to the destruction member
function.
</p>

<h3>Time utilities</h3>

All this section has been detailed reworked to include <tt>noexcept</tt> specs.


<h2>Open points</h2>

<ul>
	<li>Should <tt>max_size()</tt> in allocators be made noexcept?</li>
	<li>Classes <tt>unary_negate</tt> and <tt>binary_negate</tt> do not have their constructors 
	specified. This makes impossible to decide if they can be made <tt>noexcept</tt>. This in turn
	has a dependency for defining the <tt>noexcept</tt> specification of <tt>not1</tt> and <tt>not2</tt>.
	</li>
	<li>Function <tt>bind()</tt> needs to be <tt>noexcept</tt> specified.</li>
    <li>It is unclear from the current specification of <tt>shared_ptr::owner_before()</tt> whether it may throw or not.
        The same can be applied to <tt>weak_ptr</tt> and class template <tt>owner_less</tt>.</li>
</ul>

<h2>Acknowledgments</h2>

I am very grateful to Daniel Kr&uuml;gler and Pablo Halpern for their review and suggestions.

<h1>Proposed Wording</h1>

<h2>20.2.5 Allocator requirements</h2>

After p. 5
<pre>
template &lt;class Tp&gt;
struct SimpleAllocator {
  typedef Tp value_type;
  SimpleAllocator(ctor args);

  template &lt;class T&gt; SimpleAllocator(const SimpleAllocator&lt;T&gt;&amp; other)<ins> noexcept</ins>;

  Tp *allocate(std::size_t n);
  void deallocate(Tp *p, std::size_t n)<ins> noexcept</ins>;
};
</pre>

<h2>20.3 Utility components</h2>

After p. 1
<pre>
#include &lt;initializer_list&gt;
namespace std {
  // 20.3.1, operators:
  namespace rel_ops {
    template&lt;class T&gt; bool operator!=(const T&amp;, const T&amp;)<ins> noexcept(noexcept(x == y))</ins>;
    template&lt;class T&gt; bool operator&gt; (const T&amp;, const T&amp;)<ins> noexcept(noexcept(y &lt; x))</ins>;
    template&lt;class T&gt; bool operator&lt;=(const T&amp;, const T&amp;)<ins> noexcept(noexcept(y &lt; x))</ins>;
    template&lt;class T&gt; bool operator&gt;=(const T&amp;, const T&amp;)<ins> noexcept(noexcept(x &lt; y))</ins>;
  }

  // 20.3.2, swap:
  template&lt;class T&gt; void swap(T&amp; a, T&amp; b)<ins> noexcept(<em>see below</em>)</ins>;
  template&lt;class T, size_t N&gt; void swap(T (&amp;a)[N], T (&amp;b)[N]) <ins>noexcept(noexcept(swap(*a,*b)))</ins>;
...
  // 20.3.3, forward/move:
  template &lt;class T, class U&gt; T&amp;&amp; forward(U&amp;&amp;)<ins> noexcept</ins>;
  template &lt;class T&gt; typename remove_reference&lt;T&gt;::type&amp;&amp; move(T&amp;&amp;)<ins> noexcept</ins>;
  template &lt;class T&gt; typename conditional&lt;
    !has_nothrow_move_constructor&lt;T&gt;::value &amp;&amp; has_copy_constructor&lt;T&gt;::value,
    const T&amp;, T&amp;&amp;&gt;::type move_if_noexcept(T&amp; x)<ins> noexcept</ins>;
...
  // 20.3.5.3, pair specialized algorithms:
  template &lt;class T1, class T2&gt;
    bool operator==(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;)<ins>
      noexcept(noexcept(x.first == y.first) &amp;&amp;
               noexcept(x.second == y.second))</ins>;
  template &lt;class T1, class T2&gt;
    bool operator&lt; (const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;)<ins>
      noexcept(noexcept(x.first &lt; y.first) &amp;&amp;
               noexcept(y.first &lt; x.first) &amp;&amp;
               noexcept(x.second &lt; y.second))</ins>;
  template &lt;class T1, class T2&gt;
    bool operator!=(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;)<ins>
      noexcept(noexcept(x == y))</ins>;
  template &lt;class T1, class T2&gt;
    bool operator&gt; (const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;)<ins>
      noexcept(noexcept(y &lt; x))</ins>;
  template &lt;class T1, class T2&gt;
    bool operator&gt;=(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;)<ins>
      noexcept(noexcept(x &lt; y))</ins>;
  template &lt;class T1, class T2&gt;
    bool operator&lt;=(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;)<ins>;
      noexcept(noexcept(y &lt; x))</ins>;
  template &lt;class T1, class T2&gt;
    void swap(pair&lt;T1,T2&gt;&amp;, pair&lt;T1,T2&gt;&amp;)<ins>
      noexcept(noexcept(x.swap(y)))</ins>;
  template &lt;class T1, class T2&gt;
    <em>see below</em> make_pair(T1&amp;&amp;, T2&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>;

  // 20.3.5.4, tuple-like access to pair:
  ...
  template&lt;size_t I, class T1, class T2&gt;
    typename tuple_element&lt;I, std::pair&lt;T1, T2&gt; &gt;::type&amp; get(std::pair&lt;T1, T2&gt;&amp;)<ins>noexcept</ins>;
  template&lt;size_t I, class T1, class T2&gt; const
    typename const tuple_element&lt;I, std::pair&lt;T1, T2&gt; &gt;::type&amp; get(const std::pair&lt;T1, T2&gt;&amp;)<ins>noexcept</ins>;
...
}
</pre>

<h2>20.3.1 Operators</h2>

After p. 1
<pre>template &lt;class T&gt; bool operator!=(const T&amp; x, const T&amp; y)<ins> noexcept(noexcept(x == y))</ins>;</pre>

After p. 3
<pre>template &lt;class T&gt; bool operator&gt;(const T&amp; x, const T&amp; y)<ins> noexcept(noexcept(y &lt; x))</ins>;</pre>

After p. 5
<pre>template &lt;class T&gt; bool operator&lt;=(const T&amp; x, const T&amp; y)<ins> noexcept(noexcept(y &lt; x))</ins>;</pre>

After p. 7
<pre>template &lt;class T&gt; bool operator&gt;=(const T&amp; x, const T&amp; y)<ins> noexcept(noexcept(x &lt; y))</ins>;</pre>

<h2>20.3.2 swap</h2>

Before p. 1
<pre>template&lt;class T&gt; void swap(T&amp; a, T&amp; b)<ins> noexcept(<em>see below</em>);</pre>
<p><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T,T&amp;&amp;&gt;::value</ins>
</pre>

Before p. 3
<pre>
template&lt;class T, size_t N&gt;
  void swap(T (&amp;a)[N], T (&amp;b)[N])<ins> noexcept(noexcept(swap(*a,*b)))</ins>;
</pre>

<h2>20.3.3 forward/move helpers</h2>

After p. 1
<pre>template &lt;class T, class U&gt; T&amp;&amp; forward(U&amp;&amp; u)<ins> noexcept</ins>;</pre>

After p. 5
<pre>template &lt;class T&gt; typename remove_reference&lt;T&gt;::type&amp;&amp; move(T&amp;&amp; t)<ins> noexcept</ins>;</pre>

After p. 8
<pre>
template &lt;class T&gt; typename conditional&lt;
  !has_nothrow_move_constructor&lt;T&gt;::value &amp;&amp; has_copy_constructor&lt;T&gt;::value,
  const T&amp;, T&amp;&amp;&gt;::type move_if_noexcept(T&amp; x)<ins> noexcept</ins>;
</pre>

<h2>20.3.5.2 Class template pair</h2>

Before p. 1
<pre>
namespace std {
  template &lt;class T1, class T2&gt;
  struct pair {
    typedef T1 first_type;
    typedef T2 second_type;

    T1 first;
    T2 second;
    pair(const pair&amp;) = default;
    constexpr pair()<ins> noexcept(<em>see below</em>)</ins>;
    pair(const T1&amp; x, const T2&amp; y)<ins> noexcept(<em>see below</em>)</ins>;
    template&lt;class U, class V&gt; pair(U&amp;&amp; x, V&amp;&amp; y)<ins> noexcept(<em>see below</em>)</ins>;
    template&lt;class U, class V&gt; pair(const pair&lt;U, V&gt;&amp; p)<ins> noexcept(<em>see below</em>)</ins>;
    template&lt;class U, class V&gt; pair(pair&lt;U, V&gt;&amp;&amp; p)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class... Args1, class... Args2&gt;
      pair(piecewise_construct_t,
	   tuple&lt;Args1...&gt; first_args, tuple&lt;Args2...&gt; second_args)<ins> noexcept(<em>see below</em>)</ins>;

    template&lt;class U, class V&gt; pair&amp; operator=(const pair&lt;U, V&gt;&amp; p)<ins> noexcept(<em>see below</em>)</ins>;
      pair&amp; operator=(pair&amp;&amp; p);
    template&lt;class U, class V&gt; pair&amp; operator=(pair&lt;U, V&gt;&amp;&amp; p)<ins> noexcept(<em>see below</em>)</ins>;

    void swap(pair&amp; p)<ins>
      noexcept(noexcept(swap(first, p.first)) &amp;&amp;
	       noexcept(swap(second, p.second)))</ins>;
  };
}
</pre>

<pre>constexpr pair()<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T1&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;T2&gt;::value</ins>
</pre>

Before p. 2
<pre>pair(const T1&amp; x, const T2&amp; y)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T1, const T1&amp;&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;T2, const T2&amp;&gt;::value</ins>
</pre>

Before p. 3
<pre>template&lt;class U, class V&gt; pair(U&amp;&amp; x, V&amp;&amp; y)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T1, U&amp;&amp;&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;T2, V&amp;&amp;&gt;::value</ins>
</pre>

Before p. 5
<pre>template&lt;class U, class V&gt; pair(const pair&lt;U, V&gt;&amp; p)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T1, const U&amp;&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;T2, const V&amp;&gt;::value</ins>
</pre>

Before p. 6
<pre>template&lt;class U, class V&gt; pair(pair&lt;U, V&gt;&amp;&amp; p)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T1, U&amp;&amp;&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;T2, V&amp;&amp;&gt;::value</ins>
</pre>

Before p. 7
<pre>
template&lt;class... Args1, class... Args2&gt;
  pair(piecewise_construct_t,
       tuple&lt;Args1...&gt; first_args, tuple&lt;Args2...&gt; second_args)<ins>noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T1, Args1&amp;&amp;...&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;T2, Args2&amp;&amp;...&gt;::value</ins>
</pre>

Before p. 9
<pre>template&lt;class U, class V&gt; pair&amp; operator=(const pair&lt;U, V&gt;&amp; p)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(declval&lt;T1&amp;&gt;() = declval&lt;const U&amp;&gt;()) &amp;&amp;</ins>
  <ins>noexcept(declval&lt;T2&amp;&gt;() = declval&lt;const V&amp;&gt;())</ins>
</pre>

Before p. 12
<pre>pair&amp; operator=(pair&amp;&amp; p)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(declval&lt;T1&amp;&gt;() = declval&lt;T1&amp;&amp;&gt;()) &amp;&amp;</ins>
  <ins>noexcept(declval&lt;T2&amp;&gt;() = declval&lt;T2&amp;&amp;&gt;())</ins>
</pre>

Before p. 14
<pre>template&lt;class U, class V&gt; pair&amp; operator=(pair&lt;U, V&gt;&amp;&amp; p)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(declval&lt;T1&amp;&gt;() = declval&lt;U&amp;&amp;&gt;()) &amp;&amp;</ins>
  <ins>noexcept(declval&lt;T2&amp;&gt;() = declval&lt;V&amp;&amp;&gt;())</ins>
</pre>

Before p. 16
<pre>
void swap(pair&amp; p)<ins>
  noexcept(noexcept(swap(first, p.first)) &amp;&amp;
	   noexcept(swap(second, p.second)))</ins>;
</pre>

<h2>20.3.5.3 Specialized algorithms</h2>

Before p. 1
<pre>
template &lt;class T1, class T2&gt;
  bool operator==(const pair&lt;T1, T2&gt;&amp; x, const pair&lt;T1, T2&gt;&amp; y)<ins>
    noexcept(noexcept(x.first==y.first) &amp;&amp;
             noexcept(x.second==y.second))</ins>;
</pre>

After p. 1
<pre>
template &lt;class T1, class T2&gt;
  bool operator&lt;(const pair&lt;T1, T2&gt;&amp; x, const pair&lt;T1, T2&gt;&amp; y)<ins>;
    noexcept(noexcept(x.first &lt; y.first) &amp;&amp;
             noexcept(y.first &lt; x.first) &amp;&amp;
             noexcept(x.second &lt; y.second))</ins>;
</pre>

After p. 2
<pre>
template &lt;class T1, class T2&gt;
  bool operator!=(const pair&lt;T1, T2&gt;&amp; x, const pair&lt;T1, T2&gt;&amp; y)<ins>
    noexcept(noexcept(x == y))</ins>;
</pre>

After p. 3
<pre>
template &lt;class T1, class T2&gt;
  bool operator&gt;(const pair&lt;T1, T2&gt;&amp; x, const pair&lt;T1, T2&gt;&amp; y)<ins>
    noexcept(noexcept(y &lt; x))</ins>;
</pre>

After p. 4
<pre>
template &lt;class T1, class T2&gt;
  bool operator&gt;=(const pair&lt;T1, T2&gt;&amp; x, const pair&lt;T1, T2&gt;&amp; y)<ins>
    noexcept(noexcept(x &lt; y))</ins>;
</pre>

After p. 5
<pre>
template &lt;class T1, class T2&gt;
  bool operator&lt;=(const pair&lt;T1, T2&gt;&amp; x, const pair&lt;T1, T2&gt;&amp; y)<ins>
    noexcept(noexcept(y &lt; x))</ins>;
</pre>

After p. 6
<pre>
template&lt;class T1, class T2&gt; void swap(pair&lt;T1, T2&gt;&amp; x, pair&lt;T1, T2&gt;&amp; y)<ins>
  noexcept(noexcept(x.swap(y)))</ins>;
</pre>

After p. 7
<pre>
template &lt;class T1, class T2&gt;
  pair&lt;V1, V2&gt; make_pair(T1&amp;&amp;, T2&amp;&amp;)<ins> noexcept(<em>see below</em>);
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;V1, T1&amp;&amp;&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;V2, T2&amp;&amp;&gt;::value</ins>
</pre>

<h2>20.3.5.4 Tuple-like access to pair</h2>

After p. 4
<pre>
template&lt;size_t I, class T1, class T2&gt;
  typename tuple_element&lt;I, std::pair&lt;T1, T2&gt; &gt;::type&amp; get(pair&lt;T1, T2&gt;&amp;)<ins> noexcept</ins>;
template&lt;size_t I, class T1, class T2&gt;
  const typename tuple_element&lt;I, std::pair&lt;T1, T2&gt; &gt;::type&amp; get(const pair&lt;T1, T2&gt;&amp;)<ins> noexcept</ins>;
</pre>

<h2>20.4.1 In general</h2>

After p. 2
<pre>
namespace std {
...
  // 20.4.2.4, tuple creation functions:
  const unspecified ignore;
  template &lt;class... Types&gt;
    tuple&lt;VTypes...&gt; make_tuple(Types&amp;&amp;...)<ins> noexcept(<em>see below</em>)</ins>;
  template &lt;class... Types&gt;
    tuple&lt;ATypes...&gt; pack_arguments forward_as_tuple(Types&amp;&amp;...)<ins> noexcept</ins>;
  template&lt;class... Types&gt;
    tuple&lt;Types&amp;...&gt; tie(Types&amp;...)<ins> noexcept</ins>;
  template &lt;class... TTypes, class... UTypes&gt;
    tuple&lt;TTypes..., UTypes...&gt; tuple_cat(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
  template &lt;class... TTypes, class... UTypes&gt;
    tuple&lt;TTypes..., UTypes...&gt; tuple_cat(tuple&lt;TTypes...&gt;&amp;&amp;, const tuple&lt;UTypes...&gt;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
  template &lt;class... TTypes, class... UTypes&gt;
    tuple&lt;TTypes..., UTypes...&gt; tuple_cat(const tuple&lt;TTypes...&gt;&amp;, tuple&lt;UTypes...&gt;&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
  template &lt;class... TTypes, class... UTypes&gt;
    tuple&lt;TTypes..., UTypes...&gt; tuple_cat(tuple&lt;TTypes...&gt;&amp;&amp;, tuple&lt;UTypes...&gt;&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
  ...
  // 20.4.2.6, element access:
  template &lt;size_t I, class... Types&gt;
    typename tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type&amp; get(tuple&lt;Types...&gt;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
  template &lt;size_t I, class ... types&gt;
    typename tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type const&amp; get(const tuple&lt;Types...&gt;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
  
  // 20.4.2.7, relational operators:
  template&lt;class... TTypes, class... UTypes&gt;
    bool operator==(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
  template&lt;class... TTypes, class... UTypes&gt;
    bool operator&lt;(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
  template&lt;class... TTypes, class... UTypes&gt;
    bool operator!=(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;)<ins> noexcept(t == u)</ins>;
  template&lt;class... TTypes, class... UTypes&gt;
    bool operator&gt;(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;)<ins> noexcept(u &lt; t)</ins>;
  template&lt;class... TTypes, class... UTypes&gt;
    bool operator&lt;=(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;)<ins> noexcept(u &lt; t)</ins>;
  template&lt;class... TTypes, class... UTypes&gt;
    bool operator&gt;=(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;)<ins> noexcept(t &lt; u)</ins>;
  ...
  // 20.4.2.9, specialized algorithms:
  template &lt;class... Types&gt;
    void swap(tuple&lt;Types...&gt;&amp; x, tuple&lt;Types...&gt;&amp; y)<ins> noexcept(<em>see below</em>)</ins>;
}
</pre>

<h2>20.4.2 Class template tuple</h2>

Before p. 1
<pre>
namespace std {
  template &lt;class... Types&gt;
  class tuple {
  public:

    // 20.4.2.1, tuple construction
    constexpr tuple()<ins> noexcept(<em>see below</em>)</ins>;
    explicit tuple(const Types&amp;...)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class... UTypes&gt;
      explicit tuple(UTypes&amp;&amp;...)<ins> noexcept(<em>see below</em>)</ins>;
  
    tuple(const tuple&amp;) = default<ins> noexcept(<em>see below</em>)</ins>;
    tuple(tuple&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
  
    template &lt;class... UTypes&gt;
      tuple(const tuple&lt;UTypes...&gt;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class... UTypes&gt;
      tuple(tuple&lt;UTypes...&gt;&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
  
    template &lt;class U1, class U2&gt;
      tuple(const pair&lt;U1, U2&gt;&amp;)<ins> noexcept(<em>see below</em>)</ins>; // iff sizeof...(Types) == 2
    template &lt;class U1, class U2&gt;
      tuple(pair&lt;U1, U2&gt;&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>; // iff sizeof...(Types) == 2
  
    // allocator-extended constructors
    template &lt;class Alloc&gt;
      tuple(allocator_arg_t, const Alloc&amp; a)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class Alloc&gt;
      tuple(allocator_arg_t, const Alloc&amp; a, const Types&amp;...)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class Alloc, class... UTypes&gt;
      tuple(allocator_arg_t, const Alloc&amp; a, const UTypes&amp;&amp;...)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class Alloc&gt;
      tuple(allocator_arg_t, const Alloc&amp; a, const tuple&amp;)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class Alloc&gt;
      tuple(allocator_arg_t, const Alloc&amp; a, tuple&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class Alloc, class... UTypes&gt;
      tuple(allocator_arg_t, const Alloc&amp; a, const tuple&lt;UTypes...&gt;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class Alloc, class... UTypes&gt;
      tuple(allocator_arg_t, const Alloc&amp; a, tuple&lt;UTypes...&gt;&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class Alloc, class U1, class U2&gt;
      tuple(allocator_arg_t, const Alloc&amp; a, const pair&lt;U1, U2&gt;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class Alloc, class U1, class U2&gt;
      tuple(allocator_arg_t, const Alloc&amp; a, pair&lt;U1, U2&gt;&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
  
    // 20.4.2.2, tuple assignment
    tuple&amp; operator=(const tuple&amp;)<ins> noexcept(<em>see below</em>)</ins>;
    tuple&amp; operator=(tuple&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
  
    template &lt;class... UTypes&gt;
      tuple&amp; operator=(const tuple&lt;UTypes...&gt;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class... UTypes&gt;
      tuple&amp; operator=(tuple&lt;UTypes...&gt;&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
  
    template &lt;class U1, class U2&gt;
      tuple&amp; operator=(const pair&lt;U1, U2&gt;&amp;)<ins> noexcept(<em>see below</em>)</ins>; // iff sizeof...(Types) == 2
    template &lt;class U1, class U2&gt;
      tuple&amp; operator=(pair&lt;U1, U2&gt;&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>; // iff sizeof...(Types) == 2
  
    // 20.4.2.3, tuple swap
    void swap(tuple&amp;)<ins> noexcept(declval&lt;tuple&lt;Types...&gt;&amp;&gt;().swap(declval&lt;tuple&lt;Types...&gt;&amp;&gt;()))</ins>;

  };
}
</pre>

<h2>20.4.2.1 Construction</h2>

<p><del>1 For each tuple constructor, an exception is thrown only if the construction of one of the types in Types
	throws an exception.</del></p>
	
Before p. 2
<pre>constexpr tuple()<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T<sub>i</sub>&gt;::value</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt></ins></p>

Before p. 4
<pre>explicit tuple(const Types&amp;...)<ins> noexcept<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T<sub>i</sub>, const T<sub>i</sub>&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt>.</ins></p>

Before p. 6
<pre>
template &lt;class... UTypes&gt;
  explicit tuple(UTypes&amp;&amp;... u)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T<sub>i</sub>, U<sub>i</sub>&amp;&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt> and <tt>U<sub>i</sub></tt> is the i-th type in <tt>UTypes</tt></ins>.</p>

Before p. 10
<pre>tuple(tuple&amp;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T<sub>i</sub>, T<sub>i</sub>&amp;&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt>.</ins></p>

Before p. 12
<pre>template &lt;class... UTypes&gt; tuple(const tuple&lt;UTypes...&gt;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T<sub>i</sub>, const U<sub>i</sub>&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt> and <tt>U<sub>i</sub></tt> is the i-th type in <tt>UTypes</tt></ins>.</p>

Before p. 15
<pre>template &lt;class... UTypes&gt; tuple(tuple&lt;UTypes...&gt;&amp;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T<sub>i</sub>, U<sub>i</sub>&amp;&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt> and <tt>U<sub>i</sub></tt> is the i-th type in <tt>UTypes</tt></ins>.</p>

Before p. 17
<pre>template &lt;class U1, class U2&gt; tuple(const pair&lt;U1, U2&gt;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T<sub>1</sub>, const U1&amp;&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;T<sub>2</sub>, const U2&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt>.</ins></p>

Before p. 19
<pre>template &lt;class U1, class U2&gt; tuple(pair&lt;U1, U2&gt;&amp;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T<sub>1</sub>, U1&amp;&amp;&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;T<sub>2</sub>, U2&amp;&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt>.</ins></p>

Before p. 21
<pre>
template &lt;class Alloc&gt;
  tuple(allocator_arg_t, const Alloc&amp; a)<ins> noexcept(<em>see below</em>)</ins>;
template &lt;class Alloc&gt;
  tuple(allocator_arg_t, const Alloc&amp; a, const Types&amp;...)<ins> noexcept(<em>see below</em>)</ins>;
template &lt;class Alloc, class... UTypes&gt;
  tuple(allocator_arg_t, const Alloc&amp; a, const UTypes&amp;&amp;...)<ins> noexcept(<em>see below</em>)</ins>;
template &lt;class Alloc&gt;
  tuple(allocator_arg_t, const Alloc&amp; a, const tuple&amp;)<ins> noexcept(<em>see below</em>)</ins>;
template &lt;class Alloc&gt;
  tuple(allocator_arg_t, const Alloc&amp; a, tuple&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
template &lt;class Alloc, class... UTypes&gt;
  tuple(allocator_arg_t, const Alloc&amp; a, const tuple&lt;UTypes...&gt;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
template &lt;class Alloc, class... UTypes&gt;
  tuple(allocator_arg_t, const Alloc&amp; a, tuple&lt;UTypes...&gt;&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
template &lt;class Alloc, class U1, class U2&gt;
  tuple(allocator_arg_t, const Alloc&amp; a, const pair&lt;U1, U2&gt;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
template &lt;class Alloc, class U1, class U2&gt;
  tuple(allocator_arg_t, const Alloc&amp; a, pair&lt;U1, U2&gt;&amp;&amp;)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the one in the preceding corresponding constructor.</ins></p>

<h2>20.4.2.2 Assignment</h2>

<p><del>1 For each tuple assignment operator, an exception is thrown only if the assignment of one of the types in
	Types throws an exception</del></p>

Before p. 2
<pre>tuple&amp; operator=(const tuple&amp; u)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>noexcept(declval&lt;T<sub>i</sub>&amp;&gt;() = declval&lt;const T<sub>i</sub>&amp;&gt;())</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt>.</ins></p>

Before p. 5
<pre>tuple&amp; operator=(tuple&amp;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>noexcept(declval&lt;T<sub>i</sub>&amp;&gt;() = declval&lt;T<sub>i</sub>&amp;&amp;&gt;())</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt>.</ins></p>

Before p. 8
<pre>
template &lt;class... UTypes&gt;
  tuple&amp; operator=(const tuple&lt;UTypes...&gt;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>noexcept(declval&lt;T<sub>i</sub>&amp;&gt;() = declval&lt;const U<sub>i</sub>&amp;&gt;())</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt> and <tt>U<sub>i</sub></tt> is the i-th type in <tt>UTypes</tt></ins>.</p>

Before p. 11
<pre>
template &lt;class... UTypes&gt;
  tuple&amp; operator=(tuple&lt;UTypes...&gt;&amp;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>noexcept(declval&lt;T<sub>i</sub>&amp;&gt;() = declval&lt;U<sub>i</sub>&amp;&amp;&gt;())</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt> and <tt>U<sub>i</sub></tt> is the i-th type in <tt>UTypes</tt></ins>.</p>

Before p. 14
<pre>template &lt;class U1, class U2&gt; tuple&amp; operator=(const pair&lt;U1, U2&gt;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>nothrow(declval&lt;T<sub>1</sub>&amp;&gt;() = declval&lt;const U1&amp;&gt;()) &amp;&amp;</ins>
  <ins>nothrow(declval&lt;T<sub>2</sub>&amp;&gt;() = declval&lt;const U2&amp;&gt;())</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt>.</ins></p>

Before p. 18
<pre>template &lt;class U1, class U2&gt; tuple&amp; operator=(pair&lt;U1, U2&gt;&amp;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>nothrow(declval&lt;T<sub>1</sub>&amp;&gt;() = declval&lt;U1&amp;&amp;&gt;()) &amp;&amp;</ins>
  <ins>nothrow(declval&lt;T<sub>2</sub>&amp;&gt;() = declval&lt;U2&amp;&amp;&gt;())</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt>.</ins></p>

<h2>20.4.2.3 swap</h2>

Before p. 1
<pre>void swap(tuple&amp; rhs)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>noexcept(swap(declval&lt;T<sub>i</sub>&amp;&gt;, declval&lt;T<sub>i</sub>&amp;&gt;))</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt>.</ins></p>

<h2>20.4.2.4 Tuple creation functions</h2>

Before p. 1
<pre>
template&lt;class... Types&gt;
  tuple&lt;VTypes...&gt; make_tuple(Types&amp;&amp;... t)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;V<sub>i</sub>, T<sub>i</sub>&amp;&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>V<sub>i</sub></tt> is the i-th type in <tt>VTypes</tt> and <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt>.</ins></p>

Before p. 4
<pre>
template&lt;class... Types&gt;
  tuple&lt;Types&amp;&amp;...&gt;forward_as_tuple(Types&amp;&amp;... t)<ins> noexcept</ins>;
</pre>

Before p. 6
<pre>
template&lt;class... Types&gt;
  tuple&lt;Types&amp;...&gt; tie(Types&amp;... t)<ins> noexcept</ins>;
</pre>

Before p. 8
<pre>
template &lt;class... TTypes, class... UTypes&gt;
  tuple&lt;TTypes..., UTypes...&gt; tuple_cat(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T<sub>i</sub>, const T<sub>i</sub>&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>TTypes</tt>, and the logical and of the following expressions:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;U<sub>i</sub>, const U<sub>i</sub>&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>U<sub>i</sub></tt> is the i-th type in <tt>UTypes</tt>.</ins></p>

Before p. 10
<pre>
template &lt;class... TTypes, class... UTypes&gt;
  tuple&lt;TTypes..., UTypes...&gt; tuple_cat(tuple&lt;TTypes...&gt;&amp;&amp; t, const tuple&lt;UTypes...&gt;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T<sub>i</sub>, T<sub>i</sub>&amp;&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>TTypes</tt>, and the logical and of the following expressions:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;U<sub>i</sub>, const U<sub>i</sub>&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>U<sub>i</sub></tt> is the i-th type in <tt>UTypes</tt>.</ins></p>

Before p. 12
<pre>
template &lt;class... TTypes, class... UTypes&gt;
  tuple&lt;TTypes..., UTypes...&gt; tuple_cat(const tuple&lt;TTypes...&gt;&amp; t, tuple&lt;UTypes...&gt;&amp;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T<sub>i</sub>, const T<sub>i</sub>&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>TTypes</tt>, and the logical and of the following expressions:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;U<sub>i</sub>, U<sub>i</sub>&amp;&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>U<sub>i</sub></tt> is the i-th type in <tt>UTypes</tt>.</ins></p>

Before p. 14
<pre>
template &lt;class... TTypes, class... UTypes&gt;
  tuple&lt;TTypes..., UTypes...&gt; tuple_cat(tuple&lt;TTypes...&gt;&amp;&amp; t, tuple&lt;UTypes...&gt;&amp;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T<sub>i</sub>, T<sub>i</sub>&amp;&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>TTypes</tt>, and the logical and of the following expressions:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;U<sub>i</sub>, U<sub>i</sub>&amp;&amp;&gt;::value</ins>
</pre>
<p><ins>where <tt>U<sub>i</sub></tt> is the i-th type in <tt>UTypes</tt>.</ins></p>

<h2>20.4.2.7 Relational operators</h2>

Before p. 1
<pre>
template&lt;class... TTypes, class... UTypes&gt;
  bool operator==(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>noexcept(declval&lt;const T<sub>i</sub> &amp;&gt;() == declval&lt;const U<sub>i</sub>&amp;&gt;())</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt> and <tt>U<sub>i</sub></tt> is the i-th type in <tt>UTypes</tt></ins>.</p>

Before p. 4
<pre>
template&lt;class... TTypes, class... UTypes&gt;
  bool operator&lt;(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to the logical and of the following expressions:</ins></p>
<pre>
  <ins>noexcept(declval&lt;const T<sub>i</sub>&amp;&gt;() &lt; declval&lt;const U<sub>i</sub>&amp;&gt;())</ins>
  <ins>noexcept(declval&lt;const U<sub>i</sub>&amp;&gt;() &lt; declval&lt;const T<sub>i</sub>&amp;&gt;())</ins>
</pre>
<p><ins>where <tt>T<sub>i</sub></tt> is the i-th type in <tt>Types</tt> and <tt>U<sub>i</sub></tt> is the i-th type in <tt>UTypes</tt></ins>.</p>

After p. 4
<pre>
template&lt;class... TTypes, class... UTypes&gt;
  bool operator!=(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u)<ins> noexcept(noexcept(t == u))</ins>;
</pre>

After p. 5
<pre>
template&lt;class... TTypes, class... UTypes&gt;
  bool operator&gt;(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u)<ins> noexcept(noexcept(u &lt; t))</ins>;
</pre>

After p. 6
<pre>
template&lt;class... TTypes, class... UTypes&gt;
  bool operator&lt;=(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u)<ins> noexcept(noexcept(u &lt; t))</ins>;
</pre>

After p. 7
<pre>
template&lt;class... TTypes, class... UTypes&gt;
  bool operator&gt;=(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u)<ins> noexcept(noexcept(t &lt; u))</ins>;
</pre>

<h2>20.4.2.9 Tuple specialized algorithms</h2>

Before p. 1
<pre>
template &lt;class... Types&gt;
  void swap(tuple&lt;Types...&gt;&amp; x, tuple&lt;Types...&gt;&amp; y)<ins>
    noexcept(declval&lt;tuple&lt;Types...&gt;&amp;&gt;().swap(declval&lt;tuple&lt;Types...&gt;&amp;&gt;()))</ins>;
</pre>

<h2>20.5 Class template bitset</h2>

Before p. 1
<pre>
#include &lt;string&gt;
#include &lt;iosfwd&gt; // for istream, ostream
namespace std {
  template &lt;size_t N&gt; class bitset;

  // 20.5.4 bitset operators:
  template &lt;size_t N&gt;
    bitset&lt;N&gt; operator&amp;(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;)<ins> noexcept</ins>;
  template &lt;size_t N&gt;
    bitset&lt;N&gt; operator|(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;)<ins> noexcept</ins>;
  template &lt;size_t N&gt;
    bitset&lt;N&gt; operator^(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;)<ins> noexcept</ins>;
  template &lt;class charT, class traits, size_t N&gt;
    basic_istream&lt;charT, traits&gt;&amp;
    operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp; is, bitset&lt;N&gt;&amp; x);
  template &lt;class charT, class traits, size_t N&gt;
    basic_ostream&lt;charT, traits&gt;&amp;
    operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const bitset&lt;N&gt;&amp; x);
}
</pre>

After p. 1
<pre>
namespace std {
  template&lt;size_t N&gt; class bitset {
  public:
    // bit reference:
    class reference {
      friend class bitset;
      reference();
    public:
      ~reference();
      reference&amp; operator=(bool x); // for b[i] = x;
      reference&amp; operator=(const reference&amp;); // for b[i] = b[j];
      bool operator~() const; // flips the bit
      operator bool() const; // for x = b[i];
      reference&amp; flip(); // for b[i].flip();
    };

    // 20.5.1 constructors:
    constexpr bitset()<ins> noexcept</ins>;
    constexpr bitset(unsigned long long val)<ins> noexcept</ins>;
    template&lt;class charT, class traits, class Allocator&gt;
      explicit bitset(
        const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
        typename basic_string&lt;charT,traits,Allocator&gt;::size_type pos = 0,
        typename basic_string&lt;charT,traits,Allocator&gt;::size_type n =
          basic_string&lt;charT,traits,Allocator&gt;::npos,
          charT zero = charT(0), charT one = charT(1));
    explicit bitset(const char *str);

    // 20.5.2 bitset operations:
    bitset&lt;N&gt;&amp; operator&amp;=(const bitset&lt;N&gt;&amp; rhs)<ins> noexcept</ins>;
    bitset&lt;N&gt;&amp; operator|=(const bitset&lt;N&gt;&amp; rhs)<ins> noexcept</ins>;
    bitset&lt;N&gt;&amp; operator^=(const bitset&lt;N&gt;&amp; rhs)<ins> noexcept</ins>;
...
    bitset&lt;N&gt;&amp; set()<ins> noexcept</ins>;
    bitset&lt;N&gt;&amp; set(size_t pos, bool val = true);
    bitset&lt;N&gt;&amp; reset()<ins> noexcept</ins>;
    bitset&lt;N&gt;&amp; reset(size_t pos);
    bitset&lt;N&gt; operator~() const<ins> noexcept</ins>;
    bitset&lt;N&gt;&amp; flip()<ins> noexcept</ins>;
    bitset&lt;N&gt;&amp; flip(size_t pos);

    // element access:
    constexpr bool operator[](size_t pos) const; // for b[i];
    reference operator[](size_t pos); // for b[i];

    unsigned long to_ulong() const;
    unsigned long long to_ullong() const;
    template &lt;class charT = char,
        class traits = char_traits&lt;charT&gt;,
        class Allocator = allocator&lt;charT&gt; &gt;
      basic_string&lt;charT, traits, Allocator&gt;
      to_string(charT zero = charT(0), charT one = charT(1)) const;
    size_t count() const<ins> noexcept</ins>;
    constexpr size_t size()<ins> noexcept</ins>;
    bool operator==(const bitset&lt;N&gt;&amp; rhs) const<ins> noexcept</ins>;
    bool operator!=(const bitset&lt;N&gt;&amp; rhs) const<ins> noexcept</ins>;
    bool test(size_t pos);
    bool all() const<ins> noexcept</ins>;
    bool any() const<ins> noexcept</ins>;
    bool none() const<ins> noexcept</ins>;
...
  };

  // 20.5.3 Hash support
  template &lt;class T&gt; struct hash;
  template &lt;size_t N&gt; struct hash&lt;bitset&lt;N&gt; &gt;;
}
</pre>

<h2>20.5.1 bitset constructors</h2>

Before p. 1
<pre>constexpr bitset()<ins> noexcept</ins>;</pre>

After p. 1
<pre>constexpr bitset(unsigned long long val)<ins> noexcept</ins>;</pre>

<h2>20.5.2 bitset members</h2>

Before p. 1
<pre>bitset&lt;N&gt;&amp; operator&amp;=(const bitset&lt;N&gt;&amp; rhs)<ins> noexcept</ins>;</pre>

After p. 2
<pre>bitset&lt;N&gt;&amp; operator|=(const bitset&lt;N&gt;&amp; rhs)<ins> noexcept</ins>;</pre>

After p. 4
<pre>bitset&lt;N&gt;&amp; operator^=(const bitset&lt;N&gt;&amp; rhs)<ins> noexcept</ins>;</pre>

After p. 6
<pre>bitset&lt;N&gt;&amp; operator&lt;&lt;=(size_t pos)<ins> noexcept</ins>;</pre>

After p. 8
<pre>bitset&lt;N&gt;&amp; operator&gt;&gt;=(size_t pos)<ins> noexcept</ins>;</pre>

After p. 10
<pre>bitset&lt;N&gt;&amp; set()<ins> noexcept</ins>;</pre>

After p. 16
<pre>bitset&lt;N&gt;&amp; reset()<ins> noexcept</ins>;</pre>

After p. 22
<pre>bitset&lt;N&gt; operator~() const<ins> noexcept</ins>;</pre>

After p. 24
<pre>bitset&lt;N&gt;&amp; flip()<ins> noexcept</ins>;</pre>

After p. 36
<pre>size_t count() const<ins> noexcept</ins>;</pre>

After p. 37
<pre>constexpr size_t size()<ins> noexcept</ins>;</pre>

After p. 38
<pre>bool operator==(const bitset&lt;N&gt;&amp; rhs) const<ins> noexcept</ins>;</pre>

After p. 39
<pre>bool operator!=(const bitset&lt;N&gt;&amp; rhs) const<ins> noexcept</ins>;</pre>

After p. 43
<pre>bool all() const<ins> noexcept</ins>;</pre>

After p. 44
<pre>bool any() const<ins> noexcept</ins>;</pre>

After p. 45
<pre>bool none() const<ins> noexcept</ins>;</pre>

After p. 46
<pre>bitset&lt;N&gt; operator&lt;&lt;(size_t pos) const<ins> noexcept</ins>;</pre>

After p. 47
<pre>bitset&lt;N&gt; operator&gt;&gt;(size_t pos) const<ins> noexcept</ins>;</pre>

<h2>20.5.4 bitset operators</h2>

Before p. 1
<pre>bitset&lt;N&gt; operator&amp;(const bitset&lt;N&gt;&amp; lhs, const bitset&lt;N&gt;&amp; rhs)<ins> noexcept</ins>;</pre>

After p. 1
<pre>bitset&lt;N&gt; operator|(const bitset&lt;N&gt;&amp; lhs, const bitset&lt;N&gt;&amp; rhs)<ins> noexcept</ins>;</pre>

After p. 2
<pre>bitset&lt;N&gt; operator^(const bitset&lt;N&gt;&amp; lhs, const bitset&lt;N&gt;&amp; rhs)<ins> noexcept</ins>;</pre>

<h2>20.8.5 Arithmetic operations</h2>

After p. 1
<pre>
template &lt;class T&gt; struct plus : binary_function&lt;T,T,T&gt; {
  T operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x + y))</ins>;
};
</pre>

After p. 2
<pre>
template &lt;class T&gt; struct minus : binary_function&lt;T,T,T&gt; {
  T operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x - y))</ins>;
};
</pre>

After p. 3
<pre>
template &lt;class T&gt; struct multiplies : binary_function&lt;T,T,T&gt; {
  T operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x + y))</ins>;
};
</pre>

After p. 4
<pre>
template &lt;class T&gt; struct divides : binary_function&lt;T,T,T&gt; {
  T operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x / y))</ins>;
};
</pre>

After p. 5
<pre>
template &lt;class T&gt; struct modulus : binary_function&lt;T,T,T&gt; {
  T operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x % y))</ins>;
};
</pre>

After p. 6
<pre>
template &lt;class T&gt; struct negate : unary_function&lt;T,T&gt; {
  T operator()(const T& x) const<ins> noexcept(noexcept(-x))</ins>;
};
</pre>

<h2>20.8.6 Comparisons</h2>

After p. 1
<pre>
template &lt;class T&gt; struct equal_to : binary_function&lt;T,T,bool&gt; {
  bool operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x == y))</ins>;
};
</pre>

After p. 2
<pre>
template &lt;class T&gt; struct not_equal_to : binary_function&lt;T,T,bool&gt; {
  bool operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x != y))</ins>;
};
</pre>

After p. 3
<pre>
template &lt;class T&gt; struct greater : binary_function&lt;T,T,bool&gt; {
  bool operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x &gt; y))</ins>;
};
</pre>

After p. 4
<pre>
template &lt;class T&gt; struct less : binary_function&lt;T,T,bool&gt; {
  bool operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x &lt; y))</ins>;
};
</pre>

After p. 5
<pre>
template &lt;class T&gt; struct greater_equal : binary_function&lt;T,T,bool&gt; {
  bool operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x &gt;= y))</ins>;
};
</pre>

After p. 6
<pre>
template &lt;class T&gt; struct less_equal : binary_function&lt;T,T,bool&gt; {
  bool operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x &lt;= y))</ins>;
};
</pre>

<h2>20.8.7 Logical operations</h2>

After p. 1
<pre>
template &lt;class T&gt; struct logical_and : binary_function&lt;T,T,bool&gt; {
  bool operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x &amp;&amp; y))</ins>;
};
</pre>

After p. 2
<pre>
template &lt;class T&gt; struct logical_or : binary_function&lt;T,T,bool&gt; {
  bool operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x || y))</ins>;
};
</pre>

After p. 3
<pre>
template &lt;class T&gt; struct logical_not : unary_function&lt;T,bool&gt; {
  bool operator()(const T&amp; x) const<ins> noexcept(noexcept(!x))</ins>;
};
</pre>

<h2>20.8.8 Bitwise operations</h2>

After p. 1
<pre>
template &lt;class T&gt; struct bit_and : binary_function&lt;T,T,T&gt; {
  T operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x &amp; y))</ins>;
};
</pre>

After p. 2
<pre>
template &lt;class T&gt; struct bit_or : binary_function&lt;T,T,T&gt; {
  T operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x | y))</ins>;
};
</pre>

After p. 3
<pre>
template &lt;class T&gt; struct bit_xor : binary_function&lt;T,T,T&gt; {
  T operator()(const T&amp; x, const T&amp; y) const<ins> noexcept(noexcept(x ^ y))</ins>;
};
</pre>

<h2>20.8.9 Negators</h2>

After p. 1
<pre>
template &lt;class Predicate&gt;
  class unary_negate
    : public unary_function&lt;typename Predicate::argument_type,bool&gt; {
  public:
    explicit unary_negate(const Predicate&amp; pred);
    bool operator()(const typename Predicate::argument_type&amp; x) const<ins> noexcept(noexcept(!pred(x))</ins>;
};
</pre>

After p. 3
<pre>
template &lt;class Predicate&gt;
  class binary_negate
    : public binary_function&lt;typename Predicate::first_argument_type,
        typename Predicate::second_argument_type, bool&gt; {
  public:
    explicit binary_negate(const Predicate&amp; pred);
    bool operator()(const typename Predicate::first_argument_type&amp; x,
		    const typename Predicate::second_argument_type&amp; y) const
      <ins> noexcept(noexcept(!pred(x,y))</ins>;
  };
</pre>

<h2>20.8.14.1 Class bad_function_call</h2>

After p. 1
<pre>
namespace std {
  class bad_function_call : public std::exception {
  public:
    // 20.8.14.1.1, constructor:
    bad_function_call()<ins> noexcept</ins>;
  };
} // namespace std
</pre>

<h2>20.8.14.1.1 bad_function_call constructor</h2>

Before p. 1
<pre>bad_function_call()<ins> noexcept</ins>;</pre>

<h2>20.8.14.2 Class template function</h2>

Before p. 1
<pre>
namespace std {
  template&lt;class&gt; class function; // undefined

  template&lt;class R, class... ArgTypes&gt;
  class function&lt;R(ArgTypes...)&gt;
    : public unary_function&lt;T1, R&gt; // iff sizeof...(ArgTypes) == 1 and ArgTypes contains T1
    : public binary_function&lt;T1, T2, R&gt; // iff sizeof...(ArgTypes) == 2 and ArgTypes contains T1 and T2
  {
  public:
...
    function(function&amp;&amp;)<ins> noexcept</ins>;
...
    template&lt;class A&gt; 
      function(allocator_arg_t, const A&amp;, function&amp;&amp;)<ins> noexcept</ins>;
...
    function&amp; operator=(function&amp;&amp;)<ins> noexcept</ins>;
    function&amp; operator=(nullptr_t)<ins> noexcept</ins>;
    template&lt;class F&gt; function&amp; operator=(F&amp;&amp;)<ins> noexcept</ins>;
    template&lt;class F&gt; function&amp; operator=(reference_wrapper&lt;F&gt;);

    ~function()<ins> noexcept</ins>;

    // 20.8.14.2.2, function modifiers:
...
    template&lt;class F, class A&gt; void assign(F&amp;&amp;, const A&amp;)<ins> noexcept</ins>;
  };
...
  template &lt;class R, class... ArgTypes&gt;
    void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&gt;&amp;)<ins> noexcept</ins>;
...
}
</pre>

<h2>20.8.14.2.1 function construct/copy/destroy</h2>

After p. 7
<pre>
function(function&amp;&amp; f)<ins> noexcept</ins>;
template &lt;class A&gt; function(allocator_arg_t, const A&amp; a, function&amp;&amp; f)<ins> noexcept</ins>;
</pre>

After p. 14
<pre>function&amp; operator=(function&amp;&amp; f)<ins> noexcept</ins>;</pre>

After p. 16
<pre>function&amp; operator=(nullptr_t)<ins> noexcept</ins>;</pre>

After p. 19
<pre>template&lt;class F&gt; function&amp; operator=(F&amp;&amp; f)<ins>noexcept</ins>;</pre>

After p. 24
<pre>~function()<ins> noexcept</ins>;</pre>

<h2>20.8.14.2.2 function modifiers</h2>

After p. 2
<pre>
template&lt;class F, class A&gt;
  void assign(F&amp;&amp; f, const A&amp; a)<ins> noexcept</ins>;
</pre>

<h2>20.8.14.2.7 specialized algorithms</h2>

Before p. 1
<pre>
template&lt;class R, class... ArgTypes&gt;
  void swap(function&lt;R(ArgTypes...)&gt;&amp; f1, function&lt;R(ArgTypes...)&gt;&amp; f2)<ins> noexcept</ins>;
</pre>

<h2>20.9 Memory</h2>

After p. 1
<pre>
namespace std {
...
  // 20.9.8, temporary buffers:
  template &lt;class T&gt;
    pair&lt;T*,ptrdiff_t&gt; get_temporary_buffer(ptrdiff_t n)<ins> noexcept</ins>;
  template &lt;class T&gt;
    void return_temporary_buffer(T* p)<ins> noexcept</ins>;
...
  // 20.9.9, specialized algorithms:
...
  template &lt;class InputIterator, class ForwardIterator&gt;
    ForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
				       ForwardIterator result)<ins> noexcept(<em>see below</em>)</ins>;
  template &lt;class InputIterator, class Size, class ForwardIterator&gt;
    ForwardIterator uninitialized_copy_n(InputIterator first, Size n,
					 ForwardIterator result)<ins> noexcept(<em>see below</em>)</ins>;
  template &lt;class ForwardIterator, class T&gt;
    void uninitialized_fill(ForwardIterator first, ForwardIterator last,
			    const T&amp; x)<ins> noexcept(<em>see below</em>)</ins>;
  template &lt;class ForwardIterator, class Size, class T&gt;
    void uninitialized_fill_n(ForwardIterator first, Size n, const T&amp; x)<ins> noexcept(<em>see below</em>)</ins>;
...
    // 20.9.11.5, shared_ptr atomic access:
...
    template&lt;class T&gt;
      shared_ptr&lt;T&gt; atomic_load(const shared_ptr&lt;T&gt;* p)<ins> noexcept</ins>;
...
    template&lt;class T&gt;
      void atomic_store(shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt; r)<ins> noexcept</ins>;
...
    template&lt;class T&gt;
      shared_ptr&lt;T&gt; atomic_exchange(shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt; r)<ins> noexcept</ins>;
...
    template&lt;class T&gt;
      bool atomic_compare_exchange_weak(
        shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt;* v, shared_ptr&lt;T&gt; w)<ins> noexcept</ins>;
    template&lt;class T&gt;
      bool atomic_compare_exchange_strong(
        shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt;* v, shared_ptr&lt;T&gt; w)<ins> noexcept</ins>;
...
}
</pre>

<h2>20.9.4 Allocator traits</h2>

After p. 1
<pre>
namespace std {
  template &lt;class Alloc&gt; struct allocator_traits {
...
  static void deallocate(Alloc&amp; a, pointer p, size_type n)<ins> noexcept</ins>;

  template &lt;class T, class... Args&gt;
    static void construct(Alloc&amp; a, T* p, Args&amp;&amp;... args)<ins>
      noexcept(noexcept(a.construct(p,std::forward&lt;Args&gt;(args)...)))</ins>;

  template &lt;class T&gt;
    static void destroy(Alloc&amp; a, T* p)<ins> noexcept(noexcept(a.destroy(p)))</ins>;
...
  };
}
</pre>

<h2>20.9.4.2 Allocator traits static member functions</h2>

After p. 2
<pre>static void deallocate(Alloc&amp; a, pointer p, size_type n)<ins> noexcept</ins>;</pre>

After p. 3
<pre>
template &lt;class T, class... Args&gt;
  static void construct(Alloc&amp; a, T* p, Args&amp;&amp;... args) <ins>
    noexcept(noexcept(a.construct(p,std::forward&lt;Args&gt;(args)...)))</ins>;
</pre>

After p. 4
<pre>
template &lt;class T&gt;
  static void destroy(Alloc&amp; a, T* p)<ins> noexcept(noexcept(a.destroy(p)))</ins>;
</pre>

<h2>20.9.5 The default allocator</h2>

Before p. 1
<pre>
namespace std {
  template &lt;class T&gt; class allocator;
...
  template &lt;class T&gt; class allocator {
  public:
...
    pointer address(reference x) const<ins> noexcept</ins>;
    const_pointer address(const_reference x) const<ins> noexcept</ins>;
...
    void deallocate(pointer p, size_type n)<ins> noexcept</ins>;
...
    template&lt;class U, class... Args&gt;
      void construct(U* p, Args&&... args)<ins> noexcept(<em>see below</em>)</ins>;

    template &lt;class U&gt;
      void destroy(U* p)<ins> noexcept(noexcept(p-&gt;~U()))</ins>;
...
  };
}
</pre>

<h2>20.9.5.1 allocator members</h2>

After p. 1
<pre>pointer address(reference x) const<ins> noexcept</ins>;</pre>

After p. 2
<pre>const_pointer address(const_reference x) const<ins> noexcept</ins>;</pre>

After p. 7
<pre>
void deallocate(pointer p, size_type n)<ins> noexcept</ins>;
</pre>

After p. 11
<pre>
template &lt;class U, class... Args&gt;
  void construct(U* p, Args&amp;&amp;... args)<ins> noexcept(<em>see below</em>);
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;U,Args&amp;&amp;...&gt;::value</ins>
</pre>

After p. 12
<pre>
template &lt;class U&gt;
  void destroy(U* p)<ins> noexcept(noexcept(p-&gt;~U()))</ins>;
</pre>

<h2>20.9.7 Raw storage iterator</h2>

After p. 1
<pre>
namespace std {
  template &lt;class OutputIterator, class T&gt;
  class raw_storage_iterator
    : public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
  public:
    explicit raw_storage_iterator(OutputIterator x)<ins> noexcept</ins>;

    raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator*()<ins> noexcept</ins>;
    raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator=(const T&amp; element)<ins> noexcept(<em>see below</em>)</ins>;
    raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator++()<ins> noexcept</ins>;
    raw_storage_iterator&lt;OutputIterator,T&gt; operator++(int)<ins> noexcept</ins>;
  };
}
</pre>

Before p. 2
<pre>raw_storage_iterator(OutputIterator x)<ins> noexcept</ins>;</pre>

After p. 2
<pre>raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator*()<ins> noexcept</ins>;</pre>

After p. 3
<pre>raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator=(const T&amp; element)<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T, const T&amp;&gt::value</ins>
</pre>


After p. 5
<pre>raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator++()<ins> noexcept</ins>;</pre>

After p. 6
<pre>raw_storage_iterator&lt;OutputIterator,T&gt; operator++(int)<ins> noexcept</ins>;</pre>

<h2>20.9.8 Temporary buffers</h2>

Before p. 1
<pre>
template &lt;class T&gt;
  pair&lt;T*, ptrdiff_t&gt; get_temporary_buffer(ptrdiff_t n)<ins> noexcept</ins>;
</pre>

After p. 2
<pre>
template &lt;class T&gt; void return_temporary_buffer(T* p)<ins> noexcept</ins>;
</pre>

<h2>20.9.9.2 uninitialized_copy</h2>

Before p. 1
<pre>
template &lt;class InputIterator, class ForwardIterator&gt;
  ForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
				     ForwardIterator result)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;decltype(*result),decltype(*first)&gt;::value</ins>
</pre>

After p. 2
<pre>
template &lt;class InputIterator, class Size, class ForwardIterator&gt;
  ForwardIterator uninitialized_copy_n(InputIterator first, Size n,
                                       ForwardIterator result)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;decltype(*result),decltype(*first)&gt;::value</ins>
</pre>

<h2>20.9.9.3 uninitialized_fill</h2>

Before p. 1
<pre>
template &lt;class ForwardIterator, class T&gt;
  void uninitialized_fill(ForwardIterator first, ForwardIterator last,
			  const T&amp; x)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;decltype(*first),decltype(x)&gt;::value</ins>
</pre>

<h2>20.9.9.4 uninitialized_fill_n</h2>

Before p. 1
<pre>
template &lt;class ForwardIterator, class Size, class T&gt;
  void uninitialized_fill_n(ForwardIterator first, Size n, const T&amp; x)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;decltype(*first),decltype(x)&gt;::value</ins>
</pre>

<h2>20.9.10 Class template unique_ptr</h2>

After p. 6
<pre>
namespace std {
  template&lt;class T&gt; struct default_delete;
  template&lt;class T&gt; struct default_delete&lt;T[]&gt;;

  template&lt;class T, class D = default_delete&lt;T&gt;&gt; class unique_ptr;
  template&lt;class T, class D&gt; class unique_ptr&lt;T[], D&gt;;

  template&lt;class T, class D&gt; void swap(unique_ptr&lt;T, D&gt;&amp; x, unique_ptr&lt;T, D&gt;&amp; y)<ins> neoxcept</ins>;

  template&lt;class T1, class D1, class T2, class D2&gt;
    bool operator==(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y)<ins>
      noexcept(declval&lt;const unique_ptr&lt;T1, D1&gt;::pointer&amp;&gt;() == declval&lt;const unique_ptr&lt;T2, D2&gt;::pointer&amp;&gt;())</ins>;
  template&lt;class T1, class D1, class T2, class D2&gt;
    bool operator!=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y)<ins>
      noexcept(declval&lt;const unique_ptr&lt;T1, D1&gt;::pointer&amp;&gt;() != declval&lt;const unique_ptr&lt;T2, D2&gt;::pointer&amp;&gt;())</ins>;
  template&lt;class T1, class D1, class T2, class D2&gt;
    bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y)<ins>
      noexcept(declval&lt;const unique_ptr&lt;T1, D1&gt;::pointer&amp;&gt;() &lt; declval&lt;const unique_ptr&lt;T2, D2&gt;::pointer&amp;&gt;())</ins>;
  template&lt;class T1, class D1, class T2, class D2&gt;
    bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y)<ins>
      noexcept(declval&lt;const unique_ptr&lt;T1, D1&gt;::pointer&amp;&gt;() &lt;= declval&lt;const unique_ptr&lt;T2, D2&gt;::pointer&amp;&gt;())</ins>;
  template&lt;class T1, class D1, class T2, class D2&gt;
    bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y)<ins>
      noexcept(declval&lt;const unique_ptr&lt;T1, D1&gt;::pointer&amp;&gt;() &gt; declval&lt;const unique_ptr&lt;T2, D2&gt;::pointer&amp;&gt;())</ins>;
  template&lt;class T1, class D1, class T2, class D2&gt;
    bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y)<ins>
      noexcept(declval&lt;const unique_ptr&lt;T1, D1&gt;::pointer&amp;&gt;() &gt;= declval&lt;const unique_ptr&lt;T2, D2&gt;::pointer&amp;&gt;())</ins>;
}
</pre>

<h2>20.9.10.1.2 default_delete</h2>

Before p. 1
<pre>
namespace std {
  template &lt;class T&gt; struct default_delete {
    constexpr default_delete()<ins> noexcept</ins>;
    template &lt;class U&gt; default_delete(const default_delete&lt;U&gt;&)<ins> noexcept</ins>;
    void operator()(T*<ins> ptr</ins>) const<ins> noexcept(noexcept(ptr-&gt;~T()))</ins>;
  };
}

constexpr default_delete()<ins> noexcept</ins>;
</pre>

After p. 1
<pre>template &lt;class U&gt; default_delete(const default_delete&lt;U&gt;& other)<ins> noexcept</ins>;</pre>

After p. 3
<pre>void operator()(T *ptr) const<ins> noexcept(noexcept(ptr-&gt;~T()))</ins>;</pre>

<h2>20.9.10.1.3 default_delete&lt;T[]&gt;</h2>

Before p. 1
<pre>
namespace std {
  template &lt;class T&gt; struct default_delete&lt;T[]&gt; {
    constexpr default_delete()<ins> noexcept</ins>;
    void operator()(T* ptr) const<ins> noexcept(noexcept(ptr-&gt;~T()))</ins>;
    template <class U> void operator()(U*) const = delete;
  };
}
void operator()(T* ptr) const<ins> noexcept(noexcept(ptr-&gt;~T()))</ins>;
</pre>

<h2>20.9.10.2 unique_ptr for single objects</h2>

Before p. 1
<pre>
namespace std {
  template &lt;class T, class D = default_delete&lt;T&gt;&gt; class unique_ptr {
  public:
...
    // observers
    typename add_lvalue_reference&lt;T&gt;::type operator*() const<ins> noexcept</ins>;
...
  };
}
</pre>

<h2>20.9.10.2.4 unique_ptr observers</h2>

Before p. 1
<pre>typename add_lvalue_reference&lt;T&gt;::type operator*() const<ins> noexcept</ins>;</pre>

<h2>20.9.10.3 unique_ptr for array objects with a runtime length</h2>

Before p. 1
<pre>
namespace std {
  template &lt;class T, class D&gt; class unique_ptr&lt;T[], D&gt; {
  public:
...
    T&amp; operator[](size_t i) const<ins> noexcept</ins>;
...
  };
}
</pre>

<h2>20.9.10.3.2 unique_ptr observers</h2>

Before p. 1
<pre>T&amp; operator[](size_t i) const<ins> noexcept</ins>;</pre>

<h2>20.9.10.4 unique_ptr specialized algorithms</h2>

Before p. 1
<pre>template &lt;class T, class D&gt; void swap(unique_ptr&lt;T, D&gt;&amp; x, unique_ptr&lt;T, D&gt;&amp; y)<ins> noexcept</ins>;</pre>

After p. 1
<pre>
template &lt;class T1, class D1, class T2, class D2&gt;
  bool operator==(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y)<ins>
    noexcept(declval&lt;const unique_ptr&lt;T1, D1&gt;::pointer&amp;&gt;() == declval&lt;const unique_ptr&lt;T2, D2&gt;::pointer&amp;&gt;())</ins>;
</pre>

After p. 2
<pre>
template &lt;class T1, class D1, class T2, class D2&gt;
  bool operator!=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y)<ins>
    noexcept(declval&lt;const unique_ptr&lt;T1, D1&gt;::pointer&amp;&gt;() != declval&lt;const unique_ptr&lt;T2, D2&gt;::pointer&amp;&gt;())</ins>;
</pre>

After p. 3
<pre>
template &lt;class T1, class D1, class T2, class D2&gt;
  bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y)<ins>
    noexcept(declval&lt;const unique_ptr&lt;T1, D1&gt;::pointer&amp;&gt;() &lt; declval&lt;const unique_ptr&lt;T2, D2&gt;::pointer&amp;&gt;())</ins>;
</pre>

After p. 4
<pre>
template &lt;class T1, class D1, class T2, class D2&gt;
  bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y)<ins>
    noexcept(declval&lt;const unique_ptr&lt;T1, D1&gt;::pointer&amp;&gt;() &lt;= declval&lt;const unique_ptr&lt;T2, D2&gt;::pointer&amp;&gt;())</ins>;
</pre>

After p. 5
<pre>
template &lt;class T1, class D1, class T2, class D2&gt;
  bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y)<ins>
    noexcept(declval&lt;const unique_ptr&lt;T1, D1&gt;::pointer&amp;&gt;() &gt; declval&lt;const unique_ptr&lt;T2, D2&gt;::pointer&amp;&gt;())</ins>;
</pre>

After p. 6
<pre>
template &lt;class T1, class D1, class T2, class D2&gt;
  bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y)<ins>
    noexcept(declval&lt;const unique_ptr&lt;T1, D1&gt;::pointer&amp;&gt;() &gt;= declval&lt;const unique_ptr&lt;T2, D2&gt;::pointer&amp;&gt;())</ins>;
</pre>

<h2>20.9.11.2 Class template shared_ptr</h2>

After p. 1
<pre>
namespace std {
  template&lt;class T&gt; class shared_ptr {
  public:
...
    // 20.9.11.2.3, assignment:
    shared_ptr&amp; operator=(const shared_ptr&amp; r)<ins> noexcept</ins>;
    template&lt;class Y&gt; shared_ptr&amp; operator=(const shared_ptr&lt;Y&gt;&amp; r)<ins> noexcept</ins>;
    shared_ptr& operator=(shared_ptr&amp;&amp; r)<ins> noexcept</ins>;
    template&lt;class Y&gt; shared_ptr&amp; operator=(shared_ptr&lt;Y>&amp;&amp; r)<ins> noexcept</ins>;
...
    void reset()<ins> noexcept</ins>;
...
  };
...
}
</pre>

<h2>20.9.11.2.3 shared_ptr assignment</h2>

Before p. 1
<pre>
shared_ptr&amp; operator=(const shared_ptr&amp; r)<ins> noexcept</ins>;
template&lt;class Y&gt; shared_ptr&amp; operator=(const shared_ptr&lt;Y&gt;&amp; r)<ins> noexcept</ins>;
template&lt;class Y&gt; shared_ptr&amp; operator=(auto_ptr&lt;Y&gt;&amp;&amp; r);
</pre>

After p. 3
<pre>
shared_ptr&amp; operator=(shared_ptr&amp;&amp; r)<ins> noexcept</ins>;
template&lt;class Y&gt; shared_ptr&amp; operator=(shared_ptr&lt;Y&gt;&amp;&amp; r)<ins> noexcept</ins>;
</pre>

<h2>20.9.11.2.4 shared_ptr modifiers</h2>

After p. 2
<pre>void reset()<ins> noexcept</ins>;</pre>

<h2>20.9.11.3 Class template weak_ptr</h2>

After p. 1
<pre>
namespace std {
  template&lt;class T&gt; class weak_ptr {
  public:
...
    void reset()<ins> noexcept</ins>;
...
  };
}
</pre>

<h2>20.9.11.3.4 weak_ptr modifiers</h2>

After p. 2
<pre>void reset()<ins> noexcept</ins>;</pre>

<h2>20.9.11.5 shared_ptr atomic access</h2>

After p. 5
<pre>
template&lt;class T&gt;
  shared_ptr&lt;T&gt; atomic_load(const shared_ptr&lt;T&gt;* p)<ins> noexcept</ins>;
</pre>

After p. 11
<pre>
template&lt;class T&gt;
  void atomic_store(shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt; r)<ins> noexcept</ins>;
</pre>

After p. 17
<pre>
template&lt;class T&gt;
shared_ptr&lt;T&gt; atomic_exchange(shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt; r)<ins> noexcept</ins>;
</pre>

After p. 23
<pre>
template&lt;class T&gt;
  bool atomic_compare_exchange_weak(
    shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt;* v, shared_ptr&lt;T&gt; w)<ins> noexcept</ins>;
</pre>

After p. 25
<pre>
template&lt;class T&gt;
  bool atomic_compare_exchange_strong(
    shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt;* v, shared_ptr&lt;T&gt; w)<ins> noexcept</ins>;
</pre>

<h2>20.9.13 Align</h2>

Before p. 1
<pre>
void *align(std::size_t alignment, std::size_t size,
  void *&amp;ptr, std::size_t&amp; space)<ins> noexcept</ins>;
</pre>

<h2>20.10 Class scoped_allocator</h2>

Modify p. 1
<pre>
// scoped allocator adaptor
template &lt;class OuterAlloc, class... InnerAlloc&gt;
  class scoped_allocator_adaptor;
template &lt;class OuterA1, class OuterA2, class... InnerAllocs&gt;
  bool operator==(const scoped_allocator_adaptor&lt;OuterA1, InnerAllocs...&gt;&amp; a,<del>)</del>
		  const scoped_allocator_adaptor&lt;OuterA2, InnerAllocs...&gt;&amp; b)<ins> noexcept</ins>;
template &lt;class OuterA1, class OuterA2, class... InnerAllocs&gt;
  bool operator!=(const scoped_allocator_adaptor&lt;OuterA1, InnerAllocs...&gt;&amp; a,<del>)</del>
		  const scoped_allocator_adaptor&lt;OuterA2, InnerAllocs...&gt;&amp; b)<ins> noexcept</ins>;
</pre>

After p. 2
<pre>
namespace std {
  template &lt;class OuterAlloc, class... InnerAllocs&gt;
    class scoped_allocator_adaptor : public OuterAlloc {
...
    scoped_allocator_adaptor()<ins> noexcept</ins>;
    template &lt;class OuterA2&gt;<del>}</del>
      scoped_allocator_adaptor(OuterA2&amp;&amp; outerAlloc,
                               const InnerAllocs&amp;... innerAllocs)<ins> noexcept;</ins>
    scoped_allocator_adaptor(const scoped_allocator_adaptor&amp; other)<ins> noexcept</ins>;
    template &lt;class OuterA2&gt;
      scoped_allocator_adaptor(const scoped_allocator_adaptor&lt;OuterA2, InnerAllocs...&gt;&amp; other)<ins> noexcept</ins>;
    template &lt;class OuterA2&gt;
      scoped_allocator_adaptor(const scoped_allocator_adaptor&lt;OuterA2, InnerAllocs...&gt;&amp;&amp; other)<ins> noexcept</ins>;
...
    inner_allocator_type&amp; inner_allocator()<ins> noexcept</ins>;
    const inner_allocator_type&amp; inner_allocator() const<ins> noexcept</ins>;
    outer_allocator_type&amp; outer_allocator()<ins> noexcept</ins>;
    const outer_allocator_type&amp; outer_allocator() const<ins> noexcept</ins>;
...
    void deallocate(pointer p, size_type n)<ins> noexcept</ins>;
...
    template &lt;class T, class... Args&gt;
      void construct(T* p, Args&amp;&amp; args)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class T1, class T2, class... Args1, class... Args2&gt;
      void construct(pair&lt;T1, T2&gt;* p, piecewise_construct t,
                     tuple&lt;Args1...&gt; x, tuple&lt;Args2...&gt; y)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class T1, class T2&gt;
      void construct(pair&lt;T1, T2&gt;* p)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class T1, class T2, class U, class V&gt;
      void construct(pair&lt;T1, T2&gt;* p, U&amp;&amp; x, V&amp;&amp; y)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class T1, class T2, class U, class V&gt;
      void construct(pair&lt;T1, T2&gt;* p, const pair&lt;U, V&gt;&amp; x)<ins> noexcept(<em>see below</em>)</ins>;
    template &lt;class T1, class T2, class U, class V&gt;
      void construct(pair&lt;T1, T2&gt;* p, pair&lt;U, V&gt;&amp;&amp; x)<ins> noexcept(<em>see below</em>)</ins>;

    template &lt;class T&gt;
      void destroy(T* p)<ins> noexcept(noexcept(p-&gt;~T()))</ins>;

  };
template &lt;class OuterA1, class OuterA2, class... InnerAllocs&gt;
  bool operator==(const scoped_allocator_adaptor&lt;OuterA1, InnerAllocs...&gt;&amp; a,
                  const scoped_allocator_adaptor&lt;OuterA2, InnerAllocs...&gt;&amp; b)<ins> noexcept</ins>;
template &lt;class OuterA1, class OuterA2, class... InnerAllocs&gt;
  bool operator!=(const scoped_allocator_adaptor&lt;OuterA1, InnerAllocs...&gt;&amp; a,
                  const scoped_allocator_adaptor&lt;OuterA2, InnerAllocs...&gt;&amp; b)<ins> noexcept</ins>;
}
</pre>

<h2>20.10.2 Scoped allocator adaptor constructors</h2>

Before p. 1
<pre>scoped_allocator_adaptor()<ins> noexcept;</pre>

After p. 1
<pre>
template &lt;class OuterA2&gt;
  scoped_allocator_adaptor(OuterA2&amp;&amp; outerAlloc,
                           const InnerAllocs&amp;... innerAllocs)<ins> noexcept<Ins>;
</pre>

After p. 3
<pre>scoped_allocator_adaptor(const scoped_allocator_adaptor&amp; other)<ins> noexcept</ins>;</pre>

After p. 4
<pre>
template &lt;class OuterA2&gt;
  scoped_allocator_adaptor(const scoped_allocator_adaptor&lt;OuterA2,
			   InnerAllocs...&gt;&amp; other)<ins> noexcept</ins>;
</pre>

After p. 6
<pre>
template &lt;class OuterA2&gt;
  scoped_allocator_adaptor(const scoped_allocator_adaptor&lt;OuterA2,
			   InnerAllocs...&gt;&amp;&amp; other)<ins> noexcept</ins>;
</pre>

<h2>20.10.3 Scoped allocator adaptor members</h2>

After p. 1
<pre>
inner_allocator_type&amp; inner_allocator()<ins> noexcept</ins>;
const inner_allocator_type&amp; inner_allocator() const<ins> noexcept</ins>;
</pre>

After p. 2
<pre>
outer_allocator_type&amp; outer_allocator()<ins> noexcept</ins>;
</pre>

After p. 3
<pre>
const outer_allocator_type&amp; outer_allocator() const<ins> noexcept</ins>;
</pre>

After p. 6
<pre>void deallocate(pointer p, size_type n)<ins> noexcept</ins>;</pre>

After p. 8
<pre>
template &lt;class T, class... Args&gt;
  void construct(T* p, Args&amp;&amp;... args)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to one of the following:</ins></p>
<ul>
  <li><ins>If <tt>uses_allocator&lt;T, inner_allocator_type&gt;::value</tt> is <tt>false</tt> and 
  <tt>is_constructible&lt;T,Args...>::value</tt> is <tt>true</tt>,</ins></li>
</ul>
<pre>
        <ins>is_nothrow_constructible&lt;T,Args&amp;&amp;...&gt;:value</ins>
</pre>
<ul>
  <li><ins>Otherwise, if <tt>uses_allocator&lt;T, inner_allocator_type&gt;::value</tt> is <tt>true</tt> and 
  <tt>is_constructible&lt;T,allocator_arg_t, inner_allocator_type, Args...&gt;::value</tt> is <tt>true</tt>,</ins></li>
</ul>
<pre>
        <ins>is_nothrow_constructible&lt;T,allocator_arg_t, inner_allocator_type, Args&amp;&amp;...&gt;:value</ins>
</pre>
<ul>
  <li><ins>Otherwise, if <tt>uses_allocator&lt;T, inner_allocator_type&gt;::value</tt> is <tt>true</tt> and 
  <tt>is_constructible&lt;T,Args..., inner_allocator_type&gt;::value</tt>is <tt>true</tt>,</ins></li>
</ul>
<pre>
        <ins>is_nothrow_constructible&lt;T, Args&amp;&amp;..., inner_allocator_type&gt;:value</ins>
</pre>

After p. 9
<pre>
template &lt;class T1, class T2, class... Args1, class... Args2&gt;
  void construct(pair<T1, T2>* p,piecewise_construct_t,
		 tuple<Args1...> x, tuple<Args2...> y)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to one of the following:</ins></p>
<ul>
  <li><ins>If <tt>uses_allocator&lt;T1, inner_allocator_type&gt;::value</tt> is <tt>false</tt> and 
  <tt>is_constructible&lt;T1,Args1...&gt;::value</tt> is true</tt></ins></li>
</ul>
<pre>
        <ins>is_nothrow_constructible&lt;T1, Args1...&gt;:value</ins>
</pre>
<ul>
  <li><ins>Otherwise, if <tt>uses_allocator&lt;T1, inner_allocator_type&gt;::value</tt> is <tt>true</tt> and 
  <tt>is_constructible&lt;T1,allocator_arg_t, inner_allocator_type, Args1...&gt;::value</tt> is <tt>true</tt></ins></li>
</ul>
<pre>
        <ins>is_nothrow_constructible&lt;T1, allocator_arg_t, inner_allocator_type, Args1...&gt;:value &amp;&amp;</ins>
        <ins>noexcept(tuple_cat(tuple&lt;allocator_arg_t, inner_allocator_type&amp;&gt;(allocator_arg, inner_allocator_type()), x)</ins>
</pre>
<ul>
  <li><ins>Otherwise, if <tt>uses_allocator&lt;T1, inner_allocator_type&gt;::value</tt> is <tt>true</tt> and 
  <tt>is_constructible&lt;T1, Args1..., inner_allocator_type&gt;::value</tt> is <tt>true</tt></ins></li>
</ul>
<pre>
        <ins>is_nothrow_constructible&lt;T1, Args1..., inner_allocator_type&gt;:value &amp;&amp;</ins>
        <ins>noexcept(tuple_cat(x, tuple&lt;inner_allocator_type&amp;&gt;(inner_allocator_type()))</ins>
</pre>
<p><ins>and one of the following:</ins></p>
<ul>
  <li><ins>If <tt>uses_allocator&lt;T2, inner_allocator_type&gt;::value</tt> is <tt>false</tt> and 
  <tt>is_constructible&lt;T1,Args2...&gt;::value</tt> is true</tt></ins></li>
</ul>
<pre>
        <ins>is_nothrow_constructible&lt;T2, Args2...&gt;:value</ins>
</pre>
<ul>
  <li><ins>Otherwise, if <tt>uses_allocator&lt;T2, inner_allocator_type&gt;::value</tt> is <tt>true</tt> and 
  <tt>is_constructible&lt;T2,allocator_arg_t, inner_allocator_type, Args2...&gt;::value</tt> is <tt>true</tt></ins></li>
</ul>
<pre>
        <ins>is_nothrow_constructible&lt;T2, allocator_arg_t, inner_allocator_type, Args2...&gt;:value &amp;&amp;</ins>
        <ins>noexcept(tuple_cat(tuple&lt;allocator_arg_t, inner_allocator_type&amp;&gt;(allocator_arg, inner_allocator_type()), y)</ins>
</pre>
<ul>
  <li><ins>Otherwise, if <tt>uses_allocator&lt;T2, inner_allocator_type&gt;::value</tt> is <tt>true</tt> and 
  <tt>is_constructible&lt;T2, Args2..., inner_allocator_type&gt;::value</tt> is <tt>true</tt></ins></li>
</ul>
<pre>
        <ins>is_nothrow_constructible&lt;T2, Args2..., inner_allocator_type&gt;:value &amp;&amp;</ins>
        <ins>noexcept(tuple_cat(y, tuple&lt;inner_allocator_type&amp;&gt;(inner_allocator_type()))</ins>
</pre>


After p. 11
<pre>
template &lt;class T1, class T2&gt;
  void construct(pair&lt;T1, T2&gt;* p)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T1&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;T2&gt;::value</ins>
</pre>

After p. 12
<pre>
template &lt;class T1, class T2, class U, class V&gt;
  void construct(pair&lt;T1, T2&gt;* p, U&amp;&amp; x, V&amp;&amp; y)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T1, U&amp;&amp;&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;T2, V&amp;&amp;&gt;::value</ins>
</pre>

After p. 13
<pre>
template &lt;class T1, class T2, class U, class V&gt;
  void construct(pair&lt;T1, T2&gt;* p, const pair&lt;U, V&gt;&amp; x)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T1, const U&amp;&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;T2, const V&amp;&gt;::value</ins>
</pre>

After p. 14
<pre>
template &lt;class T1, class T2, class U, class V&gt;
  void construct(pair&lt;T1, T2&gt;* p, pair&lt;U, V&gt;&amp;&amp; x)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;T1, U&amp;&amp;&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;T2, V&amp;&amp;&gt;::value</ins>
</pre>

After p. 15
<pre>
template &lt;class T&gt;
  void destroy(T* p)<ins> noexcept(noexcept(p-&gt;~T()))</ins>;
</pre>

<h2>20.11.2.2 duration_values</h2>

Before p. 1
<pre>
template &lt;class Rep&gt;
struct duration_values {
public:
  static constexpr Rep zero()<ins> noexcept(<em>seee below</em>)</ins>;;
  static constexpr Rep min()<ins> noexcept(<em>seee below</em>)</ins>;;
  static constexpr Rep max()<ins> noexcept(<em>seee below</em>)</ins>;;
};
</pre>

After p. 1
<pre>static constexpr Rep zero()<ins> noexcept(<em>seee below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(Rep(0)) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;Rep, const Rep&amp;&gt;::value</ins>
</pre>

After p. 3
<pre>static constexpr Rep min()<ins> noexcept(<em>seee below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(numeric_limits&lt;Rep&gt;::lowest()) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;Rep, const Rep&amp;&gt;::value</ins>
</pre>

After p. 5
<pre>static constexpr Rep max()<ins> noexcept(<em>seee below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(numeric_limits&lt;Rep&gt;::max()) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;Rep, const Rep&amp;&gt;::value</ins>
</pre>

<h2>20.11.3.1 duration constructors</h2>

Before p. 1
<pre>
template &lt;class Rep2&gt;
  constexpr explicit duration(const Rep2&amp; r)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;Rep, const Rep2&amp;&gt;::value</ins>
</pre>

After p. 3
<pre>
template &lt;class Rep2, class Period2&gt;
  constexpr duration(const duration&lt;Rep2, Period2&gt;&amp; d) <ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;Rep, const Rep2&amp;&gt;::value &amp;&amp;</ins>
  <ins>noexcept(duration_cast&lt;duration&gt;(d))</ins>
</pre>

<h2>20.11.3.2 duration observer</h2>

Before p. 1
<pre>constexpr rep count() const<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;Rep, const Rep&amp;&gt;::value</ins>
</pre>

<h2>20.11.3.3 duration arithmetic</h2>

Before p. 1
<pre>constexpr duration operator+() const<ins> noexcept</ins>;</pre>

After p. 1
<pre>
constexpr duration operator-() const<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(-rep_) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;Rep, const Rep&amp;&gt;::value</ins>
</pre>

After p. 2
<pre>duration& operator++()<ins> noexcept(noexcept(++rep_))</ins>;</pre>

After p. 4
<pre>duration operator++(int)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(rep_++) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;Rep, const Rep&amp;&gt;::value</ins>
</pre>

After p. 5
<pre>
duration& operator--()<ins> noexcept(noexcept(--rep_))</ins>;
</pre>

After p. 7
<pre>
duration operator--(int)<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(rep_--) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;Rep, const Rep&amp;&gt;::value</ins>
</pre>

After p. 8
<pre>duration&amp; operator+=(const duration&amp; d)<ins>noexcept(noexcept(rep_+=d.count()))</ins>;</pre>

After p. 10
<pre>duration&amp; operator-=(const duration&amp; d)<ins>noexcept(noexcept(rep_-=d.count()))</ins>;</pre>

After p. 12
<pre>duration&amp; operator*=(const rep&amp; rhs)<ins>noexcept(noexcept(rep_*=rhs))</ins>;</pre>

After p. 14
<pre>duration&amp; operator/=(const rep&amp; rhs)<ins>noexcept(noexcept(rep_/=rhs))</ins>;</pre>

After p. 16
<pre>duration&amp; operator%=(const rep&amp; rhs)<ins>noexcept(noexcept(rep_%=rhs))</ins>;</pre>

After p. 18
<pre>duration&amp; operator%=(const duration&amp; d)<ins>noexcept(noexcept(rep_%=d.count()))</ins>;</pre>

<h2>20.11.3.4 duration special values</h2>

Before p. 1
<pre>
static constexpr duration zero()<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(duration_values&lt;rep&gt;::zero()) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;duration, const Rep&amp;&gt;::value</ins>
</pre>

After p. 1
<pre>
static constexpr duration min()<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(duration_values&lt;rep&gt;::min()) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;duration, const Rep&amp;&gt;::value</ins>
</pre>

After p. 2
<pre>
static constexpr duration max()<ins> noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(duration_values&lt;rep&gt;::max()) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;duration, const Rep&amp;&gt;::value</ins>
</pre>

<h2>20.11.3.5 duration non-member arithmetic</h2>

After p. 1
<pre>
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
  typename common_type&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt;<del>{</del>&gt;<del>}</del>::type
  operator+(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs)<ins>
    noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;CD,decltype(lhs)&gt;::value &amp;&amp;</ins>
  <ins>noexcept(declval&lt;CD&amp;&gt;()+=rhs) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;CD,const CD&amp;&gt;::value</ins>
</pre>

<pre>
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
  typename common_type&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt;<del>{</del>&gt;<del>}</del>::type
  operator-(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs)<ins>
    noexcept(<em>see below</em>)</ins>;
</pre>

<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;CD,lhs&gt;::value &amp;&amp;</ins>
  <ins>noexcept(declval&lt;CD&amp;&gt;()-=rhs) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;CD,const CD&amp;&gt;::value</ins>
</pre>

<pre>
template &lt;class Rep1, class Period, class Rep2&gt;
  duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
  operator*(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s)<ins>
    noexcept(<em>see below</em>)</ins>;
</pre>

<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;CD,d&gt;::value &amp;&amp;</ins>
  <ins>noexcept(declval&lt;CD&amp;&gt;() *= s) &amp;&amp;</ins>
  <ins>std::ins_nothrow_constructible&lt;CD,const CD&amp;&gt;::value</ins>
</pre>

<pre>
template &lt;class Rep1, class Period, class Rep2&gt;
  duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
  operator*(const Rep1&amp; s, const duration&lt;Rep2, Period&gt;&amp; d)<ins>
    noexcept(<em>see below</em>)</ins>;
</pre>
  
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>std:is_nothrow_constructible&lt;Rep1,CR(Rep1,Rep2);&gt;::value &amp;&amp;</ins>
  <ins>noexcept(d * s) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;CD,CR(Rep1,Rep2),Period&gt;::value</ins>
</pre>

<pre>
template &lt;class Rep1, class Period, class Rep2&gt;
  duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
  operator/(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s)<ins>
    noexcept(<em>see below</em>);</ins>
</pre>

<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>std:is_nothrow_constructible&lt;CD,decltype(d)&gt;::value &amp;&amp;</ins>
  <ins>noexcept(declval&lt;CD&amp;&gt;() /= s) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;CD,const CD&amp;&gt;::value</ins>
</pre>

<pre>
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
  typename common_type&lt;Rep1, Rep2&gt;::type
  operator/(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs)<ins>
    noexcept(<em>see below</em>)</ins>;
</pre>

<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(declval&lt;CD&gt;()/declval&lt;CD&gt;()) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;CD,const CD&amp;&gt;::value</ins>
</pre>

<pre>
template &lt;class Rep1, class Period, class Rep2&gt;
  duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
  operator%(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s)<ins>
    noexcept(<em>see below</em>)</ins>;
</pre>

<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;CD,decltype(d);&gt;::value &amp;&amp;</ins>
  <ins>noexcept(declval&lt;CD&amp;&gt;() %= s) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;CD,const CD&amp;&gt;::value</ins>
</pre>

<pre>
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
  typename common_type&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt;&gt;::type
  operator%(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs)<ins>
    noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;CD,decltype(lhs)&gt;::value &amp;&amp;</ins>
  <ins>noexcept(declval&lt;CD&amp;&gt;() %= rhs) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;CD,const CD&amp;&gt;::value</ins>
</pre>

<h2>20.11.3.6 duration comparisons</h2>

After p. 1

<pre>
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
  bool operator==(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs)<ins>
    noexcept(<em>see below</em>)</ins>;
</pre>

<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;CT,decltype(lhs)&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;CT, decltype(rhs)&gt;::value &amp;&amp;</ins>
  <ins>noexcept(declval&lt;const CT&amp;&gt;().count()) &amp;&amp;</ins>
  <ins>noexcept(declval&lt;const CT::Rep&amp;&gt;() == declval&lt;const CT::Rep&amp;&gt;())</ins>
</pre>

<pre>
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
  bool operator!=(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs)<ins>
    noexcept(noexcept(lhs==rhs))</ins>;
</pre>

<pre>
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
  bool operator&lt;(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs)<ins>
    noexcept(<em>see below</em>)</ins>;
</pre>

<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;CT,decltype(lhs)&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;CT, decltype(rhs)&gt;::value &amp;&amp;</ins>
  <ins>noexcept(declval&lt;const CT&amp;&gt;().count()) &amp;&amp;</ins>
  <ins>noexcept(declval&lt;const CT::Rep&amp;&gt;() &lt; declval&lt;const CT::Rep&amp;&gt;())</ins>
</pre>

<pre>
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
  bool operator&lt;=(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs)<ins>
    noexcept(noexcept(rhs &lt; lhs))</ins>;
</pre>

<pre>
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
  bool operator&gt;(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs)<ins>
    noexcept(noexcept(rhs &lt; lhs))</ins>;
</pre>

<pre>
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
  bool operator&gt;=(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs)<ins>
    noexcept(noexcept(lhs &lt; rhs))</ins>;
</pre>

<h2>20.11.3.7 duration_cast</h2>

Before p. 1
<pre>
template &lt;class ToDuration, class Rep, class Period&gt;
  ToDuration duration_cast(const duration&lt;Rep, Period&gt;&amp; d)<ins>
    noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<ul>
	<li><ins>The expression <tt>d.count()</tt> may throw exceptions.</ins></li>
	<li><ins>The construction of a <tt>ToDuration::rep</tt> from a <tt>Rep</tt> value may throw exceptions.</li>
	<li><ins>The construction of a <tt>ToDuration</tt> value from a <tt>ToDuration::rep</tt> may
		throw an exception</ins></li>
	<li><ins>The construction of a <tt>CR</tt> value from a <tt>Period</tt> may throw exception.</ins></li>
	<li><ins>The evalutation of an expression <tt>r * p</tt> (where <tt>r</tt> is of type <tt>rep</tt> and p is of
		type <tt>Period</tt> may throw exceptions.</ins></li>
	<li><ins>The construction of a <tt>ToDuration::rep</tt> value from a <tt>CR</tt> may throw exceptions.</ins></li>
	<li><ins>The construction of a <tt>CR</tt> value from a <tt>ToDuration::period</tt> may throw exceptions.</ins></li>
	<li><ins>The evalutation of an expression <tt>r * p1 / p2 </tt> (where <tt>r</tt> is of type <tt>rep</tt>, p1 is of
		type <tt>Period</tt> and <tt>p2</tt> is of type <tt>ToDuration::period</tt> may throw exceptions.</ins></li>
</ul></ins>

<h2>20.11.4.1 time_point constructors</h2>

Before p. 1
<pre>
time_point()<ins>
  noexcept(noexcep(duration::zero()) &amp;&amp; 
           noexcept(is_nothrow_constructible&lt;duration, duration&amp;&amp;&gt;::value))</ins>;
</pre>

After p. 1
<pre>
time_point(const duration&amp; d)<ins>
  noexcept(is_nothrow_constructible&lt;duration, duration&amp;&amp;&gt;::value))</ins>;
</pre>

After p. 2
<pre>
template &lt;class Duration2&gt;
  time_point(const time_point&lt;clock, Duration2&gt;&amp; t)<ins>
    noexcept(noexcept(t.time_since_epoch()))</ins>;
</pre>

<h2>20.11.4.2 time_point observer</h2>

Before p. 1
<pre>
duration time_since_epoch() const<ins>
  noexcept(<em>see below</em>)</ins>;
</pre>

<p><ins>1 <em>Remarks:</em> <tt>true</tt> unless any of the following expression is met:</ins></p>
<ul>
	<li><ins>The construction of a <tt>duration</tt> from another <tt>duration</tt> may throw.</ins></li>
</ul>

<h2>20.11.4.3 time_point arithmetic</h2>

Before p. 1
<pre>time_point&amp; operator+=(const duration&amp; d)<ins> noexcept(noexcept(d_ += d))</ins>;</pre>

After p. 2
<pre>time_point&amp; operator-=(const duration&amp; d)<ins> noexcept(noexcept(d_ -= d))</ins>;</pre>

<h2>20.11.4.4 time_point special values</h2>

Before p. 1
<pre>static constexpr time_point min()<ins> noexcept(<em>see below</em>)</ins>;</pre>

<p><ins>1 <em>Remarks:</em> <tt>true</tt> unless any of the following expression is met:</ins></p>
<ul>
	<li><ins>The expression <tt>duration::min()</tt> may throw exceptions.</ins></li>
	<li><ins>The construction of a <tt>time_point</tt> from a <tt>duration</tt> may throw exceptions.</ins></li>
</ul>

Before p. 2
<pre>static constexpr time_point max()<ins> noexcept(<em>see below</em>)</ins>;</pre>
<p><ins>2 <em>Remarks:</em> <tt>true</tt> unless any of the following expression is met:</ins></p>
<ul>
	<li><ins>The expression <tt>duration::max()</tt> may throw exceptions.</ins></li>
	<li><ins>The construction of a <tt>time_point</tt> from a <tt>duration</tt> may throw exceptions.</ins></li>
</ul>

<h2>20.11.4.5 time_point non-member arithmetic</h2>

<pre>
template &lt;class Clock, class Duration1, class Rep2, class Period2&gt;
  time_point&lt;Clock, typename common_type&lt;Duration1, duration&lt;Rep2, Period2&gt;&gt;::type&gt;
  operator+(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs)<ins>
    noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>is_nothrow_constructible&lt;CT,decltype(lhs)&gt;::value &amp;&amp;</ins>
  <ins>noexcept(declval&lt;const CT&amp;&gt;() += rhs) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;CT,CT&amp;&amp;&gt;::value</ins>
</pre>
<p><ins>where CT is the type fo the return value.</ins></p>

<pre>
template &lt;class Rep1, class Period1, class Clock, class Duration2&gt;
  time_point&lt;Clock, typename common_type&lt;duration&lt;Rep1, Period1&gt;, Duration2&gt;::type&gt;
  operator+(const duration&lt;Rep1, Period1&gt;&amp; lhs, const time_point&lt;Clock, Duration2&gt;&amp; rhs)<ins>
    noexcept(<em>see below</em>)<Ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(rhs + lhs) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;CT,CT&amp;&amp;&gt;::value</ins>
</pre>
<p><ins>where CT is the type fo the return value.</ins></p>

<pre>
template &lt;class Clock, class Duration1, class Rep2, class Period2&gt;
  time_point&lt;Clock, typename common_type&lt;Duration1, duration&lt;Rep2, Period2&gt;&gt;::type&gt;
  operator-(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs)<ins>
    noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(-rhs) &amp;&amp;</ins>
  <ins>noexcept(lhs + rhs) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;CT,CT&amp;&amp;&gt;::value</ins>
</pre>
<p><ins>where CT is the type fo the return value.</ins></p>

<pre>
template &lt;class Clock, class Duration1, class Duration2&gt;
  typename common_type&lt;Duration1, Duration2&gt;::type
  operator-(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const time_point&lt;Clock, Duration2&gt;&amp; rhs)<ins>
    noexcept(<em>see below</em>)</ins>;
</pre>
<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(lhs.time_since_epoch()) &amp;&amp;</ins>
  <ins>noexcept(rhs.time_since_epoch()) &amp;&amp;</ins>
  <ins>noexcept(declval&lt;const Duration1&amp;&gt;() - declval&lt;const Duration2&amp;&gt;()) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;CT,CT&amp;&amp;&gt;::value</ins>
</pre>
<p><ins>where CT is the type fo the return value.</ins></p>

<h2>20.11.4.6 time_point comparisons</h2>

Before p. 1
<pre>
template &lt;class Clock, class Duration1, class Duration2&gt;
  bool operator==(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const time_point&lt;Clock, Duration2&gt;&amp; rhs)<ins>
    noexcept(noexcept(lhs.time_since_epoch()) &amp;&amp;
             noexcept(rhs.time_since_epoch()) &amp;&amp;
             noexcept(declval&lt;const Duration1&amp;&gt;() == declval&lt;const Duration2&amp;&gt;())</ins>;
</pre>

After p. 1
<pre>
template &lt;class Clock, class Duration1, class Duration2&gt;
  bool operator!=(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const time_point&lt;Clock, Duration2&gt;&amp; rhs)<ins>
    noexcept(noexcept(lhs == rhs))</ins>;
</pre>

After p. 2
<pre>
template &lt;class Clock, class Duration1, class Duration2&gt;
  bool operator&lt;(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const time_point&lt;Clock, Duration2&gt;&amp; rhs)<ins>
    noexcept(noexcept(lhs.time_since_epoch()) &amp;&amp;
             noexcept(rhs.time_since_epoch()) &amp;&amp;
             noexcept(declval&lt;const Duration1&amp;&gt;() &lt; declval&lt;const Duration2&amp;&gt;())</ins>;
</pre>

After p. 3
<pre>
template &lt;class Clock, class Duration1, class Duration2&gt;
  bool operator&lt;=(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const time_point&lt;Clock, Duration2&gt;&amp; rhs)<ins>
    noexcept(noexcept(rhs &lt; lhs))</ins>;
</pre>

After p. 4

<pre>
template &lt;class Clock, class Duration1, class Duration2&gt;
  bool operator&gt;(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const time_point&lt;Clock, Duration2&gt;&amp; rhs)<ins>
    noexcept(noexcept(rhs &lt; lhs))</ins>;
</pre>

After p. 5
<pre>
template &lt;class Clock, class Duration1, class Duration2&gt;
  bool operator&gt;=(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const time_point&lt;Clock, Duration2&gt;&amp; rhs)<ins>
    noexcept(noexcept(lhs &lt; rhs))</ins>;
</pre>

<h2>20.11.4.7 time_point_cast</h2>

Before p. 1
<pre>
template &lt;class ToDuration, class Clock, class Duration&gt;
  time_point&lt;Clock, ToDuration&gt; time_point_cast(const time_point&lt;Clock, Duration&gt;&amp; t)<ins>
    noexcept(<em>see below</em>);
</pre>

<p><ins><em>Remarks</em>: The expression inside <tt>noexcept</tt> is equivalent to:</ins></p>
<pre>
  <ins>noexcept(t.time_since_epoch()) &amp;&amp;</ins>
  <ins>noexcept(duration_cast&lt;ToDuration&gt;(declval&lt;const Duration&amp;&gt;())) &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;time_point&lt;Clock,ToDuration&gt;,ToDuration&gt;::value &amp;&amp;</ins>
  <ins>is_nothrow_constructible&lt;time_point&lt;Clock,ToDuration&gt;,time_point&lt;Clock,ToDuration&gt;&amp;&amp;&gt;::value</ins>
</pre>

<h2>20.13.3 type_index members</h2>

Before p. 1
<pre>type_index(const type_info&amp; rhs)<ins> noexcept</ins>;</pre>

After p. 1
<pre>bool operator==(const type_index&amp; rhs) const<ins> noexcept</ins>;</pre>

After p. 2
<pre>bool operator!=(const type_index&amp; rhs) const<ins> noexcept</ins>;</pre>

After p. 3
<pre>bool operator&lt;(const type_index&amp; rhs) const<ins> noexcept</ins>;</pre>

After p. 4
<pre>bool operator&lt;=(const type_index&amp; rhs) const<ins> noexcept</ins>;</pre>

After p. 5
<pre>bool operator&gt;(const type_index&amp; rhs) const<ins> noexcept</ins>;</pre>

After p. 6
<pre>bool operator&gt;=(const type_index&amp; rhs) const<ins> noexcept</ins>;</pre>




</body>
</html>
