[libc++][ranges] P2542R8: Implement `views::concat` #120920

changkhothuychung · 2024-12-22T21:29:36Z

Closes #105419
Closes #105348
Closes #105349

implement views::concat (P2542)

Revert "implement views::concat (P2542) "

llvmbot · 2024-12-22T21:30:09Z

@llvm/pr-subscribers-libcxx

Author: Nhat Nguyen (changkhothuychung)

Changes

Patch is 52.01 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/120920.diff

14 Files Affected:

(added) libcxx/include/__ranges/concat_view.h (+624)
(added) libcxx/test/std/ranges/range.adaptors/range.concat/adaptor.pass.cpp (+71)
(added) libcxx/test/std/ranges/range.adaptors/range.concat/begin.pass.cpp (+38)
(added) libcxx/test/std/ranges/range.adaptors/range.concat/ctad.pass.cpp (+54)
(added) libcxx/test/std/ranges/range.adaptors/range.concat/ctor.default.pass.cpp (+81)
(added) libcxx/test/std/ranges/range.adaptors/range.concat/ctor.view.pass.cpp (+70)
(added) libcxx/test/std/ranges/range.adaptors/range.concat/end.pass.cpp (+99)
(added) libcxx/test/std/ranges/range.adaptors/range.concat/iterator/compare.pass.cpp (+76)
(added) libcxx/test/std/ranges/range.adaptors/range.concat/iterator/decrement.pass.cpp (+89)
(added) libcxx/test/std/ranges/range.adaptors/range.concat/iterator/deref.pass.cpp (+56)
(added) libcxx/test/std/ranges/range.adaptors/range.concat/iterator/increment.pass.cpp (+84)
(added) libcxx/test/std/ranges/range.adaptors/range.concat/iterator/iter_move.pass.cpp (+74)
(added) libcxx/test/std/ranges/range.adaptors/range.concat/iterator/iter_swap.pass.cpp (+79)
(added) libcxx/test/std/ranges/range.adaptors/range.concat/types.h (+44)

diff --git a/libcxx/include/__ranges/concat_view.h b/libcxx/include/__ranges/concat_view.h
new file mode 100644
index 00000000000000..9d17aae65ecaf5
--- /dev/null
+++ b/libcxx/include/__ranges/concat_view.h
@@ -0,0 +1,624 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_CONCAT_VIEW_H
+#define _LIBCPP___RANGES_CONCAT_VIEW_H
+
+#include <__algorithm/ranges_find_if.h>
+#include <__assert>
+#include <__concepts/constructible.h>
+#include <__concepts/copyable.h>
+#include <__concepts/derived_from.h>
+#include <__concepts/equality_comparable.h>
+#include <__config>
+#include <__functional/bind_back.h>
+#include <__functional/invoke.h>
+#include <__functional/reference_wrapper.h>
+#include <__iterator/concepts.h>
+#include <__iterator/default_sentinel.h>
+#include <__iterator/distance.h>
+#include <__iterator/iter_move.h>
+#include <__iterator/iter_swap.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/next.h>
+#include <__memory/addressof.h>
+#include <__ranges/access.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/movable_box.h>
+#include <__ranges/non_propagating_cache.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/view_interface.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_nothrow_convertible.h>
+#include <__type_traits/is_object.h>
+#include <__type_traits/maybe_const.h>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+#include <tuple>
+#include <variant>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+namespace ranges {
+
+template <class T, class... Ts>
+struct extract_last : extract_last<Ts...> {};
+
+template <class T>
+struct extract_last<T> {
+  using type = T;
+};
+
+template <class _T, class... _Ts>
+struct derived_from_pack {
+  constexpr static bool value =
+      derived_from_pack<_T, typename extract_last<_Ts...>::type>::value && derived_from_pack<_Ts...>::value;
+};
+
+template <class _T, class _IterCategory>
+struct derived_from_pack<_T, _IterCategory> {
+  constexpr static bool value = derived_from<_T, _IterCategory>;
+};
+
+template <class View, class... Views>
+struct last_view : last_view<Views...> {};
+
+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) {
+  { *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>...>;
+
+template <class... 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>...>;
+
+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>> &&
+     ...);
+
+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...>;
+
+template <bool Const, class... Rs>
+concept concat_is_random_access =
+    (random_access_range<__maybe_const<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>);
+
+template <bool Const, class... Rs>
+concept concat_is_bidirectional =
+    ((bidirectional_range<__maybe_const<Const, Rs>> && ...) &&
+     (constant_time_reversible<__maybe_const<Const, Rs>> && ...));
+
+template <bool Const, class... Views>
+concept all_forward = // exposition only
+    (forward_range<__maybe_const<Const, Views>> && ...);
+
+template <bool Const, class... Ts>
+struct apply_drop_first;
+
+template <bool Const, class Head, class... Tail>
+struct apply_drop_first<Const, Head, Tail...> {
+  static constexpr bool value = (sized_range<__maybe_const<Const, Tail>> && ...);
+};
+
+template <input_range... Views>
+  requires(view<Views> && ...) && (sizeof...(Views) > 0) && concatable<Views...>
+class concat_view : public view_interface<concat_view<Views...>> {
+  tuple<Views...> views_;
+
+  template <bool Const>
+  class iterator;
+  class sentinel;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr concat_view() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit concat_view(Views... views) : views_(std::move(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<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;
+  }
+
+  constexpr auto end()
+    requires(!(__simple_view<Views> && ...))
+  {
+    if constexpr (common_range<typename 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<typename last_view<Views...>::type>) {
+      // 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_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_t<common_type_t<decltype(sizes)...>>;
+          return (CT(sizes) + ...);
+        },
+        tuple_transform(ranges::size, views_));
+  }
+};
+
+template <class... _Views>
+concat_view(_Views&&...) -> concat_view<views::all_t<_Views>...>;
+
+template <input_range... Views>
+  requires(view<Views> && ...) && (sizeof...(Views) > 0) && concatable<Views...>
+template <bool Const>
+class concat_view<Views...>::iterator {
+public:
+  constexpr static bool derive_pack_random_iterator =
+      derived_from_pack<typename iterator_traits<iterator_t<__maybe_const<Const, Views>>>::iterator_category...,
+                        random_access_iterator_tag>::value;
+  constexpr static bool derive_pack_bidirectional_iterator =
+      derived_from_pack<typename iterator_traits<iterator_t<__maybe_const<Const, Views>>>::iterator_category...,
+                        bidirectional_iterator_tag>::value;
+  constexpr static bool derive_pack_forward_iterator =
+      derived_from_pack<typename iterator_traits< iterator_t<__maybe_const<Const, Views>>>::iterator_category...,
+                        forward_iterator_tag>::value;
+  using iterator_category =
+      _If<!is_reference_v<concat_reference_t<__maybe_const<Const, Views>...>>,
+          input_iterator_tag,
+          _If<derive_pack_random_iterator,
+              random_access_iterator_tag,
+              _If<derive_pack_bidirectional_iterator,
+                  bidirectional_iterator_tag,
+                  _If<derive_pack_forward_iterator, forward_iterator_tag, input_iterator_tag > > > >;
+  using iterator_concept =
+      _If<concat_is_random_access<Const, Views...>,
+          random_access_iterator_tag,
+          _If<concat_is_bidirectional<Const, Views...>,
+              bidirectional_iterator_tag,
+              _If< all_forward<Const, Views...>, forward_iterator_tag, 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>>...>;
+  using base_iter       = variant<iterator_t<__maybe_const<Const, Views>>...>;
+
+  base_iter it_;                                        // exposition only
+  __maybe_const<Const, concat_view>* parent_ = nullptr; // 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_.emplace<N - 1>(ranges::end(get<N - 1>(parent_->views_)));
+        } else {
+          it_.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 {
+      difference_type n_size = ranges::size(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_.emplace<N - 1>(ranges::begin(get<N - 1>(parent_->views_)) + prev_size);
+        advance_bwd<N - 1>(prev_size, steps - offset);
+      }
+    }
+  }
+
+  template <size_t... Is, typename Func>
+  constexpr void apply_fn_with_const_index(size_t index, Func&& func, std::index_sequence<Is...>) {
+    ((index == Is ? (func(std::integral_constant<size_t, Is>{}), 0) : 0), ...);
+  }
+
+  template <size_t N, typename Func>
+  constexpr void apply_fn_with_const_index(size_t index, Func&& func) {
+    apply_fn_with_const_index(index, std::forward<Func>(func), std::make_index_sequence<N>{});
+  }
+
+  template <class... Args>
+  explicit constexpr iterator(__maybe_const<Const, concat_view>* parent, Args&&... args)
+    requires constructible_from<base_iter, Args&&...>
+      : it_(std::forward<Args>(args)...), parent_(parent) {}
+
+public:
+  iterator() = default;
+
+  constexpr iterator(iterator<!Const> i)
+    requires Const && (convertible_to<iterator_t<Views>, iterator_t<const Views>> && ...)
+      : it_(base_iter(in_place_index<i.index()>, std::get<i.index()>(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 iterator& operator++() {
+    size_t active_index = it_.index();
+    apply_fn_with_const_index<std::variant_size_v<decltype(it_)>>(active_index, [&](auto index_constant) {
+      constexpr size_t i = index_constant.value;
+      ++get<i>(it_);
+      satisfy<i>();
+    });
+    return *this;
+  }
+
+  constexpr void operator++(int) { ++*this; }
+
+  constexpr iterator operator++(int)
+    requires(forward_range<__maybe_const<Const, Views>> && ...)
+  {
+    auto tmp = *this;
+    ++*this;
+    return tmp;
+  }
+
+  constexpr iterator& operator--()
+    requires concat_is_bidirectional<Const, Views...>
+  {
+    size_t active_index = it_.index();
+    apply_fn_with_const_index<std::variant_size_v<decltype(it_)>>(active_index, [&](auto index_constant) {
+      constexpr size_t i = index_constant.value;
+      prev<i>();
+    });
+    return *this;
+  }
+
+  constexpr iterator operator--(int)
+    requires concat_is_bidirectional<Const, Views...>
+  {
+    auto __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
+  friend constexpr bool operator==(const iterator& x, const iterator& y)
+    requires(equality_comparable<iterator_t<__maybe_const<Const, Views>>> && ...)
+  {
+    return x.it_ == y.it_;
+  }
+
+  constexpr decltype(auto) operator[](difference_type n) const
+    requires concat_is_random_access<Const, Views...>
+  {
+    return *((*this) + n);
+  }
+
+  friend constexpr iterator operator+(const iterator& it, difference_type n)
+    requires concat_is_random_access<Const, Views...>
+  {
+    auto temp = it;
+    temp += n;
+    return temp;
+  }
+
+  friend constexpr iterator operator+(difference_type n, const iterator& it)
+    requires concat_is_random_access<Const, Views...>
+  {
+    return it + n;
+  }
+
+  constexpr iterator& operator+=(difference_type n)
+    requires concat_is_random_access<Const, Views...>
+  {
+    size_t active_index = it_.index();
+    if (n > 0) {
+      std::visit(
+          [&](auto& active_it) {
+            apply_fn_with_const_index<std::tuple_size_v<decltype(parent_->views_)>>(
+                active_index, [&](auto index_constant) {
+                  constexpr size_t I  = index_constant.value;
+                  auto& active_view   = std::get<I>(parent_->views_);
+                  difference_type idx = active_it - ranges::begin(active_view);
+                  advance_fwd<I>(idx, n);
+                });
+          },
+          it_);
+    }
+
+    else if (n < 0) {
+      std::visit(
+          [&](auto& active_it) {
+            apply_fn_with_const_index<std::tuple_size_v<decltype(parent_->views_)>>(
+                active_index, [&](auto index_constant) {
+                  constexpr size_t I  = index_constant.value;
+                  auto& active_view   = std::get<I>(parent_->views_);
+                  difference_type idx = active_it - ranges::begin(active_view);
+                  advance_bwd<I>(idx, -n);
+                });
+          },
+          it_);
+    }
+
+    return *this;
+  }
+
+  constexpr iterator& operator-=(difference_type n)
+    requires concat_is_random_access<Const, Views...>
+  {
+    *this += -n;
+    return *this;
+  }
+
+  friend constexpr bool operator==(const iterator& it, default_sentinel_t) {
+    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_));
+  }
+
+  friend constexpr bool operator<(const iterator& x, const iterator& y)
+    requires(random_access_range<__maybe_const<Const, Views>> && ...)
+  {
+    return x.it_ < y.it_;
+  }
+
+  friend constexpr bool operator>(const iterator& x, const iterator& y)
+    requires(random_access_range<__maybe_const<Const, Views>> && ...)
+  {
+    return x.it_ > y.it_;
+  }
+
+  friend constexpr bool operator<=(const iterator& x, const iterator& y)
+    requires(random_access_range<__maybe_const<Const, Views>> && ...)
+  {
+    return x.it_ <= y.it_;
+  }
+
+  friend constexpr bool operator>=(const iterator& x, const iterator& y)
+    requires(random_access_range<__maybe_const<Const, Views>> && ...)
+  {
+    return x.it_ >= y.it_;
+  }
+
+  friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+    requires((random_access_range<__maybe_const<Const, Views>> && ...) &&
+             (three_way_comparable<__maybe_const<Const, Views>> && ...))
+  {
+    return x.it_ <=> y.it_;
+  }
+
+  friend constexpr decltype(auto) iter_move(const iterator& it) noexcept(
+
+      ((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>...> >) &&
+       ...))
+
+  {
+    return std::visit(
+        [](const auto& i) -> concat_rvalue_reference_t<__maybe_const<Const, Views>...> { return ranges::iter_move(i); },
+        it.it_);
+  }
+
+  friend constexpr void iter_swap(const iterator& x, const iterator& y)
+
+      noexcept((noexcept(ranges::swap(*x, *y))) &&
+               (noexcept(ranges::iter_swap(std::declval<const iterator_t<__maybe_const<Const, Views>>>(),
+                                           std::declval<const iterator_t<__maybe_const<Const, Views>>>())) &&
+                ...))
+
+    requires swappable_with<iter_reference_t<iterator>, iter_reference_t<iterator>> &&
+             (... && indirectly_swappable<iterator_t<__maybe_const<Const, Views>>>)
+  {
+    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_);
+  }
+
+  friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+    requires concat_is_random_access<Const, Views...>
+  {
+    size_t ix = x.it_.index();
+    size_t iy = y.it_.index();
+
+    if (ix > iy) {
+      std::visit(
+          [&](auto& it_x, auto& it_y) {
+            it_x.apply_fn_with_const_index<std::tuple_size_v<decltype(x.parent_->views_)>>(
+                ix, [&](auto index_constant) {
+                  constexpr size_t index_x = index_constant.value;
+                  auto dx = ranges::__distance(ranges::begin(std::get<index_x>(x.parent_->views_)), it_x);
+
+                  it_y.apply_fn_with_const_index<std::tuple_size_v<decltype(y.parent_->views_)>>(
+                      iy, [&](auto index_constant) {
+                        constexpr size_t index_y = index_constant.value;
+                        auto dy = ranges::__distance(ranges::begin(std::get<index_y>(y.parent_->views_)), it_y);
+                        difference_type s = 0;
+                        for (size_t idx = index_y + 1; idx < index_x; idx++) {
+                          s += ranges::size(std::get<idx>(x.parent_->views_));
+                        }
+                        return dy + s + dx;
+                      });
+                });
+          },
+          x.it_,
+          y.it_);
+    } else if (ix < iy) {
+      return -(y - x);
+    } else {
+      std::visit([&](const auto& it1, const auto& it2) { return it1 - it2; }, x.it_, y.it_);
+    }
+  }
+
+  friend constexpr iterator operator-(const iterator& it, difference_type n)
+    requires concat_is_random_access<Const, Views...>
+  {
+    auto temp = it;
+    temp -= n;
+    re...
[truncated]

github-actions · 2024-12-22T21:33:10Z

✅ With the latest revision this PR passed the C/C++ code formatter.

changkhothuychung · 2024-12-23T23:04:22Z

I have no idea why I am getting error: no type named 'concat_view' in namespace 'std::ranges' in the buildkite. My test runs successfully locally. Does anyone know what is wrong?

…lvm-project into views-concat

libcxx/include/__ranges/concat_view.h

libcxx/include/__cxx03/__ranges/concat_view.h

libcxx/test/std/ranges/range.adaptors/range.concat/ctad.pass.cpp

philnik777

Please make sure you're following the libc++ Coding Guidelines.

libcxx/include/CMakeLists.txt

…lvm-project into views-concat

libcxx/include/module.modulemap.in

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/iter_swap.pass.cpp

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/random_access.pass.cpp

…er_swap.pass.cpp Co-authored-by: A. Jiang <[email protected]>

…ndom_access.pass.cpp Co-authored-by: A. Jiang <[email protected]>

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/ctor.other.pass.cpp

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/ctor.pass.cpp

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/random_access.pass.cpp

…ndom_access.pass.cpp Co-authored-by: A. Jiang <[email protected]>

…or.other.pass.cpp Co-authored-by: A. Jiang <[email protected]>

…or.pass.cpp Co-authored-by: A. Jiang <[email protected]>

libcxx/test/std/ranges/range.adaptors/range.concat/ctor.default.pass.cpp

…t.pass.cpp Co-authored-by: A. Jiang <[email protected]>

frederick-vs-ja

Looks like that all comments are addressed. CI failures are unrelated. @huixie90

libcxx/docs/ReleaseNotes/22.rst

Co-authored-by: Hristo Hristov <[email protected]>

Zingam · 2025-09-07T09:19:31Z

libcxx/test/std/ranges/range.adaptors/range.concat/begin.pass.cpp

+// REQUIRES: std-at-least-c++26
+
+#include <ranges>


Suggested change

// REQUIRES: std-at-least-c++26

#include <ranges>

// REQUIRES: std-at-least-c++26

// class concat_view;

// constexpr iterator<true> begin() const

// requires((range<const Views> && ...) && concatable<const Views...>);

#include <ranges>

Usually in the tests the relevant bits of the synopsis are put on top like shown above. Would you care to add those to your tests?

Other examples from the <ranges> library:

llvm-project/libcxx/test/std/ranges/range.adaptors/range.zip/begin.pass.cpp

Line 11 in d418421

// constexpr auto begin() requires (!(simple-view<Views> && ...));

llvm-project/libcxx/test/std/ranges/range.adaptors/range.join.with/range.join.with.view/base.pass.cpp

Line 13 in d418421

// constexpr View base() const& requires copy_constructible<View>;

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/minus.pass.cpp

Zingam · 2025-09-07T09:27:22Z

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/deref.pass.cpp

+    decltype(auto) it1 = view.begin();
+    decltype(auto) it2 = view.begin() + 3;
+
+    ASSERT_SAME_TYPE(const int&, decltype(*it1));


Suggested change

decltype(auto) it1 = view.begin();

decltype(auto) it2 = view.begin() + 3;

ASSERT_SAME_TYPE(const int&, decltype(*it1));

std::same_as<(const int&> decltype(auto) it1 = view.begin();

decltype(auto) it2 = view.begin() + 3;

FYI only - should have the same effect with one line less.

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/decrement.pass.cpp

huixie90 · 2025-09-07T14:07:57Z

Looks like that all comments are addressed. CI failures are unrelated. @huixie90
reviewing

huixie90

thanks for the update and sorry for the delay of review!

huixie90 · 2025-09-07T12:09:24Z

libcxx/include/__ranges/concat_view.h

+struct __extract_last_impl : __extract_last_impl<_Tail...> {};
+template <class _Tp>
+struct __extract_last_impl<_Tp> {
+  using type _LIBCPP_NODEBUG = _Tp;


we should uglyfy the name __type

__uglification isn't necessary and doesn't seem better to me. IMO __extract_last_impl is effectively an internal type trait, so (pretty) nested type name type is perhaps suitable and consistent.

huixie90 · 2025-09-07T12:33:26Z

libcxx/include/__ranges/concat_view.h

+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires(range<const _Views> && ...)
+  {
+    if constexpr (common_range<__maybe_const<true, __extract_last<_Views...>>>) {


There is an obvious bug in the standard spec on this. see
https://cplusplus.github.io/LWG/issue4166

libstdc++ has shipped a fix as if the lwg issue is resolved. I'd prefer to doing the same in libc++ by implementing the latest proposed fix

In any case, we need test cases where only the last range is common, and we exercise the iteration logic

So with the new fix we are gonna add _all_forward conditions to both the overloading's right?

Yes. We should subsequently add test coverage for this.

libcxx/test/std/ranges/range.adaptors/range.concat/ctor.default.pass.cpp

libcxx/test/std/ranges/range.adaptors/range.concat/ctor.view.pass.cpp

huixie90 · 2025-09-07T12:46:29Z

libcxx/test/std/ranges/range.adaptors/range.concat/begin.pass.cpp

+    std::ranges::concat_view v(SimpleCommon{buffer}, SimpleCommon{buffer});
+    static_assert(std::is_same_v<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+    assert(v.begin() == std::as_const(v).begin());
+


i think the runtime test is a bit insufficient. could we test that the element that begin points to is expected?

huixie90 · 2025-09-07T14:13:01Z

libcxx/include/__ranges/concat_view.h

+    return __temp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, default_sentinel_t)


do we have tests for this?

huixie90 · 2025-09-07T14:14:29Z

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/iter_move.pass.cpp

+  ThrowingMove() = default;
+  ThrowingMove(ThrowingMove&&) {}
+};
+


we should have more thourough tests on

concat-rvalue-reference-t

i.e. underlying elelemnt's rvlaue_reference_t are different

std::string&&. vs std::string etc

huixie90 · 2025-09-07T14:14:52Z

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/iter_move.pass.cpp

+constexpr bool test() {
+  using Sentinel = sentinel_wrapper<Iterator>;
+  using View     = minimal_view<Iterator, Sentinel>;
+


the noexcep spec needs to be tested more carefully

huixie90 · 2025-09-07T14:15:10Z

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/iter_swap.pass.cpp

+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+


the noexcept spec needs to be tested carefully

huixie90 · 2025-09-07T14:15:33Z

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/iter_swap.pass.cpp

+    assert(*it1 == 1);
+    assert(*it2 == 0);
+  }
+


we need to test both branches

if constexpr (is_same_v<decltype(it1), decltype(it2)>) { ranges::iter_swap(it1, it2); } else { ranges::swap(*x, *y);

…lvm-project into views-concat

changkhothuychung added 5 commits December 22, 2024 15:53

initial commit

cda974f

Merge pull request #2 from changkhothuychung/concat

daf965a

implement views::concat (P2542)

Revert "implement views::concat (P2542) "

5cfcf49

Merge pull request #3 from changkhothuychung/revert-2-concat

59c609c

Revert "implement views::concat (P2542) "

initial commit

11ec4bc

changkhothuychung requested a review from a team as a code owner December 22, 2024 21:29

llvmbot added the libc++ libc++ C++ Standard Library. Not GNU libstdc++. Not libc++abi. label Dec 22, 2024

changkhothuychung marked this pull request as draft December 22, 2024 21:29

changkhothuychung added 6 commits December 22, 2024 19:54

fix

c155a3b

clang format

7d9b059

cxx03

020c09f

modulemap

c41a46b

fix

c9b9f0c

Merge branch 'main' into views-concat

c73cc63

changkhothuychung marked this pull request as ready for review December 23, 2024 05:45

changkhothuychung changed the title ~~[libcxx] implement views::concat~~ [libc++] implement views::concat Dec 23, 2024

changkhothuychung added 3 commits December 24, 2024 02:29

fix some includes

ad8a1ff

Merge branch 'views-concat' of https://github.com/changkhothuychung/l…

03e0424

…lvm-project into views-concat

clang format

a1e2823

frederick-vs-ja reviewed Dec 24, 2024

View reviewed changes

libcxx/include/__ranges/concat_view.h Outdated Show resolved Hide resolved

libcxx/include/__cxx03/__ranges/concat_view.h Outdated Show resolved Hide resolved

hawkinsw reviewed Dec 24, 2024

View reviewed changes

libcxx/test/std/ranges/range.adaptors/range.concat/ctad.pass.cpp Outdated Show resolved Hide resolved

philnik777 requested changes Dec 24, 2024

View reviewed changes

libcxx/include/CMakeLists.txt Outdated Show resolved Hide resolved

changkhothuychung added 5 commits December 27, 2024 11:52

remove cxx03 version

3167c0d

fix ugly names

bfca49c

clang-format

df76233

some fix

60a09f6

clang format

dc2dbbf

Merge branch 'views-concat' of https://github.com/changkhothuychung/l…

61bb8ab

…lvm-project into views-concat

frederick-vs-ja reviewed Aug 19, 2025

View reviewed changes

libcxx/include/module.modulemap.in Show resolved Hide resolved

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/iter_swap.pass.cpp Outdated Show resolved Hide resolved

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/random_access.pass.cpp Outdated Show resolved Hide resolved

changkhothuychung and others added 5 commits August 19, 2025 10:50

module map

8f1217a

Update libcxx/test/std/ranges/range.adaptors/range.concat/iterator/it…

caa7db5

…er_swap.pass.cpp Co-authored-by: A. Jiang <[email protected]>

Update libcxx/test/std/ranges/range.adaptors/range.concat/iterator/ra…

2b4b0b6

…ndom_access.pass.cpp Co-authored-by: A. Jiang <[email protected]>

clang format

1edac7a

versoning

d89ae46

frederick-vs-ja reviewed Aug 19, 2025

View reviewed changes

changkhothuychung and others added 3 commits August 20, 2025 00:19

Update libcxx/test/std/ranges/range.adaptors/range.concat/iterator/ra…

c94e292

…ndom_access.pass.cpp Co-authored-by: A. Jiang <[email protected]>

Update libcxx/test/std/ranges/range.adaptors/range.concat/iterator/ct…

d4b806f

…or.other.pass.cpp Co-authored-by: A. Jiang <[email protected]>

Update libcxx/test/std/ranges/range.adaptors/range.concat/iterator/ct…

165f318

…or.pass.cpp Co-authored-by: A. Jiang <[email protected]>

frederick-vs-ja reviewed Aug 20, 2025

View reviewed changes

libcxx/test/std/ranges/range.adaptors/range.concat/ctor.default.pass.cpp Outdated Show resolved Hide resolved

Update libcxx/test/std/ranges/range.adaptors/range.concat/ctor.defaul…

448323b

…t.pass.cpp Co-authored-by: A. Jiang <[email protected]>

frederick-vs-ja approved these changes Aug 21, 2025

View reviewed changes

Merge branch 'main' into views-concat

706370c

Zingam reviewed Sep 4, 2025

View reviewed changes

libcxx/docs/ReleaseNotes/22.rst Outdated Show resolved Hide resolved

changkhothuychung and others added 2 commits September 6, 2025 15:39

Update libcxx/docs/ReleaseNotes/22.rst

12c83a2

Co-authored-by: Hristo Hristov <[email protected]>

Merge branch 'main' into views-concat

795da40

Zingam reviewed Sep 7, 2025

View reviewed changes

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/minus.pass.cpp Outdated Show resolved Hide resolved

Zingam reviewed Sep 7, 2025

View reviewed changes

libcxx/test/std/ranges/range.adaptors/range.concat/iterator/decrement.pass.cpp Outdated Show resolved Hide resolved

huixie90 requested changes Sep 7, 2025

View reviewed changes

changkhothuychung added 6 commits September 10, 2025 14:14

update tests

66d26a6

Merge branch 'main' into views-concat

f4013da

fix bug in end() functions

f420df1

naming concepts

d7ef4eb

add test with different types

e823c03

Merge branch 'views-concat' of https://github.com/changkhothuychung/l…

ea49c38

…lvm-project into views-concat

[libc++][ranges] P2542R8: Implement views::concat #120920

Are you sure you want to change the base?

[libc++][ranges] P2542R8: Implement views::concat #120920

Uh oh!

Conversation

changkhothuychung commented Dec 22, 2024 • edited by frederick-vs-ja Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

llvmbot commented Dec 22, 2024

Uh oh!

github-actions bot commented Dec 22, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

changkhothuychung commented Dec 23, 2024

Uh oh!

Uh oh!

Uh oh!

Uh oh!

philnik777 left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

frederick-vs-ja left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Zingam Sep 7, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

huixie90 commented Sep 7, 2025

Uh oh!

huixie90 left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

huixie90 Sep 7, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

[libc++][ranges] P2542R8: Implement `views::concat` #120920

[libc++][ranges] P2542R8: Implement `views::concat` #120920

changkhothuychung commented Dec 22, 2024 •

edited by frederick-vs-ja

Loading

github-actions bot commented Dec 22, 2024 •

edited

Loading

Zingam Sep 7, 2025 •

edited

Loading

huixie90 Sep 7, 2025 •

edited

Loading