implement views::concat (P2542)

[changkhothuychung]

paper link: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2542r8.html

[github-actions]

⚠️ C/C++ code formatter, clang-format found issues in your code. ⚠️

You can test this locally with the following command:

git-clang-format --diff 497b2ebb9edcfd5315586b796f47589e9820b4b9 bf9d232583ff7e6ad7bbb9e554a826bba5d529cb -- libcxx/include/__ranges/concat_view.h

View the diff from clang-format here.

diff --git a/libcxx/include/__ranges/concat_view.h b/libcxx/include/__ranges/concat_view.h
index 78bf3f4c5..fdc4e98c6 100644
--- a/libcxx/include/__ranges/concat_view.h
+++ b/libcxx/include/__ranges/concat_view.h
@@ -48,52 +48,40 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-//#if _LIBCPP_STD_VER >= 20
+// #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
 
+template <class View, class... Views>
+struct last_view : last_view<Views...> {};
 
-template<class View, class... Views> 
-struct last_view : last_view<Views...>
-{
-
-}; 
-
-template<class View>
-struct last_view<View> 
-{
-    using type = View; 
+template <class View>
+struct last_view<View> {
+  using type = View;
 };
 
 template <class Ref, class RRef, class It>
-concept concat_indirectly_readable_impl =  
-requires (const It it) { 
+concept concat_indirectly_readable_impl = requires(const It it) {
   { *it } -> convertible_to<Ref>;
   { ranges::iter_move(it) } -> convertible_to<RRef>;
 };
 
-
 template <class... Rs>
-using concat_reference_t = common_reference_t<range_reference_t<Rs>...>; 
+using concat_reference_t = common_reference_t<range_reference_t<Rs>...>;
 
 template <class... Rs>
-using concat_value_t = common_type_t<range_value_t<Rs>...>; 
+using concat_value_t = common_type_t<range_value_t<Rs>...>;
 
 template <class... Rs>
-using concat_rvalue_reference_t = common_reference_t<range_rvalue_reference_t<Rs>...>; 
+using concat_rvalue_reference_t = common_reference_t<range_rvalue_reference_t<Rs>...>;
 
 template <class... Rs>
-concept concat_indirectly_readable = 
-  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>> && ...);
-
+concept concat_indirectly_readable =
+    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>> &&
+     ...);
 
 template <class... Rs>
 concept concatable = requires { // exposition only
@@ -103,301 +91,274 @@ concept concatable = requires { // exposition only
 } && concat_indirectly_readable<Rs...>;
 
 template <bool Const, class... Rs>
-concept concat_is_random_access = 
-   all_random_access<Const, Rs...> &&
-   (sized_range<maybe_const<Const, Rs>> && ...);
+concept concat_is_random_access = all_random_access<Const, Rs...> && (sized_range<maybe_const<Const, Rs>> && ...);
 
 template <class R>
-concept constant_time_reversible =          // exposition only
-(bidirectional_range<R> && common_range<R>) ||
-(sized_range<R> && random_access_range<R>);
+concept constant_time_reversible = // exposition only
+    (bidirectional_range<R> && common_range<R>) || (sized_range<R> && random_access_range<R>);
 
 template <bool Const, class... Rs>
-concept concat_is_bidirectional = 
-    (bidirectional_range<maybe_const<Const, V>> 
-    && ... && 
-    constant-time-reversible<maybe_const<Const, Fs>>);
-
+concept concat_is_bidirectional =
+    (bidirectional_range<maybe_const<Const, V>> && ... && constant - time - reversible<maybe_const<Const, Fs>>);
 
 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
+  requires(view<Views> && ...) && (sizeof...(Views) > 0) && concatable<Views...>
+class concat_view : public view_interface<concat_view<Views...>> {
+  tuple<Views...> views_; // exposition only
 
-    template <bool Const>
-    class iterator;                           // exposition only
-    class sentinel; 
-
-    public:
+  template <bool Const>
+  class iterator; // exposition only
+  class sentinel;
 
-    constexpr concat_view() = default;
+public:
+  constexpr concat_view() = default;
 
-    constexpr explicit concat_view(Views... views): tuple(views...) {}
+  constexpr explicit concat_view(Views... views) : tuple(views...) {}
 
-    constexpr iterator<false> begin() requires(!(simple-view<Views> && ...))
-    {
-        iterator<false> it(this, in_place_index<0>, ranges::begin(get<0>(views_)));
-        it.template satisfy<0>();
-        return it;
-    }
+  constexpr iterator<false> begin()
+    requires(!(simple - view<Views> && ...))
+  {
+    iterator<false> it(this, in_place_index<0>, ranges::begin(get<0>(views_)));
+    it.template satisfy<0>();
+    return it;
+  }
 
-    constexpr iterator<true> begin() const
+  constexpr iterator<true> begin() const
     requires((range<const Views> && ...) && concatable<const Views...>)
-    {
-        iterator<true> it(this, in_place_index<0>, ranges::begin(get<0>(views_)));
-        it.template satisfy<0>();
-        return it;
+  {
+    iterator<true> it(this, in_place_index<0>, ranges::begin(get<0>(views_)));
+    it.template satisfy<0>();
+    return it;
+  }
+
+  constexpr auto end()
+    requires(!(simple - view<Views> && ...))
+  {
+    if constexpr (common_range<last_view<Views...>::type>) {
+      // last_view to be implemented
+      constexpr auto N = sizeof...(Views);
+      return iterator<false>(this, in_place_index<N - 1>, ranges::end(get<N - 1>(views_)));
+    } else {
+      return default_sentinel;
     }
-
-    constexpr auto end() requires(!(simple-view<Views> && ...))
-    {
-        if constexpr (common_range<last_view<Views...>::type>) {
-            // last_view to be implemented 
-            constexpr auto N = sizeof...(Views);
-            return iterator<false>(this, in_place_index<N - 1>, 
-                            ranges::end(get<N - 1>(views_)));
-        } else {
-            return default_sentinel;
-        }
-    }
-
-    constexpr auto end() const requires(range<const Views>&&...)
-    {
-        if constexpr (common_range<last_view>) {
-            // last_view to be implemented 
-            constexpr auto N = sizeof...(Views);
-            return iterator<true>(this, in_place_index<N - 1>, 
-                            ranges::end(get<N - 1>(views_)));
-        } else {
-            return default_sentinel;
-        }
+  }
+
+  constexpr auto end() const
+    requires(range<const Views> && ...)
+  {
+    if constexpr (common_range<last_view>) {
+      // last_view to be implemented
+      constexpr auto N = sizeof...(Views);
+      return iterator<true>(this, in_place_index<N - 1>, ranges::end(get<N - 1>(views_)));
+    } else {
+      return default_sentinel;
     }
-
-    constexpr auto size() requires(sized_range<Views>&&...)
-    {
-        return apply([](auto... sizes) {
-            using CT = make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
-            return (CT(sizes) + ...);
+  }
+
+  constexpr auto size()
+    requires(sized_range<Views> && ...)
+  {
+    return apply(
+        [](auto... sizes) {
+          using CT = make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
+          return (CT(sizes) + ...);
         },
         tuple_transform(ranges::size, views_));
-    }
-
-    constexpr auto size() const requires(sized_range<const Views>&&...)
-    {
-        return apply([](auto... sizes) {
-            using CT = make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
-            return (CT(sizes) + ...);
+  }
+
+  constexpr auto size() const
+    requires(sized_range<const Views> && ...)
+  {
+    return apply(
+        [](auto... sizes) {
+          using CT = make_unsigned_like_t<common_type_t<decltype(sizes)...>>;
+          return (CT(sizes) + ...);
         },
         tuple_transform(ranges::size, views_));
-    }
-  
+  }
 };
 
-
-
-// begin class iterator 
-
+// begin class iterator
 
 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 = _If<random_access_range<_View...>,
-                                random_access_iterator_tag,
-                                _If<bidirectional_range<_View...>,
-                                    bidirectional_iterator_tag,
-                                    _If<forward_range<_View...>,
-                                        forward_iterator_tag,
-                                        /* else */ input_iterator_tag 
-                                        >
-                                    >
-                                >;
-    //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
+  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 =
+      _If<random_access_range<_View...>,
+          random_access_iterator_tag,
+          _If<bidirectional_range<_View...>,
+              bidirectional_iterator_tag,
+              _If<forward_range<_View...>,
+                  forward_iterator_tag,
+                  /* else */ input_iterator_tag > > >;
+  // 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 <std::size_t N>
-    constexpr void satisfy()
-    {
-        if constexpr (N < (sizeof...(Views) - 1)) {
-            if (get<N>(it_) == ranges::end(get<N>(parent_->views_))) {
-                it_.template emplace<N + 1>(ranges::begin(get<N + 1>(parent_->views_)));
-                satisfy<N + 1>();
-            }
-        }
-    }
 
-    template <std::size_t N>
-    constexpr void prev()
-    {
-        if constexpr (N == 0) {
-            --get<0>(it_);
-        } else {
-            if (get<N>(it_) == ranges::begin(get<N>(parent_->views_))) {
-                using prev_view = maybe-const<Const, tuple_element_t<N - 1, tuple<Views...>>>;
-                if constexpr (common_range<prev_view>) {
-                    it_.template emplace<N - 1>(ranges::end(get<N - 1>(parent_->views_)));
-                } else {
-                    it_.template emplace<N - 1>(
-                        ranges::next(ranges::begin(get<N - 1>(parent_->views_)),
-                                    ranges::size(get<N - 1>(parent_->views_))));
-                }
-                prev<N - 1>();
-            } else {
-                --get<N>(it_);
-            }
-        }
-    }
+  maybe_const<Const, concat_view>* parent_ = nullptr; // exposition only
+  base_iter it_;                                      // exposition only
 
-    template <std::size_t N>
-    constexpr void advance_fwd(difference_type offset, difference_type steps)
-    {
-        using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base-iter>>;
-        if constexpr (N == sizeof...(Views) - 1) {
-            get<N>(it_) += static_cast<underlying_diff_type>(steps);
-        } 
-        else {
-            auto n_size = ranges::distance(get<N>(parent_->views_));
-            if (offset + steps < n_size) {
-                get<N>(it_) += static_cast<underlying_diff_type>(steps);
-            } else {
-                it_.template emplace<N + 1>(ranges::begin(get<N + 1>(parent_->views_)));
-                advance-fwd<N + 1>(0, offset + steps - n_size);
-            }
-        }
+  template <std::size_t N>
+  constexpr void satisfy() {
+    if constexpr (N < (sizeof...(Views) - 1)) {
+      if (get<N>(it_) == ranges::end(get<N>(parent_->views_))) {
+        it_.template emplace<N + 1>(ranges::begin(get<N + 1>(parent_->views_)));
+        satisfy<N + 1>();
+      }
     }
-
-    template <std::size_t N>
-    constexpr void advance_bwd(difference_type offset, difference_type steps)
-    {
-        using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base-iter>>;
-        if constexpr (N == 0) {
-            get<N>(it_) -= static_cast<underlying_diff_type>(steps);
+  }
+
+  template <std::size_t N>
+  constexpr void prev() {
+    if constexpr (N == 0) {
+      --get<0>(it_);
+    } else {
+      if (get<N>(it_) == ranges::begin(get<N>(parent_->views_))) {
+        using prev_view = maybe - const<Const, tuple_element_t<N - 1, tuple<Views...>>>;
+        if constexpr (common_range<prev_view>) {
+          it_.template emplace<N - 1>(ranges::end(get<N - 1>(parent_->views_)));
         } else {
-            if (offset >= steps) {
-                get<N>(it_) -= static_cast<underlying_diff_type>(steps);
-            } else {
-                auto prev_size = ranges::distance(get<N - 1>(parent_->views_));
-                it_.template emplace<N - 1>(ranges::begin(get<N - 1>(parent_->views_)) + prev_size);
-                advance-bwd<N - 1>(prev_size, steps - offset);
-            }
+          it_.template emplace<N - 1>(
+              ranges::next(ranges::begin(get<N - 1>(parent_->views_)), ranges::size(get<N - 1>(parent_->views_))));
         }
+        prev<N - 1>();
+      } else {
+        --get<N>(it_);
+      }
+    }
+  }
+
+  template <std::size_t N>
+  constexpr void advance_fwd(difference_type offset, difference_type steps) {
+    using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base - iter>>;
+    if constexpr (N == sizeof...(Views) - 1) {
+      get<N>(it_) += static_cast<underlying_diff_type>(steps);
+    } else {
+      auto n_size = ranges::distance(get<N>(parent_->views_));
+      if (offset + steps < n_size) {
+        get<N>(it_) += static_cast<underlying_diff_type>(steps);
+      } else {
+        it_.template emplace<N + 1>(ranges::begin(get<N + 1>(parent_->views_)));
+        advance - fwd<N + 1>(0, offset + steps - n_size);
+      }
+    }
+  }
+
+  template <std::size_t N>
+  constexpr void advance_bwd(difference_type offset, difference_type steps) {
+    using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base - iter>>;
+    if constexpr (N == 0) {
+      get<N>(it_) -= static_cast<underlying_diff_type>(steps);
+    } else {
+      if (offset >= steps) {
+        get<N>(it_) -= static_cast<underlying_diff_type>(steps);
+      } else {
+        auto prev_size = ranges::distance(get<N - 1>(parent_->views_));
+        it_.template emplace<N - 1>(ranges::begin(get<N - 1>(parent_->views_)) + prev_size);
+        advance - bwd<N - 1>(prev_size, steps - offset);
+      }
     }
+  }
 
-    template <class... Args>
-    explicit constexpr iterator(maybe-const<Const, concat_view>* parent, Args&&... args) 
-        requires constructible_from<base-iter, Args&&...> 
-        : it_(std::forward<Args>...), parent_(parent) {}
+  template <class... Args>
+  explicit constexpr iterator(maybe - const<Const, concat_view>* parent, Args&&... args)
+    requires constructible_from<base - iter, Args&&...>
+      : it_(std::forward<Args>...), parent_(parent) {}
 
-  public:
+public:
+  iterator() = default;
 
-    iterator() = default;
+  constexpr iterator(iterator<!Const> i)
+    requires Const && (convertible_to<iterator_t<Views>, iterator_t<const Views>> && ...)
+      : it_(std::move(i.it_)), parent_(i.parent_) {}
 
-    constexpr iterator(iterator<!Const> i) 
-        requires Const && (convertible_to<iterator_t<Views>, iterator_t<const Views>> && ...)
-        : it_(std::move(i.it_)), parent_(i.parent_) {}
+  constexpr decltype(auto) operator*() const {
+    using reference = concat_reference_t<maybe_const<Const, Views>...>;
+    return std::visit([](auto&& it) -> reference { return *it; }, it_);
+  }
 
-    constexpr decltype(auto) operator*() const
-    {
-        using reference = concat_reference_t<maybe_const<Const, Views>...>;
-        return std::visit([](auto&& it) -> reference { return *it; }, it_); 
-    }
+  constexpr iterator& operator++() {
+    constexpr auto i = it_.index();
+    ++get<i>(it_);
+    satisfy<i>();
+    return *this;
+  }
 
-    constexpr iterator& operator++()
-    {
-        constexpr auto i = it_.index(); 
-        ++get<i>(it_);
-        satisfy<i>();
-        return *this;
-    }
+  constexpr void operator++(int) { ++*this; }
 
-    constexpr void operator++(int)
-    {
-        ++*this; 
-    }
+  /*
 
-    /*
+  constexpr iterator operator++(int)
+      requires all-forward<Const, Views...>;
 
-    constexpr iterator operator++(int) 
-        requires all-forward<Const, Views...>;
-    
-    constexpr iterator& operator--() 
-        requires concat-is-bidirectional<Const, Views...>;
+  constexpr iterator& operator--()
+      requires concat-is-bidirectional<Const, Views...>;
 
-    constexpr iterator operator--(int) 
-        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 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...>;
+  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& 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& 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 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<maybe-const<Const, Views>> &&...));
+  friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+      requires (all-random-access<Const, Views...> &&
+       (three_way_comparable<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+(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+(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 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, 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-(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 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 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;
+  friend constexpr void iter_swap(const iterator& x, const iterator& y) noexcept(see below)
+      requires see below;
 
-    */
+  */
 };
 
-
-
-
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER >= 20