[views.span] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp41sf74h6/{from.md → to.md} +66 -35

tmp/tmp41sf74h6/{from.md → to.md} RENAMED Viewed

@@ -39,16 +39,15 @@ namespace std {
       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 explicit(extent != dynamic_extent) span(R&& r);
     constexpr span(const span& other) noexcept = default;
     template<class OtherElementType, size_t OtherExtent>
       constexpr explicit(see below) span(const span<OtherElementType, OtherExtent>& s) noexcept;
-    ~span() noexcept = default;
     constexpr span& operator=(const span& other) noexcept = default;
     // [span.sub], subviews
     template<size_t Count>
       constexpr span<element_type, Count> first() const;
@@ -63,14 +62,15 @@ namespace std {
       size_type offset, size_type count = dynamic_extent) const;
     // [span.obs], observers
     constexpr size_type size() const noexcept;
     constexpr size_type size_bytes() const noexcept;
- [[nodiscard]] constexpr bool empty() const noexcept;
     // [span.elem], element access
     constexpr reference operator[](size_type idx) const;
     constexpr reference front() const;
     constexpr reference back() const;
     constexpr pointer data() const noexcept;
     // [span.iterators], iterator support
@@ -87,11 +87,12 @@ namespace std {
     pointer data_;              // exposition only
     size_type size_;            // exposition only
   };
   template<class It, class EndOrSize>
-    span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<It>>>;
   template<class T, size_t N>
     span(T (&)[N]) -> span<T, N>;
   template<class T, size_t N>
     span(array<T, N>&) -> span<T, N>;
   template<class T, size_t N>
@@ -105,10 +106,14 @@ namespace std {
 [[term.trivially.copyable.type]].
 `ElementType` is required to be a complete object type that is not an
 abstract class type.
 ##### Constructors, copy, and assignment <a id="span.cons">[[span.cons]]</a>
 ``` cpp
 constexpr span() noexcept;
 ```
@@ -131,14 +136,15 @@ template<class It>
 *Preconditions:*
 - \[`first`, `first + count`) is a valid range.
 - `It` models `contiguous_iterator`.
-- If `extent` is not equal to `dynamic_extent`, then `count` is equal to
-  `extent`.
-*Effects:* Initializes *`data_`* with `to_address(first)` and *`size_`*
 with `count`.
 *Throws:* Nothing.
 ``` cpp
@@ -155,28 +161,29 @@ template<class It, class End>
 - `End` satisfies `sized_sentinel_for<It>`.
 - `is_convertible_v<End, size_t>` is `false`.
 *Preconditions:*
-- If `extent` is not equal to `dynamic_extent`, then `last - first` is
-  equal to `extent`.
 - \[`first`, `last`) is a valid range.
 - `It` models `contiguous_iterator`.
 - `End` models `sized_sentinel_for<It>`.
-*Effects:* Initializes *`data_`* with `to_address(first)` and *`size_`*
 with `last - first`.
 *Throws:* When and what `last - first` throws.
 ``` cpp
 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;
 ```
-*Constraints:* Let `U` be `remove_pointer_t<decltype(data(arr))>`.
 - `extent == dynamic_extent || N == extent` is `true`, and
 - `is_convertible_v<U(*)[], element_type(*)[]>` is `true`.
   \[*Note 3*: The intent is to allow only qualification conversions of
   the array element type to `element_type`. — *end note*]
@@ -184,11 +191,11 @@ template<class T, size_t N> constexpr span(const array<T, N>& arr) noexcept;
 *Effects:* Constructs a `span` that is a view over the supplied array.
 [*Note 1*: `type_identity_t` affects class template argument
 deduction. — *end note*]
-*Ensures:* `size() == N && data() == data(arr)` is `true`.
 ``` cpp
 template<class R> constexpr explicit(extent != dynamic_extent) span(R&& r);
 ```
@@ -205,21 +212,34 @@ template<class R> constexpr explicit(extent != dynamic_extent) span(R&& r);
   \[*Note 4*: The intent is to allow only qualification conversions of
   the range reference type to `element_type`. — *end note*]
 *Preconditions:*
-- If `extent` is not equal to `dynamic_extent`, then `ranges::size(r)`
-  is equal to `extent`.
 - `R` models `ranges::contiguous_range` and `ranges::sized_range`.
 - If `is_const_v<element_type>` is `false`, `R` models
   `ranges::borrowed_range`.
-*Effects:* Initializes *`data_`* with `ranges::data(r)` and *`size_`*
-with `ranges::size(r)`.
 *Throws:* What and when `ranges::data(r)` and `ranges::size(r)` throw.
 ``` cpp
 constexpr span(const span& other) noexcept = default;
 ```
 *Ensures:* `other.size() == size() && other.data() == data()`.
@@ -236,12 +256,12 @@ template<class OtherElementType, size_t OtherExtent>
 - `is_convertible_v<OtherElementType(*)[], element_type(*)[]>` is
   `true`. \[*Note 5*: The intent is to allow only qualification
   conversions of the `OtherElementType` to
   `element_type`. — *end note*]
-*Preconditions:* If `extent` is not equal to `dynamic_extent`, then
-`s.size()` is equal to `extent`.
 *Effects:* Constructs a `span` that is a view over the range
 \[`s.data()`, `s.data() + s.size()`).
 *Ensures:* `size() == s.size() && data() == s.data()`.
@@ -260,11 +280,12 @@ constexpr span& operator=(const span& other) noexcept = default;
 ##### Deduction guides <a id="span.deduct">[[span.deduct]]</a>
 ``` cpp
 template<class It, class EndOrSize>
-  span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<It>>>;
 ```
 *Constraints:* `It` satisfies `contiguous_iterator`.
 ``` cpp
@@ -280,22 +301,22 @@ template<class R>
 template<size_t Count> constexpr span<element_type, Count> first() const;
 ```
 *Mandates:* `Count <= Extent` is `true`.
-*Preconditions:* `Count <= size()` is `true`.
 *Effects:* Equivalent to: `return R{data(), Count};` where `R` is the
 return type.
 ``` cpp
 template<size_t Count> constexpr span<element_type, Count> last() const;
 ```
 *Mandates:* `Count <= Extent` is `true`.
-*Preconditions:* `Count <= size()` is `true`.
 *Effects:* Equivalent to: `return R{data() + (size() - Count), Count};`
 where `R` is the return type.
 ``` cpp
@@ -309,12 +330,10 @@ template<size_t Offset, size_t Count = dynamic_extent>
 Offset <= Extent && (Count == dynamic_extent || Count <= Extent - Offset)
 ```
 is `true`.
-*Preconditions:*
 ``` cpp
 Offset <= size() && (Count == dynamic_extent || Count <= size() - Offset)
 ```
 is `true`.
@@ -336,29 +355,27 @@ Count != dynamic_extent ? Count
 ``` cpp
 constexpr span<element_type, dynamic_extent> first(size_type count) const;
 ```
-*Preconditions:* `count <= size()` is `true`.
 *Effects:* Equivalent to: `return {data(), count};`
 ``` cpp
 constexpr span<element_type, dynamic_extent> last(size_type count) const;
 ```
-*Preconditions:* `count <= size()` is `true`.
 *Effects:* Equivalent to: `return {data() + (size() - count), count};`
 ``` cpp
 constexpr span<element_type, dynamic_extent> subspan(
   size_type offset, size_type count = dynamic_extent) const;
 ```
-*Preconditions:*
 ``` cpp
 offset <= size() && (count == dynamic_extent || count <= size() - offset)
 ```
 is `true`.
@@ -382,46 +399,60 @@ constexpr size_type size_bytes() const noexcept;
 ```
 *Effects:* Equivalent to: `return size() * sizeof(element_type);`
 ``` cpp
-[[nodiscard]] constexpr bool empty() const noexcept;
 ```
 *Effects:* Equivalent to: `return size() == 0;`
 ##### Element access <a id="span.elem">[[span.elem]]</a>
 ``` cpp
 constexpr reference operator[](size_type idx) const;
 ```
-*Preconditions:* `idx < size()` is `true`.
-*Effects:* Equivalent to: `return *(data() + idx);`
 ``` cpp
 constexpr reference front() const;
 ```
-*Preconditions:* `empty()` is `false`.
-*Effects:* Equivalent to: `return *data();`
 ``` cpp
 constexpr reference back() const;
 ```
-*Preconditions:* `empty()` is `false`.
-*Effects:* Equivalent to: `return *(data() + (size() - 1));`
 ``` cpp
 constexpr pointer data() const noexcept;
 ```
-*Effects:* Equivalent to: `return `*`data_`*`;`
 ##### Iterator support <a id="span.iterators">[[span.iterators]]</a>
 ``` cpp
 using iterator = implementation-defined  // type of span::iterator;

       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 explicit(extent != dynamic_extent) span(R&& r);
+    constexpr explicit(extent != dynamic_extent) span(std::initializer_list<value_type> il);
     constexpr span(const span& other) noexcept = default;
     template<class OtherElementType, size_t OtherExtent>
       constexpr explicit(see below) span(const span<OtherElementType, OtherExtent>& s) noexcept;
     constexpr span& operator=(const span& other) noexcept = default;
     // [span.sub], subviews
     template<size_t Count>
       constexpr span<element_type, Count> first() const;
       size_type offset, size_type count = dynamic_extent) const;
     // [span.obs], observers
     constexpr size_type size() const noexcept;
     constexpr size_type size_bytes() const noexcept;
+    constexpr bool empty() const noexcept;
     // [span.elem], element access
     constexpr reference operator[](size_type idx) const;
+    constexpr reference at(size_type idx) const;                            // freestanding-deleted
     constexpr reference front() const;
     constexpr reference back() const;
     constexpr pointer data() const noexcept;
     // [span.iterators], iterator support
     pointer data_;              // exposition only
     size_type size_;            // exposition only
   };
   template<class It, class EndOrSize>
+    span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<It>>,
+                                maybe-static-ext<EndOrSize>>;
   template<class T, size_t N>
     span(T (&)[N]) -> span<T, N>;
   template<class T, size_t N>
     span(array<T, N>&) -> span<T, N>;
   template<class T, size_t N>
 [[term.trivially.copyable.type]].
 `ElementType` is required to be a complete object type that is not an
 abstract class type.
+For a `span` `s`, any operation that invalidates a pointer in the range
+\[`s.data()`, `s.data() + s.size()`) invalidates pointers, iterators,
+and references to elements of `s`.
 ##### Constructors, copy, and assignment <a id="span.cons">[[span.cons]]</a>
 ``` cpp
 constexpr span() noexcept;
 ```
 *Preconditions:*
 - \[`first`, `first + count`) is a valid range.
 - `It` models `contiguous_iterator`.
+If `extent` is not equal to `dynamic_extent`, then `count == extent` is
+`true`.
+*Effects:* Initializes *data\_* with `to_address(first)` and *size\_*
 with `count`.
 *Throws:* Nothing.
 ``` cpp
 - `End` satisfies `sized_sentinel_for<It>`.
 - `is_convertible_v<End, size_t>` is `false`.
 *Preconditions:*
 - \[`first`, `last`) is a valid range.
 - `It` models `contiguous_iterator`.
 - `End` models `sized_sentinel_for<It>`.
+If `extent` is not equal to `dynamic_extent`, then
+`(last - first) == extent` is `true`.
+*Effects:* Initializes *data\_* with `to_address(first)` and *size\_*
 with `last - first`.
 *Throws:* When and what `last - first` throws.
 ``` cpp
 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;
 ```
+*Constraints:* Let `U` be `remove_pointer_t<decltype(std::data(arr))>`.
 - `extent == dynamic_extent || N == extent` is `true`, and
 - `is_convertible_v<U(*)[], element_type(*)[]>` is `true`.
   \[*Note 3*: The intent is to allow only qualification conversions of
   the array element type to `element_type`. — *end note*]
 *Effects:* Constructs a `span` that is a view over the supplied array.
 [*Note 1*: `type_identity_t` affects class template argument
 deduction. — *end note*]
+*Ensures:* `size() == N && data() == std::data(arr)` is `true`.
 ``` cpp
 template<class R> constexpr explicit(extent != dynamic_extent) span(R&& r);
 ```
   \[*Note 4*: The intent is to allow only qualification conversions of
   the range reference type to `element_type`. — *end note*]
 *Preconditions:*
 - `R` models `ranges::contiguous_range` and `ranges::sized_range`.
 - If `is_const_v<element_type>` is `false`, `R` models
   `ranges::borrowed_range`.
+If `extent` is not equal to `dynamic_extent`, then
+`ranges::size(r) == extent` is `true`.
+*Effects:* Initializes *data\_* with `ranges::data(r)` and *size\_* with
+`ranges::size(r)`.
 *Throws:* What and when `ranges::data(r)` and `ranges::size(r)` throw.
+``` cpp
+constexpr explicit(extent != dynamic_extent) span(std::initializer_list<value_type> il);
+```
+*Constraints:* `is_const_v<element_type>` is `true`.
+If `extent` is not equal to `dynamic_extent`, then `il.size() == extent`
+is `true`.
+*Effects:* Initializes *data\_* with `il.begin()` and *size\_* with
+`il.size()`.
 ``` cpp
 constexpr span(const span& other) noexcept = default;
 ```
 *Ensures:* `other.size() == size() && other.data() == data()`.
 - `is_convertible_v<OtherElementType(*)[], element_type(*)[]>` is
   `true`. \[*Note 5*: The intent is to allow only qualification
   conversions of the `OtherElementType` to
   `element_type`. — *end note*]
+If `extent` is not equal to `dynamic_extent`, then `s.size() == extent`
+is `true`.
 *Effects:* Constructs a `span` that is a view over the range
 \[`s.data()`, `s.data() + s.size()`).
 *Ensures:* `size() == s.size() && data() == s.data()`.
 ##### Deduction guides <a id="span.deduct">[[span.deduct]]</a>
 ``` cpp
 template<class It, class EndOrSize>
+  span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<It>>,
+                              maybe-static-ext<EndOrSize>>;
 ```
 *Constraints:* `It` satisfies `contiguous_iterator`.
 ``` cpp
 template<size_t Count> constexpr span<element_type, Count> first() const;
 ```
 *Mandates:* `Count <= Extent` is `true`.
+`Count <= size()` is `true`.
 *Effects:* Equivalent to: `return R{data(), Count};` where `R` is the
 return type.
 ``` cpp
 template<size_t Count> constexpr span<element_type, Count> last() const;
 ```
 *Mandates:* `Count <= Extent` is `true`.
+`Count <= size()` is `true`.
 *Effects:* Equivalent to: `return R{data() + (size() - Count), Count};`
 where `R` is the return type.
 ``` cpp
 Offset <= Extent && (Count == dynamic_extent || Count <= Extent - Offset)
 ```
 is `true`.
 ``` cpp
 Offset <= size() && (Count == dynamic_extent || Count <= size() - Offset)
 ```
 is `true`.
 ``` cpp
 constexpr span<element_type, dynamic_extent> first(size_type count) const;
 ```
+`count <= size()` is `true`.
 *Effects:* Equivalent to: `return {data(), count};`
 ``` cpp
 constexpr span<element_type, dynamic_extent> last(size_type count) const;
 ```
+`count <= size()` is `true`.
 *Effects:* Equivalent to: `return {data() + (size() - count), count};`
 ``` cpp
 constexpr span<element_type, dynamic_extent> subspan(
   size_type offset, size_type count = dynamic_extent) const;
 ```
 ``` cpp
 offset <= size() && (count == dynamic_extent || count <= size() - offset)
 ```
 is `true`.
 ```
 *Effects:* Equivalent to: `return size() * sizeof(element_type);`
 ``` cpp
+constexpr bool empty() const noexcept;
 ```
 *Effects:* Equivalent to: `return size() == 0;`
 ##### Element access <a id="span.elem">[[span.elem]]</a>
 ``` cpp
 constexpr reference operator[](size_type idx) const;
 ```
+`idx < size()` is `true`.
+*Returns:* `*(data() + idx)`.
+*Throws:* Nothing.
+``` cpp
+constexpr reference at(size_type idx) const;
+```
+*Returns:* `*(data() + idx)`.
+*Throws:* `out_of_range` if `idx >= size()` is `true`.
 ``` cpp
 constexpr reference front() const;
 ```
+`empty()` is `false`.
+*Returns:* `*data()`.
+*Throws:* Nothing.
 ``` cpp
 constexpr reference back() const;
 ```
+`empty()` is `false`.
+*Returns:* `*(data() + (size() - 1))`.
+*Throws:* Nothing.
 ``` cpp
 constexpr pointer data() const noexcept;
 ```
+*Returns:* *data\_*.
 ##### Iterator support <a id="span.iterators">[[span.iterators]]</a>
 ``` cpp
 using iterator = implementation-defined  // type of span::iterator;

Diff to HTML by rtfpessoa