[libc++][ranges] Implement `views::take`.

[var-const]

Summary

The view itself has been implemented previously -- this patch only adds
the ability to pipe it.

Also implements P1739 (partially) and LWG3407.

[var-const]

Remove unnecessary change.

[philnik]

libcxx/include/__fwd/string_view.h

2

__string_view/fwd.h would make more sense I think. Same for span.

18

21–36

Shouldn't string_view be C++17 or later?

libcxx/include/__ranges/take_view.h

267

I would only use the stable names. The numbers bit-rot way to fast.

[jloser]

libcxx/include/__fwd/string_view.h

21–36

Technically yes, but for libc++, no. We support string_view in older standards as an extension.

[ldionne]

You might also want to take a look at D115122 for inspiration if you have not already -- just leaving this note since I stumbled upon a comment that suggested doing that on my ranges::drop review. In particular, you should look at this comment and make sure we're OK: https://reviews.llvm.org/D116950#inline-1160422.

Since I'm about to go OOO and I don't see any real blocking issues, I'm going to approve this -- I don't think I'd need to see this again after CI is passing and my comments have been addressed.

libcxx/include/__fwd/string_view.h

2

FWIW I don't really have a strong opinion. The only downside to this is that we might end up with a lot of one-header subdirectories if we start adding forward declarations to more classes, and putting everything under __fwd/ would avoid that.

libcxx/include/__ranges/take_view.h

50–51

Can you land the indentation change as a NFC patch before this one? No need for a review, I'd just like to avoid mixing it with this patch.

259

I don't think this comment is necessary to keep around in the long run. I understand its purpose in the context of this review, however.

267

I think I agree -- we're guilty of this in other places and I think that was a mistake, in retrospect.

288–289

It is not clear to me that we want to use std::forward here. Indeed, http://eel.is/c++draft/range.take#view does say U(ranges​::​begin(E), ranges​::​begin(E) + std​::​min<D>(ranges​::​distance(E), F)) where E is the expression in views::take(E, F). However, we generally want to avoid forwarding in more than one expression at a time because that sets us up for double-moves. In this case it should not matter since begin has to take either T& or T const&, but I think I'd drop the forward here. IIUC, the same is true for ranges::distance.

[ldionne]

libcxx/docs/Status/RangesIssues.csv

15 ↗

(On Diff #422200)

Note that this is technically not quite complete until we ship ranges::drop.

[huixie90]

libcxx/include/__fwd/string_view.h

2

I am in favour of fwd folder. I don’t like to have too many files with the exact same name fwd.hpp

libcxx/include/__ranges/take_view.h

224

I remember that clangd always suggests me to add inline in those partial variable template specialisations. I don’t get why but those constexpr bool variable template in the standard all have inlines

268

I think it should be the different type of _Range&& instead of _Range

292

question : the spec doesn’t say “if the expression is ill formed, goto otherwise clause”. do we need sfinae here?

339

Should the second _Np be _Np&& ?

libcxx/test/std/ranges/range.adaptors/range.take/adaptor.pass.cpp

52

Could you add a test for

If decltype((F)) does not model convertible_­to<D>, views​::​take(E, F) is ill-formed

[philnik]

libcxx/include/__fwd/string_view.h

2

I don't like having a __fwd subdirectory because that would mean we have a single header spread across multiple subdirecories. That makes it a lot harder to see what is part of a header.

[huixie90]

libcxx/include/__fwd/string_view.h

2

I think having a single fwd folder whose subdirectories hierarchies follow the non-fwd hierarchies is pretty neat. You can easily find the forward declarations by adding a fwd at the beginning. One example code base is Boost.Hana

[var-const]

Partially address review feedback and rebase.

[var-const]

In D123600#3450020, @ldionne wrote:

In particular, you should look at this comment and make sure we're OK: https://reviews.llvm.org/D116950#inline-1160422.

There is a test case for a fixed-size span:

// `views::take(span, n)` returns a `span` with a dynamic extent, regardless of the input `span`.
{
  std::span<int, 8> s(buf);
  std::same_as<std::span<int, std::dynamic_extent>> decltype(auto) result = s | std::views::take(3);
  assert(result.size() == 3);
}

libcxx/docs/Status/RangesIssues.csv

15 ↗

(On Diff #422200)

Great point, thanks. Removed for now.

libcxx/include/__fwd/string_view.h

2

I'm slightly in favor of having all the forward declarations under a single folder because it would make it easier to see what can and cannot be forward-declared. While having contents of a single header spread across several directories in general would be bad, I think splitting out forward declarations following a consistent pattern shouldn't cause any issues. @philnik How strongly do you feel about this?

18

Thanks!

21–36

string_view is not guarded on the language version.

libcxx/include/__ranges/take_view.h

224

IIUC, this is to prevent potential ODR violations. Added inline, thanks.

259

Yeah, I guess it would have made more sense as a review comment. Removed.

267

Thanks, this is a good point, but there doesn't seem to be a great alternative. Added short descriptions instead.

libcxx/test/std/ranges/range.adaptors/range.take/adaptor.pass.cpp

52

This is checked by

static_assert(!CanBePiped<SomeView&,   decltype(std::views::take(/*n=*/NotAView{}))>);

Would you prefer a more tailored test? (e.g. rather than having an empty type, come up with a more plausible number type that isn't convertible?)

[philnik]

libcxx/include/__fwd/string_view.h

2

The reason you want to forward declare the things here is to avoid including all of the header and having longer compile times, right? If there is another technical reason for that, please tell me! So there shouldn't be any reason for new headers to have them in 2-3 years (hopefully). I don't think there will be a lot of new forward declared headers because of this, so I think having forward declarations in another directory is quite surprising.
So yeah, I do feel quite strongly about this.

11

Just so you don't miss them when moving the headers.

[huixie90]

libcxx/test/std/ranges/range.adaptors/range.take/adaptor.pass.cpp

52

ah. i didn't spot this particular line. I was looking at the lines that are checking is_invocable_v<decltype(views::take), ...> and didn't see something like is_invocable_v<decltype(views::take), SomeView, NotADifference>

[ldionne]

This still LGTM, but there are a few comments from other reviewers that need addressing.

libcxx/include/__fwd/string_view.h

2

The main reason for having forward declarations is to avoid circular dependencies. For example, <span> includes some headers from <__ranges/...>, and it's possible that some of them also require including <span>. Having an easy way to add forward declarations is useful for that.

I don't want us to block this patch on such a simple issue. Let's add forward declarations in __fwd/FOO.h from here on, and we can always change that (or even try to remove as many forward declarations as possible) in the future, if there is a good reason to do so.

[var-const]

Address feedback.

libcxx/include/__fwd/string_view.h

2

@philnik Like Louis said, having some forward declarations is probably unavoidable. But even if we were to remove them in the future, it seems like it would still be (very slightly) easier if they're all within a single folder. In any case, changing this structure in either direction is very straightforward, so we can always change our solution later on with minimal hassle. I'm inclined to keep as is -- if you still feel strongly, I can do a follow-up (feel free to ping me on Discord if that's the case).

11

Thanks a lot!

libcxx/include/__ranges/take_view.h

268

In this case, I don't think it matters. range_difference_t<T> depends on iterator_t<T>, which in turn is defined as decltype(ranges::begin(std::declval<T&>())). I think the type of T& would be the same regardless of whether T is _Range or _Range&&. It's a good question in general, though -- please let me know if you see a similar pattern where this could make a difference.

288–289

Done, thanks for calling this out!

292

The way I interpret it is that it says "If the type satisfies such and such condition, do this, otherwise go to the next clause". If the resulting expression is ill-formed, then the type does not satisfy the condition, so it should check the next clause. Sorry if I misunderstood the question -- in that case, please elaborate a little.

339

I don't think so. Do you have a case in mind where it would make a difference?

[var-const]

Fix the CI.

[var-const]

Fix the CI:

• appease clang-tidy;
• make sure to undefine min/max macros in the forward-declaration headers;
• tweak the modulemap linter to recognize forward-declaration headers.

[var-const]

Fix CI.

[var-const]

Fix CI.

[var-const]

Fix the CI.

libcxx/include/CMakeLists.txt

set(files
   __functional/pointer_to_binary_function.h
   __functional/pointer_to_unary_function.h
   __functional/ranges_operations.h
   __functional/reference_wrapper.h
   __functional/unary_function.h
   __functional/unary_negate.h
   __functional/unwrap_ref.h
   __functional/weak_result_type.h
+  __fwd/span.h
+  __fwd/string_view.h
   __hash_table
   __ios/fpos.h
   __iterator/access.h
   __iterator/advance.h
   __iterator/back_insert_iterator.h
   __iterator/common_iterator.h
   __iterator/concepts.h
   __iterator/counted_iterator.h

libcxx/include/__fwd/span.h

+// -*- 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_FWD_SPAN_H
+#define _LIBCPP_FWD_SPAN_H
+
+#include <__config>
+#include <cstddef>
+#include <limits>
+
+#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 > 17
+
+inline constexpr size_t dynamic_extent = numeric_limits<size_t>::max();
+template <typename _Tp, size_t _Extent = dynamic_extent> class span;
+
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_FWD_SPAN_H

libcxx/include/__fwd/string_view.h

+// -*- 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_FWD_STRING_VIEW_H
+#define _LIBCPP_FWD_STRING_VIEW_H
+
+#include <__config>
+#include <iosfwd> // char_traits
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _CharT, class _Traits = char_traits<_CharT> >
+class _LIBCPP_TEMPLATE_VIS basic_string_view;
+
+typedef basic_string_view<char>     string_view;
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+typedef basic_string_view<char8_t>  u8string_view;
+#endif
+typedef basic_string_view<char16_t> u16string_view;
+typedef basic_string_view<char32_t> u32string_view;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+typedef basic_string_view<wchar_t>  wstring_view;
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_FWD_STRING_VIEW_H

libcxx/include/__ranges/take_view.h

 // -*- 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_TAKE_VIEW_H
 #define _LIBCPP___RANGES_TAKE_VIEW_H
 
+#include <__algorithm/min.h>
 #include <__algorithm/ranges_min.h>
 #include <__config>
+#include <__functional/bind_back.h>
+#include <__fwd/span.h>
+#include <__fwd/string_view.h>
 #include <__iterator/concepts.h>
 #include <__iterator/counted_iterator.h>
 #include <__iterator/default_sentinel.h>
+#include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
+#include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
+#include <__ranges/iota_view.h>
+#include <__ranges/range_adaptor.h>
 #include <__ranges/size.h>
+#include <__ranges/subrange.h>
 #include <__ranges/view_interface.h>
+#include <__utility/auto_cast.h>
+#include <__utility/forward.h>
 #include <__utility/move.h>
 #include <concepts>
 #include <type_traits>
 
 #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 > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 namespace ranges {
 
 template<view _View>
 class take_view : public view_interface<take_view<_View>> {
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
   range_difference_t<_View> __count_ = 0;
 
   template<bool> class __sentinel;
 
 public:
if constexpr (sized_range<const _View>) {
       } else {
         return default_sentinel;
       }
     } else {
       return __sentinel<true>{ranges::end(__base_)};
     }
   }
 
-
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto size() requires sized_range<_View> {
     auto __n = ranges::size(__base_);
     return ranges::min(__n, static_cast<decltype(__n)>(__count_));
   }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr auto size() const requires sized_range<const _View> {

 };
 
 template<class _Range>
 take_view(_Range&&, range_difference_t<_Range>) -> take_view<views::all_t<_Range>>;
 
 template<class _Tp>
 inline constexpr bool enable_borrowed_range<take_view<_Tp>> = enable_borrowed_range<_Tp>;
 
+namespace views {
+namespace __take {
+
+template <class _Tp>
+inline constexpr bool __is_empty_view = false;
+
+template <class _Tp>
+inline constexpr bool __is_empty_view<empty_view<_Tp>> = true;
+
+template <class _Tp>
+inline constexpr bool __is_passthrough_specialization = false;
+
+template <class _Tp, size_t _Extent>
+inline constexpr bool __is_passthrough_specialization<span<_Tp, _Extent>> = true;
+
+template <class _CharT, class _Traits>
+inline constexpr bool __is_passthrough_specialization<basic_string_view<_CharT, _Traits>> = true;
+
+template <class _Iter, class _Sent, subrange_kind _Kind>
+inline constexpr bool __is_passthrough_specialization<subrange<_Iter, _Sent, _Kind>> = true;
+
+template <class _Tp>
+inline constexpr bool __is_iota_specialization = false;
+
+template <class _Np, class _Bound>
+inline constexpr bool __is_iota_specialization<iota_view<_Np, _Bound>> = true;
+
+template <class _Tp>
+struct __passthrough_type;
+
+template <class _Tp, size_t _Extent>
+struct __passthrough_type<span<_Tp, _Extent>> {
+  using type = span<_Tp>;
+};
+
+template <class _CharT, class _Traits>
+struct __passthrough_type<basic_string_view<_CharT, _Traits>> {
+  using type = basic_string_view<_CharT, _Traits>;
+};
+
+template <class _Iter, class _Sent, subrange_kind _Kind>
+struct __passthrough_type<subrange<_Iter, _Sent, _Kind>> {
+  using type = subrange<_Iter>;
+};
+
+template <class _Tp>
+using __passthrough_type_t = typename __passthrough_type<_Tp>::type;
+
+struct __fn {
+  // [range.take.overview]: the `empty_view` case.
+  template <class _Range, convertible_to<range_difference_t<_Range>> _Np>
+    requires __is_empty_view<remove_cvref_t<_Range>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Range&& __range, _Np&&) const
+    noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))))
+    -> decltype(      _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)))
+    { return          _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)); }
+
+  // [range.take.overview]: the `span | basic_string_view | subrange` case.
+  template <class _Range,
+            convertible_to<range_difference_t<_Range>> _Np,
+            class _RawRange = remove_cvref_t<_Range>,
+            class _Dist = range_difference_t<_Range>>
+    requires (!__is_empty_view<_RawRange> &&
+              random_access_range<_RawRange> &&
+              sized_range<_RawRange> &&
+              __is_passthrough_specialization<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Range&& __rng, _Np&& __n) const
+    noexcept(noexcept(__passthrough_type_t<_RawRange>(
+                              ranges::begin(__rng),
+                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
+                              )))
+    -> decltype(      __passthrough_type_t<_RawRange>(
+                              // Note: deliberately not forwarding `__rng` to guard against double moves.
+                              ranges::begin(__rng),
+                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
+                              ))
+    { return          __passthrough_type_t<_RawRange>(
+                              ranges::begin(__rng),
+                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
+                              ); }
+
+  // [range.take.overview]: the `iota_view` case.
+  template <class _Range,
+            convertible_to<range_difference_t<_Range>> _Np,
+            class _RawRange = remove_cvref_t<_Range>,
+            class _Dist = range_difference_t<_Range>>
+    requires (!__is_empty_view<_RawRange> &&
+              random_access_range<_RawRange> &&
+              sized_range<_RawRange> &&
+              __is_iota_specialization<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Range&& __rng, _Np&& __n) const
+    noexcept(noexcept(ranges::iota_view(
+                              *ranges::begin(__rng),
+                              *ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
+                              )))
+    -> decltype(      ranges::iota_view(
+                              // Note: deliberately not forwarding `__rng` to guard against double moves.
+                              *ranges::begin(__rng),
+                              *ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
+                              ))
+    { return          ranges::iota_view(
+                              *ranges::begin(__rng),
+                              *ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
+                              ); }
+
+  // [range.take.overview]: the "otherwise" case.
+  template <class _Range, convertible_to<range_difference_t<_Range>> _Np,
+            class _RawRange = remove_cvref_t<_Range>>
+    // Note: without specifically excluding the other cases, GCC sees this overload as ambiguous with the other
+    // overloads.
+    requires (!(__is_empty_view<_RawRange> ||
+               (__is_iota_specialization<_RawRange> &&
+                sized_range<_RawRange> &&
+                random_access_range<_RawRange>) ||
+               (__is_passthrough_specialization<_RawRange> &&
+                sized_range<_RawRange> &&
+                random_access_range<_RawRange>)
+             ))
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Range&& __range, _Np&& __n) const
+    noexcept(noexcept(take_view(std::forward<_Range>(__range), std::forward<_Np>(__n))))
+    -> decltype(      take_view(std::forward<_Range>(__range), std::forward<_Np>(__n)))
+    { return          take_view(std::forward<_Range>(__range), std::forward<_Np>(__n)); }
+
+  template <class _Np>
+    requires constructible_from<decay_t<_Np>, _Np>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Np&& __n) const
+    noexcept(is_nothrow_constructible_v<decay_t<_Np>, _Np>)
+  { return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Np>(__n))); }
+};
+
+} // namespace __take
+
+inline namespace __cpo {
+  inline constexpr auto take = __take::__fn{};
+} // namespace __cpo
+} // namespace views
+
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___RANGES_TAKE_VIEW_H

libcxx/include/module.modulemap

module std [system] {
   module shared_mutex {
     header "shared_mutex"
     export version
   }
   module span {
     header "span"
     export ranges.__ranges.enable_borrowed_range
     export version
+    module span_fwd { private header "__fwd/span.h" }
   }
   module sstream {
     header "sstream"
     // FIXME: should re-export istream, ostream, ios, streambuf, string?
     export *
   }
   module stack {
     header "stack"
module string {
     export __string
     export *
   }
   module string_view {
     header "string_view"
     export initializer_list
     export __string
     export *
+    module string_view_fwd { private header "__fwd/string_view.h" }
   }
   module strstream {
     header "strstream"
     export *
   }
   module system_error {
     header "system_error"
     export *

libcxx/include/span

 
 } // namespace std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__debug>
+#include <__fwd/span.h>
 #include <__iterator/concepts.h>
 #include <__iterator/wrap_iter.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/size.h>
 #include <array>        // for array

 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
-inline constexpr size_t dynamic_extent = numeric_limits<size_t>::max();
-template <typename _Tp, size_t _Extent = dynamic_extent> class span;
-
 template <class _Tp>
 struct __is_std_array : false_type {};
 
 template <class _Tp, size_t _Sz>
 struct __is_std_array<array<_Tp, _Sz>> : true_type {};
 
 template <class _Tp>
 struct __is_std_span : false_type {};

libcxx/include/string_view

 }  // namespace std
 
 
 */
 
 #include <__algorithm/min.h>
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__fwd/string_view.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/size.h>
 #include <__string>
 #include <compare>
 #include <iosfwd>
 #include <iterator>
 #include <limits>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TEMPLATE_VIS basic_string_view;
-
-typedef basic_string_view<char>     string_view;
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-typedef basic_string_view<char8_t>  u8string_view;
-#endif
-typedef basic_string_view<char16_t> u16string_view;
-typedef basic_string_view<char32_t> u32string_view;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-typedef basic_string_view<wchar_t>  wstring_view;
-#endif
-
 // TODO: This is a workaround for some vendors to carry a downstream diff to accept `nullptr` in
 //       string_view constructors. This can be refactored when this exact form isn't needed anymore.
 template <class _Traits>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
 inline size_t __char_traits_length_checked(const typename _Traits::char_type* __s) _NOEXCEPT {
   // This needs to be a single statement for C++11 constexpr
   return _LIBCPP_ASSERT(__s != nullptr, "null pointer passed to non-null argument of char_traits<...>::length"), _Traits::length(__s);
 }

libcxx/test/libcxx/lint/lint_modulemap.sh.py

with open(modulemap_name, 'r') as f:
                 # Check that these lines are all of the expected format.
                 # This incidentally checks for typos in the module name.
                 if re.match(r'^\s*module (\w+)\s+[{] private header "\1(.h)?"\s+export [*] [}]', line):
                     # It's a top-level private header, such as <__bit_reference>.
                     pass
                 elif re.match(r'^\s*module (\w+)\s+[{] private header "__\w+/\1[.]h" [}]', line):
                     # It's a private submodule, such as <__utility/swap.h>.
                     pass
+                elif re.match(r'^\s*module (\w+)_fwd\s+[{] private header "__fwd/\1[.]h" [}]', line):
+                    # It's a private submodule with forward declarations, such as <__fwd/span.h>.
+                    pass
                 else:
                     okay = False
                     print("LINE DOESN'T MATCH REGEX in libcxx/include/module.modulemap!")
                     print(line)
                 # Check that these lines are alphabetized.
                 if (prevline is not None) and (line < prevline):
                     okay = False
                     print('LINES OUT OF ORDER in libcxx/include/module.modulemap!')
                     print(prevline)
                     print(line)
                 prevline = line
             else:
                 prevline = None
     assert okay

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__functional/pointer_to_binary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/pointer_to_binary_function.h'}}
 #include <__functional/pointer_to_unary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/pointer_to_unary_function.h'}}
 #include <__functional/ranges_operations.h> // expected-error@*:* {{use of private header from outside its module: '__functional/ranges_operations.h'}}
 #include <__functional/reference_wrapper.h> // expected-error@*:* {{use of private header from outside its module: '__functional/reference_wrapper.h'}}
 #include <__functional/unary_function.h> // expected-error@*:* {{use of private header from outside its module: '__functional/unary_function.h'}}
 #include <__functional/unary_negate.h> // expected-error@*:* {{use of private header from outside its module: '__functional/unary_negate.h'}}
 #include <__functional/unwrap_ref.h> // expected-error@*:* {{use of private header from outside its module: '__functional/unwrap_ref.h'}}
 #include <__functional/weak_result_type.h> // expected-error@*:* {{use of private header from outside its module: '__functional/weak_result_type.h'}}
+#include <__fwd/span.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/span.h'}}
+#include <__fwd/string_view.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/string_view.h'}}
 #include <__ios/fpos.h> // expected-error@*:* {{use of private header from outside its module: '__ios/fpos.h'}}
 #include <__iterator/access.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/access.h'}}
 #include <__iterator/advance.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/advance.h'}}
 #include <__iterator/back_insert_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/back_insert_iterator.h'}}
 #include <__iterator/common_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/common_iterator.h'}}
 #include <__iterator/concepts.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/concepts.h'}}
 #include <__iterator/counted_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/counted_iterator.h'}}
 #include <__iterator/data.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/data.h'}}

libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp

 static_assert(test(std::views::all, a));
 static_assert(test(std::views::common, a));
 static_assert(test(std::views::counted, a, 10));
 //static_assert(test(std::views::drop, a, 10));
 //static_assert(test(std::views::drop_while, a, [](int x){ return x < 10; }));
 //static_assert(test(std::views::elements<0>, pairs));
 static_assert(test(std::views::filter, a, [](int x){ return x < 10; }));
 //static_assert(test(std::views::join, arrays));
+//static_assert(test(std::views::split, a, 4));
 static_assert(test(std::views::lazy_split, a, 4));
 static_assert(test(std::views::reverse, a));
-//static_assert(test(std::views::take, a, 10));
+static_assert(test(std::views::take, a, 10));
 //static_assert(test(std::views::take_while, a, [](int x){ return x < 10; }));
 static_assert(test(std::views::transform, a, [](int x){ return x + 1; }));

libcxx/test/std/ranges/range.adaptors/range.take/adaptor.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::views::take
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <string_view>
+#include <utility>
+#include "test_iterators.h"
+#include "types.h"
+
+template <class View, class T>
+concept CanBePiped = requires (View&& view, T&& t) {
+  { std::forward<View>(view) | std::forward<T>(t) };
+};
+
+struct SizedView : std::ranges::view_base {
+  int* begin_ = nullptr;
+  int* end_ = nullptr;
+  constexpr SizedView(int* begin, int* end) : begin_(begin), end_(end) {}
+
+  constexpr auto begin() const { return forward_iterator<int*>(begin_); }
+  constexpr auto end() const { return sized_sentinel<forward_iterator<int*>>(forward_iterator<int*>(end_)); }
+};
+static_assert(std::ranges::forward_range<SizedView>);
+static_assert(std::ranges::sized_range<SizedView>);
+static_assert(std::ranges::view<SizedView>);
+
+template <class T>
+constexpr void test_small_range(const T& input) {
+  constexpr int N = 100;
+  auto size = std::ranges::size(input);
+
+  auto result = input | std::views::take(N);
+  assert(size < N);
+  assert(result.size() == size);
+}
+
+constexpr bool test() {
+  constexpr int N = 8;
+  int buf[N] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  // Test that `std::views::take` is a range adaptor.
+  {
+    using SomeView = SizedView;
+
+    // Test `view | views::take`
+    {
+      SomeView view(buf, buf + N);
+      std::same_as<std::ranges::take_view<SomeView>> decltype(auto) result = view | std::views::take(3);
+      assert(result.base().begin_ == buf);
+      assert(result.base().end_ == buf + N);
+      assert(result.size() == 3);
+    }
+
+    // Test `adaptor | views::take`
+    {
+      SomeView view(buf, buf + N);
+      auto f = [](int i) { return i; };
+      auto const partial = std::views::transform(f) | std::views::take(3);
+
+      using Result = std::ranges::take_view<std::ranges::transform_view<SomeView, decltype(f)>>;
+      std::same_as<Result> decltype(auto) result = partial(view);
+      assert(result.base().base().begin_ == buf);
+      assert(result.base().base().end_ == buf + N);
+      assert(result.size() == 3);
+    }
+
+    // Test `views::take | adaptor`
+    {
+      SomeView view(buf, buf + N);
+      auto f = [](int i) { return i; };
+      auto const partial = std::views::take(3) | std::views::transform(f);
+
+      using Result = std::ranges::transform_view<std::ranges::take_view<SomeView>, decltype(f)>;
+      std::same_as<Result> decltype(auto) result = partial(view);
+      assert(result.base().base().begin_ == buf);
+      assert(result.base().base().end_ == buf + N);
+      assert(result.size() == 3);
+    }
+
+    // Check SFINAE friendliness
+    {
+      struct NotAView { };
+      static_assert(!std::is_invocable_v<decltype(std::views::take)>);
+      static_assert(!std::is_invocable_v<decltype(std::views::take), NotAView, int>);
+      static_assert( CanBePiped<SomeView&,   decltype(std::views::take(3))>);
+      static_assert( CanBePiped<int(&)[10],  decltype(std::views::take(3))>);
+      static_assert(!CanBePiped<int(&&)[10], decltype(std::views::take(3))>);
+      static_assert(!CanBePiped<NotAView,    decltype(std::views::take(3))>);
+
+      static_assert(!CanBePiped<SomeView&,   decltype(std::views::take(/*n=*/NotAView{}))>);
+    }
+  }
+
+  {
+    static_assert(std::same_as<decltype(std::views::take), decltype(std::ranges::views::take)>);
+  }
+
+  // `views::take(empty_view, n)` returns an `empty_view`.
+  {
+    using Result = std::ranges::empty_view<int>;
+    [[maybe_unused]] std::same_as<Result> decltype(auto) result = std::views::empty<int> | std::views::take(3);
+  }
+
+  // `views::take(span, n)` returns a `span`.
+  {
+    std::span<int> s(buf);
+    std::same_as<decltype(s)> decltype(auto) result = s | std::views::take(3);
+    assert(result.size() == 3);
+  }
+
+  // `views::take(span, n)` returns a `span` with a dynamic extent, regardless of the input `span`.
+  {
+    std::span<int, 8> s(buf);
+    std::same_as<std::span<int, std::dynamic_extent>> decltype(auto) result = s | std::views::take(3);
+    assert(result.size() == 3);
+  }
+
+  // `views::take(string_view, n)` returns a `string_view`.
+  {
+    {
+      std::string_view sv = "abcdef";
+      std::same_as<decltype(sv)> decltype(auto) result = sv | std::views::take(3);
+      assert(result.size() == 3);
+    }
+
+    {
+      std::u32string_view sv = U"abcdef";
+      std::same_as<decltype(sv)> decltype(auto) result = sv | std::views::take(3);
+      assert(result.size() == 3);
+    }
+  }
+
+  // `views::take(subrange, n)` returns a `subrange`.
+  {
+    auto subrange = std::ranges::subrange(buf, buf + N);
+    using Result = std::ranges::subrange<int*>;
+    std::same_as<Result> decltype(auto) result = subrange | std::views::take(3);
+    assert(result.size() == 3);
+  }
+
+  // `views::take(subrange, n)` doesn't return a `subrange` if it's not a random access range.
+  {
+    SizedView v(buf, buf + N);
+    auto subrange = std::ranges::subrange(v.begin(), v.end());
+
+    using Result = std::ranges::take_view<std::ranges::subrange<forward_iterator<int*>,
+        sized_sentinel<forward_iterator<int*>>>>;
+    std::same_as<Result> decltype(auto) result = subrange | std::views::take(3);
+    assert(result.size() == 3);
+  }
+
+  // `views::take(subrange, n)` returns a `subrange` with all default template arguments.
+  {
+    std::ranges::subrange<int*, sized_sentinel<int*>, std::ranges::subrange_kind::sized> subrange;
+
+    using Result = std::ranges::subrange<int*, int*, std::ranges::subrange_kind::sized>;
+    [[maybe_unused]] std::same_as<Result> decltype(auto) result = subrange | std::views::take(3);
+  }
+
+  // `views::take(iota_view, n)` returns an `iota_view`.
+  {
+    auto iota = std::views::iota(1, 8);
+    // The second template argument of the resulting `iota_view` is different because it has to be able to hold
+    // the `range_difference_t` of the input `iota_view`.
+    using Result = std::ranges::iota_view<int, std::ranges::range_difference_t<decltype(iota)>>;
+    std::same_as<Result> decltype(auto) result = iota | std::views::take(3);
+    assert(result.size() == 3);
+  }
+
+  // When the size of the input range `s` is shorter than `n`, only `s` elements are taken.
+  {
+    test_small_range(std::span(buf));
+    test_small_range(std::string_view("abcdef"));
+    test_small_range(std::ranges::subrange(buf, buf + N));
+    test_small_range(std::views::iota(1, 8));
+  }
+
+  // Test that it's possible to call `std::views::take` with any single argument as long as the resulting closure is
+  // never invoked. There is no good use case for it, but it's valid.
+  {
+    struct X { };
+    [[maybe_unused]] auto partial = std::views::take(X{});
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}