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

Files changed (1) hide show

tmp/tmpsmilrv9d/{from.md → to.md} +324 -0

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

	@@ -0,0 +1,324 @@

+### Repeat view <a id="range.repeat">[[range.repeat]]</a>
+#### Overview <a id="range.repeat.overview">[[range.repeat.overview]]</a>
+`repeat_view` generates a sequence of elements by repeatedly producing
+the same value.
+The name `views::repeat` denotes a customization point object
+[[customization.point.object]]. Given subexpressions `E` and `F`, the
+expressions `views::repeat(E)` and `views::repeat(E, F)` are
+expression-equivalent to `repeat_view(E)` and `repeat_view(E, F)`,
+respectively.
+[*Example 1*:
+``` cpp
+for (int i : views::repeat(17, 4))
+  cout << i << ' ';
+// prints 17 17 17 17
+```
+— *end example*]
+#### Class template `repeat_view` <a id="range.repeat.view">[[range.repeat.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<class T>
+    concept integer-like-with-usable-difference-type =  // exposition only
+      is-signed-integer-like<T> || (is-integer-like<T> && weakly_incrementable<T>);
+  template<move_constructible T, semiregular Bound = unreachable_sentinel_t>
+    requires (is_object_v<T> && same_as<T, remove_cv_t<T>> &&
+              (integer-like-with-usable-difference-type<Bound> ||
+               same_as<Bound, unreachable_sentinel_t>))
+  class repeat_view : public view_interface<repeat_view<T, Bound>> {
+  private:
+    // [range.repeat.iterator], class repeat_view::iterator
+    struct iterator;                            // exposition only
+    movable-box<T> value_;                      // exposition only, see [range.move.wrap]
+    Bound bound_ = Bound();                     // exposition only
+  public:
+    repeat_view() requires default_initializable<T> = default;
+    constexpr explicit repeat_view(const T& value, Bound bound = Bound())
+      requires copy_constructible<T>;
+    constexpr explicit repeat_view(T&& value, Bound bound = Bound());
+    template<class... TArgs, class... BoundArgs>
+      requires constructible_from<T, TArgs...> &&
+               constructible_from<Bound, BoundArgs...>
+    constexpr explicit repeat_view(piecewise_construct_t,
+      tuple<TArgs...> value_args, tuple<BoundArgs...> bound_args = tuple<>{});
+    constexpr iterator begin() const;
+    constexpr iterator end() const requires (!same_as<Bound, unreachable_sentinel_t>);
+    constexpr unreachable_sentinel_t end() const noexcept;
+    constexpr auto size() const requires (!same_as<Bound, unreachable_sentinel_t>);
+  };
+  template<class T, class Bound>
+    repeat_view(T, Bound) -> repeat_view<T, Bound>;
+}
+```
+``` cpp
+constexpr explicit repeat_view(const T& value, Bound bound = Bound())
+  requires copy_constructible<T>;
+```
+*Preconditions:* If `Bound` is not `unreachable_sentinel_t`,
+`bound` ≥ 0.
+*Effects:* Initializes *value\_* with `value` and *bound\_* with
+`bound`.
+``` cpp
+constexpr explicit repeat_view(T&& value, Bound bound = Bound());
+```
+*Preconditions:* If `Bound` is not `unreachable_sentinel_t`,
+`bound` ≥ 0.
+*Effects:* Initializes *value\_* with `std::move(value)` and *bound\_*
+with `bound`.
+``` cpp
+template<class... TArgs, class... BoundArgs>
+  requires constructible_from<T, TArgs...> &&
+           constructible_from<Bound, BoundArgs...>
+constexpr explicit repeat_view(piecewise_construct_t,
+  tuple<TArgs...> value_args, tuple<BoundArgs...> bound_args = tuple<>{});
+```
+*Effects:* Initializes *value\_* with
+`make_from_tuple<T>(std::move(value_args))` and initializes *bound\_*
+with `make_from_tuple<Bound>(std::move(bound_args))`. The behavior is
+undefined if `Bound` is not `unreachable_sentinel_t` and *bound\_* is
+negative.
+``` cpp
+constexpr iterator begin() const;
+```
+*Effects:* Equivalent to:
+`return `*`iterator`*`(addressof(*`*`value_`*`));`
+``` cpp
+constexpr iterator end() const requires (!same_as<Bound, unreachable_sentinel_t>);
+```
+*Effects:* Equivalent to:
+`return `*`iterator`*`(addressof(*`*`value_`*`), `*`bound_`*`);`
+``` cpp
+constexpr unreachable_sentinel_t end() const noexcept;
+```
+*Effects:* Equivalent to: `return unreachable_sentinel;`
+``` cpp
+constexpr auto size() const requires (!same_as<Bound, unreachable_sentinel_t>);
+```
+*Effects:* Equivalent to: `return `*`to-unsigned-like`*`(`*`bound_`*`);`
+#### Class `repeat_view::iterator` <a id="range.repeat.iterator">[[range.repeat.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<move_constructible T, semiregular Bound>
+    requires (is_object_v<T> && same_as<T, remove_cv_t<T>> &&
+              (integer-like-with-usable-difference-type<Bound> ||
+               same_as<Bound, unreachable_sentinel_t>))
+  class repeat_view<T, Bound>::iterator {
+  private:
+    using index-type =                          // exposition only
+      conditional_t<same_as<Bound, unreachable_sentinel_t>, ptrdiff_t, Bound>;
+    const T* value_ = nullptr;                  // exposition only
+    index-type current_ = index-type();         // exposition only
+    constexpr explicit iterator(const T* value, index-type b = index-type());   // exposition only
+  public:
+    using iterator_concept = random_access_iterator_tag;
+    using iterator_category = random_access_iterator_tag;
+    using value_type = T;
+    using difference_type = see below;
+    iterator() = default;
+    constexpr const T& operator*() const noexcept;
+    constexpr iterator& operator++();
+    constexpr iterator operator++(int);
+    constexpr iterator& operator--();
+    constexpr iterator operator--(int);
+    constexpr iterator& operator+=(difference_type n);
+    constexpr iterator& operator-=(difference_type n);
+    constexpr const T& operator[](difference_type n) const noexcept;
+    friend constexpr bool operator==(const iterator& x, const iterator& y);
+    friend constexpr auto operator<=>(const iterator& x, const iterator& y);
+    friend constexpr iterator operator+(iterator i, difference_type n);
+    friend constexpr iterator operator+(difference_type n, iterator i);
+    friend constexpr iterator operator-(iterator i, difference_type n);
+    friend constexpr difference_type operator-(const iterator& x, const iterator& y);
+  };
+}
+```
+If `is-signed-integer-like<index-type>` is `true`, the member
+*typedef-name* `difference_type` denotes *`index-type`*. Otherwise, it
+denotes `IOTA-DIFF-T(index-type)` [[range.iota.view]].
+``` cpp
+constexpr explicit iterator(const T* value, index-type b = index-type());
+```
+*Preconditions:* If `Bound` is not `unreachable_sentinel_t`, `b` ≥ 0.
+*Effects:* Initializes *value\_* with `value` and *current\_* with `b`.
+``` cpp
+constexpr const T& operator*() const noexcept;
+```
+*Effects:* Equivalent to: `return *`*`value_`*`;`
+``` cpp
+constexpr iterator& operator++();
+```
+*Effects:* Equivalent to:
+``` cpp
+++current_;
+return *this;
+```
+``` cpp
+constexpr iterator operator++(int);
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+++*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator--();
+```
+*Preconditions:* If `Bound` is not `unreachable_sentinel_t`,
+current_ > 0.
+*Effects:* Equivalent to:
+``` cpp
+--current_;
+return *this;
+```
+``` cpp
+constexpr iterator operator--(int);
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator+=(difference_type n);
+```
+*Preconditions:* If `Bound` is not `unreachable_sentinel_t`,
+current_ + `n` ≥ 0.
+*Effects:* Equivalent to:
+``` cpp
+current_ += n;
+return *this;
+```
+``` cpp
+constexpr iterator& operator-=(difference_type n);
+```
+*Preconditions:* If `Bound` is not `unreachable_sentinel_t`,
+current_ - `n` ≥ 0.
+*Effects:* Equivalent to:
+``` cpp
+current_ -= n;
+return *this;
+```
+``` cpp
+constexpr const T& operator[](difference_type n) const noexcept;
+```
+*Effects:* Equivalent to: `return *(*this + n);`
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y);
+```
+*Effects:* Equivalent to: `return x.`*`current_`*` == y.`*`current_`*`;`
+``` cpp
+friend constexpr auto operator<=>(const iterator& x, const iterator& y);
+```
+*Effects:* Equivalent to:
+`return x.`*`current_`*` <=> y.`*`current_`*`;`
+``` cpp
+friend constexpr iterator operator+(iterator i, difference_type n);
+friend constexpr iterator operator+(difference_type n, iterator i);
+```
+*Effects:* Equivalent to:
+``` cpp
+i += n;
+return i;
+```
+``` cpp
+friend constexpr iterator operator-(iterator i, difference_type n);
+```
+*Effects:* Equivalent to:
+``` cpp
+i -= n;
+return i;
+```
+``` cpp
+friend constexpr difference_type operator-(const iterator& x, const iterator& y);
+```
+*Effects:* Equivalent to:
+``` cpp
+return static_cast<difference_type>(x.current_) - static_cast<difference_type>(y.current_);
+```

Diff to HTML by rtfpessoa