[libc++][ranges] implement ranges::elements_of

libcxx/include/CMakeLists.txt

@@ -663,6 +663,7 @@ set(files
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/drop_while_view.h
+  __ranges/elements_of.h
   __ranges/elements_view.h
   __ranges/empty.h
   __ranges/empty_view.h

libcxx/include/__ranges/elements_of.h

@@ -0,0 +1,49 @@
+// -*- 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_ELEMENTS_OF_H
+#define _LIBCPP___RANGES_ELEMENTS_OF_H
+
+#include <__config>
+#include <__memory/allocator.h>
+#include <__ranges/concepts.h>
+#include <__utility/forward.h>
+#include <cstddef>
+
+#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 <range _Range, class _Allocator = allocator<byte>>
+struct elements_of {
+  _LIBCPP_NO_UNIQUE_ADDRESS _Range range;
+  _LIBCPP_NO_UNIQUE_ADDRESS _Allocator allocator = _Allocator();
+};
+
+template <class _Range, class _Allocator = allocator<byte>>
+elements_of(_Range&&, _Allocator = _Allocator()) -> elements_of<_Range&&, _Allocator>;
+
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_ELEMENTS_OF_H

libcxx/include/module.modulemap

@@ -1737,6 +1737,7 @@ module std [system] {
       header "__ranges/drop_while_view.h"
       export std.functional.bind_back
     }
+    module elements_of                    { header "__ranges/elements_of.h" }
     module elements_view                  { header "__ranges/elements_view.h" }
     module empty                          { header "__ranges/empty.h" }
     module empty_view                     { header "__ranges/empty_view.h" }

libcxx/include/ranges

@@ -116,6 +116,10 @@ namespace std::ranges {
   // [range.dangling], dangling iterator handling
   struct dangling;
 
+  // [range.elementsof], class template elements_of
+  template<range R, class Allocator = allocator<byte>>
+    struct elements_of;
+
   template<range R>
     using borrowed_iterator_t = see below;
 
@@ -392,6 +396,7 @@ namespace std {
 #  include <__ranges/data.h>
 #  include <__ranges/drop_view.h>
 #  include <__ranges/drop_while_view.h>
+#  include <__ranges/elements_of.h>
 #  include <__ranges/elements_view.h>
 #  include <__ranges/empty.h>
 #  include <__ranges/empty_view.h>

libcxx/modules/std/ranges.inc

@@ -83,8 +83,10 @@ export namespace std {
     // [range.dangling], dangling iterator handling
     using std::ranges::dangling;
 
+#if _LIBCPP_STD_VER >= 23
     // [range.elementsof], class template elements_­of
-    // using std::ranges::elements_of;
+    using std::ranges::elements_of;
+#endif
 
     using std::ranges::borrowed_iterator_t;
 

libcxx/test/libcxx/transitive_includes/cxx23.csv

@@ -835,6 +835,7 @@ random version
 ranges cctype
 ranges compare
 ranges concepts
+ranges cstddef
 ranges cstdint
 ranges cstdio
 ranges cstring

libcxx/test/libcxx/transitive_includes/cxx26.csv

@@ -834,6 +834,7 @@ random version
 ranges cctype
 ranges compare
 ranges concepts
+ranges cstddef
 ranges cstdint
 ranges cstdio
 ranges cstring

libcxx/test/std/ranges/range.utility/range.elementsof/ctad.compile.pass.cpp

@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// 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::ranges::elements_of;
+
+#include <ranges>
+
+#include <memory>
+
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+
+template <class Iterator>
+struct Range {
+  Iterator begin() const;
+  sentinel_wrapper<Iterator> end() const;
+};
+
+constexpr bool test() {
+  types::for_each(
+      types::type_list<std::allocator<std::byte>, min_allocator<std::byte>, test_allocator<std::byte>>{},
+      []<class Allocator> {
+        types::for_each(types::cpp20_input_iterator_list<int*>{}, []<class Iterator> {
+          Range<Iterator> r;
+          static_assert(std::same_as<decltype(std::ranges::elements_of(r)),
+                                     std::ranges::elements_of<Range<Iterator>&, std::allocator<std::byte>>>);
+          static_assert(std::same_as<decltype(std::ranges::elements_of(Range<Iterator>())),
+                                     std::ranges::elements_of<Range<Iterator>&&, std::allocator<std::byte>>>);
+
+          Allocator a;
+          static_assert(std::same_as<decltype(std::ranges::elements_of(r, a)),
+                                     std::ranges::elements_of<Range<Iterator>&, Allocator>>);
+          static_assert(std::same_as<decltype(std::ranges::elements_of(Range<Iterator>(), Allocator())),
+                                     std::ranges::elements_of<Range<Iterator>&&, Allocator>>);
+
+          static_assert(std::same_as<decltype(std::ranges::elements_of{.range = r, .allocator = a}),
+                                     std::ranges::elements_of<Range<Iterator>&, Allocator>>);
+          static_assert(
+              std::same_as<decltype(std::ranges::elements_of{.range = Range<Iterator>(), .allocator = Allocator()}),
+                           std::ranges::elements_of<Range<Iterator>&&, Allocator>>);
+        });
+      });
+
+  return true;
+}
+
+static_assert(test());

libcxx/test/std/ranges/range.utility/range.elementsof/elements_of.pass.cpp

@@ -0,0 +1,107 @@
+//===----------------------------------------------------------------------===//
+//
+// 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::ranges::elements_of;
+
+#include <ranges>
+
+#include <concepts>
+#include <memory>
+#include <type_traits>
+#include <vector>
+
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+
+template <class Iterator>
+struct Range {
+  using Sentinel = sentinel_wrapper<Iterator>;
+
+  Iterator begin() { return Iterator(data_.data()); }
+
+  Sentinel end() { return Sentinel(Iterator(data_.data() + data_.size())); }
+
+private:
+  std::vector<int> data_ = {0, 1, 2, 3};
+};
+
+template <class Range, class Allocator>
+constexpr bool test_range() {
+  Range r;
+
+  using elements_of_t = std::ranges::elements_of<Range&, Allocator>;
+  {
+    // constructor
+    std::same_as<elements_of_t> decltype(auto) elements_of                 = std::ranges::elements_of(r, Allocator());
+    [[maybe_unused]] std::same_as<Range&> decltype(auto) elements_of_range = elements_of.range;
+    if (!std::is_constant_evaluated()) {
+      assert(std::ranges::distance(elements_of_range) == 4);
+    }
+    [[maybe_unused]] std::same_as<Allocator> decltype(auto) elements_of_allocator = elements_of.allocator;
+  }
+  {
+    // designated initializer
+    std::same_as<elements_of_t> decltype(auto) elements_of = std::ranges::elements_of{
+        .range     = r,
+        .allocator = Allocator(),
+    };
+    [[maybe_unused]] std::same_as<Range&> decltype(auto) elements_of_range = elements_of.range;
+    if (!std::is_constant_evaluated()) {
+      assert(std::ranges::distance(elements_of_range) == 4);
+    }
+    [[maybe_unused]] std::same_as<Allocator> decltype(auto) elements_of_allocator = elements_of.allocator;
+  }
+  {
+    // copy constructor
+    std::same_as<elements_of_t> decltype(auto) elements_of_1                 = std::ranges::elements_of(r, Allocator());
+    std::same_as<elements_of_t> auto elements_of_2                           = elements_of_1;
+    [[maybe_unused]] std::same_as<Range&> decltype(auto) elements_of_1_range = elements_of_1.range;
+    [[maybe_unused]] std::same_as<Range&> decltype(auto) elements_of_2_range = elements_of_2.range;
+    if (!std::is_constant_evaluated()) {
+      assert(std::ranges::distance(elements_of_1_range) == 4);
+      assert(std::ranges::distance(elements_of_2_range) == 4);
+    }
+    [[maybe_unused]] std::same_as<Allocator> decltype(auto) elements_of_2_allocator = elements_of_2.allocator;
+  }
+
+  using elements_of_r_t = std::ranges::elements_of<Range&&, Allocator>;
+  {
+    // move constructor
+    std::same_as<elements_of_r_t> decltype(auto) elements_of_1 = std::ranges::elements_of(std::move(r), Allocator());
+    std::same_as<elements_of_r_t> auto elements_of_2           = std::move(elements_of_1);
+    [[maybe_unused]] std::same_as<Range&&> decltype(auto) elements_of_1_range = std::move(elements_of_1.range);
+    [[maybe_unused]] std::same_as<Range&&> decltype(auto) elements_of_2_range = std::move(elements_of_2.range);
+    if (!std::is_constant_evaluated()) {
+      assert(std::ranges::distance(elements_of_1_range) == 4);
+      assert(std::ranges::distance(elements_of_2_range) == 4);
+    }
+    [[maybe_unused]] std::same_as<Allocator> decltype(auto) elements_of_2_allocator = elements_of_2.allocator;
+  }
+  return true;
+}
+
+constexpr bool test() {
+  types::for_each(types::type_list<std::allocator<std::byte>, min_allocator<std::byte>, test_allocator<std::byte>>{},
+                  []<class Allocator> {
+                    types::for_each(types::cpp20_input_iterator_list<int*>{}, []<class Iterator> {
+                      test_range<Range<Iterator>, Allocator>();
+                    });
+                  });
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}