[range.slide] - C++20 → C++23

Files changed (1) hide show

tmp/tmpwylxwmuk/{from.md → to.md} +495 -0

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

	@@ -0,0 +1,495 @@

+### Slide view <a id="range.slide">[[range.slide]]</a>
+#### Overview <a id="range.slide.overview">[[range.slide.overview]]</a>
+`slide_view` takes a view and a number N and produces a view whose Mᵗʰ
+element is a view over the Mᵗʰ through (M + N - 1)ᵗʰ elements of the
+original view. If the original view has fewer than N elements, the
+resulting view is empty.
+The name `views::slide` denotes a range adaptor object
+[[range.adaptor.object]]. Given subexpressions `E` and `N`, the
+expression `views::slide(E, N)` is expression-equivalent to
+`slide_view(E, N)`.
+[*Example 1*:
+``` cpp
+vector v = {1, 2, 3, 4};
+for (auto i : v | views::slide(2)) {
+  cout << '[' << i[0] << ", " << i[1] << "] ";          // prints [1, 2] [2, 3] [3, 4]
+}
+```
+— *end example*]
+#### Class template `slide_view` <a id="range.slide.view">[[range.slide.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<class V>
+  concept slide-caches-nothing = random_access_range<V> && sized_range<V>;       // exposition only
+  template<class V>
+  concept slide-caches-last =                                            // exposition only
+    !slide-caches-nothing<V> && bidirectional_range<V> && common_range<V>;
+  template<class V>
+  concept slide-caches-first =                                           // exposition only
+    !slide-caches-nothing<V> && !slide-caches-last<V>;
+  template<forward_range V>
+    requires view<V>
+  class slide_view : public view_interface<slide_view<V>> {
+    V base_;                            // exposition only
+    range_difference_t<V> n_;           // exposition only
+    // [range.slide.iterator], class template slide_view::iterator
+    template<bool> class iterator;      // exposition only
+    // [range.slide.sentinel], class slide_view::sentinel
+    class sentinel;                     // exposition only
+  public:
+    constexpr explicit slide_view(V base, range_difference_t<V> n);
+    constexpr V base() const & requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr auto begin()
+      requires (!(simple-view<V> && slide-caches-nothing<const V>));
+    constexpr auto begin() const requires slide-caches-nothing<const V>;
+    constexpr auto end()
+      requires (!(simple-view<V> && slide-caches-nothing<const V>));
+    constexpr auto end() const requires slide-caches-nothing<const V>;
+    constexpr auto size() requires sized_range<V>;
+    constexpr auto size() const requires sized_range<const V>;
+  };
+  template<class R>
+    slide_view(R&&, range_difference_t<R>) -> slide_view<views::all_t<R>>;
+}
+```
+``` cpp
+constexpr explicit slide_view(V base, range_difference_t<V> n);
+```
+*Preconditions:* `n > 0` is `true`.
+*Effects:* Initializes *base\_* with `std::move(base)` and *n\_* with
+`n`.
+``` cpp
+constexpr auto begin()
+  requires (!(simple-view<V> && slide-caches-nothing<const V>));
+```
+*Returns:*
+- If `V` models `slide-caches-first`,
+  ``` cpp
+  iterator<false>(ranges::begin(base_),
+                  ranges::next(ranges::begin(base_), n_ - 1, ranges::end(base_)), n_)
+  ```
+- Otherwise,
+  *`iterator`*`<false>(ranges::begin(`*`base_`*`), `*`n_`*`)`.
+*Remarks:* In order to provide the amortized constant-time complexity
+required by the `range` concept, this function caches the result within
+the `slide_view` for use on subsequent calls when `V` models
+`slide-caches-first`.
+``` cpp
+constexpr auto begin() const requires slide-caches-nothing<const V>;
+```
+*Returns:* *`iterator`*`<true>(ranges::begin(`*`base_`*`), `*`n_`*`)`.
+``` cpp
+constexpr auto end()
+  requires (!(simple-view<V> && slide-caches-nothing<const V>));
+```
+*Returns:*
+- If `V` models `slide-caches-nothing`,
+  ``` cpp
+  iterator<false>(ranges::begin(base_) + range_difference_t<V>(size()), n_)
+  ```
+- Otherwise, if `V` models `slide-caches-last`,
+  ``` cpp
+  iterator<false>(ranges::prev(ranges::end(base_), n_ - 1, ranges::begin(base_)), n_)
+  ```
+- Otherwise, if `V` models `common_range`,
+  ``` cpp
+  iterator<false>(ranges::end(base_), ranges::end(base_), n_)
+  ```
+- Otherwise, *`sentinel`*`(ranges::end(`*`base_`*`))`.
+*Remarks:* In order to provide the amortized constant-time complexity
+required by the `range` concept, this function caches the result within
+the `slide_view` for use on subsequent calls when `V` models
+`slide-caches-last`.
+``` cpp
+constexpr auto end() const requires slide-caches-nothing<const V>;
+```
+*Returns:* `begin() + range_difference_t<const V>(size())`.
+``` cpp
+constexpr auto size() requires sized_range<V>;
+constexpr auto size() const requires sized_range<const V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto sz = ranges::distance(base_) - n_ + 1;
+if (sz < 0) sz = 0;
+return to-unsigned-like(sz);
+```
+#### Class template `slide_view::iterator` <a id="range.slide.iterator">[[range.slide.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<forward_range V>
+    requires view<V>
+  template<bool Const>
+  class slide_view<V>::iterator {
+    using Base = maybe-const<Const, V>;                 // exposition only
+    iterator_t<Base> current_   = iterator_t<Base>();   // exposition only
+    iterator_t<Base> last_ele_  = iterator_t<Base>();   // exposition only,
+                                               // present only if Base models slide-caches-first
+    range_difference_t<Base> n_ = 0;                    // exposition only
+    constexpr iterator(iterator_t<Base> current, range_difference_t<Base> n) // exposition only
+      requires (!slide-caches-first<Base>);
+    constexpr iterator(iterator_t<Base> current, iterator_t<Base> last_ele,  // exposition only
+                       range_difference_t<Base> n)
+      requires slide-caches-first<Base>;
+  public:
+    using iterator_category = input_iterator_tag;
+    using iterator_concept = see below;
+    using value_type = decltype(views::counted(current_, n_));
+    using difference_type = range_difference_t<Base>;
+    iterator() = default;
+    constexpr iterator(iterator<!Const> i)
+      requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
+    constexpr auto operator*() const;
+    constexpr iterator& operator++();
+    constexpr iterator operator++(int);
+    constexpr iterator& operator--() requires bidirectional_range<Base>;
+    constexpr iterator operator--(int) requires bidirectional_range<Base>;
+    constexpr iterator& operator+=(difference_type x)
+      requires random_access_range<Base>;
+    constexpr iterator& operator-=(difference_type x)
+      requires random_access_range<Base>;
+    constexpr auto operator[](difference_type n) const
+      requires random_access_range<Base>;
+    friend constexpr bool operator==(const iterator& x, const iterator& y);
+    friend constexpr bool operator<(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr bool operator>(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr bool operator<=(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr bool operator>=(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+      requires random_access_range<Base> &&
+               three_way_comparable<iterator_t<Base>>;
+    friend constexpr iterator operator+(const iterator& i, difference_type n)
+      requires random_access_range<Base>;
+    friend constexpr iterator operator+(difference_type n, const iterator& i)
+      requires random_access_range<Base>;
+    friend constexpr iterator operator-(const iterator& i, difference_type n)
+      requires random_access_range<Base>;
+    friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+      requires sized_sentinel_for<iterator_t<Base>, iterator_t<Base>>;
+  };
+}
+```
+`iterator::iterator_concept` is defined as follows:
+- If *`Base`* models `random_access_range`, then `iterator_concept`
+  denotes `random_access_iterator_tag`.
+- Otherwise, if *`Base`* models `bidirectional_range`, then
+  `iterator_concept` denotes `bidirectional_iterator_tag`.
+- Otherwise, `iterator_concept` denotes `forward_iterator_tag`.
+If the invocation of any non-const member function of *`iterator`* exits
+via an exception, the *`iterator`* acquires a singular value.
+``` cpp
+constexpr iterator(iterator_t<Base> current, range_difference_t<Base> n)
+  requires (!slide-caches-first<Base>);
+```
+*Effects:* Initializes *current\_* with `current` and *n\_* with `n`.
+``` cpp
+constexpr iterator(iterator_t<Base> current, iterator_t<Base> last_ele,
+                   range_difference_t<Base> n)
+  requires slide-caches-first<Base>;
+```
+*Effects:* Initializes *current\_* with `current`, *last_ele\_* with
+`last_ele`, and *n\_* with `n`.
+``` cpp
+constexpr iterator(iterator<!Const> i)
+  requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
+```
+*Effects:* Initializes *current\_* with `std::move(i.`*`current_`*`)`
+and *n\_* with `i.`*`n_`*.
+[*Note 1*: *`iterator`*`<true>` can only be formed when *Base* models
+`slide-caches-nothing`, in which case *last_ele\_* is not
+present. — *end note*]
+``` cpp
+constexpr auto operator*() const;
+```
+*Returns:* `views::counted(`*`current_`*`, `*`n_`*`)`.
+``` cpp
+constexpr iterator& operator++();
+```
+*Preconditions:* *current\_* and *last_ele\_* (if present) are
+incrementable.
+*Ensures:* *current\_* and *last_ele\_* (if present) are each equal to
+`ranges::next(i)`, where `i` is the value of that data member before the
+call.
+*Returns:* `*this`.
+``` cpp
+constexpr iterator operator++(int);
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+++*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator--() requires bidirectional_range<Base>;
+```
+*Preconditions:* *current\_* and *last_ele\_* (if present) are
+decrementable.
+*Ensures:* *current\_* and *last_ele\_* (if present) are each equal to
+`ranges::prev(i)`, where `i` is the value of that data member before the
+call.
+*Returns:* `*this`.
+``` cpp
+constexpr iterator operator--(int) requires bidirectional_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator+=(difference_type x)
+  requires random_access_range<Base>;
+```
+*Preconditions:* *`current_`*` + x` and *`last_ele_`*` + x` (if
+*last_ele\_* is present) have well-defined behavior.
+*Ensures:* *current\_* and *last_ele\_* (if present) are each equal to
+`i + x`, where `i` is the value of that data member before the call.
+*Returns:* `*this`.
+``` cpp
+constexpr iterator& operator-=(difference_type x)
+  requires random_access_range<Base>;
+```
+*Preconditions:* *`current_`*` - x` and *`last_ele_`*` - x` (if
+*last_ele\_* is present) have well-defined behavior.
+*Ensures:* *current\_* and *last_ele\_* (if present) are each equal to
+`i - x`, where `i` is the value of that data member before the call.
+*Returns:* `*this`.
+``` cpp
+constexpr auto operator[](difference_type n) const
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+`return views::counted(`*`current_`*` + n, `*`n_`*`);`
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y);
+```
+*Returns:* If *last_ele\_* is present,
+`x.`*`last_ele_`*` == y.`*`last_ele_`*; otherwise,
+`x.`*`current_`*` == y.`*`current_`*.
+``` cpp
+friend constexpr bool operator<(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Returns:* `x.`*`current_`*` < y.`*`current_`*.
+``` cpp
+friend constexpr bool operator>(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return y < x;`
+``` cpp
+friend constexpr bool operator<=(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return !(y < x);`
+``` cpp
+friend constexpr bool operator>=(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return !(x < y);`
+``` cpp
+friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+  requires random_access_range<Base> &&
+           three_way_comparable<iterator_t<Base>>;
+```
+*Returns:* `x.`*`current_`*` <=> y.`*`current_`*.
+``` cpp
+friend constexpr iterator operator+(const iterator& i, difference_type n)
+  requires random_access_range<Base>;
+friend constexpr iterator operator+(difference_type n, const iterator& i)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto r = i;
+r += n;
+return r;
+```
+``` cpp
+friend constexpr iterator operator-(const iterator& i, difference_type n)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto r = i;
+r -= n;
+return r;
+```
+``` cpp
+friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+  requires sized_sentinel_for<iterator_t<Base>, iterator_t<Base>>;
+```
+*Returns:* If *last_ele\_* is present,
+`x.`*`last_ele_`*` - y.`*`last_ele_`*; otherwise,
+`x.`*`current_`*` - y.`*`current_`*.
+#### Class `slide_view::sentinel` <a id="range.slide.sentinel">[[range.slide.sentinel]]</a>
+``` cpp
+namespace std::ranges {
+  template<forward_range V>
+    requires view<V>
+  class slide_view<V>::sentinel {
+    sentinel_t<V> end_ = sentinel_t<V>();             // exposition only
+    constexpr explicit sentinel(sentinel_t<V> end);   // exposition only
+  public:
+    sentinel() = default;
+    friend constexpr bool operator==(const iterator<false>& x, const sentinel& y);
+    friend constexpr range_difference_t<V>
+      operator-(const iterator<false>& x, const sentinel& y)
+        requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+    friend constexpr range_difference_t<V>
+      operator-(const sentinel& y, const iterator<false>& x)
+        requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+  };
+}
+```
+[*Note 1*: *`sentinel`* is used only when `slide-caches-first<V>` is
+`true`. — *end note*]
+``` cpp
+constexpr explicit sentinel(sentinel_t<V> end);
+```
+*Effects:* Initializes *end\_* with `end`.
+``` cpp
+friend constexpr bool operator==(const iterator<false>& x, const sentinel& y);
+```
+*Returns:* `x.`*`last_ele_`*` == y.`*`end_`*.
+``` cpp
+friend constexpr range_difference_t<V>
+  operator-(const iterator<false>& x, const sentinel& y)
+    requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+```
+*Returns:* `x.`*`last_ele_`*` - y.`*`end_`*.
+``` cpp
+friend constexpr range_difference_t<V>
+  operator-(const sentinel& y, const iterator<false>& x)
+    requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+```
+*Returns:* `y.`*`end_`*` - x.`*`last_ele_`*.

Diff to HTML by rtfpessoa