Merge 2017-07 LWG Motion 31

Author: zygoloid

source/algorithms.tex

@@ -1294,6 +1294,19 @@
 which describe the manner in which the execution of these algorithms may be
 parallelized and the manner in which they apply the element access functions.
 
+\pnum
+If an object is modified by an element access function,
+the algorithm will perform no other unsynchronized accesses to that object.
+The modifying element access functions are those
+which are specified as modifying the object in the relevant concept.
+\begin{note}
+For example,
+\tcode{swap()}, \tcode{++}, \tcode{--}, \tcode{@=}, and assignments
+modify the object.
+For the assignment and \tcode{@=} operators,
+only the left argument is modified.
+\end{note}
+
 \pnum
 Unless otherwise stated, implementations may make arbitrary copies of elements
 (with type \tcode{T}) from sequences where \tcode{is_trivially_copy_constructible_v<T>}
@@ -4977,7 +4990,7 @@
 
 \pnum
 \complexity
-At most $N \log N$
+At most $2N \log N$
 comparisons, where
 $N = \tcode{last - first}$.
 \end{itemdescr}

source/containers.tex

@@ -9285,7 +9285,8 @@
     void push(const value_type& x)      { c.push_back(x); }
     void push(value_type&& x)           { c.push_back(std::move(x)); }
     template <class... Args>
-      reference emplace(Args&&... args) { return c.emplace_back(std::forward<Args>(args)...); }
+      decltype(auto) emplace(Args&&... args)
+        { return c.emplace_back(std::forward<Args>(args)...); }
     void pop()                          { c.pop_front(); }
     void swap(queue& q) noexcept(is_nothrow_swappable_v<Container>)
       { using std::swap; swap(c, q.c); }
@@ -9841,7 +9842,8 @@
     void push(const value_type& x)      { c.push_back(x); }
     void push(value_type&& x)           { c.push_back(std::move(x)); }
     template <class... Args>
-      reference emplace(Args&&... args) { return c.emplace_back(std::forward<Args>(args)...); }
+      decltype(auto) emplace(Args&&... args)
+        { return c.emplace_back(std::forward<Args>(args)...); }
     void pop()                          { c.pop_back(); }
     void swap(stack& s) noexcept(is_nothrow_swappable_v<Container>)
       { using std::swap; swap(c, s.c); }

source/future.tex

@@ -2111,7 +2111,8 @@
 
 \pnum
 The behavior of a program that adds specializations for
-\tcode{is_literal_type} or \tcode{is_literal_type_v} is undefined.
+any of the templates defined in this subclause is undefined,
+unless explicitly permitted by the specification of the corresponding template.
 
 \rSec1[depr.iterator.primitives]{Deprecated iterator primitives}
 

source/iostreams.tex

@@ -11451,7 +11451,7 @@
 
 \begin{itemdescr}
 \pnum
-\returns \tcode{pathstring}.
+\returns \tcode{native()}.
 
 \pnum
 \remarks Conversion, if any, is performed as specified
@@ -14313,25 +14313,22 @@
 
 \begin{itemdescr}
 \pnum
-Let \tcode{s1} and \tcode{s2} be \tcode{file_status}s, determined
-as if by \tcode{status(p1)} and \tcode{status(p2)}, respectively.
-
-\pnum
-\effects Determines \tcode{s1} and \tcode{s2}.
-If \tcode{(!exists(s1) \&\& !exists(s2)) || (is_other(s1) \&\& is_other(s2))}
-an error is reported~(\ref{fs.err.report}).
-
-\pnum
-\returns \tcode{true}, if \tcode{s1 == s2} and \tcode{p1} and \tcode{p2} resolve to the same file
+\returns \tcode{true}, if \tcode{p1} and \tcode{p2} resolve to the same file
   system entity, else \tcode{false}. The signature with argument \tcode{ec}
   returns \tcode{false} if an error occurs.
 
 \pnum
 Two paths are considered to resolve to the same file system entity if two
-  candidate entities reside on the same device at the same location. This is
+  candidate entities reside on the same device at the same location.
+  \begin{note}
+  On POSIX platforms, this is
   determined as if by the values of the POSIX \tcode{stat} structure,
   obtained as if by \tcode{stat()} for the two paths, having equal \tcode{st_dev} values
   and equal \tcode{st_ino} values.
+  \end{note}
+
+\pnum
+\remarks \tcode{!exists(p1) || !exists(p2)} is an error.
 
 \pnum
 \throws As specified in~\ref{fs.err.report}.

source/lib-intro.tex

@@ -1954,7 +1954,7 @@
 \tcode{X u = std::move(a);} &
                             &
   Shall not exit via an exception.\br
-  \postconditions \tcode{u} is equal to the prior value of \tcode{a}. & \\ \rowsep
+  \postconditions The value of \tcode{a} is unchanged and is equal to \tcode{u}. & \\ \rowsep
 
 \tcode{X u(std::move(b));}  &
                             &
@@ -2173,6 +2173,12 @@
 must be prepared to work adequately with any user-supplied specialization
 that meets the minimum requirements of this International Standard.}
 
+\pnum
+The behavior of a \Cpp program is undefined
+if it declares an explicit or partial specialization
+of any standard library variable template,
+except where explicitly permitted by the specification of that variable template.
+
 \pnum
 The behavior of a \Cpp program is undefined if it declares
 \begin{itemize}

source/numerics.tex

@@ -1162,8 +1162,11 @@
 \pnum
 \returns
 The complex natural (base-$e$) logarithm of \tcode{x}. For all \tcode{x},
-\tcode{imag(log(x))} lies in the interval \crange{$-\pi$}{$\pi$}, and
-when \tcode{x} is a negative real number, \tcode{imag(log(x))} is $\pi$.
+\tcode{imag(log(x))} lies in the interval \crange{$-\pi$}{$\pi$}.
+\begin{note}
+The semantics of this function are intended to be the same in \Cpp
+as they are for \tcode{clog} in C.
+\end{note}
 
 \pnum
 \remarks
@@ -1240,8 +1243,10 @@
 \returns
 The complex square root of \tcode{x}, in the range of the right
 half-plane.
-If the argument is a negative real number, the
-value returned lies on the positive imaginary axis.
+\begin{note}
+The semantics of this function are intended to be the same in \Cpp
+as they are for \tcode{csqrt} in C.
+\end{note}
 
 \pnum
 \remarks

source/utilities.tex

@@ -133,8 +133,7 @@
   template <size_t I, class T> class tuple_element;
 
   template <class T1, class T2> struct tuple_size<pair<T1, T2>>;
-  template <class T1, class T2> struct tuple_element<0, pair<T1, T2>>;
-  template <class T1, class T2> struct tuple_element<1, pair<T1, T2>>;
+  template <size_t I, class T1, class T2> struct tuple_element<I, pair<T1, T2>>;
 
   template<size_t I, class T1, class T2>
     constexpr tuple_element_t<I, pair<T1, T2>>& get(pair<T1, T2>&) noexcept;
@@ -1287,18 +1286,14 @@
 
 \indexlibrary{\idxcode{tuple_element}}%
 \begin{itemdecl}
-tuple_element<0, pair<T1, T2>>::type
+tuple_element<I, pair<T1, T2>>::type
 \end{itemdecl}
 \begin{itemdescr}
-\pnum\textit{Value:} The type \tcode{T1}.
-\end{itemdescr}
+\pnum
+\requires \tcode{I < 2}. The program is ill-formed if \tcode{I} is out of bounds.
 
-\indexlibrary{\idxcode{tuple_element}}%
-\begin{itemdecl}
-tuple_element<1, pair<T1, T2>>::type
-\end{itemdecl}
-\begin{itemdescr}
-\pnum\textit{Value:} The type T2.
+\pnum
+\textit{Value:} The type \tcode{T1} if \tcode{I == 0}, otherwise the type \tcode{T2}.
 \end{itemdescr}
 
 \indexlibrarymember{get}{pair}%
@@ -5030,6 +5025,7 @@
 \begin{itemdescr}
 \pnum
 \requires \tcode{I < sizeof...(Types)}.
+The program is ill-formed if \tcode{I} is out of bounds.
 
 \pnum
 \textit{Value:} The type $\tcode{T}_I$.
@@ -10494,8 +10490,8 @@
     long use_count() const noexcept;
     bool expired() const noexcept;
     shared_ptr<T> lock() const noexcept;
-    template<class U> bool owner_before(const shared_ptr<U>& b) const;
-    template<class U> bool owner_before(const weak_ptr<U>& b) const;
+    template<class U> bool owner_before(const shared_ptr<U>& b) const noexcept;
+    template<class U> bool owner_before(const weak_ptr<U>& b) const noexcept;
   };
 
   template<class T> weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
@@ -10654,8 +10650,8 @@
 
 \indexlibrarymember{owner_before}{weak_ptr}%
 \begin{itemdecl}
-template<class U> bool owner_before(const shared_ptr<U>& b) const;
-template<class U> bool owner_before(const weak_ptr<U>& b) const;
+template<class U> bool owner_before(const shared_ptr<U>& b) const noexcept;
+template<class U> bool owner_before(const weak_ptr<U>& b) const noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -11710,10 +11706,6 @@
 sets the value of the default memory resource pointer to \tcode{r},
 otherwise sets the default memory resource pointer to \tcode{new_delete_resource()}.
 
-\pnum
-\postconditions
-\tcode{get_default_resource() == r}.
-
 \pnum
 \returns
 The previous value of the default memory resource pointer.