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

Files changed (1) hide show

tmp/tmpobt86hml/{from.md → to.md} +427 -73

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

@@ -1,22 +1,24 @@
 ## Range factories <a id="range.factories">[[range.factories]]</a>
-This subclause defines *range factories*, which are utilities to create
-a `view`.
 Range factories are declared in namespace `std::ranges::views`.
 ### Empty view <a id="range.empty">[[range.empty]]</a>
 #### Overview <a id="range.empty.overview">[[range.empty.overview]]</a>
-`empty_view` produces a `view` of no elements of a particular type.
 [*Example 1*:
 ``` cpp
-empty_view<int> e;
 static_assert(ranges::empty(e));
 static_assert(0 == e.size());
 ```
 — *end example*]
@@ -40,58 +42,61 @@ namespace std::ranges {
 ### Single view <a id="range.single">[[range.single]]</a>
 #### Overview <a id="range.single.overview">[[range.single.overview]]</a>
-`single_view` produces a `view` that contains exactly one element of a
 specified value.
 The name `views::single` denotes a customization point object
 [[customization.point.object]]. Given a subexpression `E`, the
 expression `views::single(E)` is expression-equivalent to
-`single_view{E}`.
 [*Example 1*:
 ``` cpp
-single_view s{4};
-for (int i : s)
   cout << i;        // prints 4
 ```
 — *end example*]
 #### Class template `single_view` <a id="range.single.view">[[range.single.view]]</a>
 ``` cpp
 namespace std::ranges {
-  template<copy_constructible T>
     requires is_object_v<T>
   class single_view : public view_interface<single_view<T>> {
   private:
- semiregular-box<T> value_; // exposition only{} (see [range.semi.wrap])
   public:
-    single_view() = default;
-    constexpr explicit single_view(const T& t);
     constexpr explicit single_view(T&& t);
     template<class... Args>
       requires constructible_from<T, Args...>
-    constexpr single_view(in_place_t, Args&&... args);
     constexpr T* begin() noexcept;
     constexpr const T* begin() const noexcept;
     constexpr T* end() noexcept;
     constexpr const T* end() const noexcept;
     static constexpr size_t size() noexcept;
     constexpr T* data() noexcept;
     constexpr const T* data() const noexcept;
   };
 }
 ```
 ``` cpp
-constexpr explicit single_view(const T& t);
 ```
 *Effects:* Initializes *value\_* with `t`.
 ``` cpp
@@ -100,11 +105,12 @@ constexpr explicit single_view(T&& t);
 *Effects:* Initializes *value\_* with `std::move(t)`.
 ``` cpp
 template<class... Args>
-constexpr single_view(in_place_t, Args&&... args);
 ```
 *Effects:* Initializes *value\_* as if by
 *`value_`*`{in_place, std::forward<Args>(args)...}`.
@@ -143,49 +149,50 @@ constexpr const T* data() const noexcept;
 an initial value.
 The name `views::iota` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expressions `views::iota(E)` and `views::iota(E, F)` are
-expression-equivalent to `iota_view{E}` and `iota_view{E, F}`,
 respectively.
 [*Example 1*:
 ``` cpp
-for (int i : iota_view{1, 10})
-  cout << i << ' '; // prints: 1 2 3 4 5 6 7 8 9
 ```
 — *end example*]
 #### Class template `iota_view` <a id="range.iota.view">[[range.iota.view]]</a>
 ``` cpp
 namespace std::ranges {
   template<class I>
-    concept decrementable = // exposition only
-      see below;
   template<class I>
-    concept advanceable = // exposition only
-      see below;
   template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
-    requires weakly-equality-comparable-with<W, Bound> && semiregular<W>
   class iota_view : public view_interface<iota_view<W, Bound>> {
   private:
     // [range.iota.iterator], class iota_view::iterator
     struct iterator;                    // exposition only
     // [range.iota.sentinel], class iota_view::sentinel
     struct sentinel;                    // exposition only
     W value_ = W();                     // exposition only
     Bound bound_ = Bound();             // exposition only
   public:
-    iota_view() = default;
     constexpr explicit iota_view(W value);
-    constexpr iota_view(type_identity_t<W> value,
-                        type_identity_t<Bound> bound);
-    constexpr iota_view(iterator first, sentinel last) : iota_view(*first, last.bound_) {}
     constexpr iterator begin() const;
     constexpr auto end() const;
     constexpr iterator end() const requires same_as<W, Bound>;
@@ -213,11 +220,11 @@ Let `IOTA-DIFF-T(W)` be defined as follows:
 The exposition-only *decrementable* concept is equivalent to:
 ``` cpp
 template<class I>
-  concept decrementable =
     incrementable<I> && requires(I i) {
       { --i } -> same_as<I&>;
       { i-- } -> same_as<I>;
     };
 ```
@@ -237,11 +244,11 @@ only if
 The exposition-only *advanceable* concept is equivalent to:
 ``` cpp
 template<class I>
-  concept advanceable =
     decrementable<I> && totally_ordered<I> &&
     requires(I i, const I j, const IOTA-DIFF-T(I) n) {
       { i += n } -> same_as<I&>;
       { i -= n } -> same_as<I&>;
       I(j + n);
@@ -275,30 +282,49 @@ value `n` of type `D`. `I` models `advanceable` only if
 ``` cpp
 constexpr explicit iota_view(W value);
 ```
 *Preconditions:* `Bound` denotes `unreachable_sentinel_t` or `Bound()`
-is reachable from `value`.
 *Effects:* Initializes *value\_* with `value`.
 ``` cpp
-constexpr iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);
 ```
 *Preconditions:* `Bound` denotes `unreachable_sentinel_t` or `bound` is
 reachable from `value`. When `W` and `Bound` model
 `totally_ordered_with`, then `bool(value <= bound)` is `true`.
 *Effects:* Initializes *value\_* with `value` and *bound\_* with
 `bound`.
 ``` cpp
 constexpr iterator begin() const;
 ```
-*Effects:* Equivalent to: `return iterator{`*`value_`*`};`
 ``` cpp
 constexpr auto end() const;
 ```
@@ -313,11 +339,11 @@ else
 ``` cpp
 constexpr iterator end() const requires same_as<W, Bound>;
 ```
-*Effects:* Equivalent to: `return iterator{bound_};`
 ``` cpp
 constexpr auto size() const requires see below;
 ```
@@ -332,33 +358,35 @@ if constexpr (is-integer-like<W> && is-integer-like<Bound>)
     : to-unsigned-like(bound_) - to-unsigned-like(value_);
 else
   return to-unsigned-like(bound_ - value_);
 ```
-*Remarks:* The expression in the *requires-clause* is equivalent to
 ``` cpp
-(same_as<W, Bound> && advanceable<W>) || (integral<W> && integral<Bound>) ||
   sized_sentinel_for<Bound, W>
 ```
 #### Class `iota_view::iterator` <a id="range.iota.iterator">[[range.iota.iterator]]</a>
 ``` cpp
 namespace std::ranges {
   template<weakly_incrementable W, semiregular Bound>
-    requires weakly-equality-comparable-with<W, Bound>
   struct iota_view<W, Bound>::iterator {
   private:
     W value_ = W();             // exposition only
   public:
     using iterator_concept = see below;
-    using iterator_category = input_iterator_tag;
     using value_type = W;
     using difference_type = IOTA-DIFF-T(W);
-    iterator() = default;
     constexpr explicit iterator(W value);
     constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v<W>);
     constexpr iterator& operator++();
@@ -572,11 +600,16 @@ friend constexpr auto operator<=>(const iterator& x, const iterator& y)
 ``` cpp
 friend constexpr iterator operator+(iterator i, difference_type n)
   requires advanceable<W>;
 ```
-*Effects:* Equivalent to: `return i += n;`
 ``` cpp
 friend constexpr iterator operator+(difference_type n, iterator i)
   requires advanceable<W>;
 ```
@@ -586,11 +619,16 @@ friend constexpr iterator operator+(difference_type n, iterator i)
 ``` cpp
 friend constexpr iterator operator-(iterator i, difference_type n)
   requires advanceable<W>;
 ```
-*Effects:* Equivalent to: `return i -= n;`
 ``` cpp
 friend constexpr difference_type operator-(const iterator& x, const iterator& y)
   requires advanceable<W>;
 ```
@@ -614,14 +652,15 @@ if constexpr (is-integer-like<W>) {
 #### Class `iota_view::sentinel` <a id="range.iota.sentinel">[[range.iota.sentinel]]</a>
 ``` cpp
 namespace std::ranges {
   template<weakly_incrementable W, semiregular Bound>
-    requires weakly-equality-comparable-with<W, Bound>
   struct iota_view<W, Bound>::sentinel {
   private:
     Bound bound_ = Bound();     // exposition only
   public:
     sentinel() = default;
     constexpr explicit sentinel(Bound bound);
     friend constexpr bool operator==(const iterator& x, const sentinel& y);
@@ -658,22 +697,356 @@ friend constexpr iter_difference_t<W> operator-(const sentinel& x, const iterato
   requires sized_sentinel_for<Bound, W>;
 ```
 *Effects:* Equivalent to: `return -(y - x);`
 ### Istream view <a id="range.istream">[[range.istream]]</a>
 #### Overview <a id="range.istream.overview">[[range.istream.overview]]</a>
 `basic_istream_view` models `input_range` and reads (using `operator>>`)
 successive elements from its corresponding input stream.
 [*Example 1*:
 ``` cpp
 auto ints = istringstream{"0 1  2   3     4"};
-ranges::copy(istream_view<int>(ints), ostream_iterator<int>{cout, "-"});
 // prints 0-1-2-3-4-
 ```
 — *end example*]
@@ -685,32 +1058,29 @@ namespace std::ranges {
     concept stream-extractable =                // exposition only
       requires(basic_istream<CharT, Traits>& is, Val& t) {
          is >> t;
       };
-  template<movable Val, class CharT, class Traits>
     requires default_initializable<Val> &&
              stream-extractable<Val, CharT, Traits>
   class basic_istream_view : public view_interface<basic_istream_view<Val, CharT, Traits>> {
   public:
-    basic_istream_view() = default;
     constexpr explicit basic_istream_view(basic_istream<CharT, Traits>& stream);
-    constexpr auto begin()
-    {
-      if (stream_) {
-        *stream_ >> object_;
-      }
       return iterator{*this};
     }
     constexpr default_sentinel_t end() const noexcept;
   private:
     struct iterator;                            // exposition only
-    basic_istream<CharT, Traits>* stream_ = nullptr; // exposition only
-    Val object_ = Val(); // exposition only
   };
 }
 ```
 ``` cpp
@@ -723,32 +1093,23 @@ constexpr explicit basic_istream_view(basic_istream<CharT, Traits>& stream);
 constexpr default_sentinel_t end() const noexcept;
 ```
 *Effects:* Equivalent to: `return default_sentinel;`
-``` cpp
-template<class Val, class CharT, class Traits>
-basic_istream_view<Val, CharT, Traits> istream_view(basic_istream<CharT, Traits>& s);
-```
-*Effects:* Equivalent to:
-`return basic_istream_view<Val, CharT, Traits>{s};`
-#### Class template `basic_istream_view::iterator` <a id="range.istream.iterator">[[range.istream.iterator]]</a>
 ``` cpp
 namespace std::ranges {
   template<movable Val, class CharT, class Traits>
     requires default_initializable<Val> &&
              stream-extractable<Val, CharT, Traits>
-  class basic_istream_view<Val, CharT, Traits>::iterator {      // exposition only
   public:
     using iterator_concept = input_iterator_tag;
     using difference_type = ptrdiff_t;
     using value_type = Val;
-    iterator() = default;
     constexpr explicit iterator(basic_istream_view& parent) noexcept;
     iterator(const iterator&) = delete;
     iterator(iterator&&) = default;
@@ -761,11 +1122,11 @@ namespace std::ranges {
     Val& operator*() const;
     friend bool operator==(const iterator& x, default_sentinel_t);
   private:
-    basic_istream_view* parent_ = nullptr; // exposition only
   };
 }
 ```
 ``` cpp
@@ -776,37 +1137,30 @@ constexpr explicit iterator(basic_istream_view& parent) noexcept;
 ``` cpp
 iterator& operator++();
 ```
-*Preconditions:* *`parent_`*`->`*`stream_`*` != nullptr` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
-*parent_->stream_>> parent_->object_;
 return *this;
 ```
 ``` cpp
 void operator++(int);
 ```
-*Preconditions:* *`parent_`*`->`*`stream_`*` != nullptr` is `true`.
 *Effects:* Equivalent to `++*this`.
 ``` cpp
 Val& operator*() const;
 ```
-*Preconditions:* *`parent_`*`->`*`stream_`*` != nullptr` is `true`.
-*Effects:* Equivalent to: `return `*`parent_`*`->`*`object_`*`;`
 ``` cpp
 friend bool operator==(const iterator& x, default_sentinel_t);
 ```
-*Effects:* Equivalent to:
-`return x.`*`parent_`*` == nullptr || !*x.`*`parent_`*`->`*`stream_`*`;`

 ## Range factories <a id="range.factories">[[range.factories]]</a>
+### General <a id="range.factories.general">[[range.factories.general]]</a>
+Subclause [[range.factories]] defines *range factories*, which are
+utilities to create a view.
 Range factories are declared in namespace `std::ranges::views`.
 ### Empty view <a id="range.empty">[[range.empty]]</a>
 #### Overview <a id="range.empty.overview">[[range.empty.overview]]</a>
+`empty_view` produces a view of no elements of a particular type.
 [*Example 1*:
 ``` cpp
+auto e = views::empty<int>;
 static_assert(ranges::empty(e));
 static_assert(0 == e.size());
 ```
 — *end example*]
 ### Single view <a id="range.single">[[range.single]]</a>
 #### Overview <a id="range.single.overview">[[range.single.overview]]</a>
+`single_view` produces a view that contains exactly one element of a
 specified value.
 The name `views::single` denotes a customization point object
 [[customization.point.object]]. Given a subexpression `E`, the
 expression `views::single(E)` is expression-equivalent to
+`single_view<decay_t<decltype((E))>>(E)`.
 [*Example 1*:
 ``` cpp
+for (int i : views::single(4))
   cout << i;        // prints 4
 ```
 — *end example*]
 #### Class template `single_view` <a id="range.single.view">[[range.single.view]]</a>
 ``` cpp
 namespace std::ranges {
+  template<move_constructible T>
     requires is_object_v<T>
   class single_view : public view_interface<single_view<T>> {
   private:
+ movable-box<T> value_; // exposition only{} (see [range.move.wrap])
   public:
+    single_view() requires default_initializable<T> = default;
+    constexpr explicit single_view(const T& t) requires copy_constructible<T>;
     constexpr explicit single_view(T&& t);
     template<class... Args>
       requires constructible_from<T, Args...>
+    constexpr explicit single_view(in_place_t, Args&&... args);
     constexpr T* begin() noexcept;
     constexpr const T* begin() const noexcept;
     constexpr T* end() noexcept;
     constexpr const T* end() const noexcept;
     static constexpr size_t size() noexcept;
     constexpr T* data() noexcept;
     constexpr const T* data() const noexcept;
   };
+  template<class T>
+    single_view(T) -> single_view<T>;
 }
 ```
 ``` cpp
+constexpr explicit single_view(const T& t) requires copy_constructible<T>;
 ```
 *Effects:* Initializes *value\_* with `t`.
 ``` cpp
 *Effects:* Initializes *value\_* with `std::move(t)`.
 ``` cpp
 template<class... Args>
+  requires constructible_from<T, Args...>
+constexpr explicit single_view(in_place_t, Args&&... args);
 ```
 *Effects:* Initializes *value\_* as if by
 *`value_`*`{in_place, std::forward<Args>(args)...}`.
 an initial value.
 The name `views::iota` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expressions `views::iota(E)` and `views::iota(E, F)` are
+expression-equivalent to `iota_view(E)` and `iota_view(E, F)`,
 respectively.
 [*Example 1*:
 ``` cpp
+for (int i : views::iota(1, 10))
+  cout << i << ' '; // prints 1 2 3 4 5 6 7 8 9
 ```
 — *end example*]
 #### Class template `iota_view` <a id="range.iota.view">[[range.iota.view]]</a>
 ``` cpp
 namespace std::ranges {
   template<class I>
+    concept exposition onlyconceptnc{decrementable} = see belownc;  // exposition only
   template<class I>
+    concept exposition onlyconceptnc{advanceable} = see belownc;    // exposition only
   template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
+    requires weakly-equality-comparable-with<W, Bound> && copyable<W>
   class iota_view : public view_interface<iota_view<W, Bound>> {
   private:
     // [range.iota.iterator], class iota_view::iterator
     struct iterator;                    // exposition only
     // [range.iota.sentinel], class iota_view::sentinel
     struct sentinel;                    // exposition only
     W value_ = W();                     // exposition only
     Bound bound_ = Bound();             // exposition only
   public:
+    iota_view() requires default_initializable<W> = default;
     constexpr explicit iota_view(W value);
+    constexpr explicit iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);
+    constexpr explicit iota_view(iterator first, see below last);
     constexpr iterator begin() const;
     constexpr auto end() const;
     constexpr iterator end() const requires same_as<W, Bound>;
 The exposition-only *decrementable* concept is equivalent to:
 ``` cpp
 template<class I>
+  concept decrementable =               // exposition only
     incrementable<I> && requires(I i) {
       { --i } -> same_as<I&>;
       { i-- } -> same_as<I>;
     };
 ```
 The exposition-only *advanceable* concept is equivalent to:
 ``` cpp
 template<class I>
+  concept advanceable =                 // exposition only
     decrementable<I> && totally_ordered<I> &&
     requires(I i, const I j, const IOTA-DIFF-T(I) n) {
       { i += n } -> same_as<I&>;
       { i -= n } -> same_as<I&>;
       I(j + n);
 ``` cpp
 constexpr explicit iota_view(W value);
 ```
 *Preconditions:* `Bound` denotes `unreachable_sentinel_t` or `Bound()`
+is reachable from `value`. When `W` and `Bound` model
+`totally_ordered_with`, then `bool(value <= Bound())` is `true`.
 *Effects:* Initializes *value\_* with `value`.
 ``` cpp
+constexpr explicit iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);
 ```
 *Preconditions:* `Bound` denotes `unreachable_sentinel_t` or `bound` is
 reachable from `value`. When `W` and `Bound` model
 `totally_ordered_with`, then `bool(value <= bound)` is `true`.
 *Effects:* Initializes *value\_* with `value` and *bound\_* with
 `bound`.
+``` cpp
+constexpr explicit iota_view(iterator first, see below last);
+```
+*Effects:* Equivalent to:
+- If `same_as<W, Bound>` is `true`,
+  `iota_view(first.`*`value_`*`, last.`*`value_`*`)`.
+- Otherwise, if `Bound` denotes `unreachable_sentinel_t`,
+  `iota_view(first.`*`value_`*`, last)`.
+- Otherwise, `iota_view(first.`*`value_`*`, last.`*`bound_`*`)`.
+*Remarks:* The type of `last` is:
+- If `same_as<W, Bound>` is `true`, *iterator*.
+- Otherwise, if `Bound` denotes `unreachable_sentinel_t`, `Bound`.
+- Otherwise, *sentinel*.
 ``` cpp
 constexpr iterator begin() const;
 ```
+*Effects:* Equivalent to: `return `*`iterator`*`{`*`value_`*`};`
 ``` cpp
 constexpr auto end() const;
 ```
 ``` cpp
 constexpr iterator end() const requires same_as<W, Bound>;
 ```
+*Effects:* Equivalent to: `return `*`iterator`*`{`*`bound_`*`};`
 ``` cpp
 constexpr auto size() const requires see below;
 ```
     : to-unsigned-like(bound_) - to-unsigned-like(value_);
 else
   return to-unsigned-like(bound_ - value_);
 ```
+*Remarks:* The expression in the *requires-clause* is equivalent to:
 ``` cpp
+(same_as<W, Bound> && advanceable<W>) || (is-integer-like<W> && is-integer-like<Bound>) ||
   sized_sentinel_for<Bound, W>
 ```
 #### Class `iota_view::iterator` <a id="range.iota.iterator">[[range.iota.iterator]]</a>
 ``` cpp
 namespace std::ranges {
   template<weakly_incrementable W, semiregular Bound>
+    requires weakly-equality-comparable-with<W, Bound> && copyable<W>
   struct iota_view<W, Bound>::iterator {
   private:
     W value_ = W();             // exposition only
   public:
     using iterator_concept = see below;
+    using iterator_category = input_iterator_tag;       // present only if W models incrementable and
+                                                        // IOTA-DIFF-T(W) is an integral type
     using value_type = W;
     using difference_type = IOTA-DIFF-T(W);
+    iterator() requires default_initializable<W> = default;
     constexpr explicit iterator(W value);
     constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v<W>);
     constexpr iterator& operator++();
 ``` cpp
 friend constexpr iterator operator+(iterator i, difference_type n)
   requires advanceable<W>;
 ```
+*Effects:* Equivalent to:
+``` cpp
+i += n;
+return i;
+```
 ``` cpp
 friend constexpr iterator operator+(difference_type n, iterator i)
   requires advanceable<W>;
 ```
 ``` cpp
 friend constexpr iterator operator-(iterator i, difference_type n)
   requires advanceable<W>;
 ```
+*Effects:* Equivalent to:
+``` cpp
+i -= n;
+return i;
+```
 ``` cpp
 friend constexpr difference_type operator-(const iterator& x, const iterator& y)
   requires advanceable<W>;
 ```
 #### Class `iota_view::sentinel` <a id="range.iota.sentinel">[[range.iota.sentinel]]</a>
 ``` cpp
 namespace std::ranges {
   template<weakly_incrementable W, semiregular Bound>
+    requires weakly-equality-comparable-with<W, Bound> && copyable<W>
   struct iota_view<W, Bound>::sentinel {
   private:
     Bound bound_ = Bound();     // exposition only
   public:
     sentinel() = default;
     constexpr explicit sentinel(Bound bound);
     friend constexpr bool operator==(const iterator& x, const sentinel& y);
   requires sized_sentinel_for<Bound, W>;
 ```
 *Effects:* Equivalent to: `return -(y - x);`
+### 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_);
+```
 ### Istream view <a id="range.istream">[[range.istream]]</a>
 #### Overview <a id="range.istream.overview">[[range.istream.overview]]</a>
 `basic_istream_view` models `input_range` and reads (using `operator>>`)
 successive elements from its corresponding input stream.
+The name `views::istream<T>` denotes a customization point object
+[[customization.point.object]]. Given a type `T` and a subexpression `E`
+of type `U`, if `U` models
+`derived_from<basic_istream<typename U::char_type,
+typename U::traits_type>>`, then the expression `views::istream<T>(E)`
+is expression-equivalent to
+`basic_istream_view<T, typename U::char_type,
+typename U::traits_type>(E)`; otherwise, `views::istream<T>(E)` is
+ill-formed.
 [*Example 1*:
 ``` cpp
 auto ints = istringstream{"0 1  2   3     4"};
+ranges::copy(views::istream<int>(ints), ostream_iterator<int>{cout, "-"});
 // prints 0-1-2-3-4-
 ```
 — *end example*]
     concept stream-extractable =                // exposition only
       requires(basic_istream<CharT, Traits>& is, Val& t) {
          is >> t;
       };
+  template<movable Val, class CharT, class Traits = char_traits<CharT>>
     requires default_initializable<Val> &&
              stream-extractable<Val, CharT, Traits>
   class basic_istream_view : public view_interface<basic_istream_view<Val, CharT, Traits>> {
   public:
     constexpr explicit basic_istream_view(basic_istream<CharT, Traits>& stream);
+    constexpr auto begin() {
+      *stream_ >> value_;
       return iterator{*this};
     }
     constexpr default_sentinel_t end() const noexcept;
   private:
+    // [range.istream.iterator], class basic_istream_view::iterator
     struct iterator;                            // exposition only
+    basic_istream<CharT, Traits>* stream_; // exposition only
+    Val value_ = Val(); // exposition only
   };
 }
 ```
 ``` cpp
 constexpr default_sentinel_t end() const noexcept;
 ```
 *Effects:* Equivalent to: `return default_sentinel;`
+#### Class `basic_istream_view::iterator` <a id="range.istream.iterator">[[range.istream.iterator]]</a>
 ``` cpp
 namespace std::ranges {
   template<movable Val, class CharT, class Traits>
     requires default_initializable<Val> &&
              stream-extractable<Val, CharT, Traits>
+  class basic_istream_view<Val, CharT, Traits>::iterator {
   public:
     using iterator_concept = input_iterator_tag;
     using difference_type = ptrdiff_t;
     using value_type = Val;
     constexpr explicit iterator(basic_istream_view& parent) noexcept;
     iterator(const iterator&) = delete;
     iterator(iterator&&) = default;
     Val& operator*() const;
     friend bool operator==(const iterator& x, default_sentinel_t);
   private:
+    basic_istream_view* parent_; // exposition only
   };
 }
 ```
 ``` cpp
 ``` cpp
 iterator& operator++();
 ```
 *Effects:* Equivalent to:
 ``` cpp
+*parent_->stream_ >> parent_->value_;
 return *this;
 ```
 ``` cpp
 void operator++(int);
 ```
 *Effects:* Equivalent to `++*this`.
 ``` cpp
 Val& operator*() const;
 ```
+*Effects:* Equivalent to: `return `*`parent_`*`->`*`value_`*`;`
 ``` cpp
 friend bool operator==(const iterator& x, default_sentinel_t);
 ```
+*Effects:* Equivalent to: `return !*x.`*`parent_`*`->`*`stream_`*`;`

Diff to HTML by rtfpessoa