From f09f32427b21127af0ec4c4a48dc9f3b0e696e59 Mon Sep 17 00:00:00 2001
From: Jonathan Wakely <jwakely@redhat.com>
Date: Tue, 18 Feb 2020 12:33:07 +0000
Subject: [PATCH] libstdc++: Reorder declarations of std::span members

I find it easier to work with this class when the declarations match the
order in the C++2a working paper.

There's no need to use long, descriptive template parameter names like
_ContiguousIterator when the parameter is already constrained by the
std::contiguous_iterator concept. This is also consistent with the
naming conventions in the working paper.

	* include/std/span (span): Reorder members and rename template
	parameters to match declarations in the C++2a working paper.
---
 libstdc++-v3/ChangeLog        |  3 ++
 libstdc++-v3/include/std/span | 69 +++++++++++++++++++++----------------------
 2 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 7534695..6ae3955 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,5 +1,8 @@
 2020-02-18  Jonathan Wakely  <jwakely@redhat.com>
 
+	* include/std/span (span): Reorder members and rename template
+	parameters to match declarations in the C++2a working paper.
+
 	P2116R0 Remove tuple-like protocol support from fixed-extent span
 	* include/std/span (get, tuple_size, tuple_element): Remove.
 	* testsuite/23_containers/span/everything.cc: Remove checks for
diff --git a/libstdc++-v3/include/std/span b/libstdc++-v3/include/std/span
index b8d5e07..feb1c1f 100644
--- a/libstdc++-v3/include/std/span
+++ b/libstdc++-v3/include/std/span
@@ -140,25 +140,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
     public:
       // member types
-      using value_type             = remove_cv_t<_Type>;
       using element_type           = _Type;
+      using value_type             = remove_cv_t<_Type>;
       using size_type              = size_t;
-      using reference              = element_type&;
-      using const_reference        = const element_type&;
+      using difference_type        = ptrdiff_t;
       using pointer                = _Type*;
       using const_pointer          = const _Type*;
-      using iterator
-	= __gnu_cxx::__normal_iterator<pointer, span>;
-      using const_iterator
-	= __gnu_cxx::__normal_iterator<const_pointer, span>;
+      using reference              = element_type&;
+      using const_reference        = const element_type&;
+      using iterator = __gnu_cxx::__normal_iterator<pointer, span>;
+      using const_iterator = __gnu_cxx::__normal_iterator<const_pointer, span>;
       using reverse_iterator       = std::reverse_iterator<iterator>;
       using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-      using difference_type        = ptrdiff_t;
 
       // member constants
-      static inline constexpr size_t extent = _Extent;
+      static constexpr size_t extent = _Extent;
 
-      // constructors
+      // constructors, copy and assignment
 
       constexpr
       span() noexcept
@@ -166,8 +164,26 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       : _M_extent(0), _M_ptr(nullptr)
       { }
 
-      constexpr
-      span(const span&) noexcept = default;
+      template<contiguous_iterator _It>
+	requires (__is_compatible_iterator<_It>::value)
+	constexpr
+	span(_It __first, size_type __count)
+	noexcept
+	: _M_extent(__count), _M_ptr(std::to_address(__first))
+	{ __glibcxx_assert(_Extent == dynamic_extent || __count == _Extent); }
+
+      template<contiguous_iterator _It, sized_sentinel_for<_It> _End>
+	  requires (__is_compatible_iterator<_It>::value)
+	    && (!is_convertible_v<_End, size_type>)
+	constexpr
+	span(_It __first, _End __last)
+	noexcept(noexcept(__last - __first))
+	: _M_extent(static_cast<size_type>(__last - __first)),
+	  _M_ptr(std::to_address(__first))
+	{
+	  if (_Extent != dynamic_extent)
+	    __glibcxx_assert((__last - __first) == _Extent);
+	}
 
       template<typename _Tp, size_t _ArrayExtent>
 	requires (__is_compatible_array<_Tp, _ArrayExtent>::value)
@@ -203,27 +219,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	: span(ranges::data(__range), ranges::size(__range))
 	{ }
 
-      template<contiguous_iterator _ContiguousIterator,
-	sized_sentinel_for<_ContiguousIterator> _Sentinel>
-	  requires (__is_compatible_iterator<_ContiguousIterator>::value)
-	    && (!is_convertible_v<_Sentinel, size_type>)
-	constexpr
-	span(_ContiguousIterator __first, _Sentinel __last)
-	noexcept(noexcept(__last - __first))
-	: _M_extent(static_cast<size_type>(__last - __first)),
-	  _M_ptr(std::to_address(__first))
-	{
-	  if (_Extent != dynamic_extent)
-	    __glibcxx_assert((__last - __first) == _Extent);
-	}
-
-      template<contiguous_iterator _ContiguousIterator>
-	requires (__is_compatible_iterator<_ContiguousIterator>::value)
-	constexpr
-	span(_ContiguousIterator __first, size_type __count)
-	noexcept
-	: _M_extent(__count), _M_ptr(std::to_address(__first))
-	{ __glibcxx_assert(_Extent == dynamic_extent || __count == _Extent); }
+      constexpr
+      span(const span&) noexcept = default;
 
       template<typename _OType, size_t _OExtent>
 	requires (_Extent == dynamic_extent || _Extent == _OExtent)
@@ -233,7 +230,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 	: _M_extent(__s.size()), _M_ptr(__s.data())
 	{ }
 
-      // assignment
+      ~span() noexcept = default;
 
       constexpr span&
       operator=(const span&) noexcept = default;
@@ -414,8 +411,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     span(const array<_Type, _ArrayExtent>&)
       -> span<const _Type, _ArrayExtent>;
 
-  template<contiguous_iterator _Iter, typename _Sentinel>
-    span(_Iter, _Sentinel)
+  template<contiguous_iterator _Iter, typename _End>
+    span(_Iter, _End)
       -> span<remove_reference_t<iter_reference_t<_Iter>>>;
 
   template<typename _Range>
-- 
2.7.4