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

Files changed (1) hide show

tmp/tmp3yf0lczv/{from.md → to.md} +112 -277

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

@@ -1,416 +1,251 @@
 ### Split view <a id="range.split">[[range.split]]</a>
 #### Overview <a id="range.split.overview">[[range.split.overview]]</a>
-`split_view` takes a `view` and a delimiter, and splits the `view` into
-subranges on the delimiter. The delimiter can be a single element or a
-`view` of elements.
 The name `views::split` denotes a range adaptor object
 [[range.adaptor.object]]. Given subexpressions `E` and `F`, the
 expression `views::split(E, F)` is expression-equivalent to
-`split_view{E, F}`.
 [*Example 1*:
 ``` cpp
 string str{"the quick brown fox"};
-split_view sentence{str, ' '};
-for (auto word : sentence) {
-  for (char ch : word)
-    cout << ch;
-  cout << '*';
 }
-// The above prints: the*quick*brown*fox*
 ```
 — *end example*]
 #### Class template `split_view` <a id="range.split.view">[[range.split.view]]</a>
 ``` cpp
 namespace std::ranges {
-  template<auto> struct require-constant;       // exposition only
-  template<class R>
-  concept tiny-range =                          // exposition only
-    sized_range<R> &&
-    requires { typename require-constant<remove_reference_t<R>::size()>; } &&
-    (remove_reference_t<R>::size() <= 1);
-  template<input_range V, forward_range Pattern>
     requires view<V> && view<Pattern> &&
-             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
-             (forward_range<V> || tiny-range<Pattern>)
   class split_view : public view_interface<split_view<V, Pattern>> {
   private:
     V base_ = V();                              // exposition only
     Pattern pattern_ = Pattern();               // exposition only
-    iterator_t<V> current_ = iterator_t<V>();   // exposition only, present only if !forward_range<V>
-    // [range.split.outer], class template split_view::outer-iterator
- template<bool> struct outer-iterator; // exposition only
-    // [range.split.inner], class template split_view::inner-iterator
- template<bool> struct inner-iterator;       // exposition only
   public:
-    split_view() = default;
-    constexpr split_view(V base, Pattern pattern);
-    template<input_range R>
       requires constructible_from<V, views::all_t<R>> &&
                constructible_from<Pattern, single_view<range_value_t<R>>>
-    constexpr split_view(R&& r, range_value_t<R> e);
     constexpr V base() const & requires copy_constructible<V> { return base_; }
     constexpr V base() && { return std::move(base_); }
-    constexpr auto begin() {
-      if constexpr (forward_range<V>)
-        return outer-iterator<simple-view<V>>{*this, ranges::begin(base_)};
-      else {
-        current_ = ranges::begin(base_);
-        return outer-iterator<false>{*this};
-      }
-    }
-    constexpr auto begin() const requires forward_range<V> && forward_range<const V> {
- return outer-iterator<true>{*this, ranges::begin(base_)};
       }
-    constexpr auto end() requires forward_range<V> && common_range<V> {
-      return outer-iterator<simple-view<V>>{*this, ranges::end(base_)};
     }
-    constexpr auto end() const {
-      if constexpr (forward_range<V> && forward_range<const V> && common_range<const V>)
-        return outer-iterator<true>{*this, ranges::end(base_)};
-      else
-        return default_sentinel;
-    }
   };
   template<class R, class P>
     split_view(R&&, P&&) -> split_view<views::all_t<R>, views::all_t<P>>;
-  template<input_range R>
     split_view(R&&, range_value_t<R>)
       -> split_view<views::all_t<R>, single_view<range_value_t<R>>>;
 }
 ```
 ``` cpp
-constexpr split_view(V base, Pattern pattern);
 ```
 *Effects:* Initializes *base\_* with `std::move(base)`, and *pattern\_*
 with `std::move(pattern)`.
 ``` cpp
-template<input_range R>
   requires constructible_from<V, views::all_t<R>> &&
            constructible_from<Pattern, single_view<range_value_t<R>>>
-constexpr split_view(R&& r, range_value_t<R> e);
 ```
 *Effects:* Initializes *base\_* with `views::all(std::forward<R>(r))`,
-and *pattern\_* with `single_view{std::move(e)}`.
-#### Class template `split_view::outer-iterator` <a id="range.split.outer">[[range.split.outer]]</a>
 ``` cpp
 namespace std::ranges {
-  template<input_range V, forward_range Pattern>
     requires view<V> && view<Pattern> &&
-             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
-             (forward_range<V> || tiny-range<Pattern>)
-  template<bool Const>
-  struct split_view<V, Pattern>::outer-iterator {
   private:
- using Parent = // exposition only
-      conditional_t<Const, const split_view, split_view>;
- using Base   = // exposition only
-      conditional_t<Const, const V, V>;
-    Parent* parent_ = nullptr;              // exposition only
-    iterator_t<Base> current_ =             // exposition only, present only if V models forward_range
-      iterator_t<Base>();
   public:
-    using iterator_concept =
-      conditional_t<forward_range<Base>, forward_iterator_tag, input_iterator_tag>;
     using iterator_category = input_iterator_tag;
- // [range.split.outer.value], class split_view::outer-iterator::value_type
- struct value_type;
-    using difference_type   = range_difference_t<Base>;
- outer-iterator() = default;
-    constexpr explicit outer-iterator(Parent& parent)
-      requires (!forward_range<Base>);
-    constexpr outer-iterator(Parent& parent, iterator_t<Base> current)
-      requires forward_range<Base>;
-    constexpr outer-iterator(outer-iterator<!Const> i)
-      requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
     constexpr value_type operator*() const;
-    constexpr outer-iterator& operator++();
-    constexpr decltype(auto) operator++(int) {
-      if constexpr (forward_range<Base>) {
-        auto tmp = *this;
-        ++*this;
-        return tmp;
-      } else
-        ++*this;
-    }
-    friend constexpr bool operator==(const outer-iterator& x, const outer-iterator& y)
-      requires forward_range<Base>;
-    friend constexpr bool operator==(const outer-iterator& x, default_sentinel_t);
   };
 }
 ```
-Many of the following specifications refer to the notional member
-*current* of *`outer-iterator`*. *current* is equivalent to *`current_`*
-if `V` models `forward_range`, and `parent_->current_` otherwise.
-``` cpp
-constexpr explicit outer-iterator(Parent& parent)
-  requires (!forward_range<Base>);
-```
-*Effects:* Initializes *parent\_* with `addressof(parent)`.
 ``` cpp
-constexpr outer-iterator(Parent& parent, iterator_t<Base> current)
-  requires forward_range<Base>;
 ```
-*Effects:* Initializes *parent\_* with `addressof(parent)` and
-*current\_* with `std::move(current)`.
 ``` cpp
-constexpr outer-iterator(outer-iterator<!Const> i)
-  requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
 ```
-*Effects:* Initializes *parent\_* with `i.`*`parent_`* and *current\_*
-with `std::move(i.`*`current_`*`)`.
 ``` cpp
 constexpr value_type operator*() const;
 ```
-*Effects:* Equivalent to: `return value_type{*this};`
 ``` cpp
-constexpr outer-iterator& operator++();
 ```
 *Effects:* Equivalent to:
 ``` cpp
-const auto end = ranges::end(parent_->base_);
-if (current == end) return *this;
-const auto [pbegin, pend] = subrange{parent_->pattern_};
-if (pbegin == pend) ++current;
-else {
-  do {
-    auto [b, p] = ranges::mismatch(std::move(current), end, pbegin, pend);
- current = std::move(b);
-    if (p == pend) {
-      break;            // The pattern matched; skip it
   }
- } while (++current != end);
 }
 return *this;
 ```
 ``` cpp
-friend constexpr bool operator==(const outer-iterator& x, const outer-iterator& y)
-  requires forward_range<Base>;
-```
-*Effects:* Equivalent to: `return x.`*`current_`*` == y.`*`current_`*`;`
-``` cpp
-friend constexpr bool operator==(const outer-iterator& x, default_sentinel_t);
 ```
 *Effects:* Equivalent to:
-`return x.`*`current`*` == ranges::end(x.`*`parent_`*`->`*`base_`*`);`
-#### Class `split_view::outer-iterator::value_type` <a id="range.split.outer.value">[[range.split.outer.value]]</a>
-``` cpp
-namespace std::ranges {
-  template<input_range V, forward_range Pattern>
-    requires view<V> && view<Pattern> &&
-             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
-             (forward_range<V> || tiny-range<Pattern>)
-  template<bool Const>
-  struct split_view<V, Pattern>::outer-iterator<Const>::value_type
-    : view_interface<value_type> {
-  private:
-    outer-iterator i_ = outer-iterator();               // exposition only
-  public:
-    value_type() = default;
-    constexpr explicit value_type(outer-iterator i);
-    constexpr inner-iterator<Const> begin() const requires copyable<outer-iterator>;
-    constexpr inner-iterator<Const> begin() requires (!copyable<outer-iterator>);
-    constexpr default_sentinel_t end() const;
-  };
-}
-```
-``` cpp
-constexpr explicit value_type(outer-iterator i);
-```
-*Effects:* Initializes *i\_* with `std::move(i)`.
 ``` cpp
-constexpr inner-iterator<Const> begin() const requires copyable<outer-iterator>;
 ```
-*Effects:* Equivalent to:
-`return `*`inner-iterator`*`<Const>{`*`i_`*`};`
 ``` cpp
-constexpr inner-iterator<Const> begin() requires (!copyable<outer-iterator>);
 ```
 *Effects:* Equivalent to:
-`return `*`inner-iterator`*`<Const>{std::move(`*`i_`*`)};`
 ``` cpp
-constexpr default_sentinel_t end() const;
 ```
-*Effects:* Equivalent to: `return default_sentinel;`
-#### Class template `split_view::inner-iterator` <a id="range.split.inner">[[range.split.inner]]</a>
 ``` cpp
 namespace std::ranges {
-  template<input_range V, forward_range Pattern>
     requires view<V> && view<Pattern> &&
-             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
-             (forward_range<V> || tiny-range<Pattern>)
-  template<bool Const>
-  struct split_view<V, Pattern>::inner-iterator {
   private:
- using Base = conditional_t<Const, const V, V>; // exposition only
-    outer-iterator<Const> i_ = outer-iterator<Const>(); // exposition only
-    bool incremented_ = false;                          // exposition only
-  public:
-    using iterator_concept  = typename outer-iterator<Const>::iterator_concept;
-    using iterator_category = see below;
-    using value_type        = range_value_t<Base>;
-    using difference_type   = range_difference_t<Base>;
-    inner-iterator() = default;
-    constexpr explicit inner-iterator(outer-iterator<Const> i);
-    constexpr decltype(auto) operator*() const { return *i_.current; }
-    constexpr inner-iterator& operator++();
-    constexpr decltype(auto) operator++(int) {
-      if constexpr (forward_range<V>) {
-        auto tmp = *this;
-        ++*this;
-        return tmp;
-      } else
-        ++*this;
-    }
-    friend constexpr bool operator==(const inner-iterator& x, const inner-iterator& y)
-      requires forward_range<Base>;
-    friend constexpr bool operator==(const inner-iterator& x, default_sentinel_t);
-    friend constexpr decltype(auto) iter_move(const inner-iterator& i)
-    noexcept(noexcept(ranges::iter_move(i.i_.current))) {
-      return ranges::iter_move(i.i_.current);
-    }
-    friend constexpr void iter_swap(const inner-iterator& x, const inner-iterator& y)
-      noexcept(noexcept(ranges::iter_swap(x.i_.current, y.i_.current)))
-      requires indirectly_swappable<iterator_t<Base>>;
   };
 }
 ```
-The *typedef-name* `iterator_category` denotes:
-- `forward_iterator_tag` if
-  `iterator_traits<iterator_t<Base>>::iterator_category` models
-  `derived_from<forward_iterator_tag>`;
-- otherwise, `iterator_traits<iterator_t<Base>>::iterator_category`.
 ``` cpp
-constexpr explicit inner-iterator(outer-iterator<Const> i);
 ```
-*Effects:* Initializes *i\_* with `std::move(i)`.
 ``` cpp
-constexpr inner-iterator& operator++();
 ```
 *Effects:* Equivalent to:
-``` cpp
-incremented_ = true;
-if constexpr (!forward_range<Base>) {
-  if constexpr (Pattern::size() == 0) {
-    return *this;
-  }
-}
-++i_.current;
-return *this;
-```
-``` cpp
-friend constexpr bool operator==(const inner-iterator& x, const inner-iterator& y)
-  requires forward_range<Base>;
-```
-*Effects:* Equivalent to:
-`return x.`*`i_`*`.`*`current`*` == y.`*`i_`*`.`*`current`*`;`
-``` cpp
-friend constexpr bool operator==(const inner-iterator& x, default_sentinel_t);
-```
-*Effects:* Equivalent to:
-``` cpp
-auto [pcur, pend] = subrange{x.i_.parent_->pattern_};
-auto end = ranges::end(x.i_.parent_->base_);
-if constexpr (tiny-range<Pattern>) {
-  const auto & cur = x.i_.current;
-  if (cur == end) return true;
-  if (pcur == pend) return x.incremented_;
-  return *cur == *pcur;
-} else {
-  auto cur = x.i_.current;
-  if (cur == end) return true;
-  if (pcur == pend) return x.incremented_;
-  do {
-    if (*cur != *pcur) return false;
-    if (++pcur == pend) return true;
-  } while (++cur != end);
-  return false;
-}
-```
-``` cpp
-friend constexpr void iter_swap(const inner-iterator& x, const inner-iterator& y)
-  noexcept(noexcept(ranges::iter_swap(x.i_.current, y.i_.current)))
-  requires indirectly_swappable<iterator_t<Base>>;
-```
-*Effects:* Equivalent to
-`ranges::iter_swap(x.`*`i_`*`.`*`current`*`, y.`*`i_`*`.`*`current`*`)`.

 ### Split view <a id="range.split">[[range.split]]</a>
 #### Overview <a id="range.split.overview">[[range.split.overview]]</a>
+`split_view` takes a view and a delimiter, and splits the view into
+`subrange`s on the delimiter. The delimiter can be a single element or a
+view of elements.
 The name `views::split` denotes a range adaptor object
 [[range.adaptor.object]]. Given subexpressions `E` and `F`, the
 expression `views::split(E, F)` is expression-equivalent to
+`split_view(E, F)`.
 [*Example 1*:
 ``` cpp
 string str{"the quick brown fox"};
+for (auto word : views::split(str, ' ')) {
+  cout << string_view(word) << '*';
 }
+// The above prints the*quick*brown*fox*
 ```
 — *end example*]
 #### Class template `split_view` <a id="range.split.view">[[range.split.view]]</a>
 ``` cpp
 namespace std::ranges {
+  template<forward_range V, forward_range Pattern>
     requires view<V> && view<Pattern> &&
+             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>
   class split_view : public view_interface<split_view<V, Pattern>> {
   private:
     V base_ = V();                              // exposition only
     Pattern pattern_ = Pattern();               // exposition only
+    // [range.split.iterator], class split_view::iterator
+    struct iterator; // exposition only
+    // [range.split.sentinel], class split_view::sentinel
+    struct sentinel;                            // exposition only
   public:
+    split_view()
+      requires default_initializable<V> && default_initializable<Pattern> = default;
+    constexpr explicit split_view(V base, Pattern pattern);
+    template<forward_range R>
       requires constructible_from<V, views::all_t<R>> &&
                constructible_from<Pattern, single_view<range_value_t<R>>>
+    constexpr explicit split_view(R&& r, range_value_t<R> e);
     constexpr V base() const & requires copy_constructible<V> { return base_; }
     constexpr V base() && { return std::move(base_); }
+    constexpr iterator begin();
+    constexpr auto end() {
+ if constexpr (common_range<V>) {
+        return iterator{*this, ranges::end(base_), {}};
+      } else {
+        return sentinel{*this};
       }
     }
+    constexpr subrange<iterator_t<V>> find-next(iterator_t<V>); // exposition only
   };
   template<class R, class P>
     split_view(R&&, P&&) -> split_view<views::all_t<R>, views::all_t<P>>;
+  template<forward_range R>
     split_view(R&&, range_value_t<R>)
       -> split_view<views::all_t<R>, single_view<range_value_t<R>>>;
 }
 ```
 ``` cpp
+constexpr explicit split_view(V base, Pattern pattern);
 ```
 *Effects:* Initializes *base\_* with `std::move(base)`, and *pattern\_*
 with `std::move(pattern)`.
 ``` cpp
+template<forward_range R>
   requires constructible_from<V, views::all_t<R>> &&
            constructible_from<Pattern, single_view<range_value_t<R>>>
+constexpr explicit split_view(R&& r, range_value_t<R> e);
 ```
 *Effects:* Initializes *base\_* with `views::all(std::forward<R>(r))`,
+and *pattern\_* with `views::single(std::move(e))`.
+``` cpp
+constexpr iterator begin();
+```
+*Returns:*
+`{*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 `split_view` for use on subsequent calls.
+``` cpp
+constexpr subrange<iterator_t<V>> find-next(iterator_t<V> it);
+```
+*Effects:* Equivalent to:
+``` cpp
+auto [b, e] = ranges::search(subrange(it, ranges::end(base_)), pattern_);
+if (b != ranges::end(base_) && ranges::empty(pattern_)) {
+  ++b;
+  ++e;
+}
+return {b, e};
+```
+#### Class `split_view::iterator` <a id="range.split.iterator">[[range.split.iterator]]</a>
 ``` cpp
 namespace std::ranges {
+  template<forward_range V, forward_range Pattern>
     requires view<V> && view<Pattern> &&
+             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>
+  class split_view<V, Pattern>::iterator {
   private:
+ split_view* parent_ = nullptr;                              // exposition only
+    iterator_t<V> cur_ = iterator_t<V>();                       // exposition only
+ subrange<iterator_t<V>> next_ = subrange<iterator_t<V>>();  // exposition only
+    bool trailing_empty_ = false;                               // exposition only
   public:
+    using iterator_concept = forward_iterator_tag;
     using iterator_category = input_iterator_tag;
+ using value_type = subrange<iterator_t<V>>;
+ using difference_type = range_difference_t<V>;
+    iterator() = default;
+    constexpr iterator(split_view& parent, iterator_t<V> current, subrange<iterator_t<V>> next);
+    constexpr iterator_t<V> base() const;
     constexpr value_type operator*() const;
+    constexpr iterator& operator++();
+    constexpr iterator operator++(int);
+    friend constexpr bool operator==(const iterator& x, const iterator& y);
   };
 }
 ```
 ``` cpp
+constexpr iterator(split_view& parent, iterator_t<V> current, subrange<iterator_t<V>> next);
 ```
+*Effects:* Initializes *parent\_* with `addressof(parent)`, *cur\_* with
+`std::move(current)`, and *next\_* with `std::move(next)`.
 ``` cpp
+constexpr iterator_t<V> base() const;
 ```
+*Effects:* Equivalent to `return `*`cur_`*`;`
 ``` cpp
 constexpr value_type operator*() const;
 ```
+*Effects:* Equivalent to `return {`*`cur_`*`, `*`next_`*`.begin()};`
 ``` cpp
+constexpr iterator& operator++();
 ```
 *Effects:* Equivalent to:
 ``` cpp
+cur_ = next_.begin();
+if (cur_ != ranges::end(parent_->base_)) {
+  cur_ = next_.end();
+ if (cur_ == ranges::end(parent_->base_)) {
+    trailing_empty_ = true;
+    next_ = {cur_, cur_};
+  } else {
+ next_ = parent_->find-next(cur_);
   }
+} else {
+  trailing_empty_ = false;
 }
 return *this;
 ```
 ``` cpp
+constexpr iterator operator++(int);
 ```
 *Effects:* Equivalent to:
 ``` cpp
+auto tmp = *this;
+++*this;
+return tmp;
 ```
 ``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y);
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return x.cur_ == y.cur_ && x.trailing_empty_ == y.trailing_empty_;
 ```
+#### Class `split_view::sentinel` <a id="range.split.sentinel">[[range.split.sentinel]]</a>
 ``` cpp
 namespace std::ranges {
+  template<forward_range V, forward_range Pattern>
     requires view<V> && view<Pattern> &&
+             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>
+  struct split_view<V, Pattern>::sentinel {
   private:
+ sentinel_t<V> end_ = sentinel_t<V>(); // exposition only
+  public:
+    sentinel() = default;
+    constexpr explicit sentinel(split_view& parent);
+    friend constexpr bool operator==(const iterator& x, const sentinel& y);
   };
 }
 ```
 ``` cpp
+constexpr explicit sentinel(split_view& parent);
 ```
+*Effects:* Initializes *end\_* with `ranges::end(parent.`*`base_`*`)`.
 ``` cpp
+friend constexpr bool operator==(const iterator& x, const sentinel& y);
 ```
 *Effects:* Equivalent to:
+`return x.`*`cur_`*` == y.`*`end_`*` && !x.`*`trailing_empty_`*`;`

Diff to HTML by rtfpessoa