LWG Poll 2: P2051R0 C++ Standard Library Issues to be moved in Prague

source/algorithms.tex

@@ -2846,7 +2846,7 @@
       lexicographical_compare_three_way(InputIterator1 b1, InputIterator1 e1,
                                         InputIterator2 b2, InputIterator2 e2,
                                         Cmp comp)
-        -> common_comparison_category_t<decltype(comp(*b1, *b2)), strong_ordering>;
+        -> decltype(comp(*b1, *b2));
   template<class InputIterator1, class InputIterator2>
     constexpr auto
       lexicographical_compare_three_way(InputIterator1 b1, InputIterator1 e1,
@@ -8444,7 +8444,7 @@
     lexicographical_compare_three_way(InputIterator1 b1, InputIterator1 e1,
                                       InputIterator2 b2, InputIterator2 e2,
                                       Cmp comp)
-      -> common_comparison_category_t<decltype(comp(*b1, *b2)), strong_ordering>;
+      -> decltype(comp(*b1, *b2));
 \end{itemdecl}
 
 \begin{itemdescr}

source/back.tex

@@ -6,6 +6,9 @@ \chapter{Bibliography}
 
 \begin{itemize}
 \renewcommand{\labelitemi}{---}
+\item
+  IANA Time Zone Database,
+  available at \url{https://www.iana.org/time-zones}
 \item
   ISO/IEC 10967-1:2012,
   \doccite{Information technology --- Language independent arithmetic ---

source/concepts.tex

@@ -200,9 +200,9 @@
   template<class T, class... Args>
     concept constructible_from = @\seebelow@;
 
-  // \ref{concept.defaultconstructible}, concept \libconcept{default_constructible}
+  // \ref{concept.default.init}, concept \libconcept{default_initializable}
   template<class T>
-    concept default_constructible = @\seebelow@;
+    concept default_initializable = @\seebelow@;
 
   // \ref{concept.moveconstructible}, concept \libconcept{move_constructible}
   template<class T>
@@ -314,29 +314,33 @@
 \rSec2[concept.convertible]{Concept \cname{convertible_to}}
 
 \pnum
-The \libconcept{convertible_to} concept requires an expression of a particular
-type and value category to be both implicitly and explicitly convertible to some
-other type. The implicit and explicit conversions are required to produce equal
+Given types \tcode{From} and \tcode{To} and
+an expression \tcode{E} such that
+\tcode{decltype((E))} is \tcode{add_rvalue_reference_t<From>},
+\tcode{\libconcept{convertible_to}<From, To>} requires \tcode{E}
+to be both implicitly and explicitly convertible to type \tcode{To}.
+The implicit and explicit conversions are required to produce equal
 results.
 
 \begin{itemdecl}
 template<class From, class To>
   concept @\deflibconcept{convertible_to}@ =
     is_convertible_v<From, To> &&
-    requires(From (&f)()) {
+    requires(add_rvalue_reference_t<From> (&f)()) {
       static_cast<To>(f());
     };
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-Let \tcode{test} be the invented function:
+Let \tcode{FromR} be \tcode{add_rvalue_reference_t<From>} and
+\tcode{test} be the invented function:
 \begin{codeblock}
-To test(From (&f)()) {
+To test(FromR (&f)()) {
   return f();
 }
 \end{codeblock}
-and let \tcode{f} be a function with no arguments and return type \tcode{From}
+and let \tcode{f} be a function with no arguments and return type \tcode{FromR}
 such that \tcode{f()} is equality-preserving.
 Types \tcode{From} and \tcode{To} model \tcode{\libconcept{convertible_to}<From, To>}
 only if:
@@ -347,11 +351,11 @@
 \tcode{static_cast<To>(f())} is equal to \tcode{test(f)}.
 
 \item
-\tcode{From} is not a reference-to-object type, or
+\tcode{FromR} is not a reference-to-object type, or
 
 \begin{itemize}
 \item
-If \tcode{From} is an rvalue reference to a non const-qualified type, the
+If \tcode{FromR} is an rvalue reference to a non const-qualified type, the
 resulting state of the object referenced by \tcode{f()} after either above
 expression is valid but unspecified\iref{lib.types.movedfrom}.
 
@@ -735,14 +739,14 @@
   concept @\deflibconcept{constructible_from}@ = destructible<T> && is_constructible_v<T, Args...>;
 \end{itemdecl}
 
-\rSec2[concept.defaultconstructible]{Concept \cname{default_constructible}}
+\rSec2[concept.default.init]{Concept \cname{default_initializable}}
 
 \begin{itemdecl}
 template<class T>
   inline constexpr bool @\defexposconcept{is-default-initializable}@ = @\seebelow@;  // \expos
 
 template<class T>
-  concept @\deflibconcept{default_constructible}@ = constructible_from<T> &&
+  concept @\deflibconcept{default_initializable}@ = constructible_from<T> &&
                                   requires { T{}; } &&
                                   @\exposconcept{is-default-initializable}@<T>;
 \end{itemdecl}
@@ -957,14 +961,7 @@
 \begin{itemdecl}
 template<class T>
   concept @\deflibconcept{totally_ordered}@ =
-    equality_comparable<T> &&
-    requires(const remove_reference_t<T>& a,
-             const remove_reference_t<T>& b) {
-      { a <  b } -> boolean;
-      { a >  b } -> boolean;
-      { a <= b } -> boolean;
-      { a >= b } -> boolean;
-    };
+    equality_comparable<T> && @\exposconcept{partially-ordered-with}@<T, T>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -978,7 +975,6 @@
       \tcode{bool(a == b)} is \tcode{true}.
 \item If \tcode{bool(a < b)} and \tcode{bool(b < c)}, then
       \tcode{bool(a < c)}.
-\item \tcode{bool(a >  b) ==  bool(b < a)}.
 \item \tcode{bool(a <= b) == !bool(b < a)}.
 \item \tcode{bool(a >= b) == !bool(a < b)}.
 \end{itemize}
@@ -989,23 +985,12 @@
 template<class T, class U>
   concept @\deflibconcept{totally_ordered_with}@ =
     totally_ordered<T> && totally_ordered<U> &&
-    common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
+    equality_comparable_with<T, U> &&
     totally_ordered<
       common_reference_t<
         const remove_reference_t<T>&,
         const remove_reference_t<U>&>> &&
-    equality_comparable_with<T, U> &&
-    requires(const remove_reference_t<T>& t,
-             const remove_reference_t<U>& u) {
-      { t <  u } -> boolean;
-      { t >  u } -> boolean;
-      { t <= u } -> boolean;
-      { t >= u } -> boolean;
-      { u <  t } -> boolean;
-      { u >  t } -> boolean;
-      { u <= t } -> boolean;
-      { u >= t } -> boolean;
-    };
+    @\exposconcept{partially-ordered-with}@<T, U>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1045,7 +1030,7 @@
 template<class T>
   concept @\deflibconcept{copyable}@ = copy_constructible<T> && movable<T> && assignable_from<T&, const T&>;
 template<class T>
-  concept @\deflibconcept{semiregular}@ = copyable<T> && default_constructible<T>;
+  concept @\deflibconcept{semiregular}@ = copyable<T> && default_initializable<T>;
 template<class T>
   concept @\deflibconcept{regular}@ = semiregular<T> && equality_comparable<T>;
 \end{itemdecl}

source/containers.tex

@@ -3114,7 +3114,8 @@
 
 \indexheader{array}%
 \begin{codeblock}
-#include <initializer_list>
+#include <compare>              // see \ref{compare.syn}
+#include <initializer_list>     // see \ref{initializer.list.syn}
 
 namespace std {
   // \ref{array}, class template \tcode{array}
@@ -3151,7 +3152,8 @@
 
 \indexheader{deque}%
 \begin{codeblock}
-#include <initializer_list>
+#include <compare>              // see \ref{compare.syn}
+#include <initializer_list>     // see \ref{initializer.list.syn}
 
 namespace std {
   // \ref{deque}, class template \tcode{deque}
@@ -3183,7 +3185,8 @@
 
 \indexheader{forward_list}%
 \begin{codeblock}
-#include <initializer_list>
+#include <compare>              // see \ref{compare.syn}
+#include <initializer_list>     // see \ref{initializer.list.syn}
 
 namespace std {
   // \ref{forwardlist}, class template \tcode{forward_list}
@@ -3215,7 +3218,8 @@
 
 \indexheader{list}%
 \begin{codeblock}
-#include <initializer_list>
+#include <compare>              // see \ref{compare.syn}
+#include <initializer_list>     // see \ref{initializer.list.syn}
 
 namespace std {
   // \ref{list}, class template \tcode{list}
@@ -3247,7 +3251,8 @@
 
 \indexheader{vector}%
 \begin{codeblock}
-#include <initializer_list>
+#include <compare>              // see \ref{compare.syn}
+#include <initializer_list>     // see \ref{initializer.list.syn}
 
 namespace std {
   // \ref{vector}, class template \tcode{vector}
@@ -6249,7 +6254,8 @@
 
 \indexheader{map}%
 \begin{codeblock}
-#include <initializer_list>
+#include <compare>              // see \ref{compare.syn}
+#include <initializer_list>     // see \ref{initializer.list.syn}
 
 namespace std {
   // \ref{map}, class template \tcode{map}
@@ -6310,7 +6316,8 @@
 
 \indexheader{set}%
 \begin{codeblock}
-#include <initializer_list>
+#include <compare>              // see \ref{compare.syn}
+#include <initializer_list>     // see \ref{initializer.list.syn}
 
 namespace std {
   // \ref{set}, class template \tcode{set}
@@ -7805,7 +7812,8 @@
 \indexlibraryglobal{unordered_map}%
 \indexlibraryglobal{unordered_multimap}%
 \begin{codeblock}
-#include <initializer_list>
+#include <compare>              // see \ref{compare.syn}
+#include <initializer_list>     // see \ref{initializer.list.syn}
 
 namespace std {
   // \ref{unord.map}, class template \tcode{unordered_map}
@@ -7874,7 +7882,8 @@
 \indexlibraryglobal{unordered_set}%
 \indexlibraryglobal{unordered_multiset}%
 \begin{codeblock}
-#include <initializer_list>
+#include <compare>              // see \ref{compare.syn}
+#include <initializer_list>     // see \ref{initializer.list.syn}
 
 namespace std {
   // \ref{unord.set}, class template \tcode{unordered_set}
@@ -9587,7 +9596,8 @@
 
 \indexheader{queue}
 \begin{codeblock}
-#include <initializer_list>
+#include <compare>              // see \ref{compare.syn}
+#include <initializer_list>     // see \ref{initializer.list.syn}
 
 namespace std {
   template<class T, class Container = deque<T>> class queue;
@@ -9629,7 +9639,8 @@
 
 \indexheader{stack}%
 \begin{codeblock}
-#include <initializer_list>
+#include <compare>              // see \ref{compare.syn}
+#include <initializer_list>     // see \ref{initializer.list.syn}
 
 namespace std {
   template<class T, class Container = deque<T>> class stack;
@@ -10514,6 +10525,9 @@
   template<class ElementType, size_t Extent = dynamic_extent>
     class span;
 
+  template<class ElementType, size_t Extent>
+    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;
 
@@ -10568,9 +10582,7 @@
     using reference = element_type&;
     using const_reference = const element_type&;
     using iterator = @\impdefx{type of \tcode{span::iterator}}@;        // see \ref{span.iterators}
-    using const_iterator = @\impdefx{type of \tcode{span::const_iterator}}@;
     using reverse_iterator = std::reverse_iterator<iterator>;
-    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     static constexpr size_type extent = Extent;
 
     // \ref{span.cons}, constructors, copy, and assignment
@@ -10622,12 +10634,8 @@
     // \ref{span.iterators}, iterator support
     constexpr iterator begin() const noexcept;
     constexpr iterator end() const noexcept;
-    constexpr const_iterator cbegin() const noexcept;
-    constexpr const_iterator cend() const noexcept;
     constexpr reverse_iterator rbegin() const noexcept;
     constexpr reverse_iterator rend() const noexcept;
-    constexpr const_reverse_iterator crbegin() const noexcept;
-    constexpr const_reverse_iterator crend() const noexcept;
 
   private:
     pointer data_;              // \expos
@@ -11119,23 +11127,21 @@
 \rSec3[span.iterators]{Iterator support}
 
 \indexlibrarymember{iterator}{span}%
-\indexlibrarymember{const_iterator}{span}%
 \begin{itemdecl}
 using iterator = @\impdefx{type of \tcode{span::iterator}}@;
-using const_iterator = @\impdefx{type of \tcode{span::const_iterator}}@;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-The types
-model \libconcept{contiguous_iterator}\iref{iterator.concept.contiguous},
-meet the \oldconcept{RandomAccessIterator}
+The type
+models \libconcept{contiguous_iterator}\iref{iterator.concept.contiguous},
+meets the \oldconcept{RandomAccessIterator}
 requirements\iref{random.access.iterators},
 and
-meet the requirements for
+meets the requirements for
 constexpr iterators\iref{iterator.requirements.general}.
 All requirements on container iterators\iref{container.requirements} apply to
-\tcode{span::iterator} and \tcode{span::const_iterator} as well.
+\tcode{span::iterator} as well.
 \end{itemdescr}
 
 \indexlibrarymember{span}{begin}%
@@ -11184,52 +11190,6 @@
 Equivalent to: \tcode{return reverse_iterator(begin());}
 \end{itemdescr}
 
-\indexlibrarymember{span}{cbegin}%
-\begin{itemdecl}
-constexpr const_iterator cbegin() const noexcept;
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\returns
-A constant iterator referring to the first element in the span.
-If \tcode{empty()} is \tcode{true}, then it returns the same value
-as \tcode{cend()}.
-\end{itemdescr}
-
-\indexlibrarymember{span}{cend}%
-\begin{itemdecl}
-constexpr const_iterator cend() const noexcept;
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\returns
-A constant iterator which is the past-the-end value.
-\end{itemdescr}
-
-\indexlibrarymember{span}{crbegin}%
-\begin{itemdecl}
-constexpr const_reverse_iterator crbegin() const noexcept;
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\effects
-Equivalent to: \tcode{return const_reverse_iterator(cend());}
-\end{itemdescr}
-
-\indexlibrarymember{span}{crend}%
-\begin{itemdecl}
-constexpr const_reverse_iterator crend() const noexcept;
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\effects
-Equivalent to: \tcode{return const_reverse_iterator(cbegin());}
-\end{itemdescr}
-
 
 \rSec3[span.objectrep]{Views of object representation}