[libc++][ranges] implement `std::views::istream`

[huixie90]

Summary

implement std::ranges::basic_istream_view and std::views::istream. Although the view itself is constexpr,
the constructor argument is a base class std::istream where its ctor/dtor are not constexpr. So no tests are performed in
constexpr

After the discussion with Louis and a survey of other implementations, only <iosfwd> is included in the header. As a result, istream_view cannot be used by just including <ranges>. Even a declaration would result in error.

#include <ranges>
void f(std::ranges::istream_view<int>);  // error. It does not pass concept check because `>>` is defined in <istream>

User will need to include <istream> to be able to use it.

[Mordante]

I mainly looked at it out of curiosity and didn't do a full review.

libcxx/docs/Status/Cxx20Papers.csv

111

We don't add a version number for In progress items.

111

How about adding the details of the status to the ranges status page?

[huixie90]

address review feedback

[philnik]

I haven't looked very closely at the tests yet.

libcxx/docs/Status/Cxx20Papers.csv

111

If the paper is in-progress we shouldn't have a release version here. (I know it's that way in a few other places, but the numbers are completely useless)

libcxx/include/__ranges/istream_view.h

32

We want to use >= for the version checks now. I'd also move the version check outside the std namespace. It probably doesn't make much of a difference w.r.t. parsing speed, but it really doesn't hurt either.

51

_LIBCPP_HIDE_FROM_ABI

57

Probably doesn't do much, but doesn't hurt either.

105

I'm not sure the extra indirection is worth it. Why do you need to strip cv-qualifiers at all?

libcxx/test/std/ranges/range.factories/range.istream.view/begin.pass.cpp

14

AFAIK we don't separate the tested header from the other ones.

libcxx/test/std/ranges/range.factories/range.istream.view/general.pass.cpp

21

libcxx/test/std/ranges/range.factories/range.istream.view/iterator/deref.pass.cpp

50

missing newline

libcxx/test/std/ranges/range.factories/range.istream.view/iterator/member_types.compile.pass.cpp

25

Could you also test a valid one?

libcxx/test/std/ranges/range.factories/range.istream.view/range.concept.compile.pass.cpp

16

Why don't you test Traits in any way?

[huixie90]

addressed feedback

libcxx/include/__ranges/istream_view.h

105

Because usually _Up is deduced to std::istringstream&, and a reference type doesn't have nested member typedef typename _Up::char_type
Note I have to strip cv for this reason in lots of places within this function

libcxx/test/std/ranges/range.factories/range.istream.view/range.concept.compile.pass.cpp

16

The standard doesn't have any constraint on Traits other than being used in std::basic_istream<CharT, Traits>. However, basic_istream is a classic template which isn't constrained. passing an invalid Traits to std::basic_istream would just hard error. so
static_assert(!HasIstreamView<int, char, NotTraits>) would just hard error

[huixie90]

fix CI

[huixie90]

added transitive includes to istream

[ldionne]

This looks pretty good!

libcxx/docs/Status/RangesIssues.csv

1 ↗

(On Diff #458651)

Not for this review: I think we should get rid of this file entirely, since it's only a duplicate of information we already have in CXXYZIssues.csv?

libcxx/docs/Status/RangesPaper.csv

162

The plan was also to get rid of this file once the One Ranges Proposal had been completed. It was basically used to track sub parts of the One Ranges Proposal.

@var-const WDYT, can we remove this now?

libcxx/include/__ranges/istream_view.h

43

Can you confirm whether you have a test that this is explicit?

51

Do you have a test that this is noexcept?

72

I think this is a great "catch", in the sense that we usually forget to use _LIBCPP_HIDE_FROM_ABI on = default functions, but we should.

101–102

#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
...
#endif

You will probably need to update the tests with that in mind, too? The test macro to use is:

#ifndef TEST_HAS_NO_WIDE_CHARACTERS
...
#endif

If you have a test that is *only* meaningful for wide characters (e.g. the test file is only checking wchar_t related stuff), then you can use // UNSUPPORTED: no-wide-characters to disable the whole test in that case. That's better than wrapping the whole test with #ifndef TEST_HAS_NO_WIDE_CHARACTERS.

This is tested in the CI, so I would assume this would have failed in the CI (although our CI is not perfect in that regard because it uses a platform that actually provides wchar_t but we make it an error to include <wchar.h>).

113

I *think* this should be constexpr, although I'm not sure this is observable.

libcxx/test/std/ranges/range.factories/range.istream.view/begin.pass.cpp

2

General comment that applies to (probably) all tests: let's make sure we also test wchar_t and wistream_view. You should probably templatize your tests on CharT and use a mechanism similar to what @Mordante does for format.

[var-const]

I have just a few nitpicks; LGTM once the existing feedback is addressed.

libcxx/docs/Status/RangesPaper.csv

162

Yes, I'll do it next week.

libcxx/include/__ranges/istream_view.h

57

Can you add a libc++-specific test for this optimization?

libcxx/test/std/ranges/range.factories/range.istream.view/iterator/increment.pass.cpp

49

Nit: return 0; (here and elsewhere).

libcxx/test/std/ranges/range.factories/range.istream.view/iterator/member_types.compile.pass.cpp

16

Nit: unnecessary blank line.

libcxx/test/std/ranges/range.factories/range.istream.view/range.concept.compile.pass.cpp

21

Nit: unmovable Val?

22

Ultranit: s/UnMovable/Unmovable/.

[huixie90]

address feedback

[huixie90]

rebase

[huixie90]

fix Ci

[huixie90]

next try

[Mordante]

I didn't do a review, but mainly had a look why the CI fails.

libcxx/include/module.modulemap.in

1016

See the comment in ranges why this should be disabled when localization is disabled.

libcxx/include/ranges

304

Maybe move this to the end. This header "works", but can't be used when localization isn't enabled. The header includes <iosfwd> which is fine when no locales are used. However when using the "contents" of the istream_view.h header you need to include <istream>, which indirectly includes <ios> and results in an error in that header on line 216.

So I think it would be best to not provide this header when localization is disable.

I use a similar approach in <chrono> where I don't include headers when localization is disabled. (There are more conditions there, but localization is a reason on itself.)

libcxx/test/libcxx/ranges/range.factories/range.istream.view/no_unique_address.compile.pass.cpp

10

The same for the other tests.

libcxx/test/std/ranges/range.factories/range.istream.view/begin.pass.cpp

26

This macro is never defined since "test_macros.h" isn't included.

[huixie90]

Fix CI

[huixie90]

next try

[ldionne]

libcxx/docs/Status/RangesPaper.csv

162

Newline!

libcxx/test/std/ranges/range.factories/range.istream.view/utils.h

9

For functions we generally use snake_case, although we might not be 100% consistent everywhere. I think it would still be better to try to stick to snake_case.

[huixie90]

rebase

libcxx/docs/Status/Cxx20Issues.csv

 "`3385 <https://wg21.link/LWG3385>`__","``common_iterator``\  is not sufficiently constrained for non-copyable iterators","Prague","|Complete|","15.0","|ranges|"
 "`3387 <https://wg21.link/LWG3387>`__","|sect|\ [range.reverse.view] ``reverse_view<V>``\  unintentionally requires ``range<const V>``\ ","Prague","|Complete|","15.0","|ranges|"
 "`3388 <https://wg21.link/LWG3388>`__","``view``\  iterator types have ill-formed ``<=>``\  operators","Prague","","","|ranges|"
 "`3389 <https://wg21.link/LWG3389>`__","A move-only iterator still does not have a ``counted_iterator``\ ","Prague","|Complete|","15.0","|ranges|"
 "`3390 <https://wg21.link/LWG3390>`__","``make_move_iterator()``\  cannot be used to construct a ``move_iterator``\  for a move-only iterator","Prague","|Complete|","14.0","|ranges|"
 "`3393 <https://wg21.link/LWG3393>`__","Missing/incorrect feature test macro for coroutines","Prague","|Complete|","14.0"
 "`3395 <https://wg21.link/LWG3395>`__","Definition for three-way comparison needs to be updated (US 152)","Prague","","","|spaceship|"
 "`3396 <https://wg21.link/LWG3396>`__","Clarify point of reference for ``source_location::current()``\  (DE 169)","Prague","",""
-"`3397 <https://wg21.link/LWG3397>`__","``ranges::basic_istream_view::iterator``\  should not provide ``iterator_category``\ ","Prague","","","|ranges|"
+"`3397 <https://wg21.link/LWG3397>`__","``ranges::basic_istream_view::iterator``\  should not provide ``iterator_category``\ ","Prague","|Complete|","16.0","|ranges|"
 "`3398 <https://wg21.link/LWG3398>`__","``tuple_element_t``\  is also wrong for ``const subrange``\ ","Prague","|Complete|","14.0","|ranges|"
 "`3446 <https://wg21.link/LWG3446>`__","``indirectly_readable_traits``\ ambiguity for types with both ``value_type``\ and ``element_type``\ ","November virtual meeting","|Complete|","13.0"

libcxx/docs/Status/Cxx20Papers.csv

 "`P0466R5 <https://wg21.link/P0466R5>`__","LWG","Layout-compatibility and Pointer-interconvertibility Traits","Cologne","",""
 "`P0553R4 <https://wg21.link/P0553R4>`__","LWG","Bit operations","Cologne","|Complete|","9.0"
 "`P0631R8 <https://wg21.link/P0631R8>`__","LWG","Math Constants","Cologne","|Complete|","11.0"
 "`P0645R10 <https://wg21.link/P0645R10>`__","LWG","Text Formatting","Cologne","|Complete| [#note-P0645]_","14.0"
 "`P0660R10 <https://wg21.link/P0660R10>`__","LWG","Stop Token and Joining Thread, Rev 10","Cologne","",""
 "`P0784R7 <https://wg21.link/P0784R7>`__","CWG","More constexpr containers","Cologne","|Complete|","12.0"
 "`P0980R1 <https://wg21.link/P0980R1>`__","LWG","Making std::string constexpr","Cologne","|Complete|","15.0"
 "`P1004R2 <https://wg21.link/P1004R2>`__","LWG","Making std::vector constexpr","Cologne","|Complete|","15.0"
-"`P1035R7 <https://wg21.link/P1035R7>`__","LWG","Input Range Adaptors","Cologne","",""
+"`P1035R7 <https://wg21.link/P1035R7>`__","LWG","Input Range Adaptors","Cologne","|In Progress|",""
 "`P1065R2 <https://wg21.link/P1065R2>`__","LWG","Constexpr INVOKE","Cologne","|Complete|","12.0"
 "`P1135R6 <https://wg21.link/P1135R6>`__","LWG","The C++20 Synchronization Library","Cologne","|Complete|","11.0"
 "`P1207R4 <https://wg21.link/P1207R4>`__","LWG","Movability of Single-pass Iterators","Cologne","|Complete|","15.0"
 "`P1208R6 <https://wg21.link/P1208R6>`__","LWG","Adopt source_location for C++20","Cologne","",""
 "`P1355R2 <https://wg21.link/P1355R2>`__","LWG","Exposing a narrow contract for ceil2","Cologne","|Complete|","9.0"
 "`P1361R2 <https://wg21.link/P1361R2>`__","LWG","Integration of chrono with text formatting","Cologne","|In Progress|",""
 "`P1423R3 <https://wg21.link/P1423R3>`__","LWG","char8_t backward compatibility remediation","Cologne","|Complete|","15.0"
 "`P1424R1 <https://wg21.link/P1424R1>`__","LWG","'constexpr' feature macro concerns","Cologne","Superseded by `P1902 <https://wg21.link/P1902>`__",""
 "`P1466R3 <https://wg21.link/P1466R3>`__","LWG","Miscellaneous minor fixes for chrono","Cologne","",""
 "`P1474R1 <https://wg21.link/P1474R1>`__","LWG","Helpful pointers for ContiguousIterator","Cologne","|Complete|","15.0"
 "`P1502R1 <https://wg21.link/P1502R1>`__","LWG","Standard library header units for C++20","Cologne","",""
 "`P1522R1 <https://wg21.link/P1522R1>`__","LWG","Iterator Difference Type and Integer Overflow","Cologne","|Complete|","15.0"
 "`P1523R1 <https://wg21.link/P1523R1>`__","LWG","Views and Size Types","Cologne","|Complete|","15.0"
 "`P1612R1 <https://wg21.link/P1612R1>`__","LWG","Relocate Endian's Specification","Cologne","|Complete|","10.0"
 "`P1614R2 <https://wg21.link/P1614R2>`__","LWG","The Mothership has Landed","Cologne","|In Progress|",""
-"`P1638R1 <https://wg21.link/P1638R1>`__","LWG","basic_istream_view::iterator should not be copyable","Cologne","",""
+"`P1638R1 <https://wg21.link/P1638R1>`__","LWG","basic_istream_view::iterator should not be copyable","Cologne","|Complete|","16.0"
 "`P1643R1 <https://wg21.link/P1643R1>`__","LWG","Add wait/notify to atomic_ref","Cologne","",""
 "`P1644R0 <https://wg21.link/P1644R0>`__","LWG","Add wait/notify to atomic<shared_ptr>","Cologne","",""
 "`P1650R0 <https://wg21.link/P1650R0>`__","LWG","Output std::chrono::days with 'd' suffix","Cologne","",""
 "`P1651R0 <https://wg21.link/P1651R0>`__","LWG","bind_front should not unwrap reference_wrapper","Cologne","|Complete|","13.0"
 "`P1652R1 <https://wg21.link/P1652R1>`__","LWG","Printf corner cases in std::format","Cologne","|Complete|","14.0"
 "`P1661R1 <https://wg21.link/P1661R1>`__","LWG","Remove dedicated precalculated hash lookup interface","Cologne","|Nothing To Do|",""
 "`P1754R1 <https://wg21.link/P1754R1>`__","LWG","Rename concepts to standard_case for C++20, while we still can","Cologne","|In Progress|",""
 "","","","","",""

 "`P2216R3 <https://wg21.link/P2216R3>`__","LWG",std::format improvements,"June 2021","|Complete|","15.0"
 "`P2281R1 <https://wg21.link/P2281R1>`__","LWG",Clarifying range adaptor objects,"June 2021","|Complete|","14.0"
 "`P2328R1 <https://wg21.link/P2328R1>`__","LWG",join_view should join all views of ranges,"June 2021","",""
 "`P2367R0 <https://wg21.link/P2367R0>`__","LWG",Remove misuses of list-initialization from Clause 24,"June 2021","",""
 "","","","","",""
 "`P2372R3 <https://wg21.link/P2372R3>`__","LWG","Fixing locale handling in chrono formatters","October 2021","",""
 "`P2415R2 <https://wg21.link/P2415R2>`__","LWG","What is a ``view``","October 2021","|Complete|","14.0"
 "`P2418R2 <https://wg21.link/P2418R2>`__","LWG","Add support for ``std::generator``-like types to ``std::format``","October 2021","|Complete|","15.0"
-"`P2432R1 <https://wg21.link/P2432R1>`__","LWG","Fix ``istream_view``","October 2021","",""
+"`P2432R1 <https://wg21.link/P2432R1>`__","LWG","Fix ``istream_view``","October 2021","|Complete|","16.0"

libcxx/docs/Status/Cxx2bIssues.csv

 `3554 <https://wg21.link/LWG3554>`__,"``chrono::parse`` needs ``const charT*`` and ``basic_string_view<charT>`` overloads","October 2021","","","|chrono|"
 `3557 <https://wg21.link/LWG3557>`__,"The ``static_cast`` expression in ``convertible_to`` has the wrong operand","October 2021","|Complete|","14.0"
 `3559 <https://wg21.link/LWG3559>`__,"Semantic requirements of ``sized_range`` is circular","October 2021","|Nothing To Do|","","|ranges|"
 `3560 <https://wg21.link/LWG3560>`__,"``ranges::equal`` and ``ranges::is_permutation`` should short-circuit for ``sized_ranges``","October 2021","","","|ranges|"
 `3561 <https://wg21.link/LWG3561>`__,"Issue with internal counter in ``discard_block_engine``","October 2021","",""
 `3563 <https://wg21.link/LWG3563>`__,"``keys_view`` example is broken","October 2021","","","|ranges|"
 `3566 <https://wg21.link/LWG3566>`__,"Constraint recursion for ``operator<=>(optional<T>, U)``","October 2021","","","|spaceship|"
 `3567 <https://wg21.link/LWG3567>`__,"Formatting move-only iterators take two","October 2021","","","|format|"
-`3568 <https://wg21.link/LWG3568>`__,"``basic_istream_view`` needs to initialize ``value_``","October 2021","","","|ranges|"
+`3568 <https://wg21.link/LWG3568>`__,"``basic_istream_view`` needs to initialize ``value_``","October 2021","|Complete|","16.0","|ranges|"
 `3570 <https://wg21.link/LWG3570>`__,"``basic_osyncstream::emit`` should be an unformatted output function","October 2021","",""
 `3571 <https://wg21.link/LWG3571>`__,"``flush_emit`` should set ``badbit`` if the ``emit`` call fails","October 2021","",""
 `3572 <https://wg21.link/LWG3572>`__,"``copyable-box`` should be fully ``constexpr``","October 2021","|Complete|","14.0","|ranges|"
 `3573 <https://wg21.link/LWG3573>`__,"Missing Throws element for ``basic_string_view(It begin, End end)``","October 2021","|Complete|","14.0"
 `3574 <https://wg21.link/LWG3574>`__,"``common_iterator`` should be completely ``constexpr``-able","October 2021","|Complete|","14.0","|ranges|"
 `3580 <https://wg21.link/LWG3580>`__,"``iota_view``'s ``iterator``'s binary ``operator+`` should be improved","October 2021","|Complete|","14.0","|ranges|"
 `3581 <https://wg21.link/LWG3581>`__,"The range constructor makes ``basic_string_view`` not trivially move constructible","October 2021","|Complete|","14.0","|ranges|"
 `3585 <https://wg21.link/LWG3585>`__,"``variant`` converting assignment with immovable alternative","October 2021","",""

libcxx/docs/Status/RangesPaper.csv

 `[range.ref.view] <https://wg21.link/range.ref.view>`_,`ref_view <https://llvm.org/D102020>`_,[view.interface],Zoe Carver,✅
 `[range.filter] <https://wg21.link/range.filter>`_,`filter_view <https://llvm.org/D109086>`_,[range.all],Louis Dionne,✅
 `[range.transform] <https://wg21.link/range.transform>`_,`transform_view <https://llvm.org/D103056>`_,[range.all],Zoe Carver,✅
 `[range.take] <https://wg21.link/range.take>`_,`take_view <https://llvm.org/D106507>`_,[range.all],Zoe Carver,✅
 `[range.join] <https://wg21.link/range.join>`_,`join_view <https://llvm.org/D107671>`_,[range.all],Zoe Carver,✅
 `[range.split] <https://wg21.link/range.split>`_,`split_view (renamed to lazy_split_view by P2210) <https://llvm.org/D107500>`_,[range.all],Zoe Carver and Konstantin Varlamov,✅
 `[range.counted] <https://wg21.link/range.counted>`_,`view::counted <https://llvm.org/D106923>`_,[range.subrange],Zoe Carver,✅
 `[range.common] <https://wg21.link/range.common>`_,`common_view <https://llvm.org/D105753>`_,[range.all],Zoe Carver,✅
-`[range.reverse] <https://wg21.link/range.reverse>`_,`reverse_view <https://llvm.org/D107096>`_,[range.all],Zoe Carver,✅
+`[range.reverse] <https://wg21.link/range.reverse>`_,`reverse_view <https://llvm.org/D107096>`_,[range.all],Zoe Carver,✅
 No newline at end of file

libcxx/include/CMakeLists.txt

set(files
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/empty.h
   __ranges/empty_view.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
   __ranges/filter_view.h
   __ranges/iota_view.h
+  __ranges/istream_view.h
   __ranges/join_view.h
   __ranges/lazy_split_view.h
   __ranges/non_propagating_cache.h
   __ranges/owning_view.h
   __ranges/range_adaptor.h
   __ranges/rbegin.h
   __ranges/ref_view.h
   __ranges/rend.h

libcxx/include/__ranges/istream_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_ISTREAM_VIEW_H
+#define _LIBCPP___RANGES_ISTREAM_VIEW_H
+
+#include <__concepts/constructible.h>
+#include <__concepts/derived_from.h>
+#include <__concepts/movable.h>
+#include <__config>
+#include <__iterator/default_sentinel.h>
+#include <__iterator/iterator_traits.h>
+#include <__memory/addressof.h>
+#include <__ranges/view_interface.h>
+#include <__type_traits/remove_cvref.h>
+#include <__utility/forward.h>
+#include <iosfwd>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 20
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template <class _Val, class _CharT, class _Traits>
+concept __stream_extractable = requires(basic_istream<_CharT, _Traits>& __is, _Val& __t) { __is >> __t; };
+
+template <movable _Val, class _CharT, class _Traits = char_traits<_CharT>>
+  requires default_initializable<_Val> && __stream_extractable<_Val, _CharT, _Traits>
+class basic_istream_view : public view_interface<basic_istream_view<_Val, _CharT, _Traits>> {
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
+      : __stream_(std::addressof(__stream)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() {
+    *__stream_ >> __value_;
+    return __iterator{*this};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr default_sentinel_t end() const noexcept { return default_sentinel; }
+
+private:
+  class __iterator;
+
+  basic_istream<_CharT, _Traits>* __stream_;
+  _LIBCPP_NO_UNIQUE_ADDRESS _Val __value_ = _Val();
+};
+
+template <movable _Val, class _CharT, class _Traits>
+  requires default_initializable<_Val> && __stream_extractable<_Val, _CharT, _Traits>
+class basic_istream_view<_Val, _CharT, _Traits>::__iterator {
+public:
+  using iterator_concept = input_iterator_tag;
+  using difference_type  = ptrdiff_t;
+  using value_type       = _Val;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(basic_istream_view& __parent) noexcept
+      : __parent_(std::addressof(__parent)) {}
+
+  __iterator(const __iterator&)                  = delete;
+  _LIBCPP_HIDE_FROM_ABI __iterator(__iterator&&) = default;
+
+  __iterator& operator=(const __iterator&)                  = delete;
+  _LIBCPP_HIDE_FROM_ABI __iterator& operator=(__iterator&&) = default;
+
+  _LIBCPP_HIDE_FROM_ABI __iterator& operator++() {
+    *__parent_->__stream_ >> __parent_->__value_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void operator++(int) { ++*this; }
+
+  _LIBCPP_HIDE_FROM_ABI _Val& operator*() const { return __parent_->__value_; }
+
+  _LIBCPP_HIDE_FROM_ABI friend bool operator==(const __iterator& __x, default_sentinel_t) {
+    return !*__x.__get_parent_stream();
+  }
+
+private:
+  basic_istream_view* __parent_;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr basic_istream<_CharT, _Traits>* __get_parent_stream() const {
+    return __parent_->__stream_;
+  }
+};
+
+template <class _Val>
+using istream_view = basic_istream_view<_Val, char>;
+
+template <class _Val>
+using wistream_view = basic_istream_view<_Val, wchar_t>;
+
+namespace views {
+namespace __istream {
+
+// clang-format off
+template <class _Tp>
+struct __fn {
+  template <class _Up, class _UnCVRef = remove_cvref_t<_Up>>
+    requires derived_from<_UnCVRef, basic_istream<typename _UnCVRef::char_type,
+                                                  typename _UnCVRef::traits_type>>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Up&& __u) const
+    noexcept(noexcept(basic_istream_view<_Tp, typename _UnCVRef::char_type,
+                                              typename _UnCVRef::traits_type>(std::forward<_Up>(__u))))
+    -> decltype(      basic_istream_view<_Tp, typename _UnCVRef::char_type,
+                                              typename _UnCVRef::traits_type>(std::forward<_Up>(__u)))
+    {   return        basic_istream_view<_Tp, typename _UnCVRef::char_type,
+                                              typename _UnCVRef::traits_type>(std::forward<_Up>(__u));
+    }
+};
+// clang-format on
+
+} // namespace __istream
+
+inline namespace __cpo {
+template <class _Tp>
+  inline constexpr auto istream = __istream::__fn<_Tp>{};
+} // namespace __cpo
+} // namespace views
+
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 20
+
+#endif // _LIBCPP___RANGES_ISTREAM_VIEW_H

libcxx/include/module.modulemap.in

module __ranges {
       module data                   { private header "__ranges/data.h" }
       module drop_view              { private header "__ranges/drop_view.h" }
       module empty                  { private header "__ranges/empty.h" }
       module empty_view             { private header "__ranges/empty_view.h" }
       module enable_borrowed_range  { private header "__ranges/enable_borrowed_range.h" }
       module enable_view            { private header "__ranges/enable_view.h" }
       module filter_view            { private header "__ranges/filter_view.h" }
       module iota_view              { private header "__ranges/iota_view.h" }
+      module istream_view           { private header "__ranges/istream_view.h" }
       module join_view              { private header "__ranges/join_view.h" }
       module lazy_split_view        { private header "__ranges/lazy_split_view.h" }
       module non_propagating_cache  { private header "__ranges/non_propagating_cache.h" }
       module owning_view            { private header "__ranges/owning_view.h" }
       module range_adaptor          { private header "__ranges/range_adaptor.h" }
       module rbegin                 { private header "__ranges/rbegin.h" }
       module ref_view               { private header "__ranges/ref_view.h" }
       module rend                   { private header "__ranges/rend.h" }

libcxx/include/ranges

requires view<V> && view<Pattern> &&
              indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
              (forward_range<V> || tiny-range<Pattern>)
   class lazy_split_view;
 
   namespace views {
     inline constexpr unspecified lazy_split = 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>
+    using istream_view = basic_istream_view<Val, char>;
+
+  template<class Val>
+    using wistream_view = basic_istream_view<Val, wchar_t>;
+
+  namespace views { template<class T> inline constexpr unspecified istream = unspecified; }
+
   // [range.zip], zip view
   template<input_range... Views>
     requires (view<Views> && ...) && (sizeof...(Views) > 0)
   class zip_view;        // C++2b
 
   template<class... Views>
     inline constexpr bool enable_borrowed_range<zip_view<Views...>> =    // C++2b
       (enable_borrowed_range<Views> && ...);

 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/filter_view.h>
 #include <__ranges/iota_view.h>
+#include <__ranges/istream_view.h>
 #include <__ranges/join_view.h>
 #include <__ranges/lazy_split_view.h>
 #include <__ranges/rbegin.h>
 #include <__ranges/ref_view.h>
 #include <__ranges/rend.h>
 #include <__ranges/reverse_view.h>
 #include <__ranges/single_view.h>
 #include <__ranges/size.h>

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__ranges/data.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/data.h'}}
 #include <__ranges/drop_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/drop_view.h'}}
 #include <__ranges/empty.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/empty.h'}}
 #include <__ranges/empty_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/empty_view.h'}}
 #include <__ranges/enable_borrowed_range.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/enable_borrowed_range.h'}}
 #include <__ranges/enable_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/enable_view.h'}}
 #include <__ranges/filter_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/filter_view.h'}}
 #include <__ranges/iota_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/iota_view.h'}}
+#include <__ranges/istream_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/istream_view.h'}}
 #include <__ranges/join_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/join_view.h'}}
 #include <__ranges/lazy_split_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/lazy_split_view.h'}}
 #include <__ranges/non_propagating_cache.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/non_propagating_cache.h'}}
 #include <__ranges/owning_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/owning_view.h'}}
 #include <__ranges/range_adaptor.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/range_adaptor.h'}}
 #include <__ranges/rbegin.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/rbegin.h'}}
 #include <__ranges/ref_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/ref_view.h'}}
 #include <__ranges/rend.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/rend.h'}}

libcxx/test/libcxx/ranges/range.factories/range.istream.view/no_unique_address.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
+
+// clang-cl and cl currently don't support [[no_unique_address]]
+// XFAIL: msvc
+
+// Test the libc++ extension that the value stored in `std::ranges::istream_view` has been marked
+// as _LIBCPP_NO_UNIQUE_ADDRESS
+
+#include <istream>
+#include <ranges>
+
+struct Empty {
+  friend std::istream& operator>>(std::istream& i, Empty const&) { return i; }
+};
+
+static_assert(sizeof(std::ranges::istream_view<Empty>) == sizeof(void*));
+

libcxx/test/std/ranges/range.factories/range.istream.view/begin.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
+
+// constexpr auto begin();
+
+#include <cassert>
+#include <ranges>
+#include <sstream>
+
+#include "utils.h"
+
+template <class T>
+concept HasBegin = requires(T t) { t.begin(); };
+
+static_assert(HasBegin<std::ranges::istream_view<int>>);
+static_assert(!HasBegin<const std::ranges::istream_view<int>>);
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+static_assert(HasBegin<std::ranges::wistream_view<int>>);
+static_assert(!HasBegin<const std::ranges::wistream_view<int>>);
+#endif
+
+template <class CharT>
+void test() {
+  // begin should read the first element
+  {
+    auto iss = makeStringStream<CharT>("12    3");
+    std::ranges::basic_istream_view<int, CharT> isv{iss};
+    auto it = isv.begin();
+    assert(*it == 12);
+  }
+
+  // empty stream
+  {
+    auto iss = makeStringStream<CharT>("");
+    std::ranges::basic_istream_view<int, CharT> isv{iss};
+    auto it = isv.begin();
+    assert(it == isv.end());
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.istream.view/cpo.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
+
+// std::views::istream<T>
+
+#include <cassert>
+#include <ranges>
+#include <sstream>
+
+#include "utils.h"
+
+static_assert(!std::is_invocable_v<decltype((std::views::istream<int>))>);
+static_assert(std::is_invocable_v<decltype((std::views::istream<int>)), std::istream&>);
+static_assert(!std::is_invocable_v<decltype((std::views::istream<int>)), const std::istream&>);
+static_assert(!std::is_invocable_v<decltype((std::views::istream<int>)), int>);
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+static_assert(std::is_invocable_v<decltype((std::views::istream<int>)), std::wistream&>);
+static_assert(!std::is_invocable_v<decltype((std::views::istream<int>)), const std::wistream&>);
+#endif
+
+template <class CharT>
+void test() {
+  auto iss = makeStringStream<CharT>("12   3");
+  auto isv = std::views::istream<int>(iss);
+  auto it  = isv.begin();
+  assert(*it == 12);
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.istream.view/ctor.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
+
+// constexpr explicit basic_istream_view(basic_istream<CharT, Traits>& stream);
+
+#include <cassert>
+#include <ranges>
+#include <sstream>
+
+#include "utils.h"
+
+// test that the constructor is explicit
+static_assert(std::constructible_from<std::ranges::istream_view<int>, std::istream&>);
+static_assert(!std::convertible_to<std::istream&, std::ranges::istream_view<int>>);
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+static_assert(std::constructible_from<std::ranges::wistream_view<int>, std::wistream&>);
+static_assert(!std::convertible_to<std::wistream&, std::ranges::wistream_view<int>>);
+#endif
+
+template <class CharT>
+void test() {
+  // test constructor init the stream pointer to the passed one
+  {
+    auto iss = makeStringStream<CharT>("123");
+    std::ranges::basic_istream_view<int, CharT> isv{iss};
+    auto it = isv.begin();
+    assert(*it == 123);
+  }
+
+  // LWG 3568. basic_istream_view needs to initialize value_
+  {
+    auto iss = makeStringStream<CharT>("123");
+    std::ranges::basic_istream_view<int, CharT> isv{iss};
+    using Iter = std::ranges::iterator_t<decltype(isv)>;
+    Iter iter{isv};
+    assert(*iter == 0);
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.istream.view/end.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
+
+// constexpr default_sentinel_t end() const noexcept;
+
+#include <cassert>
+#include <ranges>
+#include <sstream>
+
+#include "utils.h"
+
+template <class T>
+concept NoexceptEnd =
+    requires(T t) {
+      { t.end() } noexcept;
+    };
+
+static_assert(NoexceptEnd<std::ranges::istream_view<int>>);
+static_assert(NoexceptEnd<const std::ranges::istream_view<int>>);
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+static_assert(NoexceptEnd<std::ranges::wistream_view<int>>);
+static_assert(NoexceptEnd<const std::ranges::wistream_view<int>>);
+#endif
+
+template <class CharT>
+void test() {
+  auto iss = makeStringStream<CharT>("12");
+  std::ranges::basic_istream_view<int, CharT> isv{iss};
+  [[maybe_unused]] std::same_as<std::default_sentinel_t> auto sent = isv.end();
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.istream.view/general.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
+
+// Some basic examples of how istream_view might be used in the wild. This is a general
+// collection of sample algorithms and functions that try to mock general usage of
+// this view.
+
+#include <algorithm>
+#include <cassert>
+#include <ranges>
+#include <sstream>
+
+#include "utils.h"
+
+template <class CharT>
+void test() {
+  auto ints      = makeStringStream<CharT>("0 1  2   3     4");
+  auto oss       = std::basic_ostringstream<CharT>{};
+  auto delimiter = makeString<CharT>("-");
+  std::ranges::copy(
+      std::ranges::basic_istream_view<int, CharT>(ints), std::ostream_iterator<int, CharT>{oss, delimiter.c_str()});
+  auto expected = makeString<CharT>("0-1-2-3-4-");
+  assert(oss.str() == expected);
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.istream.view/iterator/compare.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
+
+// friend bool operator==(const iterator& x, default_sentinel_t);
+
+#include <cassert>
+#include <ranges>
+#include <sstream>
+
+#include "../utils.h"
+
+template <class CharT>
+void test() {
+  // fail to read
+  {
+    auto iss = makeStringStream<CharT>("a123 4");
+    std::ranges::basic_istream_view<int, CharT> isv{iss};
+    auto it = isv.begin();
+    assert(it == std::default_sentinel);
+  }
+
+  // iterate through the end
+  {
+    auto iss = makeStringStream<CharT>("123 ");
+    std::ranges::basic_istream_view<int, CharT> isv{iss};
+    auto it = isv.begin();
+    assert(it != std::default_sentinel);
+    ++it;
+    assert(it == std::default_sentinel);
+  }
+
+  // empty stream
+  {
+    auto iss = makeStringStream<CharT>("");
+    std::ranges::basic_istream_view<int, CharT> isv{iss};
+    auto it = isv.begin();
+    assert(it == std::default_sentinel);
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.istream.view/iterator/ctor.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
+
+// constexpr explicit iterator(basic_istream_view& parent) noexcept;
+
+#include <cassert>
+#include <ranges>
+#include <sstream>
+
+#include "../utils.h"
+
+// test that the constructor is explicit
+template <class CharT>
+using IstreamView = std::ranges::basic_istream_view<int, CharT>;
+template <class CharT>
+using Iter = std::ranges::iterator_t<IstreamView<CharT>>;
+
+static_assert(std::constructible_from<Iter<char>, IstreamView<char>&>);
+static_assert(!std::convertible_to<IstreamView<char>&, Iter<char>>);
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+static_assert(std::constructible_from<Iter<wchar_t>, IstreamView<wchar_t>&>);
+static_assert(!std::convertible_to<IstreamView<wchar_t>&, Iter<wchar_t>>);
+#endif
+
+// test that the constructor is noexcept
+static_assert(std::is_nothrow_constructible_v<Iter<char>, IstreamView<char>&>);
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+static_assert(std::is_nothrow_constructible_v<Iter<wchar_t>, IstreamView<wchar_t>&>);
+#endif
+
+template <class CharT>
+void test() {
+  auto iss = makeStringStream<CharT>("123");
+  std::ranges::basic_istream_view<int, CharT> isv{iss};
+  Iter<CharT> it{isv};
+  ++it;
+  assert(*it == 123);
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.istream.view/iterator/deref.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
+
+// Val& operator*() const;
+
+#include <cassert>
+#include <ranges>
+#include <sstream>
+
+#include "../utils.h"
+
+template <class CharT>
+void test() {
+  // operator* should return correct value
+  {
+    auto iss = makeStringStream<CharT>("1 2 345 ");
+    std::ranges::basic_istream_view<int, CharT> isv{iss};
+    auto it                              = isv.begin();
+    std::same_as<int&> decltype(auto) v1 = *it;
+    assert(v1 == 1);
+  }
+
+  // operator* should return the same reference to the value stored in the view
+  {
+    auto iss = makeStringStream<CharT>("1 2 345 ");
+    std::ranges::basic_istream_view<int, CharT> isv{iss};
+    using Iter = std::ranges::iterator_t<decltype(isv)>;
+
+    Iter it1{isv};
+    Iter it2{isv};
+    assert(&*it1 == &*it2);
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.istream.view/iterator/increment.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
+
+// iterator& operator++();
+// void operator++(int);
+
+#include <cassert>
+#include <ranges>
+#include <sstream>
+
+#include "../utils.h"
+
+template <class CharT>
+void test() {
+  // operator ++()
+  {
+    auto iss = makeStringStream<CharT>("1 2 345 ");
+    std::ranges::basic_istream_view<int, CharT> isv{iss};
+    auto it = isv.begin();
+    assert(*it == 1);
+
+    std::same_as<decltype(it)&> decltype(auto) it2 = ++it;
+    assert(&it2 == &it);
+    assert(*it2 == 2);
+
+    ++it2;
+    assert(*it2 == 345);
+
+    ++it2;
+    assert(it2 == isv.end());
+  }
+
+  // operator ++(int)
+  {
+    auto iss = makeStringStream<CharT>("1 2 345 ");
+    std::ranges::basic_istream_view<int, CharT> isv{iss};
+    auto it = isv.begin();
+    assert(*it == 1);
+
+    static_assert(std::same_as<decltype(it++), void>);
+    it++;
+    assert(*it == 2);
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.istream.view/iterator/member_types.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
+
+// Member typedefs in istream_view<T>::<iterator>.
+
+#include <istream>
+#include <ranges>
+
+template <class T>
+concept HasIterCategory = requires { typename T::iterator_category; };
+
+struct MemberIteratorCategory {
+  using iterator_category = std::input_iterator_tag;
+};
+static_assert(HasIterCategory<MemberIteratorCategory>);
+
+template <class Val, class CharT>
+void test() {
+  using Iter = std::ranges::iterator_t<std::ranges::basic_istream_view<Val, CharT>>;
+  static_assert(std::is_same_v<typename Iter::iterator_concept, std::input_iterator_tag>);
+  static_assert(std::is_same_v<typename Iter::difference_type, std::ptrdiff_t>);
+  static_assert(std::is_same_v<typename Iter::value_type, Val>);
+  static_assert(!HasIterCategory<Iter>);
+}
+
+template <class CharT>
+void testOne() {
+  test<int, CharT>();
+  test<long, CharT>();
+  test<double, CharT>();
+  test<CharT, CharT>();
+}
+
+void test() {
+  testOne<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  testOne<wchar_t>();
+#endif
+}

libcxx/test/std/ranges/range.factories/range.istream.view/iterator/special_op.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
+
+//    iterator(const iterator&) = delete;
+//    iterator(iterator&&) = default;
+//    iterator& operator=(const iterator&) = delete;
+//    iterator& operator=(iterator&&) = default;
+
+#include <cassert>
+#include <ranges>
+#include <sstream>
+
+#include "../utils.h"
+
+template <class CharT>
+using Iter = std::ranges::iterator_t<std::ranges::basic_istream_view<int, CharT>>;
+static_assert(!std::copy_constructible<Iter<char>>);
+static_assert(!std::is_copy_assignable_v<Iter<char>>);
+static_assert(std::move_constructible<Iter<char>>);
+static_assert(std::is_move_assignable_v<Iter<char>>);
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+static_assert(!std::copy_constructible<Iter<wchar_t>>);
+static_assert(!std::is_copy_assignable_v<Iter<wchar_t>>);
+static_assert(std::move_constructible<Iter<wchar_t>>);
+static_assert(std::is_move_assignable_v<Iter<wchar_t>>);
+#endif
+
+template <class CharT>
+void test() {
+  // test move constructor
+  {
+    auto iss = makeStringStream<CharT>("12   3");
+    std::ranges::basic_istream_view<int, CharT> isv{iss};
+    auto it  = isv.begin();
+    auto it2 = std::move(it);
+    assert(*it2 == 12);
+  }
+
+  // test move assignment
+  {
+    auto iss1 = makeStringStream<CharT>("12   3");
+    std::ranges::basic_istream_view<int, CharT> isv1{iss1};
+    auto iss2 = makeStringStream<CharT>("45   6");
+    std::ranges::basic_istream_view<int, CharT> isv2{iss2};
+
+    auto it1 = isv1.begin();
+    assert(*it1 == 12);
+    it1 = isv2.begin();
+    assert(*it1 == 45);
+  }
+}
+
+int main(int, char**) {
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.istream.view/range.concept.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
+
+// concept checking istream_view
+
+#include <istream>
+#include <ranges>
+
+template <class Val, class CharT, class Traits = std::char_traits<CharT>>
+concept HasIstreamView = requires { typename std::ranges::basic_istream_view<Val, CharT, Traits>; };
+
+static_assert(HasIstreamView<int, char>);
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+static_assert(HasIstreamView<int, wchar_t>);
+#endif
+
+// Unmovable Val
+struct Unmovable {
+  Unmovable()            = default;
+  Unmovable(Unmovable&&) = delete;
+  template <class CharT>
+  friend std::basic_istream<CharT>& operator>>(std::basic_istream<CharT>& x, const Unmovable&) {
+    return x;
+  }
+};
+static_assert(!HasIstreamView<Unmovable, char>);
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+static_assert(!HasIstreamView<Unmovable, wchar_t>);
+#endif
+
+// !default_initializable<Val>
+struct NoDefaultCtor {
+  NoDefaultCtor(int) {}
+  friend std::istream& operator>>(std::istream& x, const NoDefaultCtor&) { return x; }
+};
+static_assert(!HasIstreamView<NoDefaultCtor, char>);
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+static_assert(!HasIstreamView<NoDefaultCtor, wchar_t>);
+#endif
+
+// !stream-extractable<Val, CharT, Traits>
+struct Foo {};
+static_assert(!HasIstreamView<Foo, char>);
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+static_assert(!HasIstreamView<Foo, wchar_t>);
+#endif
+
+template <class T>
+concept OnlyInputRange = std::ranges::input_range<T> && !std::ranges::forward_range<T>;
+
+static_assert(OnlyInputRange<std::ranges::istream_view<int>>);
+static_assert(OnlyInputRange<std::ranges::istream_view<long>>);
+static_assert(OnlyInputRange<std::ranges::istream_view<double>>);
+static_assert(OnlyInputRange<std::ranges::istream_view<char>>);
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+static_assert(OnlyInputRange<std::ranges::wistream_view<int>>);
+static_assert(OnlyInputRange<std::ranges::wistream_view<long>>);
+static_assert(OnlyInputRange<std::ranges::wistream_view<double>>);
+static_assert(OnlyInputRange<std::ranges::wistream_view<wchar_t>>);
+#endif

libcxx/test/std/ranges/range.factories/range.istream.view/utils.h

+#ifndef TEST_STD_RANGES_RANGE_FACTORIES_RANGE_ISTREAM_UTILS_H
+#define TEST_STD_RANGES_RANGE_FACTORIES_RANGE_ISTREAM_UTILS_H
+
+#include <algorithm>
+#include <sstream>
+#include <string>
+
+template <class CharT, std::size_t N>
+auto makeString(const char (&in)[N]) {
+  std::basic_string<CharT> r(N - 1, static_cast<CharT>(0));
+  std::ranges::transform(in, r.begin(), [](char c) { return static_cast<CharT>(c); });
+  return r;
+}
+
+template <class CharT, std::size_t N>
+auto makeStringStream(const char (&in)[N]) {
+  return std::basic_istringstream<CharT>(makeString<CharT>(in));
+}
+
+#endif //TEST_STD_RANGES_RANGE_FACTORIES_RANGE_ISTREAM_UTILS_H