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

Files changed (1) hide show

tmp/tmpkaga7out/{from.md → to.md} +489 -0

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

	@@ -0,0 +1,489 @@

+### Adjacent view <a id="range.adjacent">[[range.adjacent]]</a>
+#### Overview <a id="range.adjacent.overview">[[range.adjacent.overview]]</a>
+`adjacent_view` takes a view and produces a view whose Mᵗʰ element is a
+tuple of references to 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::adjacent<N>` denotes a range adaptor object
+[[range.adaptor.object]]. Given a subexpression `E` and a constant
+expression `N`, the expression `views::adjacent<N>(E)` is
+expression-equivalent to
+- `((void)E, auto(views::empty<tuple<>>))` if `N` is equal to `0`,
+- otherwise, `adjacent_view<views::all_t<decltype((E))>, N>(E)`.
+[*Example 1*:
+``` cpp
+vector v = {1, 2, 3, 4};
+for (auto i : v | views::adjacent<2>) {
+  cout << "(" << std::get<0>(i) << ", " << std::get<1>(i) << ") ";  // prints (1, 2) (2, 3) (3, 4)
+}
+```
+— *end example*]
+Define `REPEAT(T, N)` as a pack of `N` types, each of which denotes the
+same type as `T`.
+#### Class template `adjacent_view` <a id="range.adjacent.view">[[range.adjacent.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<forward_range V, size_t N>
+    requires view<V> && (N > 0)
+  class adjacent_view : public view_interface<adjacent_view<V, N>> {
+    V base_ = V();                      // exposition only
+    // [range.adjacent.iterator], class template adjacent_view::iterator
+    template<bool> class iterator;      // exposition only
+    // [range.adjacent.sentinel], class template adjacent_view::sentinel
+    template<bool> class sentinel;      // exposition only
+    struct as-sentinel{};               // exposition only
+  public:
+    adjacent_view() requires default_initializable<V> = default;
+    constexpr explicit adjacent_view(V base);
+    constexpr V base() const & requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr auto begin() requires (!simple-view<V>) {
+      return iterator<false>(ranges::begin(base_), ranges::end(base_));
+    }
+    constexpr auto begin() const requires range<const V> {
+      return iterator<true>(ranges::begin(base_), ranges::end(base_));
+    }
+    constexpr auto end() requires (!simple-view<V>) {
+      if constexpr (common_range<V>) {
+        return iterator<false>(as-sentinel{}, ranges::begin(base_), ranges::end(base_));
+      } else {
+        return sentinel<false>(ranges::end(base_));
+      }
+    }
+    constexpr auto end() const requires range<const V> {
+      if constexpr (common_range<const V>) {
+        return iterator<true>(as-sentinel{}, ranges::begin(base_), ranges::end(base_));
+      } else {
+        return sentinel<true>(ranges::end(base_));
+      }
+    }
+    constexpr auto size() requires sized_range<V>;
+    constexpr auto size() const requires sized_range<const V>;
+  };
+}
+```
+``` cpp
+constexpr explicit adjacent_view(V base);
+```
+*Effects:* Initializes *base\_* with `std::move(base)`.
+``` cpp
+constexpr auto size() requires sized_range<V>;
+constexpr auto size() const requires sized_range<const V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+using ST = decltype(ranges::size(base_));
+using CT = common_type_t<ST, size_t>;
+auto sz = static_cast<CT>(ranges::size(base_));
+sz -= std::min<CT>(sz, N - 1);
+return static_cast<ST>(sz);
+```
+#### Class template `adjacent_view::iterator` <a id="range.adjacent.iterator">[[range.adjacent.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<forward_range V, size_t N>
+    requires view<V> && (N > 0)
+  template<bool Const>
+  class adjacent_view<V, N>::iterator {
+    using Base = maybe-const<Const, V>;                                         // exposition only
+    array<iterator_t<Base>, N> current_ = array<iterator_t<Base>, N>();         // exposition only
+    constexpr iterator(iterator_t<Base> first, sentinel_t<Base> last);          // exposition only
+    constexpr iterator(as-sentinel, iterator_t<Base> first, iterator_t<Base> last);
+                                                                                // exposition only
+  public:
+    using iterator_category = input_iterator_tag;
+    using iterator_concept  = see below;
+    using value_type = tuple<REPEAT(range_value_t<Base>, 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>>;
+    friend constexpr auto iter_move(const iterator& i) noexcept(see below);
+    friend constexpr void iter_swap(const iterator& l, const iterator& r) noexcept(see below)
+      requires indirectly_swappable<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> first, sentinel_t<Base> last);
+```
+*Ensures:* *`current_`*`[0] == first` is `true`, and for every integer
+1 ≤ i < `N`,
+*`current_`*`[`i`] == ranges::next(`*`current_`*`[`i`-1], 1, last)` is
+`true`.
+``` cpp
+constexpr iterator(as-sentinel, iterator_t<Base> first, iterator_t<Base> last);
+```
+*Ensures:* If *Base* does not model `bidirectional_range`, each element
+of *current\_* is equal to *last*. Otherwise,
+*`current_`*`[N-1] == last` is `true`, and for every integer
+0 ≤ i < (`N` - 1),
+*`current_`*`[`i`] == ranges::prev(`*`current_`*`[`i`+1], 1, first)` is
+`true`.
+``` cpp
+constexpr iterator(iterator<!Const> i)
+  requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
+```
+*Effects:* Initializes each element of *current\_* with the
+corresponding element of `i.`*`current_`* as an xvalue.
+``` cpp
+constexpr auto operator*() const;
+```
+*Effects:* Equivalent to:
+``` cpp
+return tuple-transform([](auto& i) -> decltype(auto) { return *i; }, current_);
+```
+``` cpp
+constexpr iterator& operator++();
+```
+*Preconditions:* *`current_`*`.back()` is incrementable.
+*Ensures:* Each element of *current\_* is equal to `ranges::next(i)`,
+where `i` is the value of that element 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_`*`.front()` is decrementable.
+*Ensures:* Each element of *current\_* is equal to `ranges::prev(i)`,
+where `i` is the value of that element 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_`*`.back() + x` has well-defined behavior.
+*Ensures:* Each element of *current\_* is equal to `i + x`, where `i` is
+the value of that element before the call.
+*Returns:* `*this`.
+``` cpp
+constexpr iterator& operator-=(difference_type x)
+  requires random_access_range<Base>;
+```
+*Preconditions:* *`current_`*`.front() - x` has well-defined behavior.
+*Ensures:* Each element of *current\_* is equal to `i - x`, where `i` is
+the value of that element before the call.
+*Returns:* `*this`.
+``` cpp
+constexpr auto operator[](difference_type n) const
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return tuple-transform([&](auto& i) -> decltype(auto) { return i[n]; }, current_);
+```
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y);
+```
+*Returns:* `x.`*`current_`*`.back() == y.`*`current_`*`.back()`.
+``` cpp
+friend constexpr bool operator<(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Returns:* `x.`*`current_`*`.back() < y.`*`current_`*`.back()`.
+``` 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_`*`.back() <=> y.`*`current_`*`.back()`.
+``` 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>>;
+```
+*Effects:* Equivalent to:
+`return x.`*`current_`*`.back() - y.`*`current_`*`.back();`
+``` cpp
+friend constexpr auto iter_move(const iterator& i) noexcept(see below);
+```
+*Effects:* Equivalent to:
+`return `*`tuple-transform`*`(ranges::iter_move, i.`*`current_`*`);`
+*Remarks:* The exception specification is equivalent to:
+``` cpp
+noexcept(ranges::iter_move(declval<const iterator_t<Base>&>())) &&
+is_nothrow_move_constructible_v<range_rvalue_reference_t<Base>>
+```
+``` cpp
+friend constexpr void iter_swap(const iterator& l, const iterator& r) noexcept(see below)
+  requires indirectly_swappable<iterator_t<Base>>;
+```
+*Preconditions:* None of the iterators in `l.`*`current_`* is equal to
+an iterator in `r.`*`current_`*.
+*Effects:* For every integer 0 ≤ i < `N`, performs
+`ranges::iter_swap(l.`*`current_`*`[`i`], r.`*`current_`*`[`i`])`.
+*Remarks:* The exception specification is equivalent to:
+``` cpp
+noexcept(ranges::iter_swap(declval<iterator_t<Base>>(), declval<iterator_t<Base>>()))
+```
+#### Class template `adjacent_view::sentinel` <a id="range.adjacent.sentinel">[[range.adjacent.sentinel]]</a>
+``` cpp
+namespace std::ranges {
+  template<forward_range V, size_t N>
+    requires view<V> && (N > 0)
+  template<bool Const>
+  class adjacent_view<V, N>::sentinel {
+    using Base = maybe-const<Const, V>;                         // exposition only
+    sentinel_t<Base> end_ = sentinel_t<Base>();                 // exposition only
+    constexpr explicit sentinel(sentinel_t<Base> end);          // exposition only
+  public:
+    sentinel() = default;
+    constexpr sentinel(sentinel<!Const> i)
+      requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+    template<bool OtherConst>
+      requires sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+    friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
+    template<bool OtherConst>
+      requires sized_sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+    friend constexpr range_difference_t<maybe-const<OtherConst, V>>
+      operator-(const iterator<OtherConst>& x, const sentinel& y);
+    template<bool OtherConst>
+      requires sized_sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+    friend constexpr range_difference_t<maybe-const<OtherConst, V>>
+      operator-(const sentinel& y, const iterator<OtherConst>& x);
+  };
+}
+```
+``` cpp
+constexpr explicit sentinel(sentinel_t<Base> end);
+```
+*Effects:* Initializes *end\_* with `end`.
+``` cpp
+constexpr sentinel(sentinel<!Const> i)
+  requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+```
+*Effects:* Initializes *end\_* with `std::move(i.`*`end_`*`)`.
+``` cpp
+template<bool OtherConst>
+  requires sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
+```
+*Effects:* Equivalent to:
+`return x.`*`current_`*`.back() == y.`*`end_`*`;`
+``` cpp
+template<bool OtherConst>
+  requires sized_sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+friend constexpr range_difference_t<maybe-const<OtherConst, V>>
+  operator-(const iterator<OtherConst>& x, const sentinel& y);
+```
+*Effects:* Equivalent to:
+`return x.`*`current_`*`.back() - y.`*`end_`*`;`
+``` cpp
+template<bool OtherConst>
+  requires sized_sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+friend constexpr range_difference_t<maybe-const<OtherConst, V>>
+  operator-(const sentinel& y, const iterator<OtherConst>& x);
+```
+*Effects:* Equivalent to:
+`return y.`*`end_`*` - x.`*`current_`*`.back();`

Diff to HTML by rtfpessoa