Merge 2016-02 LWG Motion 6

Notably this does not merge the changes to shared_ptr and weak_ptr.

Author: zygoloid

source/algorithms.tex

@@ -245,6 +245,7 @@
                         ForwardIterator2 first2, ForwardIterator2 last2,
                         BinaryPredicate pred);
 
+  // \ref{alg.search}, search:
   template<class ForwardIterator1, class ForwardIterator2>
     ForwardIterator1 search(
       ForwardIterator1 first1, ForwardIterator1 last1,
@@ -284,6 +285,10 @@
                              Size count, const T& value,
                              BinaryPredicate pred);
 
+  template <class ForwardIterator, class Searcher>
+    ForwardIterator search(ForwardIterator first, ForwardIterator last,
+                           const Searcher &searcher);
+
   // \ref{alg.modifying.operations}, modifying sequence operations:
   // \ref{alg.copy}, copy:
   template<class InputIterator, class OutputIterator>
@@ -512,6 +517,13 @@
       ForwardIterator first, ForwardIterator middle,
       ForwardIterator last, OutputIterator result);
 
+  // \ref{alg.random.sample}, sample:
+  template<class PopulationIterator, class SampleIterator,
+           class Distance, class UniformRandomNumberGenerator>
+    SampleIterator sample(PopulationIterator first, PopulationIterator last,
+                          SampleIterator out, Distance n,
+                          UniformRandomNumberGenerator&& g);
+
   // \ref{alg.random.shuffle}, shuffle:
   template<class RandomAccessIterator, class UniformRandomNumberGenerator>
     void shuffle(RandomAccessIterator first,
@@ -2081,6 +2093,24 @@
 applications of the corresponding predicate.
 \end{itemdescr}
 
+\indexlibrary{\idxcode{search}}%
+\begin{itemdecl}
+template<class ForwardIterator, class Searcher>
+  ForwardIterator search(ForwardIterator first, ForwardIterator last,
+                         const Searcher& searcher);
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\effects
+Equivalent to \tcode{return searcher(first, last);}
+
+\pnum
+\remarks
+\tcode{Searcher} need not meet the \tcode{CopyConstructible} requirements.
+\end{itemdescr}
+
+
 \rSec1[alg.modifying.operations]{Mutating sequence operations}
 
 \rSec2[alg.copy]{Copy}
@@ -2930,14 +2960,78 @@
 assignments.
 \end{itemdescr}
 
+\rSec2[alg.random.sample]{Sample}
+
+\indexlibrary{\idxcode{sample}}%
+\begin{itemdecl}
+template<class PopulationIterator, class SampleIterator,
+         class Distance, class UniformRandomNumberGenerator>
+  SampleIterator sample(PopulationIterator first, PopulationIterator last,
+                        SampleIterator out, Distance n,
+                        UniformRandomNumberGenerator&& g);
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\requires
+\begin{itemize}
+\item
+\tcode{PopulationIterator} shall meet the requirements of an \tcode{InputIterator} type.
+\item
+\tcode{SampleIterator} shall meet the requirements of an \tcode{OutputIterator} type.
+\item
+\tcode{SampleIterator} shall meet the additional requirements of a \tcode{RandomAccessIterator} type
+unless \tcode{PopulationIterator} meets the additional requirements of a \tcode{ForwardIterator} type.
+\item
+\tcode{PopulationIterator}'s value type shall be writable to \tcode{out}.
+\item
+\tcode{Distance} shall be an integer type.
+\item
+\tcode{UniformRandomNumberGenerator} shall meet the requirements of a uniform random number generator type (\ref{rand.req.urng})
+whose return type is convertible to \tcode{Distance}.
+\item
+\tcode{out} shall not be in the range \range{first}{last}.
+\end{itemize}
+
+\pnum
+\effects
+Copies \tcode{min(last - first, n)} elements (the \defn{sample})
+from \range{first}{last} (the \defn{population}) to \tcode{out}
+such that each possible sample has equal probability of appearance.
+\enternote
+Algorithms that obtain such effects include \term{selection sampling}
+and \term{reservoir sampling}.
+\exitnote
+
+\pnum
+\returns
+The end of the resulting sample range.
+
+\pnum
+\complexity
+O(\tcode{last - first}).
+
+\pnum
+\remarks
+\begin{itemize}
+\item
+Stable if and only if \tcode{PopulationIterator} meets the
+requirements of a \tcode{ForwardIterator} type.
+\item
+To the extent that the implementation of this function makes use of
+random numbers, the object \tcode{g} shall serve as the
+implementation's source of randomness.
+\end{itemize}
+\end{itemdescr}
+
 \rSec2[alg.random.shuffle]{Shuffle}
 
 \indexlibrary{\idxcode{shuffle}}%
 \begin{itemdecl}
 template<class RandomAccessIterator, class UniformRandomNumberGenerator>
   void shuffle(RandomAccessIterator first,
-                      RandomAccessIterator last,
-                      UniformRandomNumberGenerator&& g);
+               RandomAccessIterator last,
+               UniformRandomNumberGenerator&& g);
 \end{itemdecl}
 
 \begin{itemdescr}

source/containers.tex

@@ -2479,6 +2479,11 @@
   template <class T, class Allocator>
     void swap(deque<T, Allocator>& x, deque<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
+
+  namespace pmr {
+    template <class T>
+      using deque = std::deque<T,polymorphic_allocator<T>>;
+  }
 }
 \end{codeblock}
 
@@ -2507,6 +2512,11 @@
   template <class T, class Allocator>
     void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
+
+  namespace pmr {
+    template <class T>
+      using forward_list = std::forward_list<T,polymorphic_allocator<T>>;
+  }
 }
 \end{codeblock}
 
@@ -2535,6 +2545,11 @@
   template <class T, class Allocator>
     void swap(list<T, Allocator>& x, list<T, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
+
+  namespace pmr {
+    template <class T>
+      using list = std::list<T,polymorphic_allocator<T>>;
+  }
 }
 \end{codeblock}
 
@@ -2570,6 +2585,11 @@
   // hash support
   template <class T> struct hash;
   template <class Allocator> struct hash<vector<bool, Allocator>>;
+
+  namespace pmr {
+    template <class T>
+      using vector = std::vector<T,polymorphic_allocator<T>>;
+  }
 }
 \end{codeblock}
 
@@ -5390,6 +5410,16 @@
     void swap(multimap<Key, T, Compare, Allocator>& x,
               multimap<Key, T, Compare, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
+
+  namespace pmr {
+    template <class Key, class T, class Compare = less<Key>>
+      using map = std::map<Key, T, Compare,
+                           polymorphic_allocator<pair<const Key,T>>>;
+
+    template <class Key, class T, class Compare = less<Key>>
+      using multimap = std::multimap<Key, T, Compare,
+                                     polymorphic_allocator<pair<const Key,T>>>;
+  }
 }
 \end{codeblock}
 
@@ -5453,6 +5483,16 @@
     void swap(multiset<Key, Compare, Allocator>& x,
               multiset<Key, Compare, Allocator>& y)
       noexcept(noexcept(x.swap(y)));
+
+  namespace pmr {
+    template <class Key, class Compare = less<Key>>
+      using set = std::set<Key, Compare,
+                           polymorphic_allocator<Key>>;
+
+    template <class Key, class Compare = less<Key>>
+      using multiset = std::multiset<Key, Compare,
+                                     polymorphic_allocator<Key>>;
+  }
 }
 \end{codeblock}
 
@@ -6847,6 +6887,24 @@
   template <class Key, class T, class Hash, class Pred, class Alloc>
     bool operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
                     const unordered_multimap<Key, T, Hash, Pred, Alloc>& b);
+
+  namespace pmr {
+    template <class Key,
+              class T,
+              class Hash = hash<Key>,
+              class Pred = equal_to<Key>>
+      using unordered_map =
+        std::unordered_map<Key, T, Hash, Pred,
+                           polymorphic_allocator<pair<const Key,T>>>;
+    template <class Key,
+              class T,
+              class Hash = hash<Key>,
+              class Pred = equal_to<Key>>
+      using unordered_multimap =
+        std::unordered_multimap<Key, T, Hash, Pred,
+                                polymorphic_allocator<pair<const Key,T>>>;
+
+  }
 }
 \end{codeblock}
 
@@ -6894,6 +6952,20 @@
   template <class Key, class Hash, class Pred, class Alloc>
     bool operator!=(const unordered_multiset<Key, Hash, Pred, Alloc>& a,
                     const unordered_multiset<Key, Hash, Pred, Alloc>& b);
+
+  namespace pmr {
+    template <class Key,
+              class Hash = hash<Key>,
+              class Pred = equal_to<Key>>
+      using unordered_set = std::unordered_set<Key, Hash, Pred,
+                                               polymorphic_allocator<Key>>;
+
+    template <class Key,
+              class Hash = hash<Key>,
+              class Pred = equal_to<Key>>
+      using unordered_multiset = std::unordered_multiset<Key, Hash, Pred,
+                                                         polymorphic_allocator<Key>>;
+  }
 }
 \end{codeblock}
 

source/lib-intro.tex

@@ -966,7 +966,7 @@
 
 \pnum
 The \Cpp standard library provides
-56
+60
 \term{\Cpp library headers},
 \indextext{header!C++ library}%
 as shown in Table~\ref{tab:cpp.library.headers}.
@@ -975,77 +975,76 @@
 {lllll}
 \topline
 \tcode{<algorithm>} &
+\tcode{<execution_policy>} &
+\tcode{<limits>} &
+\tcode{<random>} &
+\tcode{<strstream>} \\
+
+\tcode{<any>} &
 \tcode{<forward_list>} &
 \tcode{<list>} &
-\tcode{<scoped_allocator>} &
-\tcode{<type_traits>} \\
+\tcode{<ratio>} &
+\tcode{<system_error>} \\
 
 \tcode{<array>} &
 \tcode{<fstream>} &
 \tcode{<locale>} &
-\tcode{<set>} &
-\tcode{<typeindex>} \\
+\tcode{<regex>} &
+\tcode{<thread>} \\
 
 \tcode{<atomic>} &
 \tcode{<functional>} &
 \tcode{<map>} &
-\tcode{<shared_mutex>} &
-\tcode{<typeinfo>} \\
+\tcode{<scoped_allocator>} &
+\tcode{<tuple>} \\
 
 \tcode{<bitset>} &
 \tcode{<future>} &
 \tcode{<memory>} &
-\tcode{<sstream>} &
-\tcode{<unordered_map>} \\
+\tcode{<set>} &
+\tcode{<typeindex>} \\
 
 \tcode{<chrono>} &
 \tcode{<initializer_list>} &
-\tcode{<mutex>} &
-\tcode{<stack>} &
-\tcode{<unordered_set>} \\
+\tcode{<memory_resorce>} &
+\tcode{<shared_mutex>} &
+\tcode{<typeinfo>} \\
 
 \tcode{<codecvt>} &
 \tcode{<iomanip>} &
-\tcode{<new>} &
-\tcode{<stdexcept>} &
-\tcode{<utility>} \\
+\tcode{<mutex>} &
+\tcode{<sstream>} &
+\tcode{<type_traits>} \\
 
 \tcode{<complex>} &
 \tcode{<ios>} &
-\tcode{<numeric>} &
-\tcode{<streambuf>} &
-\tcode{<valarray>} \\
+\tcode{<new>} &
+\tcode{<stack>} &
+\tcode{<unordered_map>} \\
 
 \tcode{<condition_variable>} &
 \tcode{<iosfwd>} &
-\tcode{<ostream>} &
-\tcode{<string>} &
-\tcode{<vector>} \\
+\tcode{<numeric>} &
+\tcode{<stdexcept>} &
+\tcode{<unordered_set>} \\
 
 \tcode{<deque>} &
 \tcode{<iostream>} &
-\tcode{<queue>} &
-\tcode{<strstream>} &
-\\
+\tcode{<optional>} &
+\tcode{<streambuf>} &
+\tcode{<utility>} \\
 
 \tcode{<exception>} &
 \tcode{<istream>} &
-\tcode{<random>} &
-\tcode{<system_error>} &
-\\
+\tcode{<ostream>} &
+\tcode{<string>} &
+\tcode{<valarray>} \\
 
 \tcode{<exception_list>} &
 \tcode{<iterator>} &
-\tcode{<ratio>} &
-\tcode{<thread>} &
-\\
-
-\tcode{<execution_policy>} &
-\tcode{<limits>} &
-\tcode{<regex>} &
-\tcode{<tuple>} &
-\\
-
+\tcode{<queue>} &
+\tcode{<string_view>} &
+\tcode{<vector>} \\
 \end{floattable}