cplusplus · zygoloid · Feb 28, 2020 · Feb 17, 2020 · Feb 17, 2020 · Feb 17, 2020
diff --git a/source/algorithms.tex b/source/algorithms.tex
diff --git a/source/concepts.tex b/source/concepts.tex
@@ -562,13 +562,14 @@
 \item If \tcode{T} and \tcode{U} are the same type, the result of the operation
   is that \tcode{t1} equals \tcode{u2} and \tcode{u1} equals \tcode{t2}.
 
-\item If \tcode{T} and \tcode{U} are different types that model
-  \tcode{\libconcept{common_reference_with}<const T\&, const U\&>},
+\item If \tcode{T} and \tcode{U} are different types and
+  \tcode{\libconcept{common_reference_with}<decltype((t1)), decltype((u1))>}
+  is modeled,
   the result of the operation is that
   \tcode{C(t1)} equals \tcode{C(u2)}
   and
   \tcode{C(u1)} equals \tcode{C(t2)}
-  where \tcode{C} is \tcode{common_reference_t<const T\&, const U\&>}.
+  where \tcode{C} is \tcode{common_reference_t<decltype((t1)), decltype((u1))>}.
 \end{itemize}
 
 \pnum
@@ -648,7 +649,7 @@
 \begin{itemdecl}
 template<class T, class U>
   concept @\deflibconcept{swappable_with}@ =
-    common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
+    common_reference_with<T, U> &&
     requires(T&& t, U&& u) {
       ranges::swap(std::forward<T>(t), std::forward<T>(t));
       ranges::swap(std::forward<U>(u), std::forward<U>(u));
@@ -686,13 +687,14 @@
 
 namespace N {
   struct A { int m; };
-  struct Proxy { A* a; };
-  Proxy proxy(A& a) { return Proxy{ &a }; }
-
-  void swap(A& x, Proxy p) {
-    ranges::swap(x.m, p.a->m);
-  }
-  void swap(Proxy p, A& x) { swap(x, p); }      // satisfy symmetry requirement
+  struct Proxy {
+    A* a;
+    Proxy(A& a) : a{&a} {}
+    friend void swap(Proxy x, Proxy y) {
+      ranges::swap(*x.a, *y.a);
+    }
+  };
+  Proxy proxy(A& a) { return Proxy{ a }; }
 }
 
 int main() {
@@ -805,9 +807,11 @@
 \tcode{T} models \libconcept{copy_constructible} only if
 
 \begin{itemize}
-\item After the definition \tcode{T u = v;}, \tcode{u} is equal to \tcode{v}.
+\item After the definition \tcode{T u = v;},
+\tcode{u} is equal to \tcode{v}\iref{concepts.equality} and
+\tcode{v} is not modified.
 
-\item \tcode{T(v)} is equal to \tcode{v}.
+\item \tcode{T(v)} is equal to \tcode{v} and does not modify \tcode{v}.
 \end{itemize}
 
 \end{itemdescr}

diff --git a/source/containers.tex b/source/containers.tex
@@ -214,11 +214,9 @@
  constant                   \\ \rowsep
 
 \tcode{i <=> j}             &
-  \tcode{strong_ordering}
-  if \tcode{X::iterator} meets the random access iterator requirements,
-  otherwise \tcode{strong_equality} &
-                             &
-                             &
+  \tcode{strong_ordering}   &
+                            &
+  \constraints \tcode{X::iterator} meets the random access iterator requirements. &
  constant                   \\ \rowsep
 
 \tcode{a == b}                  &
@@ -3121,6 +3119,13 @@
   // \ref{array}, class template \tcode{array}
   template<class T, size_t N> struct array;
 
+  template<class T, size_t N>
+    constexpr bool operator==(const array<T, N>& x, const array<T, N>& y);
+  template<class T, size_t N>
+    constexpr @\placeholder{synth-three-way-result}@<T>
+      operator<=>(const array<T, N>& x, const array<T, N>& y);
+
+  // \ref{array.special}, specialized algorithms
   template<class T, size_t N>
     constexpr void swap(array<T, N>& x, array<T, N>& y) noexcept(noexcept(x.swap(y)));
 
@@ -3319,6 +3324,14 @@
 one of these tables and
 for operations where there is additional semantic information.
 
+\pnum
+\tcode{array<T, N>} is a structural type\iref{temp.param} if
+\tcode{T} is a structural type.
+Two values \tcode{a1} and \tcode{a2} of type \tcode{array<T, N>}
+are template-argument-equivalent\iref{temp.type} if and only if
+each pair of corresponding elements in \tcode{a1} and \tcode{a2}
+are template-argument-equivalent.
+
 \pnum
 The types \tcode{iterator} and \tcode{const_iterator} meet
 the constexpr iterator requirements\iref{iterator.requirements.general}.
@@ -3383,10 +3396,6 @@
 
     constexpr T *       data() noexcept;
     constexpr const T * data() const noexcept;
-
-    friend constexpr bool operator==(const array&, const array&) = default;
-    friend constexpr @\placeholder{synth-three-way-result}@<value_type>
-      operator<=>(const array&, const array&);
   };
 
   template<class T, class... U>
@@ -10529,7 +10538,7 @@
     inline constexpr bool ranges::enable_view<span<ElementType, Extent>> =
       Extent == 0 || Extent == dynamic_extent;
   template<class ElementType, size_t Extent>
-    inline constexpr bool ranges::enable_safe_range<span<ElementType, Extent>> = true;
+    inline constexpr bool ranges::enable_borrowed_range<span<ElementType, Extent>> = true;
 
   // \ref{span.objectrep}, views of object representation
   template<class ElementType, size_t Extent>
@@ -10592,11 +10601,11 @@
     template<class It, class End>
       constexpr span(It first, End last);
     template<size_t N>
-      constexpr span(element_type (&arr)[N]) noexcept;
-    template<size_t N>
-      constexpr span(array<value_type, N>& arr) noexcept;
-    template<size_t N>
-      constexpr span(const array<value_type, N>& arr) noexcept;
+      constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept;
+    template<class T, size_t N>
+      constexpr span(array<T, N>& arr) noexcept;
+    template<class T, size_t N>
+      constexpr span(const array<T, N>& arr) noexcept;
     template<class R>
       constexpr span(R&& r);
     constexpr span(const span& other) noexcept = default;
@@ -10756,14 +10765,14 @@
 
 \pnum
 \throws
-Nothing.
+When and what \tcode{last - first} throws.
 \end{itemdescr}
 
 \indexlibraryctor{span}%
 \begin{itemdecl}
-template<size_t N> constexpr span(element_type (&arr)[N]) noexcept;
-template<size_t N> constexpr span(array<value_type, N>& arr) noexcept;
-template<size_t N> constexpr span(const array<value_type, N>& arr) noexcept;
+template<size_t N> constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept;
+template<class T, size_t N> constexpr span(array<T, N>& arr) noexcept;
+template<class T, size_t N> constexpr span(const array<T, N>& arr) noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -10777,10 +10786,13 @@
 \pnum
 \effects
 Constructs a \tcode{span} that is a view over the supplied array.
+\begin{note}
+\tcode{type_identity_t} affects class template argument deduction.
+\end{note}
 
 \pnum
 \ensures
-\tcode{size() == N \&\& data() == data(arr)}.
+\tcode{size() == N \&\& data() == data(arr)} is \tcode{true}.
 \end{itemdescr}
 
 \indexlibraryctor{span}%
@@ -10796,7 +10808,7 @@
 \item \tcode{extent == dynamic_extent} is \tcode{true}.
 \item \tcode{R} satisfies \tcode{ranges::\libconcept{contiguous_range}} and
   \tcode{ranges::\libconcept{sized_range}}.
-\item Either \tcode{R} satisfies \tcode{ranges::\libconcept{safe_range}} or
+\item Either \tcode{R} satisfies \tcode{ranges::\libconcept{borrowed_range}} or
 \tcode{is_const_v<element_type>} is \tcode{true}.
 \item \tcode{remove_cvref_t<R>} is not a specialization of \tcode{span}.
 \item \tcode{remove_cvref_t<R>} is not a specialization of \tcode{array}.
@@ -10815,7 +10827,7 @@
 \item \tcode{R} models \tcode{ranges::\libconcept{contiguous_range}} and
 \tcode{ranges::\libconcept{sized_range}}.
 \item If \tcode{is_const_v<element_type>} is \tcode{false},
-\tcode{R} models \tcode{ranges::\libconcept{safe_range}}.
+\tcode{R} models \tcode{ranges::\libconcept{borrowed_range}}.
 \end{itemize}
 
 \pnum

diff --git a/source/future.tex b/source/future.tex
@@ -2477,6 +2477,13 @@
 For Windows-based operating systems a conversion from UTF-8 to
     UTF-16 occurs.
 \end{example}
+\begin{note}
+The example above is representative of
+a historical use of \tcode{filesystem::u8path}.
+Passing a \tcode{std::u8string} to \tcode{path}'s constructor is preferred
+for an indication of UTF-8 encoding more consistent with
+\tcode{path}'s handling of other encodings.
+\end{note}
 \end{itemdescr}
 
 \rSec1[depr.atomics]{Deprecated atomic initialization}

diff --git a/source/iostreams.tex b/source/iostreams.tex
@@ -5548,21 +5548,23 @@
 
 \indexlibrarymember{operator>>}{basic_istream}%
 \begin{itemdecl}
-template<class charT, class traits, class T>
-  basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&& is, T&& x);
+template<class Istream, class T>
+  Istream&& operator>>(Istream&& is, T&& x);
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \constraints
-The expression \tcode{is >> std::forward<T>(x)} is well-formed when treated as an unevaluated operand.
+The expression \tcode{is >> std::forward<T>(x)} is well-formed
+when treated as an unevaluated operand and
+\tcode{Istream} is publicly and unambiguously derived from \tcode{ios_base}.
 
 \pnum
 \effects
 Equivalent to:
 \begin{codeblock}
 is >> std::forward<T>(x);
-return is;
+return std::move(is);
 \end{codeblock}
 \end{itemdescr}
 
@@ -6759,22 +6761,24 @@
 
 \indexlibrarymember{operator<<}{basic_ostream}%
 \begin{itemdecl}
-template<class charT, class traits, class T>
-  basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&& os, const T& x);
+template<class Ostream, class T>
+  Ostream&& operator<<(Ostream&& os, const T& x);
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \constraints
-The expression \tcode{os << x} is well-formed when treated as an unevaluated operand.
+The expression \tcode{os << x} is well-formed
+when treated as an unevaluated operand and
+\tcode{Ostream} is publicly and unambiguously derived from \tcode{ios_base}.
 
 \pnum
 \effects
 As if by: \tcode{os << x;}
 
 \pnum
 \returns
-\tcode{os}.
+\tcode{std::move(os)}.
 \end{itemdescr}
 
 
@@ -11054,7 +11058,7 @@
     basic_osyncstream(basic_osyncstream&&) noexcept;
     ~basic_osyncstream();
 
-    // \ref{syncstream.osyncstream.assign}, assignment
+    // assignment
     basic_osyncstream& operator=(basic_osyncstream&&) noexcept;
 
     // \ref{syncstream.osyncstream.members}, member functions
@@ -11140,46 +11144,6 @@
 \tcode{nullptr == other.get_wrapped()} is \tcode{true}.
 \end{itemdescr}
 
-\indexlibrarydtor{basic_osyncstream}%
-\begin{itemdecl}
-~basic_osyncstream();
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\effects
-Calls \tcode{emit()}.
-If an exception is thrown from \tcode{emit()},
-that exception is caught and ignored.
-\end{itemdescr}
-
-\rSec3[syncstream.osyncstream.assign]{Assignment}
-
-\indexlibrarymember{operator=}{basic_osyncstream}%
-\begin{itemdecl}
-basic_osyncstream& operator=(basic_osyncstream&& rhs) noexcept;
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\effects
-First, calls \tcode{emit()}.
-If an exception is thrown from \tcode{emit()},
-that exception is caught and ignored.
-Move assigns \tcode{sb} from \tcode{rhs.sb}.
-\begin{note}
-This disassociates \tcode{rhs}
-from its wrapped stream buffer
-ensuring destruction of \tcode{rhs} produces no output.
-\end{note}
-
-\pnum
-\ensures
-\tcode{nullptr == rhs.get_wrapped()} is \tcode{true}.
-\tcode{get_wrapped()} returns the value
-previously returned by \tcode{rhs.get_wrapped()}.
-\end{itemdescr}
-
 \rSec3[syncstream.osyncstream.members]{Member functions}
 
 \indexlibrarymember{set_emit_on_sync}{basic_osyncstream}%

diff --git a/source/iterators.tex b/source/iterators.tex
@@ -371,7 +371,7 @@
 
   // \ref{iterators.common}, common iterators
   template<input_or_output_iterator I, sentinel_for<I> S>
-    requires (!same_as<I, S>)
+    requires (!same_as<I, S> && copyable<I>)
       class common_iterator;
 
   template<class I, class S>
@@ -1058,9 +1058,13 @@
 \begin{itemize}
 \item \tcode{iter_move(E)}, if
 \tcode{E} has class or enumeration type and
-\tcode{iter_move(E)} is a well-formed expression with overload
-resolution performed in a context that does not include a declaration of
-\tcode{ranges::iter_move}.
+\tcode{iter_move(E)} is a well-formed expression when treated as an unevaluated operand,
+with overload resolution performed in a context
+that does not include a declaration of \tcode{ranges::iter_move}
+but does include the declaration
+\begin{codeblock}
+void iter_move();
+\end{codeblock}
 
 \item Otherwise, if the expression \tcode{*E} is well-formed:
 \begin{itemize}
@@ -1357,13 +1361,17 @@
 \end{itemize}
 
 \pnum
-All integer-class types are explicitly convertible to all integral types and
-implicitly and explicitly convertible from all integral types.
+Expressions of integer-class type are
+explicitly convertible to any integral type.
+Expressions of integral type are
+both implicitly and explicitly convertible to any integer-class type.
+Conversions between integral and integer-class types
+do not exit via an exception.
 
 \pnum
-All integer-class types are contextually convertible to \tcode{bool}
-as if by \tcode{bool(a != I(0))}, where \tcode{a} is an
-instance of the integral-class type \tcode{I}.
+An expression \tcode{E} of integer-class type \tcode{I} is
+contextually convertible to \tcode{bool}
+as if by \tcode{bool(E != I(0))}.
 
 \pnum
 All integer-class types model
@@ -4556,7 +4564,7 @@
 \begin{itemdescr}
 \pnum
 \returns
-\tcode{move_iterator<Iterator>(i)}.
+\tcode{move_iterator<Iterator>(std::move(i))}.
 \end{itemdescr}
 
 \rSec3[move.sentinel]{Class template \tcode{move_sentinel}}
@@ -4704,7 +4712,7 @@
 \begin{codeblock}
 namespace std {
   template<input_or_output_iterator I, sentinel_for<I> S>
-    requires (!same_as<I, S>)
+    requires (!same_as<I, S> && copyable<I>)
   class common_iterator {
   public:
     constexpr common_iterator() = default;
@@ -5238,7 +5246,7 @@
 
 \pnum
 \effects
-Initializes \tcode{current} with \tcode{i} and
+Initializes \tcode{current} with \tcode{std::move(i)} and
 \tcode{length} with \tcode{n}.
 \end{itemdescr}