[libc++] Implements ranges::enable_borrowed_range

[Mordante]

Summary

This is the initial patch to implement ranges in libc++.

Implements parts of:

• P0896R4 One Ranges Proposal
• P1870 forwarding-range is too subtle
• LWG3379 in several library names is misleading

[curdeius]

Don't forget to add the new <ranges> header to std_includes test. Otherwise no other remarks from my side.

[curdeius]

I meant double_include: https://github.com/llvm/llvm-project/blob/master/libcxx/test/libcxx/double_include.sh.cpp.

[Mordante]

In D90999#2380694, @curdeius wrote:

Don't forget to add the new <ranges> header to std_includes test. Otherwise no other remarks from my side.

Thanks for the pointer. I'll update the patch shortly.

[Mordante]

Added the double_include.sh.cpp test as suggested by @curdeius.
move a test from ranges/ranges to ranges/range.range.

[tschuett]

https://github.com/llvm/llvm-project/blob/57b3bc8c603e25380ba56a5b95b2887010e9c1c0/libcxx/NOTES.TXT#L20

[Mordante]

In D90999#2380758, @tschuett wrote:

https://github.com/llvm/llvm-project/blob/57b3bc8c603e25380ba56a5b95b2887010e9c1c0/libcxx/NOTES.TXT#L20

Thanks, I'll look at what else I've missed.

[Mordante]

Added the other steps required when adding a new header as suggested by @tschuett.

[miscco]

I am wondering whether we should split the ranges header up into a smaller part that we use to include in other headers adn the rest.

Including all of ranges just for one trait seems a bit of an overkill.

We could always add it to concepts as that should be a transitive include for everything that includes range. Thoughts @ldionne?

libcxx/include/ranges

16

I am slightly surprised that concepts is not required

23

I am wondering whether it is wise to copy the synopsis as it should be rather than how it is. This might trick the user to believe all of it is supported. What are the conventions here?

libcxx/test/std/ranges/range.range/enable_borrowed_range.pass.cpp

24 ↗

(On Diff #303636)

I believe you are missing coverage for all the ranges that are not borrowed, e.g. vector, list, ...

[tschuett]

libcxx/include/ranges

326

Why is the curly bracket not at the end of the line above?

[Mordante]

In D90999#2381043, @miscco wrote:

I am wondering whether we should split the ranges header up into a smaller part that we use to include in other headers adn the rest.

Including all of ranges just for one trait seems a bit of an overkill.

I agree including the full ranges header in string_view and span feels a bit overkill. But I'll leave the decisions whether or not to split the header with the libc++ maintainers.

libcxx/include/ranges

16

Agreed. For this patch I don't need concepts, but std::ranges::begin() will require them.

23

Looking at other headers it does they do the same for example concepts also uses 'unspecified' and 'see below'.

326

Because that's what 'chrono' uses. However I have no objection against putting it on one line. Not sure what the libc++ coding style has to say about this.

libcxx/test/std/ranges/range.range/enable_borrowed_range.pass.cpp

24 ↗

(On Diff #303636)

I'm not convinced they really need to be tested, but adding them is not much effort. So I'll add them.

[Mordante]

Adds the additional unit tests as requested by @miscco.
Found some accidental tabs in the patch replaced them with spaces.

[Mordante]

Change the unit tests to compile time test, based on the review comment in D91004.

[ldionne]

In D90999#2381043, @miscco wrote:

I am wondering whether we should split the ranges header up into a smaller part that we use to include in other headers adn the rest.

Including all of ranges just for one trait seems a bit of an overkill.

We could always add it to concepts as that should be a transitive include for everything that includes range. Thoughts @ldionne?

I'd be fine with splitting various parts of ranges into separate headers if that makes the implementation clearer, etc.

[Mordante]

Move the enable_borrowed_range to a helper header to avoid including <ranges> in <span> and <string_view> as suggested by @miscco.

[Mordante]

Implement all new header tests as suggested by @curdeius in D92214.

[Mordante]

Rebased.

[Mordante]

• Removed unimplemented part of the synopsis
• Ran clang-format on the patch
• Rebased to trigger CI again

[Mordante]

Rebase to trigger CI. The last build failed, but so did main.

[Mordante]

Rebased to trigger CI.

[Mordante]

@ldionne Friendly ping.

[Mordante]

Rebased to update to main and a friendly ping.

[cjdb]

Overall, LGTM, but I'm wondering if we should hold off on merging till we've got consensus on how detail headers are going to be handled.
This is only because I'm seeing __ranges_enable_helpers.

libcxx/include/ranges

16

It's transitively included by <iterator>.

libcxx/test/std/ranges/range.range/enable_borrowed_range.compile.pass.cpp

2

Please change to enable_borrowed_range.pass.cpp (we've agreed in other patches to move away from .compile). Same with other files (this is just the first I noticed).

[• Quuxplusone]

libcxx/include/module.modulemap

410

We don't do this line for any other header, e.g. __functional_base, so I don't think it should be necessary here.

[Mordante]

Addresses review comments, rebased on main.

[Mordante]

libcxx/include/module.modulemap

410

I looked at __string, but that seems to be the exception. So I'll remove this one.

libcxx/include/ranges

16

Agreed, but this mandated by the standard. Since the overhead is minimal I prefer to follow the standard. If in a future revision <initializer_list> no longer requires <compare> we don't silently break our implementation.

libcxx/test/std/ranges/range.range/enable_borrowed_range.compile.pass.cpp

2

In the past had requests to rename test to use .compile. I asked for a policy on its usage on Discord, depending on the answer there I'll keep this name or rename the file.

[Mordante]

libcxx/test/std/ranges/range.range/enable_borrowed_range.compile.pass.cpp

2

As discussed on Discord we can keep compile only tests .compile. To future-proof them they shouldn't contain a main. So I'll update the .compile tests to have no main.

[Mordante]

Remove main() from the compile time tests.
Rebased on main.

[cjdb]

libcxx/include/__ranges_enable_helpers

2

Please change the path to __ranges/enable_helpers.h and move the synopsis to <ranges>.

39

We've got a _LIBCPP_HAS_NO_RANGES macro now that guards on C++20 now.

[zoecarver]

libcxx/include/__ranges_enable_helpers

11

I don't think we ever use triple underscore. This makes it hard to read. I think single underscore here is sufficient.

libcxx/include/module.modulemap

410

Hmm, my vote would be to export it as well. But I don't feel strongly. Do we have a policy on this @ldionne @EricWF?

libcxx/include/ranges

39

Same as the other comment, you can use _LIBCPP_HAS_NO_RANGES (in fact, let's guard the whole header on that).

41

Nit: I don't think it makes sense to have an empty namespace here.

[• Quuxplusone]

libcxx/include/__ranges_enable_helpers

11

Actually this is libc++ style, and has the benefit of being machine-generable (the header-inclusion test generator actually relies on their machine-generability, but only for public headers, not for these internal headers):

$ git grep '#define.*___' __*
__availability:#define _LIBCPP___AVAILABILITY
__bit_reference:#define _LIBCPP___BIT_REFERENCE
__bits:#define _LIBCPP___BITS
__errc:#define _LIBCPP___ERRC
__locale:#define _LIBCPP___LOCALE
__memory/allocator.h:#define _LIBCPP___MEMORY_ALLOCATOR_H
__memory/allocator_traits.h:#define _LIBCPP___MEMORY_ALLOCATOR_TRAITS_H
__memory/auto_ptr.h:#define _LIBCPP___MEMORY_AUTO_PTR_H
__memory/base.h:#define _LIBCPP___MEMORY_BASE_H
__memory/pointer_traits.h:#define _LIBCPP___MEMORY_POINTER_TRAITS_H
__memory/temporary_buffer.h:#define _LIBCPP___MEMORY_TEMPORARY_BUFFER_H
__memory/utilities.h:#define _LIBCPP___MEMORY_UTILITIES_H
__mutex_base:#define _LIBCPP___MUTEX_BASE
__node_handle:#define _LIBCPP___NODE_HANDLE
__sso_allocator:#define _LIBCPP___SSO_ALLOCATOR
__std_stream:#define _LIBCPP___STD_STREAM
__string:#define _LIBCPP___STRING
__tree:#define _LIBCPP___TREE
__tuple:#define _LIBCPP___TUPLE

The current exceptions-to-the-rule are

__config:#define _LIBCPP_CONFIG
__debug:#define _LIBCPP_DEBUG_H
__functional_03:#define _LIBCPP_FUNCTIONAL_03
__functional_base:#define _LIBCPP_FUNCTIONAL_BASE
__functional_base_03:#define _LIBCPP_FUNCTIONAL_BASE_03
__hash_table:#define _LIBCPP__HASH_TABLE
__nullptr:#define _LIBCPP_NULLPTR
__split_buffer:#define _LIBCPP_SPLIT_BUFFER

That said, this header name is a bit unwieldy, and vague to boot. <__enable_borrowed_range> would be strictly better. Plus, I imagine @ldionne will push for <__ranges/enable_borrowed_range.h> to match the new <__memory/*.h> regime.

If there's some reason we might want more in this header than just enable_borrowed_range, I think it's important for someone to speak up and say so now. The only other "enable helper" I'm aware of is disable_sized_range, and that can go loose in <ranges> because (unlike enable_borrowed_range) disable_sized_range is never used by anything in the library.

libcxx/test/std/containers/views/enable_borrowed_range.compile.pass.cpp

30–31

Same thing tested twice in a row. What was meant here? Ditto twice in the lines below.

36

Again, I recommend using something other than 1 as your "regular ordinary span" type. I suggest 10.

libcxx/test/std/language.support/support.limits/support.limits.general/ranges.version.pass.cpp

10 ↗

(On Diff #335849)

When adding a new header, I strongly recommend git grep-ing for the names of some other recently added headers, e.g. <charconv> and <barrier> and <concepts>, and seeing where they're used, both in util/ and in test/.

You'll need to modify some of the generators in util/, notably the header-inclusion-test generator.

I can't think of anything else you missed off the top of my head, but grepping will always tell you.

libcxx/test/std/ranges/range.range/enable_borrowed_range.compile.pass.cpp

43

I recommend using something like std::array<int, 10> as your "regular ordinary std::array" example (in general, not limited to this specific test). array<int, 1> seems like it might get some special cases, especially in Ranges, where there's a lot of obscure logic around the nebulous distinction between "O(1)" and "O(n)".

[• Quuxplusone]

libcxx/include/module.modulemap

410

FYI @zoecarver, this comment has moved since I made it. We shouldn't export __ranges_enable_borrowed_range or whatever we're calling it; but of course we should export ranges! :)

[Mordante]

libcxx/include/__ranges_enable_helpers

11

When I originally wrote this header we weren't as keen on splitting out our headers. I originally planned to add more small helpers to the header. IIRC disable_sized_range was on the list. But I agree it would be good avoid tech debt and change the header to our current style. I used __string as example which uses triple underscore. I don't have a strong opinion on what we use as long as it's consistent.

39

Thanks for the information, will adjust this code.

libcxx/include/ranges

39

I'll switch to the new guard.
I disagree on guarding the entire header. This is they normal way how we do things and I love consistency.
In fact guarding the entire header won't work; we need to include <__config> to define _LIBCPP_HAS_NO_RANGES.

libcxx/test/std/containers/views/enable_borrowed_range.compile.pass.cpp

30–31

It seems I wanted to test volatile but made a typical classical copy-paste error.

41

Dito.

[zoecarver]

Please fix the remaining few nits and land this! Thanks @Mordante! (You can accept on behalf of libc++ yourself.)

libcxx/include/__ranges_enable_helpers

11

Good to know. In that case I'm fine with triple underscore, or whatever's appropriate for the header name we land on.

[ldionne]

AFAICT, the only things are:

1. Rename the header to __ranges/borrowed_range.h or similar, with the intent of having both the concept and the helper in it.
2. Move the synopsis to <ranges>.

If I missed something else from another reviewer, please do it too, and then ship-it. No need for another round of reviews.

libcxx/include/__ranges_enable_helpers

11

I also have no opinion on the triple underscore story - I just did it that way cause it was consistent with the name of the files, but I agree triple underscores are not super pretty. 🤷🏼‍♂️

I think we should name this __ranges/borrowed_range.h and define both the concept (in the future) and this helper in it. As an example of what kind of granularity I think is good, I don't think it makes sense to have separate headers for std::enable_borrowed_range and the std::borrowed_range concept, not sure whether that was the intent in the long term or not.

libcxx/include/string_view

619

TBH, I haven't thought yet about whether we want _LIBCPP_INLINE_VISIBILITY on such inline variables. I guess it's fine if the compilers don't complain (I would have expected GCC to complain cause it expands to __always_inline__ on it).

[ldionne]

In D90999#2692573, @ldionne wrote:

AFAICT, the only things are:

1. Rename the header to __ranges/borrowed_range.h or similar, with the intent of having both the concept and the helper in it.

Forget about this. I just spoke to Arthur and he explained that the very purpose of splitting the customization point into its own header was to avoid dragging all of <ranges> in the other headers. That makes total sense, I had missed that. So then I think the name of the header should just reflect what's in it, i.e. enable_borrowed_range.h or the like.

Still LGTM with that naming sorted out.

[Mordante]

Thanks for all the reviews. I'll give it one more CI run to see whether the renaming didn't break things. Once that passes I'll land this patch.

libcxx/include/__ranges_enable_helpers

39

Note I still keep the _LIBCPP_STD_VER > 17 part, just like we did in <concepts>.

libcxx/include/string_view

619

This patch passed our CI so it should work with GCC. Since I still have quite some modifications to make I already wanted to give it one more CI run before landing.

libcxx/test/std/language.support/support.limits/support.limits.general/ranges.version.pass.cpp

10 ↗

(On Diff #335849)

IMO if something is needed for a new header it should be documented in https://libcxx.llvm.org/docs/Contributing.html#adding-a-new-header-todo.
Thanks for catching the missing python utils/generate_header_inclusion_tests.py;. That one wasn't done since that script wasn't available when I wrote this patch.

libcxx/test/std/ranges/range.range/enable_borrowed_range.compile.pass.cpp

43

Good suggestion, thanks!

[Mordante]

Addressed all review comments.
Rebased to main.

[Mordante]

Remove __ranges/enable_borrowed_range.h from include/module.modulemap.
This seems to break the build. The recently added headers in __memory
also aren't in this file so this seems not to be required.

[Mordante]

Disable ranges on Apple since it requires concepts.

[Mordante]

Disable another test for Apple.

[• Quuxplusone]

LGTM % comments. I suspect we will end up removing _LIBCPP_INLINE_VISIBILITY in the place it's commented-on, but that can be done in post.

libcxx/include/span

525

Nit: I'd prefer not to see _VSTD:: here.
Could someone (presumably @ldionne) comment on whether _LIBCPP_INLINE_VISIBILITY is a good idea here? My intuitive impression is "no, it shouldn't be here"; compare how we did it in <numbers>. (But those are partial specializations expressed via C++20 constraints, whereas this is a partial specialization expressed in the old-fashioned way. I don't know if that makes a subtle difference.)

(Note that _LIBCPP_INLINE_VAR is also a thing, but I think we don't want it here (because this is post-C++14-only) and my grepping didn't turn up any more precedents for what we're doing here with partial specialization.)

libcxx/test/std/containers/views/enable_borrowed_range.compile.pass.cpp

47–53

This test is overly complicated. Please replace the whole thing with these five lines, which test everything you've got now plus the fact that cvref-qualification matters to the specialization plus will give better error messages in the extremely unlikely case that this test ever fails.

void test() {
    static_assert(std::ranges::enable_borrowed_range<std::span<int, 0>>);
    static_assert(std::ranges::enable_borrowed_range<std::span<int, 42>>);
    static_assert(std::ranges::enable_borrowed_range<std::span<int, std::dynamic_extent>>);
    static_assert(!std::ranges::enable_borrowed_range<std::span<int, 42>&>);
    static_assert(!std::ranges::enable_borrowed_range<std::span<int, 42> const>);
}

[Mordante]

libcxx/include/span

525

@ldionne also had doubts, https://reviews.llvm.org/D90999#inline-947749. If we don't do that in <numbers> then I'll remove them before committing. The same for the _VSTD::.

[Mordante]

Addresses the final review comments.
Giving it one more CI run before landing the patch.

libcxx/include/CMakeLists.txt

 set(files
   __availability
   __bit_reference
   __bsd_locale_defaults.h
   __bsd_locale_fallbacks.h
   __debug
   __errc
   __functional_03
   __functional_base
   __functional_base_03
   __hash_table
   __libcpp_version
   __locale
   __mutex_base
   __node_handle
   __nullptr
+  __ranges_enable_helpers
   __split_buffer
   __sso_allocator
   __std_stream
   __string
   __threading_support
   __tree
   __tuple
   __undef_macros
set(files
   mutex
   new
   numbers
   numeric
   optional
   ostream
   queue
   random
+  ranges
   ratio
   regex
   scoped_allocator
   semaphore
   set
   setjmp.h
   shared_mutex
   span

libcxx/include/__ranges_enable_helpers

+// -*- C++ -*-
+//===----------------------- __ranges_enable_helpers ----------------------===//
+//
+// 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_ENABLE_HELPERS
+#define _LIBCPP___RANGES_ENABLE_HELPERS
+
+// These customization variables are used in <span> and <string_view>. The
+// separate header is used to avoid including the entire <ranges> header in
+// <span> and <string_view>.
+
+/*
+
+namespace std::ranges {
+  // [range.range], ranges
+  template<class T>
+    inline constexpr bool enable_borrowed_range = false;
+
+  // [range.view], views
+  template<class T>
+    inline constexpr bool enable_view = see below;
+
+  struct view_base { };
+}
+
+*/
+
+#include <__config>
+
+#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
+
+namespace ranges
+{
+
+// [range.range], ranges
+
+template<class>
+inline _LIBCPP_INLINE_VISIBILITY constexpr
+bool enable_borrowed_range = false;
+
+} // namespace ranges
+
+#endif //_LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_ENABLE_HELPERS

libcxx/include/module.modulemap

module queue {
     export initializer_list
     export *
   }
   module random {
     header "random"
     export initializer_list
     export *
   }
+  module ranges {
+    header "ranges"
+    export __ranges_enable_helpers
+    export *
+  }
   module ratio {
     header "ratio"
     export *
   }
   module regex {
     header "regex"
     export initializer_list
     export *
module std [system] {
   // FIXME: These should be private.
   module __bit_reference { header "__bit_reference" export * }
   module __debug { header "__debug" export * }
   module __errc { header "__errc" export * }
   module __functional_base { header "__functional_base" export * }
   module __hash_table { header "__hash_table" export * }
   module __locale { header "__locale" export * }
   module __mutex_base { header "__mutex_base" export * }
+  module __ranges_enable_helpers { header "__ranges_enable_helpers" export * }
   module __split_buffer { header "__split_buffer" export * }
   module __sso_allocator { header "__sso_allocator" export * }
   module __std_stream { header "__std_stream" export * }
   module __string { header "__string" export * }
   module __tree { header "__tree" export * }
   module __tuple { header "__tuple" export * }
   module __undef_macros { header "__undef_macros" export * }
   module __node_handle { header "__node_handle" export * }

libcxx/include/ranges

+// -*- C++ -*-
+//===--------------------------- ranges -----------------------------------===//
+//
+// 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
+#define _LIBCPP_RANGES
+
+/*
+
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
+#include <iterator>             // see [iterator.synopsis]
+
+namespace std::ranges {
+  inline namespace unspecified {
+    // [range.access], range access
+    inline constexpr unspecified begin = unspecified;
+    inline constexpr unspecified end = unspecified;
+    inline constexpr unspecified cbegin = unspecified;
+    inline constexpr unspecified cend = unspecified;
+    inline constexpr unspecified rbegin = unspecified;
+    inline constexpr unspecified rend = unspecified;
+    inline constexpr unspecified crbegin = unspecified;
+    inline constexpr unspecified crend = unspecified;
+
+    inline constexpr unspecified size = unspecified;
+    inline constexpr unspecified ssize = unspecified;
+    inline constexpr unspecified empty = unspecified;
+    inline constexpr unspecified data = unspecified;
+    inline constexpr unspecified cdata = unspecified;
+  }
+
+  // [range.range], ranges
+  template<class T>
+    concept range = see below;
+
+  template<class T>
+    inline constexpr bool enable_borrowed_range = false;
+
+  template<class T>
+    concept borrowed_range = see below;
+
+  template<class T>
+    using iterator_t = decltype(ranges::begin(declval<T&>()));
+  template<range R>
+    using sentinel_t = decltype(ranges::end(declval<R&>()));
+  template<range R>
+    using range_difference_t = iter_difference_t<iterator_t<R>>;
+  template<sized_range R>
+    using range_size_t = decltype(ranges::size(declval<R&>()));
+  template<range R>
+    using range_value_t = iter_value_t<iterator_t<R>>;
+  template<range R>
+    using range_reference_t = iter_reference_t<iterator_t<R>>;
+  template<range R>
+    using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;
+
+  // [range.sized], sized ranges
+  template<class>
+    inline constexpr bool disable_sized_range = false;
+
+  template<class T>
+    concept sized_range = see below;
+
+  // [range.view], views
+  template<class T>
+    inline constexpr bool enable_view = see below;
+
+  struct view_base { };
+
+  template<class T>
+    concept view = see below;
+
+  // [range.refinements], other range refinements
+  template<class R, class T>
+    concept output_range = see below;
+
+  template<class T>
+    concept input_range = see below;
+
+  template<class T>
+    concept forward_range = see below;
+
+  template<class T>
+    concept bidirectional_range = see below;
+
+  template<class T>
+    concept random_access_range = see below;
+
+  template<class T>
+    concept contiguous_range = see below;
+
+  template<class T>
+    concept common_range = see below;
+
+  template<class T>
+    concept viewable_range = see below;
+
+  // [view.interface], class template view_interface
+  template<class D>
+    requires is_class_v<D> && same_as<D, remove_cv_t<D>>
+  class view_interface;
+
+  // [range.subrange], sub-ranges
+  enum class subrange_kind : bool { unsized, sized };
+
+  template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K = see below>
+    requires (K == subrange_kind::sized || !sized_sentinel_for<S, I>)
+  class subrange;
+
+  template<input_or_output_iterator I, sentinel_for<I> S, subrange_kind K>
+    inline constexpr bool enable_borrowed_range<subrange<I, S, K>> = true;
+
+  // [range.dangling], dangling iterator handling
+  struct dangling;
+
+  template<range R>
+    using borrowed_iterator_t = conditional_t<borrowed_range<R>, iterator_t<R>, dangling>;
+
+  template<range R>
+    using borrowed_subrange_t =
+      conditional_t<borrowed_range<R>, subrange<iterator_t<R>>, dangling>;
+
+  // [range.empty], empty view
+  template<class T>
+    requires is_object_v<T>
+  class empty_view;
+
+  template<class T>
+    inline constexpr bool enable_borrowed_range<empty_view<T>> = true;
+
+  namespace views {
+    template<class T>
+      inline constexpr empty_view<T> empty{};
+  }
+
+  // [range.single], single view
+  template<copy_constructible T>
+    requires is_object_v<T>
+  class single_view;
+
+  namespace views { inline constexpr unspecified single = unspecified; }
+
+  // [range.iota], iota view
+  template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
+    requires weakly-equality-comparable-with<W, Bound> && semiregular<W>
+  class iota_view;
+
+  template<weakly_incrementable W, semiregular Bound>
+    inline constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true;
+
+  namespace views { inline constexpr unspecified iota = unspecified; }
+
+  // [range.istream], istream view
+  template<movable Val, class CharT, class Traits = char_traits<CharT>>
+    requires see below
+  class basic_istream_view;
+  template<class Val, class CharT, class Traits>
+    basic_istream_view<Val, CharT, Traits> istream_view(basic_istream<CharT, Traits>& s);
+
+  // [range.all], all view
+  namespace views {
+    inline constexpr unspecified all = unspecified;
+
+    template<viewable_range R>
+      using all_t = decltype(all(declval<R>()));
+  }
+
+  template<range R>
+    requires is_object_v<R>
+  class ref_view;
+
+  template<class T>
+    inline constexpr bool enable_borrowed_range<ref_view<T>> = true;
+
+  // [range.filter], filter view
+  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
+    requires view<V> && is_object_v<Pred>
+  class filter_view;
+
+  namespace views { inline constexpr unspecified filter = unspecified; }
+
+  // [range.transform], transform view
+  template<input_range V, copy_constructible F>
+    requires view<V> && is_object_v<F> &&
+             regular_invocable<F&, range_reference_t<V>> &&
+             can-reference<invoke_result_t<F&, range_reference_t<V>>>
+  class transform_view;
+
+  namespace views { inline constexpr unspecified transform = unspecified; }
+
+  // [range.take], take view
+  template<view> class take_view;
+
+  namespace views { inline constexpr unspecified take = unspecified; }
+
+  // [range.take.while], take while view
+  template<view V, class Pred>
+    requires input_range<V> && is_object_v<Pred> &&
+             indirect_unary_predicate<const Pred, iterator_t<V>>
+    class take_while_view;
+
+  namespace views { inline constexpr unspecified take_while = unspecified; }
+
+  // [range.drop], drop view
+  template<view V>
+    class drop_view;
+
+  namespace views { inline constexpr unspecified drop = unspecified; }
+
+  // [range.drop.while], drop while view
+  template<view V, class Pred>
+    requires input_range<V> && is_object_v<Pred> &&
+             indirect_unary_predicate<const Pred, iterator_t<V>>
+    class drop_while_view;
+
+  namespace views { inline constexpr unspecified drop_while = unspecified; }
+
+  // [range.join], join view
+  template<input_range V>
+    requires view<V> && input_range<range_reference_t<V>> &&
+             (is_reference_v<range_reference_t<V>> ||
+              view<range_value_t<V>>)
+  class join_view;
+
+  namespace views { inline constexpr unspecified join = unspecified; }
+
+  // [range.split], split view
+  template<class R>
+    concept tiny-range = see below;   // exposition only
+
+  template<input_range V, forward_range Pattern>
+    requires view<V> && view<Pattern> &&
+             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
+             (forward_range<V> || tiny-range<Pattern>)
+  class split_view;
+
+  namespace views { inline constexpr unspecified split = unspecified; }
+
+  // [range.counted], counted view
+  namespace views { inline constexpr unspecified counted = unspecified; }
+
+  // [range.common], common view
+  template<view V>
+    requires (!common_range<V> && copyable<iterator_t<V>>)
+  class common_view;
+
+  namespace views { inline constexpr unspecified common = unspecified; }
+
+  // [range.reverse], reverse view
+  template<view V>
+    requires bidirectional_range<V>
+  class reverse_view;
+
+  namespace views { inline constexpr unspecified reverse = unspecified; }
+
+  // [range.elements], elements view
+  template<input_range V, size_t N>
+    requires see below
+  class elements_view;
+
+  template<class R>
+    using keys_view = elements_view<views::all_t<R>, 0>;
+  template<class R>
+    using values_view = elements_view<views::all_t<R>, 1>;
+
+  namespace views {
+    template<size_t N>
+      inline constexpr unspecified elements = unspecified ;
+    inline constexpr auto keys = elements<0>;
+    inline constexpr auto values = elements<1>;
+  }
+}
+
+namespace std {
+  namespace views = ranges::views;
+
+  template<class I, class S, ranges::subrange_kind K>
+  struct tuple_size<ranges::subrange<I, S, K>>
+    : integral_constant<size_t, 2> {};
+  template<class I, class S, ranges::subrange_kind K>
+  struct tuple_element<0, ranges::subrange<I, S, K>> {
+    using type = I;
+  };
+  template<class I, class S, ranges::subrange_kind K>
+  struct tuple_element<1, ranges::subrange<I, S, K>> {
+    using type = S;
+  };
+  template<class I, class S, ranges::subrange_kind K>
+  struct tuple_element<0, const ranges::subrange<I, S, K>> {
+    using type = I;
+  };
+  template<class I, class S, ranges::subrange_kind K>
+  struct tuple_element<1, const ranges::subrange<I, S, K>> {
+    using type = S;
+  };
+}
+
+*/
+
+#include <__config>
+#include <__ranges_enable_helpers>
+#include <compare>          // Required by the standard.
+#include <initializer_list> // Required by the standard.
+#include <iterator>         // Required by the standard.
+#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
+
+#if _LIBCPP_STD_VER > 17
+
+namespace ranges
+{
+
+} // namespace ranges
+
+#endif //_LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_RANGES

libcxx/include/span

 
 // constants
 inline constexpr size_t dynamic_extent = numeric_limits<size_t>::max();
 
 // [views.span], class template span
 template <class ElementType, size_t Extent = dynamic_extent>
     class span;
 
+template<class ElementType, size_t Extent>
+    inline constexpr bool ranges::enable_view<span<ElementType, Extent>> =
+      Extent == 0 || Extent == dynamic_extent;
+template<class ElementType, size_t Extent>
+    inline constexpr bool ranges::enable_borrowed_range<span<ElementType, Extent>> = true;
+
 // [span.objectrep], views of object representation
 template <class ElementType, size_t Extent>
     span<const byte, ((Extent == dynamic_extent) ? dynamic_extent :
         (sizeof(ElementType) * Extent))> as_bytes(span<ElementType, Extent> s) noexcept;
 
 template <class ElementType, size_t Extent>
     span<      byte, ((Extent == dynamic_extent) ? dynamic_extent :
         (sizeof(ElementType) * Extent))> as_writable_bytes(span<ElementType, Extent> s) noexcept;
 
 
-namespace std {
 template <class ElementType, size_t Extent = dynamic_extent>
 class span {
 public:
     // constants and types
     using element_type = ElementType;
     using value_type = remove_cv_t<ElementType>;
     using size_type = size_t;
     using difference_type = ptrdiff_t;

 template<class Container>
     span(const Container&) -> span<const typename Container::value_type>;
 
 } // namespace std
 
 */
 
 #include <__config>
+#include <__ranges_enable_helpers>
 #include <array>        // for array
 #include <cstddef>      // for byte
 #include <iterator>     // for iterators
 #include <type_traits>  // for remove_cv, etc
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
// [span.iter], span iterator support
     _LIBCPP_INLINE_VISIBILITY span<byte, dynamic_extent> __as_writable_bytes() const noexcept
     { return {reinterpret_cast<byte *>(data()), size_bytes()}; }
 
 private:
     pointer   __data;
     size_type __size;
 };
 
+template<class _Tp, size_t _Extent>
+inline _LIBCPP_INLINE_VISIBILITY constexpr
+bool _VSTD::ranges::enable_borrowed_range<span<_Tp, _Extent>> = true;
+
 //  as_bytes & as_writable_bytes
 template <class _Tp, size_t _Extent>
 _LIBCPP_INLINE_VISIBILITY
 auto as_bytes(span<_Tp, _Extent> __s) noexcept
 -> decltype(__s.__as_bytes())
 { return    __s.__as_bytes(); }
 
 template <class _Tp, size_t _Extent>

libcxx/include/string_view

 string_view synopsis
 
 namespace std {
 
     // 7.2, Class template basic_string_view
     template<class charT, class traits = char_traits<charT>>
         class basic_string_view;
 
+    template<class charT, class traits>
+    inline constexpr bool ranges::enable_view<basic_string_view<charT, traits>> = true;  // C++20
+    template<class charT, class traits>
+    inline constexpr bool ranges::enable_borrowed_range<basic_string_view<charT, traits>> = true;  // C++20
+
     // 7.9, basic_string_view non-member comparison functions
     template<class charT, class traits>
     constexpr bool operator==(basic_string_view<charT, traits> x,
                               basic_string_view<charT, traits> y) noexcept;
     template<class charT, class traits>
     constexpr bool operator!=(basic_string_view<charT, traits> x,
                               basic_string_view<charT, traits> y) noexcept;
     template<class charT, class traits>
namespace std {
   constexpr basic_string_view<char32_t> operator "" sv( const char32_t *str, size_t len ) noexcept;
 
 }  // namespace std
 
 
 */
 
 #include <__config>
+#include <__ranges_enable_helpers>
 #include <__string>
 #include <iosfwd>
 #include <algorithm>
 #include <iterator>
 #include <limits>
 #include <stdexcept>
 #include <version>
 #include <__debug>
#if _LIBCPP_STD_VER > 17
     { return ends_with(basic_string_view(__s)); }
 #endif
 
 private:
     const   value_type* __data;
     size_type           __size;
 };
 
+#if _LIBCPP_STD_VER > 17
+template <class _CharT, class _Traits>
+inline _LIBCPP_INLINE_VISIBILITY constexpr
+bool _VSTD::ranges::enable_borrowed_range<
+    basic_string_view<_CharT, _Traits> > = true;
+#endif
 
 // [string.view.comparison]
 // operator ==
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator==(basic_string_view<_CharT, _Traits> __lhs,
                 basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {

libcxx/test/libcxx/double_include.sh.cpp

 #include <mutex>
 #endif
 #include <new>
 #include <numbers>
 #include <numeric>
 #include <optional>
 #include <queue>
 #include <random>
+#include <ranges>
 #include <ratio>
 #include <scoped_allocator>
 #include <set>
 #include <setjmp.h>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <shared_mutex>
 #endif
 #include <span>

libcxx/test/libcxx/ranges/version.compile.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
+//
+//===----------------------------------------------------------------------===//
+
+// <ranges>
+
+#include <ranges>
+
+#include "test_macros.h"
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+// Required for MSVC internal test runner compatibility.
+int main(int, char**)
+{
+  return 0;
+}

libcxx/test/std/containers/views/enable_borrowed_range.compile.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
+
+// <span>
+
+// template<class ElementType, size_t Extent>
+// inline constexpr bool ranges::enable_borrowed_range<
+//     span<ElementType, Extent>> = true;
+
+#include <span>
+
+#include "test_macros.h"
+
+template <typename T>
+void test()
+{
+    using std::ranges::enable_borrowed_range;
+    using std::span;
+    using std::dynamic_extent;
+
+    static_assert(enable_borrowed_range<span<               T, 0>>);
+    static_assert(enable_borrowed_range<span<const          T, 0>>);
+    static_assert(enable_borrowed_range<span<const volatile T, 0>>);
+    static_assert(enable_borrowed_range<span<const volatile T, 0>>);
+
+    static_assert(enable_borrowed_range<span<               T, 1>>);
+    static_assert(enable_borrowed_range<span<const          T, 1>>);
+    static_assert(enable_borrowed_range<span<const volatile T, 1>>);
+    static_assert(enable_borrowed_range<span<const volatile T, 1>>);
+
+    static_assert(enable_borrowed_range<span<               T, dynamic_extent>>);
+    static_assert(enable_borrowed_range<span<const          T, dynamic_extent>>);
+    static_assert(enable_borrowed_range<span<const volatile T, dynamic_extent>>);
+    static_assert(enable_borrowed_range<span<const volatile T, dynamic_extent>>);
+}
+
+struct S{};
+
+int main(int, char**)
+{
+    test<char>();
+    test<int>();
+    test<double>();
+    test<S>();
+    test<char*>();
+
+    return 0;
+}

libcxx/test/std/ranges/range.range/enable_borrowed_range.compile.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
+
+// <ranges>
+
+// template<class>
+//  inline constexpr bool enable_borrowed_range = false;
+
+#include <ranges>
+#include <array>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <queue>
+#include <set>
+#include <stack>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "test_macros.h"
+
+struct S{};
+
+int main(int, char**)
+{
+    using std::ranges::enable_borrowed_range;
+    static_assert(!enable_borrowed_range<char>);
+    static_assert(!enable_borrowed_range<int>);
+    static_assert(!enable_borrowed_range<double>);
+    static_assert(!enable_borrowed_range<S>);
+
+    // Sequence containers
+    static_assert(!enable_borrowed_range<std::array<int, 0>>);
+    static_assert(!enable_borrowed_range<std::array<int, 1>>);
+    static_assert(!enable_borrowed_range<std::deque<int>>);
+    static_assert(!enable_borrowed_range<std::forward_list<int>>);
+    static_assert(!enable_borrowed_range<std::list<int>>);
+    static_assert(!enable_borrowed_range<std::vector<int>>);
+
+    // Associative containers
+    static_assert(!enable_borrowed_range<std::set<int>>);
+    static_assert(!enable_borrowed_range<std::map<int, int>>);
+    static_assert(!enable_borrowed_range<std::multiset<int>>);
+    static_assert(!enable_borrowed_range<std::multimap<int, int>>);
+
+    // Unordered associative containers
+    static_assert(!enable_borrowed_range<std::unordered_set<int>>);
+    static_assert(!enable_borrowed_range<std::unordered_map<int, int>>);
+    static_assert(!enable_borrowed_range<std::unordered_multiset<int>>);
+    static_assert(!enable_borrowed_range<std::unordered_multimap<int, int>>);
+
+    // Container adaptors
+    static_assert(!enable_borrowed_range<std::stack<int>>);
+    static_assert(!enable_borrowed_range<std::queue<int>>);
+    static_assert(!enable_borrowed_range<std::priority_queue<int>>);
+
+    // Both std::span and std::string_view have their own test.
+
+    return 0;
+}

libcxx/test/std/strings/string.view/enable_borrowed_range.compile.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
+
+// <string_view>
+
+// template<class charT, class traits>
+// inline constexpr bool ranges::enable_borrowed_range<
+//     basic_string_view<charT, traits>> = true;
+
+#include <string_view>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    using std::ranges::enable_borrowed_range;
+    static_assert(enable_borrowed_range<std::basic_string_view<char>>);
+    static_assert(enable_borrowed_range<std::basic_string_view<wchar_t>>);
+    static_assert(enable_borrowed_range<std::basic_string_view<char8_t>>);
+
+    return 0;
+}

libcxx/www/cxx2a_status.html

-->
   <tr><td><a href="https://wg21.link/P0482R6">P0482R6</a></td><td>CWG</td><td>char8_t: A type for UTF-8 characters and strings</td><td>San Diego</td><td><i>In Progress</i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0487R1">P0487R1</a></td><td>LWG</td><td>Fixing operator&gt;&gt;(basic_istream&amp;, CharT*) (LWG 2499)</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
   <tr><td><a href="https://wg21.link/P0591R4">P0591R4</a></td><td>LWG</td><td>Utility functions to implement uses-allocator construction</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0595R2">P0595R2</a></td><td>CWG</td><td>P0595R2 std::is_constant_evaluated()</td><td>San Diego</td><td>Complete</td><td>9.0</td></tr>
   <tr><td><a href="https://wg21.link/P0602R4">P0602R4</a></td><td>LWG</td><td>variant and optional should propagate copy/move triviality</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
   <tr><td><a href="https://wg21.link/P0608R3">P0608R3</a></td><td>LWG</td><td>A sane variant converting constructor</td><td>San Diego</td><td>Complete</td><td>9.0</td></tr>
   <tr><td><a href="https://wg21.link/P0655R1">P0655R1</a></td><td>LWG</td><td>visit&lt;R&gt;: Explicit Return Type for visit</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0771R1">P0771R1</a></td><td>LWG</td><td>std::function move constructor should be noexcept</td><td>San Diego</td><td>Complete</td><td>6.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0896R4">P0896R4</a></td><td>LWG</td><td>The One Ranges Proposal</td><td>San Diego</td><td><i> </i></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P0896R4">P0896R4</a></td><td>LWG</td><td>The One Ranges Proposal</td><td>San Diego</td><td><i>In progress</i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0899R1">P0899R1</a></td><td>LWG</td><td>P0899R1 - LWG 3016 is not a defect</td><td>San Diego</td><td><i>Nothing to do</i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0919R3">P0919R3</a></td><td>LWG</td><td>Heterogeneous lookup for unordered containers</td><td>San Diego</td><td>Complete</td><td>12.0</td></tr>
   <tr><td><a href="https://wg21.link/P0972R0">P0972R0</a></td><td>LWG</td><td>&lt;chrono&gt; <tt>zero()</tt>, <tt>min()</tt>, and <tt>max()</tt> should be noexcept</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
   <tr><td><a href="https://wg21.link/P1006R1">P1006R1</a></td><td>LWG</td><td>Constexpr in std::pointer_traits</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
   <tr><td><a href="https://wg21.link/P1007R3">P1007R3</a></td><td>LWG</td><td><tt>std::assume_aligned</tt></td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1020R1">P1020R1</a></td><td>LWG</td><td>Smart pointer creation with default initialization</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1032R1">P1032R1</a></td><td>LWG</td><td>Misc constexpr bits</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1085R2">P1085R2</a></td><td>LWG</td><td>Should Span be Regular?</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
-->
   <tr><td><a href="https://wg21.link/P1720">P1720</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 28 - Localization library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1721">P1721</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 29 - Input/Output library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1722">P1722</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 30 - Regular Expression library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1723">P1723</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 31 - Atomics library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1855">P1855</a></td><td>LWG</td><td>Make <tt>&lt;compare&gt;</tt> freestanding</td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1862">P1862</a></td><td>LWG</td><td>Ranges adaptors for non-copyable iterators </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1865">P1865</a></td><td>LWG</td><td>Add max() to latch and barrier </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1869">P1869</a></td><td>LWG</td><td>Rename 'condition_variable_any' interruptible wait methods </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1870">P1870</a></td><td>LWG</td><td>forwarding-range is too subtle </td><td>Belfast</td><td><i> </i></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P1870">P1870</a></td><td>LWG</td><td>forwarding-range is too subtle </td><td>Belfast</td><td><i>In progress</i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1871">P1871</a></td><td>LWG</td><td>Should concepts be enabled or disabled? </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1872">P1872</a></td><td>LWG</td><td>span should have size_type, not index_type </td><td>Belfast</td><td>Complete</td><td>10.0</td></tr>
   <tr><td><a href="https://wg21.link/P1878">P1878</a></td><td>LWG</td><td>Constraining Readable Types </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1892">P1892</a></td><td>LWG</td><td>Extended locale-specific presentation specifiers for std::format </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1902">P1902</a></td><td>LWG</td><td>Missing feature-test macros 2018-2019 </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1959">P1959</a></td><td>LWG</td><td>Remove std::weak_equality and std::strong_equality</td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1960">P1960</a></td><td>LWG</td><td>NB Comment Changes Reviewed by SG1</td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1961">P1961</a></td><td>LWG</td><td>Harmonizing the definitions of total order for pointers</td><td>Belfast</td><td><i> </i></td><td></td></tr>
-->
   <tr><td><a href="https://wg21.link/LWG3367">3367</a></td><td>Integer-class conversions should not throw</td><td>Prague</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3369">3369</a></td><td><tt>span</tt>'s deduction-guide for built-in arrays doesn't work</td><td>Prague</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3371">3371</a></td><td><tt>visit_format_arg</tt> and <tt>make_format_args</tt> are not hidden friends</td><td>Prague</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3372">3372</a></td><td><tt>vformat_to</tt> should not try to deduce <tt>Out</tt> twice</td><td>Prague</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3373">3373</a></td><td><tt>{to,from}_chars_result</tt> and <tt>format_to_n_result</tt> need the  "we really mean what we say" wording</td><td>Prague</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3374">3374</a></td><td>P0653 + P1006 should have made the other <tt>std::to_address</tt> overload <tt>constexpr</tt></td><td>Prague</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3375">3375</a></td><td><tt>decay</tt> in <tt>viewable_range</tt> should be <tt>remove_cvref</tt></td><td>Prague</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3377">3377</a></td><td><tt>elements_view::iterator</tt> befriends a specialization of itself</td><td>Prague</td><td></td></tr>
-  <tr><td><a href="https://wg21.link/LWG3379">3379</a></td><td>"<tt>safe</tt>" in several library names is misleading</td><td>Prague</td><td></td></tr>
+  <tr><td><a href="https://wg21.link/LWG3379">3379</a></td><td>"<tt>safe</tt>" in several library names is misleading</td><td>Prague</td><i>In progress</i><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3380">3380</a></td><td><tt>common_type</tt> and comparison categories</td><td>Prague</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3381">3381</a></td><td><tt>begin</tt> and <tt>data</tt> must agree for <tt>contiguous_range</tt></td><td>Prague</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3382">3382</a></td><td>NTTP for <tt>pair</tt> and <tt>array</tt></td><td>Prague</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3383">3383</a></td><td>&sect;[time.zone.leap.nonmembers] <tt>sys_seconds</tt> should be replaced with <tt>seconds</tt></td><td>Prague</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3384">3384</a></td><td><tt>transform_view::<i>sentinel</i></tt> has an incorrect <tt>operator-</tt></td><td>Prague</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3385">3385</a></td><td><tt>common_iterator</tt> is not sufficiently constrained for non-copyable iterators</td><td>Prague</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3387">3387</a></td><td>&sect;[range.reverse.view] <tt>reverse_view&lt;V&gt;</tt> unintentionally requires <tt>range&lt;const V&gt;</tt></td><td>Prague</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG3388">3388</a></td><td><tt>view</tt> iterator types have ill-formed <tt>&lt;=&gt;</tt> operators</td><td>Prague</td><td></td></tr>