<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <meta http-equiv="Content-Type" content="text/html;charset=UTF8"/>

  <meta name="description" content="Proposal for C++ TS"/>
  <meta name="keywords" content="C++,cplusplus,wg21"/>
  <meta name="author" content="Alisdair Meredith"/>

  <base href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4600.html"/>

  <title>Rebase Library Fundamentals TS on C++17</title>

  <style type="text/css">
    ins {background-color:#A0FFA0}
    del {background-color:#FFA0A0}
    p {text-align:justify}
    li {text-align:justify}
    blockquote.note
    {
      background-color:#E0E0E0;
      padding-left: 15px;
      padding-right: 15px;
      padding-top: 1px;
      padding-bottom: 1px;
    }
    blockquote.recommend
    {
      background-color:#ffffb0;
      padding-left: 10px;
      padding-right: 10px;
      padding-top: 1px;
      padding-bottom: 1px;
    }
    blockquote.review
    {
      background-color:#b0ffb0;
      padding-left: 10px;
      padding-right: 10px;
      padding-top: 1px;
      padding-bottom: 1px;
    }
    blockquote.review_note
    {
      background-color:#ffffcc;
      padding-left: 15px;
      padding-right: 15px;
      padding-top: 1px;
      padding-bottom: 1px;
    }
    ul.mdash { list-style-type: '-' }

  </style>
</head>

<body>
<table>
<tr>
  <td align="left">Doc. no.:</td>
  <td align="left">P0996R1</td>
</tr>
<tr>
  <td align="left">Date:</td>
  <td align="left">2018-03-16</td>
</tr>
<tr>
  <td align="left">Project:</td>
  <td align="left">Programming Language C++</td>
</tr>
<tr>
  <td align="left">Audience:</td>
  <td align="left">Library Evolution Working Group</td>
</tr>
<tr>
  <td></td>
  <td align="left">Library Working Group</td>
</tr>
<tr>
  <td align="left">Reply to:</td>
  <td align="left">Alisdair Meredith &lt;<a href="mailto:ameredith1@bloomberg.net">ameredith1@bloomberg.net</a>&gt;</td>
</tr>
</table>

<h1>Rebase Library Fundamentals TS on C++17</h1>

<h2>Table of Contents</h2>
<ul>
<li>Revision History</li>
  <ul>
  <li>Revision 0</li>
  <li>Revision 1</li>
  </ul>
<li>1 Introduction</li>
<li>2 Stating the problem</li>
<li>3 Propose Solution</li>
<li>4 Other Directions</li>
<li>5 Formal Wording</li>
  <ul>
  <li>5.1 Strike out sections that landed in C++17</li>
  <li>5.2 Revise The Front Matter</li>
  <li>5.3 Global Search and Replace</li>
  <li>5.4 Fix Cross-references</li>
  </ul>
<li>6 Acknowledgements</li>
<li>7 References</li>
</ul>

<h2><a name="rev.hist">Revision History</a></h2>

<h3><a name="rev.0">Revision 0</a></h3>
<p>
Original version of the paper for the 2018 Jacksonville meeting.
</p>


<h3><a name="rev.0">Revision 1</a></h3>
<p>
Simplify the paper to a simple set of editorial suggestions.
</p>

<h2><a name="1.0">1 Introduction</a></h2>
<p>
The Lirary Fundamentals series of TSes are expected to produce new
revisions several times per standard cycle.  The current draft should
be updated to reflect that C++17 was published shortly after the
Albuqerque 2017 meeting.
</p>

<h2><a name="2.0">2 Stating the problem</a></h2>

<p>
The library Fundamentals TS is expected to serve as a long-running
sequence of TSes that provide experience on new library features
that may be added to future standards.  With the publication
of the latest C++ Standard in 2017, we should rebase the current TS on
that standard before adding new experimental components.  The first of
those components are expected to land soon.
</p>

<h2><a name="3.0">3 Propose Solution</a></h2>

<p>
This paper proposes the simplest imagined rebasing of the document.
It does not attempt to apply new C++17 language features to existing
components.  For example, it has not performed a review for class
template deduction guides.  It is expected such reviews will be much
simpler once the text for the landed components is excised.
</p>

<p>
Similarly, this paper makes no attempt to resolve awkward wording
updates where the underlying text of the referenced C++ standard has
changes substantially between C++14 and C++17.  In such cases, it
provides a simple issues list to track the necessary updates, which
should be provided by experts in the affected components.
</p>

<p>
First, we propose excising all components that have merged into the
main standard, and update any remaining internal cross-references to
point to the C++17 standard for their specification.
</p>

<p>
Then we update document references in clause 1, then update all numbered
cross-references into the new standard to use the updated standard ISO
clause numbering.
</p>

<p>
Finally, we give the project editor guidance on how to apply a few
simple patterns to change the remaining text to refer to the updated
experimental namespace.  Similarly, we leave it as an exercise for
the project editor to fix up cross-references from the C++14 standard
to the C++17 standard.
</p>

<h2><a name="4.0">4 Other Directions</a></h2>
<p>
A more detailed rebasing was attempted, but produced a much longer
document than the Library Working Group would have an easy time
reviewing during a meeting.  The majority of the extra text were
seen as minor changes performing obvious tasks such as fixing up
cross references, and applying consistent editing patterns such as
renaming the experimental namespace.  It was seen as more appropriate
to give editorial direction to the project editor to handle those
cases, than have a detailed line-by-line review in LWG session.
</p>


<h2><a name="5.0">5 Formal Wording</a></h2>

<h3><a name="5.1">5.1 Strike out sections that landed in C++17</a></h3>

<p>Completely excise from the document all the sections marked as
<del>deleted</del> in the index table below.
</p>

<blockquote>
<ul>
<li>1 <a href="#general">General</a></li>
  <ul>
  <li>1.1 <a href="#general.scope">Scope</a></li>
  <li>1.2 <a href="#general.references">Normative references</a></li>
  <li>1.3 <a href="#general.namespaces">Namespaces, headers, and modifications to standard classes</a></li>
  <li><del>1.4 <a href="#general.defns">Terms and definitions</a></del></li>
    <ul>
    <li><del>1.4.1 <a href="#general.defns.direct-non-list-init">direct-non-list-initialization</a></del></li>
    </ul>
  <li>1.5 <a href="#general.plans">Future plans (Informative)</a></li>
  <li>1.6 <a href="#general.feature.test">Feature-testing recommendations (Informative)</a></li>
  </ul>

<li>2 <a href="#mods">Modifications to the C++ Standard Library</a></li>
  <ul>
  <li>2.1 <a href="#mods.allocator.uses">Uses-allocator construction</a></li>
  </ul>

<li>3 <a href="#utilities">General utilities library</a></li>
  <ul>
  <li>3.1 <a href="#utility">Utility components</a></li>
    <ul>
    <li>3.1.1 <a href="#utility.synop">Header &lt;experimental/utility&gt; synopsis</a></li>
    <li>3.1.2 <a href="#utility.erased.type">Class erased_type</a></li>
    </ul>
  <li><del>3.2 <a href="#tuple">Tuples</a></del></li>
    <ul>
    <li><del>3.2.1 <a href="#header.tuple.synop">Header &lt;experimental/tuple&gt; synopsis</a></del></li>
    <li><del>3.2.2 <a href="#tuple.apply">Calling a function with a tuple of arguments</a></del></li>
    </ul>
  <li>3.3 <a href="#meta">Metaprogramming and type traits</a></li>
    <ul>
    <li>3.3.1 <a href="#meta.type.synop">Header &lt;experimental/type_traits&gt; synopsis</a></li>
    <li>3.3.2 <a href="#meta.trans.other">Other type transformations</a></li>
    <li><del>3.3.3 <a href="#meta.logical">Logical operator traits</a></del></li>
    <li>3.3.4 <a href="#meta.detect">Detection idiom</a></li>
    </ul>
  <li><del>3.4 <a href="#ratio">Compile-time rational arithmetic</a></del></li>
    <ul>
    <li><del>3.4.1 <a href="#header.ratio.synop">Header &lt;experimental/ratio&gt; synopsis</a></del></li>
    </ul>
  <li><del>3.5 <a href="#time">Time utilities</a></del></li>
    <ul>
    <li><del>3.5.1 <a href="#header.chrono.synop">Header &lt;experimental/chrono&gt; synopsis</a></del></li>
    </ul>
  <li><del>3.6 <a href="#syserror">System error support</a></del></li>
    <ul>
    <li><del>3.6.1 <a href="#header.system_error.synop">Header &lt;experimental/system_error&gt; synopsis</a></del></li>
    </ul>
  <li>3.7 <a href="#propagate_const">Class template propagate_const</a></li>
    <ul>
    <li>3.7.1 <a href="#propagate_const.general">Class template propagate_const general</a></li>
    <li>3.7.2 <a href="#propagate_const.synopsis">Header &lt;experimental/propagate_const&gt; synopsis</a></li>
    <li>3.7.3 <a href="#propagate_const.requirements">propagate_const requirements on T</a></li>
      <ul>
      <li>3.7.3.1 <a href="#propagate_const.class_type_requirements">propagate_const requirements on class type T</a></li>
      </ul>
    <li>3.7.4 <a href="#propagate_const.ctor">propagate_const constructors</a></li>
    <li>3.7.5 <a href="#propagate_const.assignment">propagate_const assignment</a></li>
    <li>3.7.6 <a href="#propagate_const.const_observers">propagate_const const observers</a></li>
    <li>3.7.7 <a href="#propagate_const.non_const_observers">propagate_const non-const observers</a></li>
    <li>3.7.8 <a href="#propagate_const.modifiers">propagate_const modifiers</a></li>
    <li>3.7.9 <a href="#propagate_const.relational">propagate_const relational operators</a></li>
    <li>3.7.10 <a href="#propagate_const.algorithms">propagate_const specialized algorithms</a></li>
    <li>3.7.11 <a href="#propagate_const.underlying">propagate_const underlying pointer access</a></li>
    <li>3.7.12 <a href="#propagate_const.hash">propagate_const hash support</a></li>
    <li>3.7.13 <a href="#propagate_const.comparison_function_objects">propagate_const comparison function objects</a></li>
    </ul>
  </ul>

<li>4 <a href="#func">Function objects</a></li>
  <ul>
  <li>4.1 <a href="#header.functional.synop">Header &lt;experimental/functional&gt; synopsis</a></li>
  <li>4.2 <a href="#func.wrap.func">Class template function</a></li>
    <ul>
    <li>4.2.1 <a href="#func.wrap.func.con">function construct/copy/destroy</a></li>
    <li>4.2.2 <a href="#func.wrap.func.mod">function modifiers</a></li>
    </ul>
  <li><del>4.3 <a href="#func.searchers">Searchers</a></del></li>
    <ul>
    <li><del>4.3.1 <a href="#func.searchers.default">Class template default_searcher</a></del></li>
      <ul>
      <li><del>4.3.1.1 <a href="#func.searchers.default.creation">default_searcher creation functions</a></del></li>
      </ul>
    <li><del>4.3.2 <a href="#func.searchers.boyer_moore">Class template boyer_moore_searcher</a></del></li>
      <ul>
      <li><del>4.3.2.1 <a href="#func.searchers.boyer_moore.creation">boyer_moore_searcher creation functions</a></del></li>
      </ul>
    <li><del>4.3.3 <a href="#func.searchers.boyer_moore_horspool">Class template boyer_moore_horspool_searcher</a></del></li>
      <ul>
      <li><del>4.3.3.1 <a href="#func.searchers.boyer_moore_horspool.creation">boyer_moore_horspool_searcher creation functions</a></del></li>
      </ul>
    </ul>
    <li><del>4.4 <a href="#func.not_fn">Function template not_fn</a></del></li>
  </ul>

<li><del>5 <a href="#optional">Optional objects</a></del></li>
  <ul>
  <li><del>5.1 <a href="#optional.general">In general</a> </li>
  <li><del>5.2 <a href="#optional.synop">Header &lt;experimental/optional&gt; synopsis</a></del></li>
  <li><del>5.3 <a href="#optional.object">optional for object types</a></del></li>
    <ul>
    <li><del>5.3.1 <a href="#optional.object.ctor">Constructors</a></del></li>
    <li><del>5.3.2 <a href="#optional.object.dtor">Destructor</a></del></li>
    <li><del>5.3.3 <a href="#optional.object.assign">Assignment</a></del></li>
    <li><del>5.3.4 <a href="#optional.object.swap">Swap</a></del></li>
    <li><del>5.3.5 <a href="#optional.object.observe">Observers</a></del></li>
    </ul>
  <li><del>5.4 <a href="#optional.inplace">In-place construction</a></del></li>
  <li><del>5.5 <a href="#optional.nullopt">No-value state indicator</a></del></li>
  <li><del>5.6 <a href="#optional.bad_optional_access">Class bad_optional_access</a></del></li>
  <li><del>5.7 <a href="#optional.relops">Relational operators</a></del></li>
  <li><del>5.8 <a href="#optional.nullops">Comparison with nullopt</a></del></li>
  <li><del>5.9 <a href="#optional.comp_with_t">Comparison with T</a></del></li>
  <li><del>5.10 <a href="#optional.specalg">Specialized algorithms</a></del></li>
  <li><del>5.11 <a href="#optional.hash">Hash support</a></del></li>
  </ul>

<li><del>6 <a href="#any">Class any</a></del></li>
  <ul>
  <li><del>6.1 <a href="#any.synop">Header &lt;experimental/any&gt; synopsis</a></del></li>
  <li><del>6.2 <a href="#any.bad_any_cast">Class bad_any_cast</a></del></li>
  <li><del>6.3 <a href="#any.class">Class any</a></del></li>
    <ul>
    <li><del>6.3.1 <a href="#any.cons">any construct/destruct</a></del></li>
    <li><del>6.3.2 <a href="#any.assign">any assignments</a></del></li>
    <li><del>6.3.3 <a href="#any.modifiers">any modifiers</a></del></li>
    <li><del>6.3.4 <a href="#any.observers">any observers</a></del></li>
    </ul>
  <li><del>6.4 <a href="#any.nonmembers">Non-member functions</a></del></li>
  </ul>

<li><del>7 <a href="#string.view">string_view</a></del></li>
  <ul>
  <li><del>7.1 <a href="#string.view.synop">Header &lt;experimental/string_view&gt; synopsis</a></del></li>
  <li><del>7.2 <a href="#string.view.template">Class template basic_string_view</a></del></li>
  <li><del>7.3 <a href="#string.view.cons">basic_string_view constructors and assignment operators</a></del></li>
  <li><del>7.4 <a href="#string.view.iterators">basic_string_view iterator support</a> </li>
  <li><del>7.5 <a href="#string.view.capacity">basic_string_view capacity</a></del></li>
  <li><del>7.6 <a href="#string.view.access">basic_string_view element access</a></del></li>
  <li><del>7.7 <a href="#string.view.modifiers">basic_string_view modifiers</a></del></li>
  <li><del>7.8 <a href="#string.view.ops">basic_string_view string operations</a></del></li>
    <ul>
    <li><del>7.8.1 <a href="#string.view.find">Searching basic_string_view</a></del></li>
    </ul>
  <li><del>7.9 <a href="#string.view.comparison">basic_string_view non-member comparison functions</a></del></li>
  <li><del>7.10 <a href="#string.view.io">Inserters and extractors</a></del></li>
  <li><del>7.11 <a href="#string.view.hash">Hash support</a></del></li>
  </ul>

<li>8 <a href="#memory">Memory</a></del></li>
  <ul>
  <li>8.1 <a href="#header.memory.synop">Header &lt;experimental/memory&gt; synopsis</a></li>
  <li><del>8.2 <a href="#memory.smartptr">Shared-ownership pointers</a></del></li>
    <ul>
    <li><del>8.2.1 <a href="#memory.smartptr.shared">Class template shared_ptr</a></del></li>
      <ul>
      <li><del>8.2.1.1 <a href="#memory.smartptr.shared.const">shared_ptr constructors</a></del></li>
      <li><del>8.2.1.2 <a href="#memory.smartptr.shared.obs">shared_ptr observers</a></del></li>
      <li><del>8.2.1.3 <a href="#memory.smartptr.shared.cast">shared_ptr casts</a></del></li>
      <li><del>8.2.1.4 <a href="#memory.smartptr.shared.hash">shared_ptr hash support</a></del></li>
      </ul>
    <li><del>8.2.2 <a href="#memory.smartptr.weak">Class template weak_ptr</a></del></li>
      <ul>
      <li><del>8.2.2.1 <a href="#memory.smartptr.weak.const">weak_ptr constructors</a></del></li>
      </ul>
    </ul>
  <li>8.3 <a href="#memory.type.erased.allocator">Type-erased allocator</a></li>
  <li>8.4 <a href="#memory.resource.synop">Header &lt;experimental/memory_resource&gt; synopsis</a></li>
  <li><del>8.5 <a href="#memory.resource">Class memory_resource</a></del></li>
    <ul>
    <li><del>8.5.1 <a href="#memory.resource.overview">Class memory_resource overview</a></del></li>
    <li><del>8.5.2 <a href="#memory.resource.public">memory_resource public member functions</a></del></li>
    <li><del>8.5.3 <a href="#memory.resource.priv">memory_resource protected virtual member functions</a></del></li>
    <li><del>8.5.4 <a href="#memory.resource.eq">memory_resource equality</a></del></li>
    </ul>
  <li><del>8.6 <a href="#memory.polymorphic.allocator.class">Class template polymorphic_allocator</a></del></li>
    <ul>
    <li><del>8.6.1 <a href="#memory.polymorphic.allocator.overview">Class template polymorphic_allocator overview</a></del></li>
    <li><del>8.6.2 <a href="#memory.polymorphic.allocator.ctor">polymorphic_allocator constructors</a></del></li>
    <li><del>8.6.3 <a href="#memory.polymorphic.allocator.mem">polymorphic_allocator member functions</a></del></li>
    <li><del>8.6.4 <a href="#memory.polymorphic.allocator.eq">polymorphic_allocator equality</a></del></li>
    </ul>
  <li>8.7 <a href="#memory.resource.adaptor">template alias resource_adaptor</a></li>
    <ul>
    <li>8.7.1 <a href="#memory.resource.adaptor.overview">resource_adaptor</a></li>
    <li>8.7.2 <a href="#memory.resource.adaptor.ctor">resource_adaptor_imp constructors</a></li>
    <li>8.7.3 <a href="#memory.resource.adaptor.mem">resource_adaptor_imp member functions</a></li>
    </ul>
  <li><del>8.8 <a href="#memory.resource.global">Access to program-wide memory_resource objects</a></del></li>
  <li><del>8.9 <a href="#memory.resource.pool">Pool resource classes</a></del></li>
    <ul>
    <li><del>8.9.1 <a href="#memory.resource.pool.overview">Classes synchronized_pool_resource and unsynchronized_pool_resource</a></del></li>
    <li><del>8.9.2 <a href="#memory.resource.pool.options">pool_options data members</a></del></li>
    <li><del>8.9.3 <a href="#memory.resource.pool.ctor">pool resource constructors and destructors</a></del></li>
    <li><del>8.9.4 <a href="#memory.resource.pool.mem">pool resource members</a></del></li>
    </ul>
  <li><del>8.10 <a href="#memory.resource.monotonic.buffer">Class monotonic_buffer_resource</a></del></li>
    <ul>
    <li><del>8.10.1 <a href="#memory.resource.monotonic.buffer.overview">Class monotonic_buffer_resource overview</a></del></li>
    <li><del>8.10.2 <a href="#memory.resource.monotonic.buffer.ctor">monotonic_buffer_resource constructor and destructor</a></del></li>
    <li><del>8.10.3 <a href="#memory.resource.monotonic.buffer.mem">monotonic_buffer_resource members</a></del></li>
    </ul>
  <li><del>8.11 <a href="#memory.resource.aliases">Alias templates using polymorphic memory resources</a></del></li>
    <ul>
    <li><del>8.11.1 <a href="#header.string.synop">Header &lt;experimental/string&gt; synopsis</a></del></li>
    <li><del>8.11.2 <a href="#header.deque.synop">Header &lt;experimental/deque&gt; synopsis</a></del></li>
    <li><del>8.11.3 <a href="#header.forward_list.synop">Header &lt;experimental/forward_list&gt; synopsis</a></del></li>
    <li><del>8.11.4 <a href="#header.list.synop">Header &lt;experimental/list&gt; synopsis</a></del></li>
    <li><del>8.11.5 <a href="#header.vector.synop">Header &lt;experimental/vector&gt; synopsis</a></del></li>
    <li><del>8.11.6 <a href="#header.map.synop">Header &lt;experimental/map&gt; synopsis</a></del></li>
    <li><del>8.11.7 <a href="#header.set.synop">Header &lt;experimental/set&gt; synopsis</a></del></li>
    <li><del>8.11.8 <a href="#header.unordered_map.synop">Header &lt;experimental/unordered_map&gt; synopsis</a></del></li>
    <li><del>8.11.9 <a href="#header.unordered_set.synop">Header &lt;experimental/unordered_set&gt; synopsis</a></del></li>
    <li><del>8.11.10 <a href="#header.regex.synop">Header &lt;experimental/regex&gt; synopsis</a></del></li>
    </ul>
  <li>8.12 <a href="#memory.observer.ptr">Non-owning pointers</a></li>
    <ul>
    <li>8.12.1 <a href="#memory.observer.ptr.overview">Class template observer_ptr overview</a></li>
    <li>8.12.2 <a href="#memory.observer.ptr.ctor">observer_ptr constructors</a></li>
    <li>8.12.3 <a href="#memory.observer.ptr.obs">observer_ptr observers</a></li>
    <li>8.12.4 <a href="#memory.observer.ptr.conv">observer_ptr conversions</a></li>
    <li>8.12.5 <a href="#memory.observer.ptr.mod">observer_ptr modifiers</a></li>
    <li>8.12.6 <a href="#memory.observer.ptr.special">observer_ptr specialized algorithms</a></li>
    <li>8.12.7 <a href="#memory.observer.ptr.hash">observer_ptr hash support</a></li>
    </ul>
  </ul>

<li>9 <a href="#container">Containers</a></li>
  <ul>
  <li>9.1 <a href="#container.erasure">Uniform container erasure</a></li>
    <ul>
    <li>9.1.1 <a href="#container.erasure.syn">Header synopsis</a></li>
    <li>9.1.2 <a href="#container.erasure.erase_if">Function template erase_if</a></li>
    <li>9.1.3 <a href="#container.erasure.erase">Function template erase</a></li>
    </ul>
  <li>9.2 <a href="#container.array">Class template array</a></li>
    <ul>
    <li>9.2.1 <a href="#container.array.synop">Header &lt;experimental/array&gt; synopsis</a></li>
    <li>9.2.2 <a href="#container.array.creation">Array creation functions</a></li>
    </ul>
  </ul>

<li>10 <a href="#iterator">Iterators library</a></li>
  <ul>
  <li>10.1 <a href="#iterator.synopsis">Header &lt;experimental/iterator&gt; synopsis</a></li>
  <li>10.2 <a href="#iterator.joiner">Class template ostream_joiner</a></li>
    <ul>
    <li>10.2.1 <a href="#iterator.ostream.joiner.cons">ostream_joiner constructor</a></li>
    <li>10.2.2 <a href="#iterator.ostream.joiner.ops">ostream_joiner operations</a></li>
    <li>10.2.3 <a href="#iterator.ostream.joiner.creation">ostream_joiner creation function</a></li>
    </ul>
  </ul>

<li>11 <a href="#futures">Futures</a></li>
  <ul>
  <li>11.1 <a href="#header.future.synop">Header &lt;experimental/future&gt; synopsis</a></li>
  <li>11.2 <a href="#futures.promise">Class template promise</a></li>
  <li>11.3 <a href="#futures.task">Class template packaged_task</a></li>
  </ul>

<li>12 <a href="#algorithms">Algorithms library</a></li>
  <ul>
  <li>12.1 <a href="#header.algorithms.synop">Header &lt;experimental/algorithm&gt; synopsis</a></li>
  <li><del>12.2 <a href="#alg.search">Search</a></del></li>
  <li><del>12.3 <a href="#alg.random.sample">Sampling</a></del></li>
  <li>12.4 <a href="#alg.random.shuffle">Shuffle</a></li>
  </ul>

<li>13 <a href="#numeric">Numerics library</a></li>
  <ul>
    <li><del>13.1 <a href="#numeric.ops">Generalized numeric operations</a></del></li>
    <ul>
    <li><del>13.1.1 <a href="#numeric.ops.overview">Header &lt;experimental/numeric&gt; synopsis</a></del></li>
    <li><del>13.1.2 <a href="#numeric.ops.gcd">Greatest common divisor</a></del></li>
    <li><del>13.1.3 <a href="#numeric.ops.lcm">Least common multiple</a></del></li>
    </ul>
  <li>13.2 <a href="#rand">Random number generation</a></li>
    <ul>
    <li>13.2.1 <a href="#rand.synopsis">Header &lt;experimental/random&gt; synopsis</a></li>
    <li>13.2.2 <a href="#rand.util">Utilities</a></li>
      <ul>
      <li>13.2.2.1 <a href="#rand.util.randint">Function template randint</a></li>
      </ul>
    </ul>
  </ul>

<li>14 <a href="#reflection">Reflection library</a></li>
  <ul>
  <li>14.1 <a href="#reflection.src_loc">Class source_location</a></li>
    <ul>
    <li>14.1.1 <a href="#reflection.src_loc.synop">Header &lt;experimental/source_location&gt; synopsis</a></li>
    <li>14.1.2 <a href="#reflection.src_loc.creation">source_location creation</a></li>
    <li>14.1.3 <a href="#reflection.src_loc.fields">source_location field access</a></li>
    </ul>
  </ul>

</ul>

<blockquote class="note">
Editor's note: Suggest move clause 8.12 (observer pointer) up the
document to be adjacent to its related header synopsis, or move 8.1 down.
</blockquote>

</blockquote>

<h3><a name="5.2">5.2 Revise The Front Matter</a></h3>
<p>
Note that in addition to the changes below, there may be a necessary application
of an ISO template for clauses 1-3, and a subsequent renumbering,
</p>

<blockquote>
<h2>1 General [general]</h2>
<h3>1.1 Scope [general.scope]</h3>
<ol>
<li>
This technical specification describes extensions to the C++ Standard Library
(1.2). These extensions are classes and functions that are likely to be used
widely within a program and/or on the interface boundaries between libraries
written by different organizations.
</li>

<li>
This technical specification is non-normative. Some of the library components
in this technical specification may be considered for standardization in a
future version of C++, but they are not currently part of any C++ standard.
Some of the components in this technical specification may never be
standardized, and others may be standardized in a substantially changed form.
</li>

<li>
The goal of this technical specification is to build more widespread existing
practice for an expanded C++ standard library. It gives advice on extensions to
those vendors who wish to provide them.
</li>
</ol>

<h3>1.2 Normative references [general.references]</h3>
<ol>
<li>
The following referenced document is indispensable for the application of this
document. For dated references, only the edition cited applies. For undated
references, the latest edition of the referenced document (including
any amendments) applies.

  <ul class="mdash">
  <li>
  ISO/IEC 14882:201<del>4</del><ins>7</ins>, <i>Programming Languages</i> &mdash; C++
  </li>
  </ul>

</li>

<li>
ISO/IEC 14882:— is herein called the C++ Standard. References to clauses within the C++ Standard are written as
"C++1<del>4</del><ins>7</ins> §3.2". The library described in ISO/IEC 14882:— clauses <del>17–30</del><ins>20–33</ins>
is herein called the C++ Standard Library.
</li>

<li>
Unless otherwise specified, the whole of the C++ Standard's Library introduction (<del>C++14 §17</del><ins>C++17 §20</ins>)
is included into this Technical Specification by reference.
</li>
</ol>

<h3>1.3 Namespaces, headers, and modifications to standard classes [general.namespaces]</h3>
<ol>
<li>
Since the extensions described in this technical specification are experimental
and not part of the C++ standard library, they should not be declared directly
within namespace <tt>std</tt>. Unless otherwise specified, all components described
in this technical specification either:

  <ul class="mdash">
  <li>
    modify an existing interface in the C++ Standard Library in-place,
  </li>
  <li>
    are declared in a namespace whose name appends <tt>::experimental::fundamentals_v<del>2</del><ins>3</ins></tt>
    to a namespace defined in the C++ Standard Library, such as <tt>std</tt> or <tt>std::chrono</tt>, or
  </li>
  <li>
    are declared in a subnamespace of a namespace described in the previous bullet, whose name is not
    the same as an existing subnamespace of namespace <tt>std</tt>.
  </li>
  </ul>

[ <i>Example:</i> This TS does not define
<tt>std::experimental::fundamentals_v<del>2</del><ins>3</ins>::<del>chrono</del><ins>pmr</ins></tt></tt>
because the C++ Standard Library defines <tt>std::<del>chrono</del><ins>pmr</ins></tt>.
<del>This TS does not define <tt>std::pmr::experimental::fundamentals_v2</tt> because the
C++ Standard Library does not define <tt>std::pmr</tt></del>. &mdash; <i>end example</i> ]
</li>

<li>
Each header described in this technical specification shall import the contents of
<tt>std::experimental::fundamentals_v<del>2</del><ins>3</ins></tt> into
<tt>std::experimental</tt> as if by

<blockquote><pre>
<del>namespace std {</del>
  <del>namespace experimental {</del>
    <del>inline namespace fundamentals_v2 {}</del>
  <del>}</del>
<del>}</del>
</pre></blockquote>
<blockquote><pre>
<ins>namespace std::experimental {</ins>
  <ins>inline namespace fundamentals_v3 {}</ins>
<ins>}</ins>
</pre></blockquote>

</li>

<blockquote class="note">
Note for the future: It would have been much simpler if the following syntax were
permitted, but that will require a separate proposal through EWG and Core, so
would bind against C++20 at the earliest:

<blockquote><pre>
namespace std::experimental::<ins>inline</ins> fundamentals_v3::pmr {
  <i>// contents...</i>
}
</pre></blockquote>


</blockquote>


<li>
This technical specification also describes some experimental modifications to
existing interfaces in the C++ Standard Library. These modifications are
described by quoting the affected parts of the standard and using underlining
to represent added text and strike-through to represent deleted text.
</li>

<li>
Unless otherwise specified, references to other entities described in this
technical specification are assumed to be qualified with
<tt>std::experimental::fundamentals_v<del>2</del><ins>3</ins>::</tt>, and
references to entities described in the standard are assumed to be qualified
with <tt>std::</tt>.
</li>

<li>
Extensions that are expected to eventually be added to an existing header
<meow> are provided inside the <tt>&lt;experimental/meow&gt;</tt> header,
which shall include the standard contents of <tt>&lt;meow&gt;</tt> as if by

<blockquote><pre>
#include &lt;meow&gt;
</pre></blockquote>

</li>
<li>
New headers are also provided in the <tt>&lt;experimental/&gt;</tt> directory,
but without such an <tt>#include</tt>.

</p>
<table>
<tr>
Table 1 — C++ library headers
</tr>
<tr>
   <td><tt>&lt;experimental/algorithm&gt;</tt></td>
   <td><tt>&lt;experimental/map&gt;</tt></td>
   <td><tt>&lt;experimental/string&gt;</tt></td>
</tr>
<tr>
   <td><tt><del>&lt;experimental/any&gt;</del></tt></td>
   <td><tt>&lt;experimental/memory&gt;</tt></td>
   <td><tt><del>&lt;experimental/string_view&gt;</del></tt></td>
</tr>
<tr>
   <td><tt>&lt;experimental/array&gt;</tt></td>
   <td><tt>&lt;experimental/memory_resource&gt;</tt></td>
   <td><tt><del>&lt;experimental/system_error&gt;</del></tt></td>
</tr>
<tr>
   <td><tt><del>&lt;experimental/chrono&gt;</del></tt></td>
   <td><tt><del>&lt;experimental/optional&gt;</del></tt></td>
   <td><tt><del>&lt;experimental/tuple&gt;</del></tt></td>
</tr>
<tr>
   <td><tt>&lt;experimental/deque&gt;</tt></td>
   <td><tt>&lt;experimental/propagate_const&gt;</tt></td>
   <td><tt>&lt;experimental/type_traits&gt;</tt></td>
</tr>
<tr>
   <td><tt>&lt;experimental/forward_list&gt;</tt></td>
   <td><tt>&lt;experimental/random&gt;</tt></td>
   <td><tt>&lt;experimental/unordered_map&gt;</tt></td>
</tr>
<tr>
   <td><tt>&lt;experimental/functional&gt;</tt></td>
   <td><tt><del>&lt;experimental/ratio&gt;</del></tt></td>
   <td><tt>&lt;experimental/unordered_set&gt;</tt></td>
</tr>
<tr>
   <td><tt>&lt;experimental/future&gt;</tt></td>
   <td><tt><del>&lt;experimental/regex&gt;</del></tt></td>
   <td><tt>&lt;experimental/utility&gt;</tt></td>
</tr>
<tr>
   <td><tt>&lt;experimental/iterator&gt;</tt></td>
   <td><tt>&lt;experimental/set&gt;</tt></td>
   <td><tt>&lt;experimental/vector&gt;</tt></td>
</tr>
<tr>
   <td><tt>&lt;experimental/list&gt;</tt></td>
   <td><tt>&lt;experimental/source_location&gt;</tt></td>
   <td><tt></tt></td>
</tr>
</table>

</li>
</ol>

<h3><del>1.4 Terms and definitions [general.defns]</del></h3>
<ol>
<li><del>
For the purposes of this document, the terms and definitions given in the C++
Standard and the following apply.
</del></li>
</ol>

<h3><del>1.4.1 [general.defns.direct-non-list-init]<del></h3>
<b><del>direct-non-list-initialization</del></b><br/>
<del>A direct-initialization that is not list-initialization.</del>

<h3>1.5 Future plans (Informative) [general.plans]</h3>
<ol>
<li>
This section describes tentative plans for future versions of this technical
specification and plans for moving content into future versions of the C++
Standard.
</li>
<li>
The C++ committee intends to release a new version of this technical
specification approximately every year, containing the library extensions we
hope to add to a near-future version of the C++ Standard. Future versions will
define their contents in <tt>std::experimental::fundamentals_v<del>3</del><ins>4</ins></tt>,
<tt>std::experimental::fundamentals_v<del>4</del><ins>5</ins></tt>, etc., with the most recent
implemented version inlined into <tt>std::experimental</tt>.
</li>
<li>
When an extension defined in this or a future version of this technical
specification represents enough existing practice, it will be moved into the
next version of the C++ Standard by removing the <tt>experimental::fundamentals_vN</tt>
segment of its namespace and by removing the <tt>experimental/</tt> prefix from its
header's path.
</li>
</ol>

<h3>1.6 Feature-testing recommendations (Informative) [general.feature.test]</h3>
<ol>
<li>
For the sake of improved portability between partial implementations of various
C++ standards, WG21 (the ISO technical committee for the C++ programming
language) recommends that implementers and programmers follow the guidelines in
this section concerning feature-test macros. [ <i>Note:</i> WG21's SD-6 makes similar
recommendations for the C++ Standard itself. &mdash; <i>end note</i> ]
</li>
<li>
Implementers who provide a new standard feature should define a macro with the
recommended name, in the same circumstances under which the feature is
available (for example, taking into account relevant command-line options), to
indicate the presence of support for that feature.  Implementers should define
that macro with the value specified in the most recent version of this
technical specification that they have implemented. The recommended macro name
is "<tt>__cpp_lib_experimental_</tt>" followed by the string in the "Macro Name Suffix"
column.
</li>
<li>
Programmers who wish to determine whether a feature is available in an
implementation should base that determination on the presence of the header
(determined with <tt>__has_include(&lt;header/name&gt;))</tt> and the state of
the macro with the recommended name.  (The absence of a tested feature may
result in a program with decreased functionality, or the relevant functionality
may be provided in a different way.  A program that strictly depends on support
for a feature can just try to use the feature unconditionally; presumably, on
an implementation lacking necessary support, translation will fail.)
</li>
</ol>

<table>
<tr>
Table 2 - Significant features in this technical specification
</tr>
<tr>
   <td><b>Doc. No.</b></td>
   <td><b>Title</b></td>
   <td><b>Primary Section</b></td>
   <td><b>Macro Name Suffix</b></td>
   <td><b>Value</b></td>
   <td><b>Header</b></td>
</tr>
<tr>
   <td><del>N3915</del></td>
   <td><del>apply() call a function with arguments from a tuple</del></td>
   <td><del>3.2.2</del></td>
   <td><del><tt>apply</tt></del></td>
   <td><del>201402</del></td>
   <td><del><tt>&lt;experimental/tuple&gt;</tt></del></td>
</tr>
<tr>
   <td><del>N3932</del></td>
   <td><del>Variable Templates For Type Traits</del></td>
   <td><del>3.3.1</del></td>
   <td><del><tt>type_trait_variable_templates</tt></del></td>
   <td><del>201402</del></td>
   <td><del><tt>&lt;experimental/type_traits&gt;</tt></del></td>
</tr>
<tr>
   <td>N3866</td>
   <td>Invocation type traits</td>
   <td>3.3.2</td>
   <td><tt>invocation_type</tt></td>
   <td>201406</td>
   <td><tt>&lt;experimental/type_traits&gt;</tt></td>
</tr>
<tr>
   <td><del>P0013R1</del></td>
   <td><del>Logical Operator Type Traits</del></td>
   <td><del>3.3.3</del></td>
   <td><del><tt>logical_traits</tt></del></td>
   <td><del>201511</del></td>
   <td><del><tt>&lt;experimental/type_traits&gt;</tt></del></td>
</tr>
<tr>
   <td>N4502</td>
   <td>The C++ Detection Idiom</td>
   <td>3.3.4</td>
   <td><tt>detect</tt></td>
   <td>201505</td>
   <td><tt>&lt;experimental/type_traits&gt;</tt></td>
</tr>
<tr>
   <td>N4388</td>
   <td>A Proposal to Add a Const-Propagating Wrapper to the Standard Library</td>
   <td>3.7</td>
   <td><tt>propagate_const</tt></td>
   <td>201505</td>
   <td><tt>&lt;experimental/propagate_const&gt;</tt></td>
</tr>
<tr>
   <td>N3916</td>
   <td>Type-erased allocator for std::function</td>
   <td>4.2</td>
   <td><tt>function_erased_allocator</tt></td>
   <td>201406</td>
   <td><tt>&lt;experimental/functional&gt;</tt></td>
</tr>
<tr>
   <td><del>N3905</del></td>
   <td><del>Extending std::search to use Additional Searching Algorithms</del></td>
   <td><del>4.3</del></td>
   <td><del><tt>boyer_moore_searching</tt></del></td>
   <td><del>201411</del></td>
   <td><del><tt>&lt;experimental/functional&gt;</tt></del></td>
</tr>
<tr>
   <td><del>N4076</del></td>
   <td><del>A proposal to add a generalized callable negator</del></td>
   <td><del>4.4</del></td>
   <td><del><tt>not_fn</tt></del></td>
   <td><del>201406</del></td>
   <td><del><tt>&lt;experimental/functional&gt;</tt></del></td>
</tr>
<tr>
   <td><del>N3672, N3793</del></td>
   <td><del>A utility class to represent optional objects</del></td>
   <td><del>5</del></td>
   <td><del><tt>optional</tt></del></td>
   <td><del>201411</del></td>
   <td><del><tt>&lt;experimental/optional&gt;</tt></del></td>
</tr>
<tr>
   <td><del>N3804</del></td>
   <td><del>Any Library Proposal</del></td>
   <td><del>6</del></td>
   <td><del><tt>any</tt></del></td>
   <td><del>201411</del></td>
   <td><del><tt>&lt;experimental/any&gt;</tt></del></td>
</tr>
<tr>
   <td><del>N3921</del></td>
   <td><del>string_view: a non-owning reference to a string</del></td>
   <td><del>7</del></td>
   <td><del><tt>string_view</tt></del></td>
   <td><del>201411</del></td>
   <td><del><tt>&lt;experimental/string_view&gt;</tt></del></td>
</tr>
<tr>
   <td><del>N3920</del></td>
   <td><del>Extending shared_ptr to Support Arrays</del></td>
   <td><del>8.2</del></td>
   <td><del><tt>shared_ptr_arrays</tt></del></td>
   <td><del>201406</del></td>
   <td><del><tt>&lt;experimental/memory&gt;</tt></del></td>
</tr>
<tr>
   <td><del>N3916</del></td>
   <td><del>Polymorphic Memory Resources</del></td>
   <td><del>8.4</del></td>
   <td><del><tt>memory_resources</tt></del></td>
   <td><del>201402</del></td>
   <td><del><tt>&lt;experimental/memory_resource&gt;</tt></del></td>
</tr>
<tr>
   <td>N4282</td>
   <td>The World’s Dumbest Smart Pointer</td>
   <td>8.12</td>
   <td><tt>observer_ptr</tt></td>
   <td>201411</td>
   <td><tt>&lt;experimental/memory&gt;</tt></td>
</tr>
<tr>
   <td>N4273</td>
   <td>Uniform Container Erasure</td>
   <td>9.1</td>
   <td><tt>erase_if</tt></td>
   <td>201411</td>
   <td><tt>&lt;experimental/vector&gt;</tt><ins>,
       <tt>&lt;experimental/deque&gt;</tt>,
       <tt>&lt;experimental/forward_list&gt;</tt>,
       <tt>&lt;experimental/list&gt;</tt>,
       <tt>&lt;experimental/map&gt;</tt>,
       <tt>&lt;experimental/set&gt;</tt>,
       <tt>&lt;experimental/unordered_map&gt;</tt>,
       <tt>&lt;experimental/unordered_set&gt;</tt>,
   </td>
</tr>
<tr>
   <td>N4391</td>
   <td>make_array</td>
   <td>9.2.2</td>
   <td><tt>make_array</tt></td>
   <td>201505</td>
   <td><tt>&lt;experimental/array&gt;</tt></td>
</tr>
<tr>
   <td>N4257</td>
   <td>Delimited iterators</td>
   <td>10.2</td>
   <td><tt>ostream_joiner</tt></td>
   <td>201411</td>
   <td><tt>&lt;experimental/iterator&gt;</tt></td>
</tr>
<tr>
   <td>N3916</td>
   <td>Type-erased allocator for std::promise</td>
   <td>11.2</td>
   <td><tt>promise_erased_allocator</tt></td>
   <td>201406</td>
   <td><tt>&lt;experimental/future&gt;</tt></td>
</tr>
<tr>
   <td>N3916</td>
   <td>Type-erased allocator for std::packaged_task</td>
   <td>11.3</td>
   <td><tt>packaged_task_erased_allocator</tt></td>
   <td>201406</td>
   <td><tt>&lt;experimental/future&gt;</tt></td>
</tr>
<tr>
   <td><del>N3925</del></td>
   <td><del>A sample Proposal</del></td>
   <td><del>12.3</del></td>
   <td><del><tt>sample</tt></del></td>
   <td><del>201402</del></td>
   <td><del><tt>&lt;experimental/algorithm&gt;</tt></del></td>
</tr>
<tr>
   <td><del>N4061</del></td>
   <td><del>Greatest Common Divisor and Least Common Multiple</del></td>
   <td><del>13.1.2, 13.1.3</del></td>
   <td><del><tt>gcd_lcm</tt></del></td>
   <td><del>201411</del></td>
   <td><del><tt>&lt;experimental/numeric&gt;</tt></del></td>
</tr>
<tr>
   <td>N4531</td>
   <td>std::rand replacement</td>
   <td>13.2.2.1</td>
   <td><tt>randint</tt></td>
   <td>201511</td>
   <td><tt>&lt;experimental/random&gt;</tt></td>
</tr>
<tr>
   <td>N4519</td>
   <td>Source-Code Information Capture</td>
   <td>14.1</td>
   <td><tt>source_location</tt></td>
   <td>201505</td>
   <td><tt>&lt;experimental/source_location&gt;</tt></td>
</tr>
</table>

</blockquote>

<h3><a name="5.3">5.3 Global Search and Replace</a></h3>

<p>
There are a couple or repeating patterns in the normative text following
the header synopses that should be applied universally.  First, replace
all opening/closing namespaces matching the following pattern:
</p>
<blockquote><pre>
<del>namespace std {</del>
namespace <ins>std::</ins>experimental {
inline namespace fundamentals_v<del>2</del><ins>3</ins> {

    // some class definition or other specification ...
    
} <i>// namespace fundamentals_v<del>2</del><ins>3</ins></i>
} <i>// namespace <ins>std::</ins>experimental</i>
<del>} <i>// namespace std</i></del>
</pre></blockquote>

<p>
An example of updating a header synopsis:
</p>

<blockquote>
<h3>14.1.1 Header <tt>&lt;experimental/source_location&gt;</tt> synopsis [reflection.src_loc.synop]</h3>
<blockquote><pre>
<del>namespace std {</del>
namespace <ins>std::</ins>experimental {
inline namespace fundamentals_v<del>2</del><ins>3</ins> {

  struct source_location {
    <i>// 14.1.2, source_location creation</i>
    static constexpr source_location current() noexcept;

    constexpr source_location() noexcept;

    <i>// 14.1.3, source_location field access</i>
    constexpr uint_least32_t line() const noexcept;
    constexpr uint_least32_t column() const noexcept;
    constexpr const char* file_name() const noexcept;
    constexpr const char* function_name() const noexcept;
  };

} <i>// namespace fundamentals_v<del>2</del><ins>3</ins></i>
} <i>// namespace <ins>std::</ins>experimental</i>
<del>} <i>// namespace std</i></del>
</pre></blockquote>

<ol>
<li>
[ <i>Note</i>: The intent of <tt>source_location</tt> is to have
a small size and efficient copying. &mdash; <i>end note</i> ]
</li>
</ol>
</blockquote>


<h3><a name="5.4">5.4 Fix Cross-references</a></h3>

<p>
Some parts of the TS update wording in the main standard, so
require normative updates to the cross-reference immediates.
</p>

<blockquote>
<h3>2.1 Uses-allocator construction [mods.allocator.uses]</h3>
<blockquote>
<h4><del>20.7</del><ins>23.10</ins>.7 uses_allocator [allocator.uses]</h4>
<h4><del>20.7</del><ins>23.10</ins>.7.1 uses_allocator trait [allocator.uses.trait]</h4>
<h4><del>20.7</del><ins>23.10</ins>.7.2 uses-allocator construction [allocator.uses.construction]</h4>
</blockquote>
</blockquote>

<p>
Next, the remaining section on type-erased allocators should be using
the <tt>pmr</tt> facility from the main <tt>std::pmr</tt> namespace that
landed in C++17, as there is no further experimental version of this
feature.
</p>

<blockquote>
<h3>8.3 Type-erased allocator [memory.type.erased.allocator]</h3>
<ol>
<li>
A <i>type-erased allocator</i> is an allocator or memory resource,
<tt>alloc</tt>, used to allocate internal data structures for an object
<tt>X</tt> of type <tt>C</tt>, but where <tt>C</tt> is not dependent on the
type of <tt>alloc</tt>. Once <tt>alloc</tt> has been supplied to <tt>X</tt>
(typically as a constructor argument), <tt>alloc</tt> can be retrieved from
<tt>X</tt> only as a pointer <tt>rptr</tt> of static type
<tt>std<del>::experimental</del>::pmr::memory_resource*</tt>
(<del>8.5</del><ins>C++17 §23.12.2 [mem.res.class]</ins>). The process by which
<tt>rptr</tt> is computed from <tt>alloc</tt> depends on the type of
<tt>alloc</tt> as described in Table 15:
</li>
<p/>
<table>
<tr>
Table 15 - Computed <tt>memory_resource</tt> for type-erased allocator
</tr>
<tr>
   <td><b>If the type of <tt>alloc</tt> is</b></td>
   <td><b>then the value of <tt>rptr</tt> is</b></td>
</tr>
<tr>
   <td>non-existent &mdash; no <tt>alloc</tt> specified</td>
   <td>The value of <tt><del>experimental::</del>pmr::get_default_resource()</tt> at the time of construction.</td>
</tr>
<tr>
   <td><tt>nullptr_t</tt></td>
   <td>The value of <tt><del>experimental::</del>pmr::get_default_resource()</tt> at the time of construction.</td>
</tr>
<tr>
   <td>a pointer type convertible to <tt>pmr::memory_resource*</tt></td>
   <td><tt>static_cast&lt;<del>experimental::</del>pmr::memory_resource*&gt;(alloc)</tt></td>
</tr>
<tr>
   <td><tt>pmr::polymorphic_allocator&lt;U&gt;</tt></td>
   <td><tt>alloc.resource()</tt></td>
</tr>
<tr>
   <td>any other type meeting the <tt>Allocator</tt> requirements (<del>C++14 §17.6.3.5</del><ins>C++17 §20.5.3.5 [allocator.requirements]</ins>)</td>
   <td>a pointer to a value of type <tt><del>experimental::</del>pmr::resource_adaptor&lt;A&gt;</tt>
       where <tt>A</tt> is the type of <tt>alloc</tt>. <tt>rptr</tt> remains valid only for the lifetime of <tt>X</tt>.</td>
</tr>
<tr>
   <td>None of the above</td>
   <td>The program is ill-formed.</td>
</tr>

</table>

<p/>

<li>
Additionally, class <tt>C</tt> shall meet the following requirements:
   <ul>
   <li><tt>C::allocator_type</tt> shall be identical to <tt>std::experimental::erased_type</tt>.</li>
   <li><tt>X.get_memory_resource()</tt> returns <tt>rptr</tt>.</li>
   </ul>
</li>
</ol>
</blockquote>

<p>
Then, there are many references to the C++14 standard, denoted thusly:
(C++14 §17.6.3.5).  They should be replaced as an editorial action with
their corresponding reference to the C++17 standard, as (C++17 §20.5.3.5).
</p>


<p>
Finally, there are a few stylistic cleanups to apply
</p>
<ul>
<li>Replace all <tt>typedef</tt>s with <tt>using</tt></li>
<li><tt>propagate_const</tt> and <tt>source_location</tt> should move class definitions out of header synopsis</li>
<li>Reorder clause 8 so <tt>&lt;memory&gt;</tt> contents are contiguous</li>
</ul>


<h2><a name="6.0">6 Acknowledgements</h2>
<p>
Thanks to the initial reviewers of R0 of this document, that helped produce this simplified
document, and especially to Geoffrey Romer as editor of the Fundamentals TS who agreed that
much of the fine detail was better left as an editorial task he would have to pick up.
</p>

<h2><a name="7.0">7 References</h2>
<ul>
  <li>
    <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4617.pdf">N4617</a>
    Programming Languages -- C++ Extensions for Library Fundamentals, Version 2 DTS,
    Geoffrey Romer
  </li>
  <li>
    <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0220r1.html">P0220R1</a>
    Adopt Library Fundamentals V1 TS Components for C++17,
    Beman Dawes
  </li>
  <li>
    <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0295r0.pdf">P0295R0</a>
    Adopt Selected Library Fundamentals V2 Components for C++17,
    Walter Brown
  </li>
</ul>


</body>
</html>
