P3016R6 Resolve inconsistencies in begin/end for valarray and braced initializer lists

Author: AlisdairM

source/containers.tex

@@ -20532,7 +20532,7 @@
 
 \pnum
 \effects
-Initializes \exposid{data_} with \tcode{il.begin()} and
+Initializes \exposid{data_} with \tcode{il.data()} and
 \exposid{size_} with \tcode{il.size()}.
 \end{itemdescr}
 

source/iterators.tex

@@ -33,6 +33,7 @@
 \begin{codeblock}
 #include <compare>              // see \ref{compare.syn}
 #include <concepts>             // see \ref{concepts.syn}
+#include <initializer_list>     // see \ref{initializer.list.syn}
 
 namespace std {
   template<class T> using @\exposid{with-reference}@ = T&;  // \expos
@@ -464,53 +465,64 @@
     class ostreambuf_iterator;
 
   // \ref{iterator.range}, range access
-  template<class C> constexpr auto begin(C& c) -> decltype(c.begin());              // freestanding
-  template<class C> constexpr auto begin(const C& c) -> decltype(c.begin());        // freestanding
-  template<class C> constexpr auto end(C& c) -> decltype(c.end());                  // freestanding
-  template<class C> constexpr auto end(const C& c) -> decltype(c.end());            // freestanding
+  template<class C> constexpr auto
+    begin(C& c) noexcept(noexcept(c.begin())) -> decltype(c.begin());               // freestanding
+  template<class C> constexpr auto
+    begin(const C& c) noexcept(noexcept(c.begin())) -> decltype(c.begin());         // freestanding
+  template<class C> constexpr auto
+    end(C& c) noexcept(noexcept(c.end())) -> decltype(c.end());                     // freestanding
+  template<class C> constexpr auto
+    end(const C& c) noexcept(noexcept(c.end())) -> decltype(c.end());               // freestanding
   template<class T, size_t N> constexpr T* begin(T (&array)[N]) noexcept;           // freestanding
   template<class T, size_t N> constexpr T* end(T (&array)[N]) noexcept;             // freestanding
-  template<class C> constexpr auto cbegin(const C& c)                               // freestanding
-    noexcept(noexcept(std::begin(c))) -> decltype(std::begin(c));
-  template<class C> constexpr auto cend(const C& c)                                 // freestanding
-    noexcept(noexcept(std::end(c))) -> decltype(std::end(c));
-  template<class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin());            // freestanding
-  template<class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin());      // freestanding
-  template<class C> constexpr auto rend(C& c) -> decltype(c.rend());                // freestanding
-  template<class C> constexpr auto rend(const C& c) -> decltype(c.rend());          // freestanding
-  template<class T, size_t N> constexpr reverse_iterator<T*> rbegin(T (&array)[N])  // freestanding
-  template<class T, size_t N> constexpr reverse_iterator<T*> rend(T (&array)[N]);   // freestanding
+  template<class C> constexpr auto
+    cbegin(const C& c) noexcept(noexcept(std::begin(c)))
+      -> decltype(std::begin(c));                                                   // freestanding
+  template<class C> constexpr auto
+    cend(const C& c) noexcept(noexcept(std::end(c))) -> decltype(std::end(c));      // freestanding
+  template<class C> constexpr auto
+    rbegin(C& c) noexcept(noexcept(c.rbegin())) -> decltype(c.rbegin());            // freestanding
+  template<class C> constexpr auto
+    rbegin(const C& c) noexcept(noexcept(c.rbegin())) -> decltype(c.rbegin());      // freestanding
+  template<class C> constexpr auto
+    rend(C& c) noexcept(noexcept(c.rend())) -> decltype(c.rend());                  // freestanding
+  template<class C> constexpr auto
+    rend(const C& c) noexcept(noexcept(c.rend())) -> decltype(c.rend());            // freestanding
+  template<class T, size_t N> constexpr reverse_iterator<T*>
+    rbegin(T (&array)[N]) noexcept;                                                 // freestanding
+  template<class T, size_t N> constexpr reverse_iterator<T*>
+    rend(T (&array)[N]) noexcept;                                                   // freestanding
   template<class E> constexpr reverse_iterator<const E*>
-    rbegin(initializer_list<E> il);                                                 // freestanding
+    rbegin(initializer_list<E> il) noexcept;                                        // freestanding
   template<class E> constexpr reverse_iterator<const E*>
-    rend(initializer_list<E> il);                                                   // freestanding
+    rend(initializer_list<E> il) noexcept;                                          // freestanding
   template<class C> constexpr auto
-    crbegin(const C& c) -> decltype(std::rbegin(c));                                // freestanding
+    crbegin(const C& c) noexcept(noexcept(std::rbegin(c)))
+      -> decltype(std::rbegin(c));                                                  // freestanding
   template<class C> constexpr auto
-    crend(const C& c) -> decltype(std::rend(c));                                    // freestanding
+    crend(const C& c) noexcept(noexcept(std::rend(c))) -> decltype(std::rend(c));   // freestanding
 
   template<class C> constexpr auto
-    size(const C& c) -> decltype(c.size());                                         // freestanding
+    size(const C& c) noexcept(noexcept(c.size())) -> decltype(c.size());            // freestanding
   template<class T, size_t N> constexpr size_t
     size(const T (&array)[N]) noexcept;                                             // freestanding
 
   template<class C> constexpr auto
-    ssize(const C& c)
+    ssize(const C& c) noexcept(noexcept(c.size()))
       -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>;               // freestanding
   template<class T, ptrdiff_t N> constexpr ptrdiff_t
     ssize(const T (&array)[N]) noexcept;                                            // freestanding
 
   template<class C> constexpr auto
-    empty(const C& c) -> decltype(c.empty());                                       // freestanding
+    empty(const C& c) noexcept(noexcept(c.empty())) -> decltype(c.empty());         // freestanding
   template<class T, size_t N> constexpr bool
     empty(const T (&array)[N]) noexcept;                                            // freestanding
-  template<class E> constexpr bool
-    empty(initializer_list<E> il) noexcept;                                         // freestanding
 
-  template<class C> constexpr auto data(C& c) -> decltype(c.data());                // freestanding
-  template<class C> constexpr auto data(const C& c) -> decltype(c.data());          // freestanding
+  template<class C> constexpr auto
+    data(C& c) noexcept(noexcept(c.data())) -> decltype(c.data());                  // freestanding
+  template<class C> constexpr auto
+    data(const C& c) noexcept(noexcept(c.data())) -> decltype(c.data());            // freestanding
   template<class T, size_t N> constexpr T* data(T (&array)[N]) noexcept;            // freestanding
-  template<class E> constexpr const E* data(initializer_list<E> il) noexcept;       // freestanding
 }
 \end{codeblock}
 
@@ -7250,19 +7262,24 @@
 \libheaderrefx{inplace_vector}{inplace.vector.syn},
 \libheaderref{list},
 \libheaderrefx{map}{associative.map.syn},
+\libheaderref{optional},
 \libheaderrefx{regex}{re.syn},
 \libheaderrefx{set}{associative.set.syn},
 \libheaderref{span},
+\libheaderref{stacktrace},
 \libheaderref{string},
 \libheaderrefx{string_view}{string.view.synop},
 \libheaderrefx{unordered_map}{unord.map.syn},
-\libheaderrefx{unordered_set}{unord.set.syn}, and
+\libheaderrefx{unordered_set}{unord.set.syn}
+\libheaderref{valarray}, and
 \libheaderref{vector}.
 
 \indexlibrary{\idxcode{begin(C\&)}}%
 \begin{itemdecl}
-template<class C> constexpr auto begin(C& c) -> decltype(c.begin());
-template<class C> constexpr auto begin(const C& c) -> decltype(c.begin());
+template<class C> constexpr auto begin(C& c) noexcept(noexcept(c.begin()))
+  -> decltype(c.begin());
+template<class C> constexpr auto begin(const C& c) noexcept(noexcept(c.begin()))
+  -> decltype(c.begin());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -7273,8 +7290,8 @@
 
 \indexlibrary{\idxcode{end(C\&)}}%
 \begin{itemdecl}
-template<class C> constexpr auto end(C& c) -> decltype(c.end());
-template<class C> constexpr auto end(const C& c) -> decltype(c.end());
+template<class C> constexpr auto end(C& c) noexcept(noexcept(c.end())) -> decltype(c.end());
+template<class C> constexpr auto end(const C& c) noexcept(noexcept(c.end())) -> decltype(c.end());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -7329,8 +7346,10 @@
 
 \indexlibrary{\idxcode{rbegin(C\&)}}%
 \begin{itemdecl}
-template<class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin());
-template<class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin());
+template<class C> constexpr auto rbegin(C& c) noexcept(noexcept(c.rbegin()))
+  -> decltype(c.rbegin());
+template<class C> constexpr auto rbegin(const C& c) noexcept(noexcept(c.rbegin()))
+  -> decltype(c.rbegin());
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7340,8 +7359,9 @@
 
 \indexlibrary{\idxcode{rend(C\&)}}%
 \begin{itemdecl}
-template<class C> constexpr auto rend(C& c) -> decltype(c.rend());
-template<class C> constexpr auto rend(const C& c) -> decltype(c.rend());
+template<class C> constexpr auto rend(C& c) noexcept(noexcept(c.rend())) -> decltype(c.rend());
+template<class C> constexpr auto rend(const C& c) noexcept(noexcept(c.rend()))
+  -> decltype(c.rend());
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7351,7 +7371,7 @@
 
 \indexlibrary{\idxcode{rbegin(T (\&array)[N])}}%
 \begin{itemdecl}
-template<class T, size_t N> constexpr reverse_iterator<T*> rbegin(T (&array)[N]);
+template<class T, size_t N> constexpr reverse_iterator<T*> rbegin(T (&array)[N]) noexcept;
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7361,7 +7381,7 @@
 
 \indexlibrary{\idxcode{rend(T (\&array)[N])}}%
 \begin{itemdecl}
-template<class T, size_t N> constexpr reverse_iterator<T*> rend(T (&array)[N]);
+template<class T, size_t N> constexpr reverse_iterator<T*> rend(T (&array)[N]) noexcept;
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7371,7 +7391,7 @@
 
 \indexlibrary{\idxcode{rbegin(initializer_list<E>)}}%
 \begin{itemdecl}
-template<class E> constexpr reverse_iterator<const E*> rbegin(initializer_list<E> il);
+template<class E> constexpr reverse_iterator<const E*> rbegin(initializer_list<E> il) noexcept;
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7381,7 +7401,7 @@
 
 \indexlibrary{\idxcode{rend(initializer_list<E>)}}%
 \begin{itemdecl}
-template<class E> constexpr reverse_iterator<const E*> rend(initializer_list<E> il);
+template<class E> constexpr reverse_iterator<const E*> rend(initializer_list<E> il) noexcept;
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7391,7 +7411,8 @@
 
 \indexlibrary{\idxcode{crbegin(const C\& c)}}%
 \begin{itemdecl}
-template<class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c));
+template<class C> constexpr auto crbegin(const C& c) noexcept(noexcept(c.crbegin()))
+  -> decltype(std::rbegin(c));
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7401,7 +7422,8 @@
 
 \indexlibrary{\idxcode{crend(const C\& c)}}%
 \begin{itemdecl}
-template<class C> constexpr auto crend(const C& c) -> decltype(std::rend(c));
+template<class C> constexpr auto crend(const C& c) noexcept(noexcept(c.crend()))
+  -> decltype(std::rend(c));
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7411,7 +7433,8 @@
 
 \indexlibrary{\idxcode{size(C\& c)}}%
 \begin{itemdecl}
-template<class C> constexpr auto size(const C& c) -> decltype(c.size());
+template<class C> constexpr auto size(const C& c) noexcept(noexcept(c.size()))
+  -> decltype(c.size());
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7431,7 +7454,7 @@
 
 \indexlibrary{\idxcode{ssize(C\& c)}}%
 \begin{itemdecl}
-template<class C> constexpr auto ssize(const C& c)
+template<class C> constexpr auto ssize(const C& c) noexcept(noexcept(c.ssize()))
   -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>;
 \end{itemdecl}
 \begin{itemdescr}
@@ -7455,7 +7478,8 @@
 
 \indexlibrary{\idxcode{empty(C\& c)}}%
 \begin{itemdecl}
-template<class C> constexpr auto empty(const C& c) -> decltype(c.empty());
+template<class C> constexpr auto empty(const C& c) noexcept(noexcept(c.empty()))
+  -> decltype(c.empty());
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7473,20 +7497,11 @@
 \tcode{false}.
 \end{itemdescr}
 
-\indexlibrary{\idxcode{empty(initializer_list<E>)}}%
-\begin{itemdecl}
-template<class E> constexpr bool empty(initializer_list<E> il) noexcept;
-\end{itemdecl}
-\begin{itemdescr}
-\pnum
-\returns
-\tcode{il.size() == 0}.
-\end{itemdescr}
-
 \indexlibrary{\idxcode{data(C\& c)}}%
 \begin{itemdecl}
-template<class C> constexpr auto data(C& c) -> decltype(c.data());
-template<class C> constexpr auto data(const C& c) -> decltype(c.data());
+template<class C> constexpr auto data(C& c) noexcept(noexcept(c.data())) -> decltype(c.data());
+template<class C> constexpr auto data(const C& c) noexcept(noexcept(c.data()))
+  -> decltype(c.data());
 \end{itemdecl}
 \begin{itemdescr}
 \pnum
@@ -7503,13 +7518,3 @@
 \returns
 \tcode{array}.
 \end{itemdescr}
-
-\indexlibrary{\idxcode{data(initializer_list<E>)}}%
-\begin{itemdecl}
-template<class E> constexpr const E* data(initializer_list<E> il) noexcept;
-\end{itemdecl}
-\begin{itemdescr}
-\pnum
-\returns
-\tcode{il.begin()}.
-\end{itemdescr}