[range.chunk.by] - C++20 → C++23

Files changed (1) hide show

tmp/tmpxesjn9d8/{from.md → to.md} +255 -0

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

	@@ -0,0 +1,255 @@

+### Chunk by view <a id="range.chunk.by">[[range.chunk.by]]</a>
+#### Overview <a id="range.chunk.by.overview">[[range.chunk.by.overview]]</a>
+`chunk_by_view` takes a view and a predicate, and splits the view into
+`subrange`s between each pair of adjacent elements for which the
+predicate returns `false`.
+The name `views::chunk_by` denotes a range adaptor object
+[[range.adaptor.object]]. Given subexpressions `E` and `F`, the
+expression `views::chunk_by(E, F)` is expression-equivalent to
+`chunk_by_view(E, F)`.
+[*Example 1*:
+``` cpp
+vector v = {1, 2, 2, 3, 0, 4, 5, 2};
+for (auto r : v | views::chunk_by(ranges::less_equal{})) {
+  cout << '[';
+  auto sep = "";
+  for (auto i : r) {
+    cout << sep << i;
+    sep = ", ";
+  }
+  cout << "] ";
+}
+// The above prints [1, 2, 2, 3] [0, 4, 5] [2]
+```
+— *end example*]
+#### Class template `chunk_by_view` <a id="range.chunk.by.view">[[range.chunk.by.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred>
+    requires view<V> && is_object_v<Pred>
+  class chunk_by_view : public view_interface<chunk_by_view<V, Pred>> {
+    V base_ = V();                                          // exposition only
+    movable-box<Pred> pred_;                                // exposition only
+    // [range.chunk.by.iter], class chunk_by_view::iterator
+    class iterator;                                         // exposition only
+  public:
+    chunk_by_view() requires default_initializable<V> && default_initializable<Pred> = default;
+    constexpr explicit chunk_by_view(V base, Pred pred);
+    constexpr V base() const & requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr const Pred& pred() const;
+    constexpr iterator begin();
+    constexpr auto end();
+    constexpr iterator_t<V> find-next(iterator_t<V>);       // exposition only
+    constexpr iterator_t<V> find-prev(iterator_t<V>)        // exposition only
+      requires bidirectional_range<V>;
+  };
+  template<class R, class Pred>
+    chunk_by_view(R&&, Pred) -> chunk_by_view<views::all_t<R>, Pred>;
+}
+```
+``` cpp
+constexpr explicit chunk_by_view(V base, Pred pred);
+```
+*Effects:* Initializes *base\_* with `std::move(base)` and *pred\_* with
+`std::move(pred)`.
+``` cpp
+constexpr const Pred& pred() const;
+```
+*Effects:* Equivalent to: `return *`*`pred_`*`;`
+``` cpp
+constexpr iterator begin();
+```
+*Preconditions:* *`pred_`*`.has_value()` is `true`.
+*Returns:*
+*`iterator`*`(*this, ranges::begin(`*`base_`*`), `*`find-next`*`(ranges::begin(`*`base_`*`)))`.
+*Remarks:* In order to provide the amortized constant-time complexity
+required by the `range` concept, this function caches the result within
+the `chunk_by_view` for use on subsequent calls.
+``` cpp
+constexpr auto end();
+```
+*Effects:* Equivalent to:
+``` cpp
+if constexpr (common_range<V>) {
+  return iterator(*this, ranges::end(base_), ranges::end(base_));
+} else {
+  return default_sentinel;
+}
+```
+``` cpp
+constexpr iterator_t<V> find-next(iterator_t<V> current);
+```
+*Preconditions:* *`pred_`*`.has_value()` is `true`.
+*Returns:*
+``` cpp
+ranges::next(ranges::adjacent_find(current, ranges::end(base_), not_fn(ref(*pred_))),
+             1, ranges::end(base_))
+```
+``` cpp
+constexpr iterator_t<V> find-prev(iterator_t<V> current) requires bidirectional_range<V>;
+```
+*Preconditions:*
+- `current` is not equal to `ranges::begin(`*`base_`*`)`.
+- *`pred_`*`.has_value()` is `true`.
+*Returns:* An iterator `i` in the range \[`ranges::begin(`*`base_`*`)`,
+`current`) such that:
+- `ranges::adjacent_find(i, current, not_fn(ref(*`*`pred_`*`)))` is
+  equal to `current`; and
+- if `i` is not equal to `ranges::begin(`*`base_`*`)`, then
+  `bool(invoke(*`*`pred_`*`, *ranges::prev(i), *i))` is `false`.
+#### Class `chunk_by_view::iterator` <a id="range.chunk.by.iter">[[range.chunk.by.iter]]</a>
+``` cpp
+namespace std::ranges {
+  template<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred>
+    requires view<V> && is_object_v<Pred>
+  class chunk_by_view<V, Pred>::iterator {
+    chunk_by_view* parent_ = nullptr;                                   // exposition only
+    iterator_t<V> current_ = iterator_t<V>();                           // exposition only
+    iterator_t<V> next_    = iterator_t<V>();                           // exposition only
+    constexpr iterator(chunk_by_view& parent, iterator_t<V> current,    // exposition only
+                       iterator_t<V> next);
+  public:
+    using value_type = subrange<iterator_t<V>>;
+    using difference_type  = range_difference_t<V>;
+    using iterator_category = input_iterator_tag;
+    using iterator_concept = see below;
+    iterator() = default;
+    constexpr value_type operator*() const;
+    constexpr iterator& operator++();
+    constexpr iterator operator++(int);
+    constexpr iterator& operator--() requires bidirectional_range<V>;
+    constexpr iterator operator--(int) requires bidirectional_range<V>;
+    friend constexpr bool operator==(const iterator& x, const iterator& y);
+    friend constexpr bool operator==(const iterator& x, default_sentinel_t);
+  };
+}
+```
+`iterator::iterator_concept` is defined as follows:
+- If `V` models `bidirectional_range`, then `iterator_concept` denotes
+  `bidirectional_iterator_tag`.
+- Otherwise, `iterator_concept` denotes `forward_iterator_tag`.
+``` cpp
+constexpr iterator(chunk_by_view& parent, iterator_t<V> current, iterator_t<V> next);
+```
+*Effects:* Initializes *parent\_* with `addressof(parent)`, *current\_*
+with `current`, and *next\_* with `next`.
+``` cpp
+constexpr value_type operator*() const;
+```
+*Preconditions:* *current\_* is not equal to *next\_*.
+*Returns:* `subrange(`*`current_`*`, `*`next_`*`)`.
+``` cpp
+constexpr iterator& operator++();
+```
+*Preconditions:* *current\_* is not equal to *next\_*.
+*Effects:* Equivalent to:
+``` cpp
+current_ = next_;
+next_ = parent_->find-next(current_);
+return *this;
+```
+``` cpp
+constexpr iterator operator++(int);
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+++*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator--() requires bidirectional_range<V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+next_ = current_;
+current_ = parent_->find-prev(next_);
+return *this;
+```
+``` cpp
+constexpr iterator operator--(int) requires bidirectional_range<V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y);
+```
+*Returns:* `x.`*`current_`*` == y.`*`current_`*.
+``` cpp
+friend constexpr bool operator==(const iterator& x, default_sentinel_t);
+```
+*Returns:* `x.`*`current_`*` == x.`*`next_`*.

Diff to HTML by rtfpessoa