[range.concat] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpnbs3htie/{from.md → to.md} +788 -0

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

	@@ -0,0 +1,788 @@

+### Concat view <a id="range.concat">[[range.concat]]</a>
+#### Overview <a id="range.concat.overview">[[range.concat.overview]]</a>
+`concat_view` presents a view that concatenates all the underlying
+ranges.
+The name `views::concat` denotes a customization point object
+[[customization.point.object]]. Given a pack of subexpressions `Es...`,
+the expression `views::concat(Es...)` is expression-equivalent to
+- `views::all(Es...)` if `Es` is a pack with only one element whose type
+  models `input_range`,
+- otherwise, `concat_view(Es...)`.
+[*Example 1*:
+``` cpp
+vector<int> v1{1, 2, 3}, v2{4, 5}, v3{};
+array a{6, 7, 8};
+auto s = views::single(9);
+for (auto&& i : views::concat(v1, v2, v3, a, s)) {
+  print("{} ", i);      // prints 1 2 3 4 5 6 7 8 9
+}
+```
+— *end example*]
+#### Class template `concat_view` <a id="range.concat.view">[[range.concat.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<class... Rs>
+  using concat-reference-t = common_reference_t<range_reference_t<Rs>...>;      // exposition only
+  template<class... Rs>
+  using concat-value-t = common_type_t<range_value_t<Rs>...>;                   // exposition only
+  template<class... Rs>
+  using concat-rvalue-reference-t =                                             // exposition only
+    common_reference_t<range_rvalue_reference_t<Rs>...>;
+  template<class... Rs>
+    concept concat-indirectly-readable = see below;     // exposition only
+  template<class... Rs>
+    concept concatable = see below;                     // exposition only
+  template<bool Const, class... Rs>
+    concept concat-is-random-access = see below;        // exposition only
+  template<bool Const, class... Rs>
+    concept concat-is-bidirectional = see below;        // exposition only
+  template<input_range... Views>
+    requires (view<Views> && ...) && (sizeof...(Views) > 0) &&
+              concatable<Views...>
+  class concat_view : public view_interface<concat_view<Views...>> {
+    tuple<Views...> views_;                                             // exposition only
+    // [range.concat.iterator], class template concat_view::iterator
+    template<bool> class iterator;                                      // exposition only
+  public:
+    constexpr concat_view() = default;
+    constexpr explicit concat_view(Views... views);
+    constexpr iterator<false> begin() requires (!(simple-view<Views> && ...));
+    constexpr iterator<true> begin() const
+      requires (range<const Views> && ...) && concatable<const Views...>;
+    constexpr auto end() requires (!(simple-view<Views> && ...));
+    constexpr auto end() const
+      requires (range<const Views> && ...) && concatable<const Views...>;
+    constexpr auto size() requires (sized_range<Views> && ...);
+    constexpr auto size() const requires (sized_range<const Views> && ...);
+  };
+  template<class... R>
+    concat_view(R&&...) -> concat_view<views::all_t<R>...>;
+}
+```
+``` cpp
+template<class... Rs>
+  concept concat-indirectly-readable = see below;                           // exposition only
+```
+The exposition-only `concat-indirectly-readable` concept is equivalent
+to:
+``` cpp
+template<class Ref, class RRef, class It>
+  concept concat-indirectly-readable-impl =                         // exposition only
+    requires (const It it) {
+      { *it } -> convertible_to<Ref>;
+      { ranges::iter_move(it) } -> convertible_to<RRef>;
+    };
+template<class... Rs>
+  concept concat-indirectly-readable =                              // exposition only
+    common_reference_with<concat-reference-t<Rs...>&&,
+                          concat-value-t<Rs...>&> &&
+    common_reference_with<concat-reference-t<Rs...>&&,
+                          concat-rvalue-reference-t<Rs...>&&> &&
+    common_reference_with<concat-rvalue-reference-t<Rs...>&&,
+                          concat-value-t<Rs...> const&> &&
+    (concat-indirectly-readable-impl<concat-reference-t<Rs...>,
+                                     concat-rvalue-reference-t<Rs...>,
+                                     iterator_t<Rs>> && ...);
+```
+``` cpp
+template<class... Rs>
+  concept concatable = see below;                                           // exposition only
+```
+The exposition-only `concatable` concept is equivalent to:
+``` cpp
+template<class... Rs>
+  concept concatable = requires {                                   // exposition only
+    typename concat-reference-t<Rs...>;
+    typename concat-value-t<Rs...>;
+    typename concat-rvalue-reference-t<Rs...>;
+  } && concat-indirectly-readable<Rs...>;
+```
+``` cpp
+template<bool Const, class... Rs>
+  concept concat-is-random-access = see below;                              // exposition only
+```
+Let `Fs` be the pack that consists of all elements of `Rs` except the
+last element, then *`concat-is-random-access`* is equivalent to:
+``` cpp
+template<bool Const, class... Rs>
+  concept concat-is-random-access =                                 // exposition only
+    all-random-access<Const, Rs...> &&
+    (common_range<maybe-const<Const, Fs>> && ...);
+```
+``` cpp
+template<bool Const, class... Rs>
+  concept concat-is-bidirectional = see below;                              // exposition only
+```
+Let `Fs` be the pack that consists of all elements of `Rs` except the
+last element, then *`concat-is-bidirectional`* is equivalent to:
+``` cpp
+template<bool Const, class... Rs>
+  concept concat-is-bidirectional =                                 // exposition only
+    all-bidirectional<Const, Rs...> &&
+    (common_range<maybe-const<Const, Fs>> && ...);
+```
+``` cpp
+constexpr explicit concat_view(Views... views);
+```
+*Effects:* Initializes *views\_* with `std::move(views)...`.
+``` cpp
+constexpr iterator<false> begin() requires (!(simple-view<Views> && ...));
+constexpr iterator<true> begin() const
+  requires (range<const Views> && ...) && concatable<const Views...>;
+```
+*Effects:* Let *is-const* be `true` for the const-qualified overload,
+and `false` otherwise. Equivalent to:
+``` cpp
+iterator<is-const> it(this, in_place_index<0>, ranges::begin(std::get<0>(views_)));
+it.template satisfy<0>();
+return it;
+```
+``` cpp
+constexpr auto end() requires (!(simple-view<Views> && ...));
+constexpr auto end() const
+  requires (range<const Views> && ...) && concatable<const Views...>;
+```
+*Effects:* Let *is-const* be `true` for the const-qualified overload,
+and `false` otherwise. Equivalent to:
+``` cpp
+constexpr auto N = sizeof...(Views);
+if constexpr (common_range<maybe-const<is-const, Views...[N - 1]>>) {
+  return iterator<is-const>(this, in_place_index<N - 1>,
+                            ranges::end(std::get<N - 1>(views_)));
+} else {
+  return default_sentinel;
+}
+```
+``` cpp
+constexpr auto size() requires (sized_range<Views> && ...);
+constexpr auto size() const requires (sized_range<const Views> && ...);
+```
+*Effects:* Equivalent to:
+``` cpp
+return apply(
+  [](auto... sizes) {
+    using CT = make-unsigned-like-t<common_type_t<decltype(sizes)...>>;
+    return (CT(sizes) + ...);
+  },
+  tuple-transform(ranges::size, views_));
+```
+#### Class `concat_view::iterator` <a id="range.concat.iterator">[[range.concat.iterator]]</a>
+``` cpp
+namespace std::ranges {
+  template<input_range... Views>
+    requires (view<Views> && ...) && (sizeof...(Views) > 0) &&
+              concatable<Views...>
+  template<bool Const>
+  class concat_view<Views...>::iterator {
+  public:
+    using iterator_category = see below;                                // not always present
+    using iterator_concept = see below;
+    using value_type = concat-value-t<maybe-const<Const, Views>...>;
+    using difference_type = common_type_t<range_difference_t<maybe-const<Const, Views>>...>;
+  private:
+    using base-iter =                                                       // exposition only
+      variant<iterator_t<maybe-const<Const, Views>>...>;
+    maybe-const<Const, concat_view>* parent_ = nullptr;                     // exposition only
+    base-iter it_;                                                          // exposition only
+    template<size_t N>
+      constexpr void satisfy();                                             // exposition only
+    template<size_t N>
+      constexpr void prev();                                                // exposition only
+    template<size_t N>
+      constexpr void advance-fwd(difference_type offset,                    // exposition only
+                                 difference_type steps);
+    template<size_t N>
+      constexpr void advance-bwd(difference_type offset,                    // exposition only
+                                 difference_type steps);
+    template<class... Args>
+      constexpr explicit iterator(maybe-const<Const, concat_view>* parent,  // exposition only
+                                  Args&&... args)
+        requires constructible_from<base-iter, Args&&...>;
+  public:
+    iterator() = default;
+    constexpr iterator(iterator<!Const> i)
+      requires Const && (convertible_to<iterator_t<Views>, iterator_t<const Views>> && ...);
+    constexpr decltype(auto) operator*() const;
+    constexpr iterator& operator++();
+    constexpr void operator++(int);
+    constexpr iterator operator++(int)
+      requires all-forward<Const, Views...>;
+    constexpr iterator& operator--()
+      requires concat-is-bidirectional<Const, Views...>;
+    constexpr iterator operator--(int)
+      requires concat-is-bidirectional<Const, Views...>;
+    constexpr iterator& operator+=(difference_type n)
+      requires concat-is-random-access<Const, Views...>;
+    constexpr iterator& operator-=(difference_type n)
+      requires concat-is-random-access<Const, Views...>;
+    constexpr decltype(auto) operator[](difference_type n) const
+      requires concat-is-random-access<Const, Views...>;
+    friend constexpr bool operator==(const iterator& x, const iterator& y)
+      requires (equality_comparable<iterator_t<maybe-const<Const, Views>>> && ...);
+    friend constexpr bool operator==(const iterator& it, default_sentinel_t);
+    friend constexpr bool operator<(const iterator& x, const iterator& y)
+      requires all-random-access<Const, Views...>;
+    friend constexpr bool operator>(const iterator& x, const iterator& y)
+      requires all-random-access<Const, Views...>;
+    friend constexpr bool operator<=(const iterator& x, const iterator& y)
+      requires all-random-access<Const, Views...>;
+    friend constexpr bool operator>=(const iterator& x, const iterator& y)
+      requires all-random-access<Const, Views...>;
+    friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+      requires (all-random-access<Const, Views...> &&
+                (three_way_comparable<iterator_t<maybe-const<Const, Views>>> && ...));
+    friend constexpr iterator operator+(const iterator& it, difference_type n)
+      requires concat-is-random-access<Const, Views...>;
+    friend constexpr iterator operator+(difference_type n, const iterator& it)
+      requires concat-is-random-access<Const, Views...>;
+    friend constexpr iterator operator-(const iterator& it, difference_type n)
+      requires concat-is-random-access<Const, Views...>;
+    friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+      requires concat-is-random-access<Const, Views...>;
+    friend constexpr difference_type operator-(const iterator& x, default_sentinel_t)
+      requires see below;
+    friend constexpr difference_type operator-(default_sentinel_t, const iterator& x)
+      requires see below;
+    friend constexpr decltype(auto) iter_move(const iterator& it) noexcept(see below);
+    friend constexpr void iter_swap(const iterator& x, const iterator& y) noexcept(see below)
+      requires see below;
+  };
+}
+```
+`iterator::iterator_concept` is defined as follows:
+- If `concat-is-random-access<Const, Views...>` is modeled, then
+  `iterator_concept` denotes `random_access_iterator_tag`.
+- Otherwise, if `concat-is-bidirectional<Const, Views...>` is modeled,
+  then `iterator_concept` denotes `bidirectional_iterator_tag`.
+- Otherwise, if `all-forward<Const, Views...>` is modeled, then
+  `iterator_concept` denotes `forward_iterator_tag`.
+- Otherwise, `iterator_concept` denotes `input_iterator_tag`.
+The member *typedef-name* `iterator_category` is defined if and only if
+`all-forward<Const, Views...>` is modeled. In that case,
+`iterator::iterator_category` is defined as follows:
+- If `is_reference_v<concat-reference-t<maybe-const<Const, Views>...>>`
+  is `false`, then `iterator_category` denotes `input_iterator_tag`.
+- Otherwise, let `Cs` denote the pack of types
+  `iterator_traits<iterator_t<maybe-const<Const, Views>>>::iterator_category...`.
+  - If
+    `(derived_from<Cs, random_access_iterator_tag> && ...) && concat-is-random-ac-{cess}<Const, Views...>`
+    is `true`, `iterator_category` denotes `random_access_iterator_tag`.
+  - Otherwise, if
+    `(derived_from<Cs, bidirectional_iterator_tag> && ...) && concat-is-{bidirectional}<Const, Views...>`
+    is `true`, `iterator_category` denotes `bidirectional_iterator_tag`.
+  - Otherwise, if `(derived_from<Cs, forward_iterator_tag> && ...)` is
+    `true`, `iterator_category` denotes `forward_iterator_tag`.
+  - Otherwise, `iterator_category` denotes `input_iterator_tag`.
+``` cpp
+template<size_t N>
+  constexpr void satisfy();
+```
+*Effects:* Equivalent to:
+``` cpp
+if constexpr (N < (sizeof...(Views) - 1)) {
+  if (std::get<N>(it_) == ranges::end(std::get<N>(parent_->views_))) {
+    it_.template emplace<N + 1>(ranges::begin(std::get<N + 1>(parent_->views_)));
+    satisfy<N + 1>();
+  }
+}
+```
+``` cpp
+template<size_t N>
+  constexpr void prev();
+```
+*Effects:* Equivalent to:
+``` cpp
+if constexpr (N == 0) {
+  --std::get<0>(it_);
+} else {
+  if (std::get<N>(it_) == ranges::begin(std::get<N>(parent_->views_))) {
+    it_.template emplace<N - 1>(ranges::end(std::get<N - 1>(parent_->views_)));
+    prev<N - 1>();
+  } else {
+    --std::get<N>(it_);
+  }
+}
+```
+``` cpp
+template<size_t N>
+  constexpr void advance-fwd(difference_type offset, difference_type steps);
+```
+*Effects:* Equivalent to:
+``` cpp
+using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base-iter>>;
+if constexpr (N == sizeof...(Views) - 1) {
+  std::get<N>(it_) += static_cast<underlying_diff_type>(steps);
+} else {
+  auto n_size = ranges::distance(std::get<N>(parent_->views_));
+  if (offset + steps < n_size) {
+    std::get<N>(it_) += static_cast<underlying_diff_type>(steps);
+  } else {
+    it_.template emplace<N + 1>(ranges::begin(std::get<N + 1>(parent_->views_)));
+    advance-fwd<N + 1>(0, offset + steps - n_size);
+  }
+}
+```
+``` cpp
+template<size_t N>
+  constexpr void advance-bwd(difference_type offset, difference_type steps);
+```
+*Effects:* Equivalent to:
+``` cpp
+using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base-iter>>;
+if constexpr (N == 0) {
+  std::get<N>(it_) -= static_cast<underlying_diff_type>(steps);
+} else {
+  if (offset >= steps) {
+    std::get<N>(it_) -= static_cast<underlying_diff_type>(steps);
+  } else {
+    auto prev_size = ranges::distance(std::get<N - 1>(parent_->views_));
+    it_.template emplace<N - 1>(ranges::end(std::get<N - 1>(parent_->views_)));
+    advance-bwd<N - 1>(prev_size, steps - offset);
+  }
+}
+```
+``` cpp
+template<class... Args>
+  constexpr explicit iterator(maybe-const<Const, concat_view>* parent,
+                              Args&&... args)
+    requires constructible_from<base-iter, Args&&...>;
+```
+*Effects:* Initializes *parent\_* with `parent`, and initializes *it\_*
+with `std::forward<Args>(args)...`.
+``` cpp
+constexpr iterator(iterator<!Const> it)
+  requires Const &&
+           (convertible_to<iterator_t<Views>, iterator_t<const Views>> && ...);
+```
+*Preconditions:* `it.`*`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Initializes *parent\_* with `it.`*`parent_`*, and let i be
+`it.`*`it_`*`.index()`, initializes *it\_* with
+*`base-iter`*`(in_place_index<`i`>, std::get<`i`>(std::move(it.`*`it_`*`)))`.
+``` cpp
+constexpr decltype(auto) operator*() const;
+```
+*Preconditions:* *`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+using reference = concat-reference-t<maybe-const<Const, Views>...>;
+return std::visit([](auto&& it) -> reference { return *it; },
+                  it_);
+```
+``` cpp
+constexpr iterator& operator++();
+```
+*Preconditions:* *`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Let i be *`it_`*`.index()`. Equivalent to:
+``` cpp
+++std::get<i>(it_);
+satisfy<i>();
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to:
+``` cpp
+++*this;
+```
+``` cpp
+constexpr iterator operator++(int)
+  requires all-forward<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+++*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator--()
+  requires concat-is-bidirectional<Const, Views...>;
+```
+*Preconditions:* *`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Let i be *`it_`*`.index()`. Equivalent to:
+``` cpp
+prev<i>();
+return *this;
+```
+``` cpp
+constexpr iterator operator--(int)
+  requires concat-is-bidirectional<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator+=(difference_type n)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Preconditions:* *`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Let i be *`it_`*`.index()`. Equivalent to:
+``` cpp
+if (n > 0) {
+  advance-fwd<i>(std::get<i>(it_) - ranges::begin(std::get<i>(parent_->views_)), n);
+} else if (n < 0) {
+  advance-bwd<i>(std::get<i>(it_) - ranges::begin(std::get<i>(parent_->views_)), -n);
+}
+return *this;
+```
+``` cpp
+constexpr iterator& operator-=(difference_type n)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+*this += -n;
+return *this;
+```
+``` cpp
+constexpr decltype(auto) operator[](difference_type n) const
+  requires concat-is-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return *((*this) + n);
+```
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y)
+  requires (equality_comparable<iterator_t<maybe-const<Const, Views>>> && ...);
+```
+*Preconditions:* `x.`*`it_`*`.valueless_by_exception()` and
+`y.`*`it_`*`.valueless_by_exception()` are each `false`.
+*Effects:* Equivalent to:
+``` cpp
+return x.it_ == y.it_;
+```
+``` cpp
+friend constexpr bool operator==(const iterator& it, default_sentinel_t);
+```
+*Preconditions:* `it.`*`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+constexpr auto last_idx = sizeof...(Views) - 1;
+return it.it_.index() == last_idx &&
+       std::get<last_idx>(it.it_) == ranges::end(std::get<last_idx>(it.parent_->views_));
+```
+``` cpp
+friend constexpr bool operator<(const iterator& x, const iterator& y)
+  requires all-random-access<Const, Views...>;
+friend constexpr bool operator>(const iterator& x, const iterator& y)
+  requires all-random-access<Const, Views...>;
+friend constexpr bool operator<=(const iterator& x, const iterator& y)
+  requires all-random-access<Const, Views...>;
+friend constexpr bool operator>=(const iterator& x, const iterator& y)
+  requires all-random-access<Const, Views...>;
+friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+  requires (all-random-access<Const, Views...> &&
+            (three_way_comparable<iterator_t<maybe-const<Const, Views>>> && ...));
+```
+*Preconditions:* `x.`*`it_`*`.valueless_by_exception()` and
+`y.`*`it_`*`.valueless_by_exception()` are each `false`.
+Let op be the operator.
+*Effects:* Equivalent to:
+``` cpp
+return x.it_ op y.it_;
+```
+``` cpp
+friend constexpr iterator operator+(const iterator& it, difference_type n)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto temp = it;
+temp += n;
+return temp;
+```
+``` cpp
+friend constexpr iterator operator+(difference_type n, const iterator& it)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return it + n;
+```
+``` cpp
+friend constexpr iterator operator-(const iterator& it, difference_type n)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto temp = it;
+temp -= n;
+return temp;
+```
+``` cpp
+friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+  requires concat-is-random-access<Const, Views...>;
+```
+*Preconditions:* `x.`*`it_`*`.valueless_by_exception()` and
+`y.`*`it_`*`.valueless_by_exception()` are each `false`.
+*Effects:* Let i_`x` denote `x.`*`it_`*`.index()` and i_`y` denote
+`y.`*`it_`*`.index()`.
+- If i_`x`` > `i_`y`, let d_`y` be
+  `ranges::distance(std::get<`i_`y``>(y.`*`it_`*`), ranges::end(std::get<`i_`y``>(y.`*`parent_`*`->`*`views_`*`)))`,
+  d_`x` be
+  `ranges::distance(ranges::begin(std::get<`i_`x``>(x.`*`parent_`*`->`*`views_`*`)), std::get<`i_`x``>(x.`*`it_`*`))`.
+  Let s denote the sum of the sizes of all the ranges
+  `std::get<`i`>(x.`*`parent_`*`->`*`views_`*`)` for every integer i in
+  the range \[i_`y`` + 1`, i_`x`) if there is any, and `0` otherwise, of
+  type `difference_type`, equivalent to:
+  ``` cpp
+  return $d_y$ + s + $d_x$;
+  ```
+- otherwise, if i_`x`` < `i_`y` is `true`, equivalent to:
+  ``` cpp
+  return -(y - x);
+  ```
+- otherwise, equivalent to:
+  ``` cpp
+  return std::get<$i_x$>(x.it_) - std::get<$i_y$>(y.it_);
+  ```
+``` cpp
+friend constexpr difference_type operator-(const iterator& x, default_sentinel_t)
+  requires see below;
+```
+*Preconditions:* `x.`*`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Let i_`x` denote `x.`*`it_`*`.index()`, d_`x` be
+`ranges::distance(std::get<`i_`x``>(x.`*`it_`*`), ranges::end(std::get<`i_`x``>(x.`*`parent_`*`->`*`views_`*`)))`.
+Let s denote the sum of the sizes of all the ranges
+`std::get<`i`>(x.`*`parent_`*`->`*`views_`*`)` for every integer i in
+the range \[i_`x`` + 1`, `sizeof...(Views)`) if there is any, and `0`
+otherwise, of type difference_type, equivalent to:
+``` cpp
+return -($d_x$ + s);
+```
+*Remarks:* Let `Fs` be the pack that consists of all elements of `Views`
+except the first element, the expression in the *requires-clause* is
+equivalent to:
+``` cpp
+(sized_sentinel_for<sentinel_t<maybe-const<Const, Views>>,
+                    iterator_t<maybe-const<Const, Views>>> && ...) &&
+(sized_range<maybe-const<Const, Fs>> && ...)
+```
+``` cpp
+friend constexpr difference_type operator-(default_sentinel_t, const iterator& x)
+  requires see below;
+```
+*Effects:* Equivalent to:
+``` cpp
+return -(x - default_sentinel);
+```
+*Remarks:* Let `Fs` be the pack that consists of all elements of `Views`
+except the first element, the expression in the *requires-clause* is
+equivalent to:
+``` cpp
+(sized_sentinel_for<sentinel_t<maybe-const<Const, Views>>,
+                    iterator_t<maybe-const<Const, Views>>> && ...) &&
+(sized_range<maybe-const<Const, Fs>> && ...)
+```
+``` cpp
+friend constexpr decltype(auto) iter_move(const iterator& it) noexcept(see below);
+```
+*Preconditions:* `it.`*`it_`*`.valueless_by_exception()` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+return std::visit([](const auto& i)
+                  -> concat-rvalue-reference-t<maybe-const<Const, Views>...> {
+                    return ranges::iter_move(i);
+                  },
+                  it.it_);
+```
+*Remarks:* The exception specification is equivalent to:
+``` cpp
+((is_nothrow_invocable_v<decltype(ranges::iter_move),
+                         const iterator_t<maybe-const<Const, Views>>&> &&
+  is_nothrow_convertible_v<range_rvalue_reference_t<maybe-const<Const, Views>>,
+                           concat-rvalue-reference-t<maybe-const<Const, Views>...>>) &&
+ ...)
+```
+``` cpp
+friend constexpr void iter_swap(const iterator& x, const iterator& y) noexcept(see below)
+  requires see below;
+```
+*Preconditions:* `x.`*`it_`*`.valueless_by_exception()` and
+`y.`*`it_`*`.valueless_by_exception()` are each `false`.
+*Effects:* Equivalent to:
+``` cpp
+std::visit([&](const auto& it1, const auto& it2) {
+             if constexpr (is_same_v<decltype(it1), decltype(it2)>) {
+               ranges::iter_swap(it1, it2);
+             } else {
+               ranges::swap(*x, *y);
+             }
+           },
+           x.it_, y.it_);
+```
+*Remarks:* The exception specification is equivalent to
+``` cpp
+(noexcept(ranges::swap(*x, *y)) && ... && noexcept(ranges::iter_swap(its, its)))
+```
+where `its` is a pack of lvalues of type
+`const iterator_t<`*`maybe-const`*`<Const, Views>>` respectively.
+The expression in the *requires-clause* is equivalent to
+``` cpp
+swappable_with<iter_reference_t<iterator>, iter_reference_t<iterator>> &&
+(... && indirectly_swappable<iterator_t<maybe-const<Const, Views>>>)
+```

Diff to HTML by rtfpessoa