as_const_view, views::as_const

includes testing

Author: strega-nil

libcxx/include/CMakeLists.txt

@@ -636,6 +636,7 @@ set(files
   __random/weibull_distribution.h
   __ranges/access.h
   __ranges/all.h
+  __ranges/as_const_view.h
   __ranges/as_rvalue_view.h
   __ranges/chunk_by_view.h
   __ranges/common_view.h

libcxx/include/__ranges/as_const_view.h

@@ -0,0 +1,213 @@
+// -*- 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_AS_CONST_VIEW_H
+#define _LIBCPP___RANGES_AS_CONST_VIEW_H
+
+#include <__concepts/constructible.h>
+#include <__iterator/concepts.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/const_access.h>
+#include <__ranges/empty_view.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/size.h>
+#include <__ranges/view_interface.h>
+#include <__type_traits/is_specialization.h>
+#include <__utility/auto_cast.h>
+#include <__utility/move.h>
+#include <cstddef>
+#include <span>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+namespace ranges {
+template <input_range _View>
+  requires view<_View>
+class as_const_view : public view_interface<as_const_view<_View>> {
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
+
+public:
+  _LIBCPP_HIDE_FROM_ABI as_const_view()
+    requires default_initializable<_View>
+  = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit as_const_view(_View __base) : __base_(std::move(__base)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
+    requires(!__simple_view<_View>)
+  {
+    return ranges::cbegin(__base_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires range<const _View>
+  {
+    return ranges::cbegin(__base_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires(!__simple_view<_View>)
+  {
+    return ranges::cend(__base_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires range<const _View>
+  {
+    return ranges::cend(__base_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_View>
+  {
+    return ranges::size(__base_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _View>
+  {
+    return ranges::size(__base_);
+  }
+};
+
+template <class _Range>
+as_const_view(_Range&&) -> as_const_view<views::all_t<_Range>>;
+
+template <class _Tp>
+inline constexpr bool enable_borrowed_range<as_const_view<_Tp>> = enable_borrowed_range<_Tp>;
+
+namespace views {
+namespace __as_const {
+
+template <class _Tp>
+concept __has_type = requires { typename _Tp::type; };
+
+template <class _Tp>
+struct __empty_view_case {};
+template <class _Tp>
+struct __empty_view_case<empty_view<_Tp>> {
+  using type = const _Tp;
+};
+
+template <class _Tp>
+struct __span_case {};
+template <class _Tp, size_t _Extent>
+struct __span_case<span<_Tp, _Extent>> {
+  using type = span<const _Tp, _Extent>;
+};
+
+template <class _Tp>
+struct __ref_view_case {};
+template <class _Tp>
+  requires constant_range<const _Tp>
+struct __ref_view_case<ref_view<_Tp>> {
+  using type = const _Tp&;
+};
+
+template <class _Tp>
+struct __constant_range_case {};
+template <class _Tp>
+  requires constant_range<const _Tp> && (!view<_Tp>)
+struct __constant_range_case<_Tp> {
+  using type = const _Tp&;
+};
+
+struct __fn : __range_adaptor_closure<__fn> {
+  // [range.as.const.overview]: the basic `constant_range` case
+  template <class _Range>
+    requires constant_range<all_t<_Range>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto
+  operator()(_Range&& __range) noexcept(noexcept(views::all(std::forward<_Range>(__range))))
+      -> decltype(/*--------------------------*/ views::all(std::forward<_Range>(__range))) {
+    return /*---------------------------------*/ views::all(std::forward<_Range>(__range));
+  }
+
+  // [range.as.const.overview]: the `empty_view` case
+  template <class _Range, class _UType = std::remove_cvref_t<_Range>>
+    requires(!constant_range<all_t<_Range>>) && __has_type<__empty_view_case<_UType>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto
+  operator()(_Range&&) noexcept(noexcept(auto(views::empty<typename __empty_view_case<_UType>::type>)))
+      -> decltype(/*------------------*/ auto(views::empty<typename __empty_view_case<_UType>::type>)) {
+    return /*-------------------------*/ auto(views::empty<typename __empty_view_case<_UType>::type>);
+  }
+
+  // [range.as.const.overview]: the `span` case
+  template <class _Range, class _UType = std::remove_cvref_t<_Range>>
+    requires(!constant_range<all_t<_Range>>) && __has_type<__span_case<_UType>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto
+  operator()(_Range&& __range) noexcept(noexcept(typename __span_case<_UType>::type(std::forward<_UType>(__range))))
+      -> decltype(/*--------------------------*/ typename __span_case<_UType>::type(std::forward<_UType>(__range))) {
+    return /*---------------------------------*/ typename __span_case<_UType>::type(std::forward<_UType>(__range));
+  }
+
+  // [range.as.const.overview]: the `ref_view` case
+  template <class _Range, class _UType = std::remove_cvref_t<_Range>>
+    requires(!constant_range<all_t<_Range>>) && __has_type<__ref_view_case<_UType>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Range&& __range) noexcept(
+      noexcept(ref_view(static_cast<typename __ref_view_case<_UType>::type>(__range.base()))))
+      -> decltype(/*--------------------------*/ ref_view(
+          static_cast<typename __ref_view_case<_UType>::type>(__range.base()))) {
+    return /*---------------------------------*/ ref_view(
+        static_cast<typename __ref_view_case<_UType>::type>(__range.base()));
+  }
+
+  // [range.as.const.overview]: the second `constant_range` case
+  template <class _Range, class _UType = std::remove_cvref_t<_Range>>
+    requires(!constant_range<all_t<_Range>>) && is_lvalue_reference_v<_Range> &&
+                __has_type<__constant_range_case<_UType>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Range&& __range) noexcept(
+      noexcept(ref_view(static_cast<typename __constant_range_case<_UType>::type>(__range))))
+      -> decltype(/*--------------------------*/ ref_view(
+          static_cast<typename __constant_range_case<_UType>::type>(__range))) {
+    return /*---------------------------------*/ ref_view(
+        static_cast<typename __constant_range_case<_UType>::type>(__range));
+  }
+
+  // [range.as.const.overview]: otherwise
+  template <class _Range>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto
+  operator()(_Range&& __range) noexcept(noexcept(as_const_view(std::forward<_Range>(__range))))
+      -> decltype(/*--------------------------*/ as_const_view(std::forward<_Range>(__range))) {
+    return /*---------------------------------*/ as_const_view(std::forward<_Range>(__range));
+  }
+};
+
+} // namespace __as_const
+
+inline namespace __cpo {
+inline constexpr auto as_const = __as_const::__fn{};
+} // namespace __cpo
+} // namespace views
+
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_AS_CONST_VIEW_H

libcxx/include/module.modulemap

@@ -1700,6 +1700,7 @@ module std_private_ranges_all                        [system] {
   export std_private_functional_perfect_forward
   export std_private_ranges_owning_view
 }
+module std_private_ranges_as_const_view              [system] { header "__ranges/as_const_view.h" }
 module std_private_ranges_as_rvalue_view             [system] { header "__ranges/as_rvalue_view.h" }
 module std_private_ranges_chunk_by_view              [system] { header "__ranges/chunk_by_view.h" }
 module std_private_ranges_common_view                [system] { header "__ranges/common_view.h" }

libcxx/include/ranges

@@ -430,6 +430,7 @@ namespace std {
 #endif
 
 #if _LIBCPP_STD_VER >= 23
+#  include <__ranges/as_const_view.h>
 #  include <__ranges/as_rvalue_view.h>
 #  include <__ranges/chunk_by_view.h>
 #  include <__ranges/from_range.h>

libcxx/test/std/ranges/range.adaptors/range.as.const/adaptor.pass.cpp

@@ -0,0 +1,155 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// std::views::as_const
+
+#include <cassert>
+#include <functional>
+#include <ranges>
+#include <vector>
+
+#include "test_iterators.h"
+
+template <class View, class T>
+concept HasPipe = requires {
+  { std::declval<View>() | std::declval<T>() };
+};
+
+struct DefaultConstructibleView : std::ranges::view_base {
+  int i_;
+  int* begin();
+  int* end();
+};
+struct NoView {};
+
+static_assert(std::is_invocable_v<decltype(std::views::as_const), DefaultConstructibleView>);
+static_assert(!std::is_invocable_v<decltype(std::views::as_const)>);
+static_assert(!std::is_invocable_v<decltype(std::views::as_const), NoView>);
+static_assert(HasPipe<DefaultConstructibleView&, decltype(std::views::as_const)>);
+static_assert(HasPipe<int (&)[10], decltype(std::views::as_const)>);
+static_assert(!HasPipe<int (&&)[10], decltype(std::views::as_const)>);
+static_assert(!HasPipe<NoView, decltype(std::views::as_const)>);
+static_assert(std::is_same_v<decltype(std::views::as_const), decltype(std::ranges::views::as_const)>);
+
+struct const_iterator_range {
+  constexpr std::const_iterator<int*> begin() const { return {}; }
+  constexpr std::const_iterator<int*> end() const { return {}; }
+};
+static_assert(!std::ranges::view<const_iterator_range>);
+static_assert(std::ranges::range<const_iterator_range>);
+
+constexpr bool test() {
+  // Let E be an expression, let T be decltype((E)), and let U be remove_cvref_t<T>.
+  // The expression views::as_const(E) is expression-equivalent to:
+
+  // - If views::all_t<T> models constant_range, then views::all(E).
+  {
+    [[maybe_unused]] std::same_as<std::views::all_t<const_iterator_range>> decltype(auto) view =
+        const_iterator_range{} | std::views::as_const;
+  }
+  {
+    // ambiguous with empty_view case
+    [[maybe_unused]] std::same_as<std::views::all_t<std::ranges::empty_view<const int>>> decltype(auto) view =
+        std::views::empty<const int> | std::views::as_const;
+  }
+  {
+    // ambiguous with span case
+    int a[3] = {};
+    [[maybe_unused]] std::same_as<std::views::all_t<std::span<const int>>> decltype(auto) view1 =
+        std::span<const int>(a) | std::views::as_const;
+    [[maybe_unused]] std::same_as<std::views::all_t<std::span<const int, 3>>> decltype(auto) view2 =
+        std::span<const int, 3>(a) | std::views::as_const;
+  }
+  {
+    // ambiguous with ref_view case
+    std::array<int, 3> a                              = {};
+    std::ranges::ref_view<const std::array<int, 3>> r = a;
+    [[maybe_unused]] std::same_as<std::ranges::ref_view<const std::array<int, 3>>> decltype(auto) view =
+        r | std::views::as_const;
+  }
+  {
+    // ambiguous with constant_range case
+    std::array<const int, 3> a = {};
+    [[maybe_unused]] std::same_as<std::ranges::ref_view<std::array<const int, 3>>> decltype(auto) view =
+        a | std::views::as_const;
+  }
+
+  // - Otherwise, if U denotes empty_view<X> for some type X, then auto(views::empty<const X>).
+  {
+    [[maybe_unused]] std::same_as<std::ranges::empty_view<const int>> decltype(auto) view =
+        std::views::empty<int> | std::views::as_const;
+  }
+
+  // - Otherwise, if U denotes span<X, Extent> for some type X and some extent Extent, then span<const X, Extent>(E).
+  {
+    int a[3]                                               = {};
+    std::same_as<std::span<const int>> decltype(auto) view = std::span<int>(a) | std::views::as_const;
+    assert(std::to_address(view.begin()) == a);
+    assert(std::to_address(view.end()) == a + 3);
+  }
+  {
+    int a[3]                                                  = {};
+    std::same_as<std::span<const int, 3>> decltype(auto) view = std::span<int, 3>(a) | std::views::as_const;
+    assert(std::to_address(view.begin()) == a);
+    assert(std::to_address(view.end()) == a + 3);
+  }
+
+  // - Otherwise, if U denotes ref_view<X> for some type X and const X models constant_range, then ref_view(static_cast<const X&>(E.base())).
+  {
+    std::array<int, 3> a                        = {};
+    std::ranges::ref_view<std::array<int, 3>> r = a;
+    [[maybe_unused]] std::same_as<std::ranges::ref_view<const std::array<int, 3>>> decltype(auto) view =
+        r | std::views::as_const;
+  }
+
+  // - Otherwise, if E is an lvalue, const U models constant_range, and U does not model view, then ref_view(static_cast<const U&>(E)).
+  {
+    std::array<int, 3> a = {};
+    [[maybe_unused]] std::same_as<std::ranges::ref_view<const std::array<int, 3>>> decltype(auto) view =
+        a | std::views::as_const;
+  }
+
+  // - Otherwise, as_const_view(E).
+  { // view | views::as_const
+    DefaultConstructibleView v{{}, 3};
+    std::same_as<std::ranges::as_const_view<DefaultConstructibleView>> decltype(auto) view = v | std::views::as_const;
+    assert(view.base().i_ == 3);
+  }
+
+  { // adaptor | views::as_const
+    DefaultConstructibleView v{{}, 3};
+    const auto partial = std::views::transform(std::identity{}) | std::views::as_const;
+    std::same_as<std::ranges::as_const_view<
+        std::ranges::transform_view<DefaultConstructibleView, std::identity>>> decltype(auto) view = partial(v);
+    assert(view.base().base().i_ == 3);
+  }
+
+  { // views::as_const | adaptor
+    DefaultConstructibleView v{{}, 3};
+    const auto partial = std::views::as_const | std::views::transform(std::identity{});
+    std::same_as<std::ranges::transform_view<std::ranges::as_const_view<DefaultConstructibleView>,
+                                             std::identity>> decltype(auto) view = partial(v);
+    assert(view.base().base().i_ == 3);
+  }
+
+  { // range | views::as_const
+    [[maybe_unused]] std::same_as<std::ranges::as_const_view<std::views::all_t<std::vector<int>>>> decltype(auto) view =
+        std::vector<int>{} | std::views::as_const;
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}