libstdc++
ranges
Go to the documentation of this file.
1 // <ranges> -*- C++ -*-
2 
3 // Copyright (C) 2019-2022 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file include/ranges
26  * This is a Standard C++ Library header.
27  * @ingroup concepts
28  */
29 
30 #ifndef _GLIBCXX_RANGES
31 #define _GLIBCXX_RANGES 1
32 
33 #if __cplusplus > 201703L
34 
35 #pragma GCC system_header
36 
37 #include <concepts>
38 
39 #if __cpp_lib_concepts
40 
41 #include <compare>
42 #include <initializer_list>
43 #include <iterator>
44 #include <optional>
45 #include <span>
46 #include <tuple>
47 #include <bits/ranges_util.h>
48 #include <bits/refwrap.h>
49 
50 /**
51  * @defgroup ranges Ranges
52  *
53  * Components for dealing with ranges of elements.
54  */
55 
56 namespace std _GLIBCXX_VISIBILITY(default)
57 {
58 _GLIBCXX_BEGIN_NAMESPACE_VERSION
59 namespace ranges
60 {
61  // [range.access] customization point objects
62  // [range.req] range and view concepts
63  // [range.dangling] dangling iterator handling
64  // Defined in <bits/ranges_base.h>
65 
66  // [view.interface] View interface
67  // [range.subrange] Sub-ranges
68  // Defined in <bits/ranges_util.h>
69 
70  // C++20 24.6 [range.factories] Range factories
71 
72  /// A view that contains no elements.
73  template<typename _Tp> requires is_object_v<_Tp>
74  class empty_view
75  : public view_interface<empty_view<_Tp>>
76  {
77  public:
78  static constexpr _Tp* begin() noexcept { return nullptr; }
79  static constexpr _Tp* end() noexcept { return nullptr; }
80  static constexpr _Tp* data() noexcept { return nullptr; }
81  static constexpr size_t size() noexcept { return 0; }
82  static constexpr bool empty() noexcept { return true; }
83  };
84 
85  template<typename _Tp>
86  inline constexpr bool enable_borrowed_range<empty_view<_Tp>> = true;
87 
88  namespace __detail
89  {
90  template<typename _Tp>
91  concept __boxable = copy_constructible<_Tp> && is_object_v<_Tp>;
92 
93  template<__boxable _Tp>
94  struct __box : std::optional<_Tp>
95  {
96  using std::optional<_Tp>::optional;
97 
98  constexpr
99  __box()
100  noexcept(is_nothrow_default_constructible_v<_Tp>)
101  requires default_initializable<_Tp>
102  : std::optional<_Tp>{std::in_place}
103  { }
104 
105  __box(const __box&) = default;
106  __box(__box&&) = default;
107 
108  using std::optional<_Tp>::operator=;
109 
110  // _GLIBCXX_RESOLVE_LIB_DEFECTS
111  // 3477. Simplify constraints for semiregular-box
112  // 3572. copyable-box should be fully constexpr
113  constexpr __box&
114  operator=(const __box& __that)
115  noexcept(is_nothrow_copy_constructible_v<_Tp>)
116  requires (!copyable<_Tp>)
117  {
118  if (this != std::__addressof(__that))
119  {
120  if ((bool)__that)
121  this->emplace(*__that);
122  else
123  this->reset();
124  }
125  return *this;
126  }
127 
128  constexpr __box&
129  operator=(__box&& __that)
130  noexcept(is_nothrow_move_constructible_v<_Tp>)
131  requires (!movable<_Tp>)
132  {
133  if (this != std::__addressof(__that))
134  {
135  if ((bool)__that)
136  this->emplace(std::move(*__that));
137  else
138  this->reset();
139  }
140  return *this;
141  }
142  };
143 
144  // For types which are already copyable, this specialization of the
145  // copyable wrapper stores the object directly without going through
146  // std::optional. It provides just the subset of the primary template's
147  // API that we currently use.
148  template<__boxable _Tp>
149  requires copyable<_Tp> || (is_nothrow_move_constructible_v<_Tp>
150  && is_nothrow_copy_constructible_v<_Tp>)
151  struct __box<_Tp>
152  {
153  private:
154  [[no_unique_address]] _Tp _M_value = _Tp();
155 
156  public:
157  __box() requires default_initializable<_Tp> = default;
158 
159  constexpr explicit
160  __box(const _Tp& __t)
161  noexcept(is_nothrow_copy_constructible_v<_Tp>)
162  : _M_value(__t)
163  { }
164 
165  constexpr explicit
166  __box(_Tp&& __t)
167  noexcept(is_nothrow_move_constructible_v<_Tp>)
168  : _M_value(std::move(__t))
169  { }
170 
171  template<typename... _Args>
172  requires constructible_from<_Tp, _Args...>
173  constexpr explicit
174  __box(in_place_t, _Args&&... __args)
175  noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
176  : _M_value(std::forward<_Args>(__args)...)
177  { }
178 
179  __box(const __box&) = default;
180  __box(__box&&) = default;
181  __box& operator=(const __box&) requires copyable<_Tp> = default;
182  __box& operator=(__box&&) requires copyable<_Tp> = default;
183 
184  // When _Tp is nothrow_copy_constructible but not copy_assignable,
185  // copy assignment is implemented via destroy-then-copy-construct.
186  constexpr __box&
187  operator=(const __box& __that) noexcept
188  {
189  static_assert(is_nothrow_copy_constructible_v<_Tp>);
190  if (this != std::__addressof(__that))
191  {
192  _M_value.~_Tp();
193  std::construct_at(std::__addressof(_M_value), *__that);
194  }
195  return *this;
196  }
197 
198  // Likewise for move assignment.
199  constexpr __box&
200  operator=(__box&& __that) noexcept
201  {
202  static_assert(is_nothrow_move_constructible_v<_Tp>);
203  if (this != std::__addressof(__that))
204  {
205  _M_value.~_Tp();
206  std::construct_at(std::__addressof(_M_value), std::move(*__that));
207  }
208  return *this;
209  }
210 
211  constexpr bool
212  has_value() const noexcept
213  { return true; };
214 
215  constexpr _Tp&
216  operator*() noexcept
217  { return _M_value; }
218 
219  constexpr const _Tp&
220  operator*() const noexcept
221  { return _M_value; }
222 
223  constexpr _Tp*
224  operator->() noexcept
225  { return std::__addressof(_M_value); }
226 
227  constexpr const _Tp*
228  operator->() const noexcept
229  { return std::__addressof(_M_value); }
230  };
231  } // namespace __detail
232 
233  /// A view that contains exactly one element.
234  template<copy_constructible _Tp> requires is_object_v<_Tp>
235  class single_view : public view_interface<single_view<_Tp>>
236  {
237  public:
238  single_view() requires default_initializable<_Tp> = default;
239 
240  constexpr explicit
241  single_view(const _Tp& __t)
242  noexcept(is_nothrow_copy_constructible_v<_Tp>)
243  : _M_value(__t)
244  { }
245 
246  constexpr explicit
247  single_view(_Tp&& __t)
248  noexcept(is_nothrow_move_constructible_v<_Tp>)
249  : _M_value(std::move(__t))
250  { }
251 
252  // _GLIBCXX_RESOLVE_LIB_DEFECTS
253  // 3428. single_view's in place constructor should be explicit
254  template<typename... _Args>
255  requires constructible_from<_Tp, _Args...>
256  constexpr explicit
257  single_view(in_place_t, _Args&&... __args)
258  noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
259  : _M_value{in_place, std::forward<_Args>(__args)...}
260  { }
261 
262  constexpr _Tp*
263  begin() noexcept
264  { return data(); }
265 
266  constexpr const _Tp*
267  begin() const noexcept
268  { return data(); }
269 
270  constexpr _Tp*
271  end() noexcept
272  { return data() + 1; }
273 
274  constexpr const _Tp*
275  end() const noexcept
276  { return data() + 1; }
277 
278  static constexpr size_t
279  size() noexcept
280  { return 1; }
281 
282  constexpr _Tp*
283  data() noexcept
284  { return _M_value.operator->(); }
285 
286  constexpr const _Tp*
287  data() const noexcept
288  { return _M_value.operator->(); }
289 
290  private:
291  [[no_unique_address]] __detail::__box<_Tp> _M_value;
292  };
293 
294  template<typename _Tp>
295  single_view(_Tp) -> single_view<_Tp>;
296 
297  namespace __detail
298  {
299  template<typename _Wp>
300  constexpr auto __to_signed_like(_Wp __w) noexcept
301  {
302  if constexpr (!integral<_Wp>)
303  return iter_difference_t<_Wp>();
304  else if constexpr (sizeof(iter_difference_t<_Wp>) > sizeof(_Wp))
305  return iter_difference_t<_Wp>(__w);
306  else if constexpr (sizeof(ptrdiff_t) > sizeof(_Wp))
307  return ptrdiff_t(__w);
308  else if constexpr (sizeof(long long) > sizeof(_Wp))
309  return (long long)(__w);
310 #ifdef __SIZEOF_INT128__
311  else if constexpr (__SIZEOF_INT128__ > sizeof(_Wp))
312  return __int128(__w);
313 #endif
314  else
315  return __max_diff_type(__w);
316  }
317 
318  template<typename _Wp>
319  using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>()));
320 
321  template<typename _It>
322  concept __decrementable = incrementable<_It>
323  && requires(_It __i)
324  {
325  { --__i } -> same_as<_It&>;
326  { __i-- } -> same_as<_It>;
327  };
328 
329  template<typename _It>
330  concept __advanceable = __decrementable<_It> && totally_ordered<_It>
331  && requires( _It __i, const _It __j, const __iota_diff_t<_It> __n)
332  {
333  { __i += __n } -> same_as<_It&>;
334  { __i -= __n } -> same_as<_It&>;
335  _It(__j + __n);
336  _It(__n + __j);
337  _It(__j - __n);
338  { __j - __j } -> convertible_to<__iota_diff_t<_It>>;
339  };
340 
341  template<typename _Winc>
342  struct __iota_view_iter_cat
343  { };
344 
345  template<incrementable _Winc>
346  struct __iota_view_iter_cat<_Winc>
347  { using iterator_category = input_iterator_tag; };
348  } // namespace __detail
349 
350  template<weakly_incrementable _Winc,
351  semiregular _Bound = unreachable_sentinel_t>
352  requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound>
353  && copyable<_Winc>
354  class iota_view : public view_interface<iota_view<_Winc, _Bound>>
355  {
356  private:
357  struct _Sentinel;
358 
359  struct _Iterator : __detail::__iota_view_iter_cat<_Winc>
360  {
361  private:
362  static auto
363  _S_iter_concept()
364  {
365  using namespace __detail;
366  if constexpr (__advanceable<_Winc>)
367  return random_access_iterator_tag{};
368  else if constexpr (__decrementable<_Winc>)
369  return bidirectional_iterator_tag{};
370  else if constexpr (incrementable<_Winc>)
371  return forward_iterator_tag{};
372  else
373  return input_iterator_tag{};
374  }
375 
376  public:
377  using iterator_concept = decltype(_S_iter_concept());
378  // iterator_category defined in __iota_view_iter_cat
379  using value_type = _Winc;
380  using difference_type = __detail::__iota_diff_t<_Winc>;
381 
382  _Iterator() requires default_initializable<_Winc> = default;
383 
384  constexpr explicit
385  _Iterator(_Winc __value)
386  : _M_value(__value) { }
387 
388  constexpr _Winc
389  operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>)
390  { return _M_value; }
391 
392  constexpr _Iterator&
393  operator++()
394  {
395  ++_M_value;
396  return *this;
397  }
398 
399  constexpr void
400  operator++(int)
401  { ++*this; }
402 
403  constexpr _Iterator
404  operator++(int) requires incrementable<_Winc>
405  {
406  auto __tmp = *this;
407  ++*this;
408  return __tmp;
409  }
410 
411  constexpr _Iterator&
412  operator--() requires __detail::__decrementable<_Winc>
413  {
414  --_M_value;
415  return *this;
416  }
417 
418  constexpr _Iterator
419  operator--(int) requires __detail::__decrementable<_Winc>
420  {
421  auto __tmp = *this;
422  --*this;
423  return __tmp;
424  }
425 
426  constexpr _Iterator&
427  operator+=(difference_type __n) requires __detail::__advanceable<_Winc>
428  {
429  using __detail::__is_integer_like;
430  using __detail::__is_signed_integer_like;
431  if constexpr (__is_integer_like<_Winc>
432  && !__is_signed_integer_like<_Winc>)
433  {
434  if (__n >= difference_type(0))
435  _M_value += static_cast<_Winc>(__n);
436  else
437  _M_value -= static_cast<_Winc>(-__n);
438  }
439  else
440  _M_value += __n;
441  return *this;
442  }
443 
444  constexpr _Iterator&
445  operator-=(difference_type __n) requires __detail::__advanceable<_Winc>
446  {
447  using __detail::__is_integer_like;
448  using __detail::__is_signed_integer_like;
449  if constexpr (__is_integer_like<_Winc>
450  && !__is_signed_integer_like<_Winc>)
451  {
452  if (__n >= difference_type(0))
453  _M_value -= static_cast<_Winc>(__n);
454  else
455  _M_value += static_cast<_Winc>(-__n);
456  }
457  else
458  _M_value -= __n;
459  return *this;
460  }
461 
462  constexpr _Winc
463  operator[](difference_type __n) const
464  requires __detail::__advanceable<_Winc>
465  { return _Winc(_M_value + __n); }
466 
467  friend constexpr bool
468  operator==(const _Iterator& __x, const _Iterator& __y)
469  requires equality_comparable<_Winc>
470  { return __x._M_value == __y._M_value; }
471 
472  friend constexpr bool
473  operator<(const _Iterator& __x, const _Iterator& __y)
474  requires totally_ordered<_Winc>
475  { return __x._M_value < __y._M_value; }
476 
477  friend constexpr bool
478  operator>(const _Iterator& __x, const _Iterator& __y)
479  requires totally_ordered<_Winc>
480  { return __y < __x; }
481 
482  friend constexpr bool
483  operator<=(const _Iterator& __x, const _Iterator& __y)
484  requires totally_ordered<_Winc>
485  { return !(__y < __x); }
486 
487  friend constexpr bool
488  operator>=(const _Iterator& __x, const _Iterator& __y)
489  requires totally_ordered<_Winc>
490  { return !(__x < __y); }
491 
492 #ifdef __cpp_lib_three_way_comparison
493  friend constexpr auto
494  operator<=>(const _Iterator& __x, const _Iterator& __y)
495  requires totally_ordered<_Winc> && three_way_comparable<_Winc>
496  { return __x._M_value <=> __y._M_value; }
497 #endif
498 
499  friend constexpr _Iterator
500  operator+(_Iterator __i, difference_type __n)
501  requires __detail::__advanceable<_Winc>
502  {
503  __i += __n;
504  return __i;
505  }
506 
507  friend constexpr _Iterator
508  operator+(difference_type __n, _Iterator __i)
509  requires __detail::__advanceable<_Winc>
510  { return __i += __n; }
511 
512  friend constexpr _Iterator
513  operator-(_Iterator __i, difference_type __n)
514  requires __detail::__advanceable<_Winc>
515  {
516  __i -= __n;
517  return __i;
518  }
519 
520  friend constexpr difference_type
521  operator-(const _Iterator& __x, const _Iterator& __y)
522  requires __detail::__advanceable<_Winc>
523  {
524  using __detail::__is_integer_like;
525  using __detail::__is_signed_integer_like;
526  using _Dt = difference_type;
527  if constexpr (__is_integer_like<_Winc>)
528  {
529  if constexpr (__is_signed_integer_like<_Winc>)
530  return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value));
531  else
532  return (__y._M_value > __x._M_value)
533  ? _Dt(-_Dt(__y._M_value - __x._M_value))
534  : _Dt(__x._M_value - __y._M_value);
535  }
536  else
537  return __x._M_value - __y._M_value;
538  }
539 
540  private:
541  _Winc _M_value = _Winc();
542 
543  friend iota_view;
544  friend _Sentinel;
545  };
546 
547  struct _Sentinel
548  {
549  private:
550  constexpr bool
551  _M_equal(const _Iterator& __x) const
552  { return __x._M_value == _M_bound; }
553 
554  constexpr auto
555  _M_distance_from(const _Iterator& __x) const
556  { return _M_bound - __x._M_value; }
557 
558  _Bound _M_bound = _Bound();
559 
560  public:
561  _Sentinel() = default;
562 
563  constexpr explicit
564  _Sentinel(_Bound __bound)
565  : _M_bound(__bound) { }
566 
567  friend constexpr bool
568  operator==(const _Iterator& __x, const _Sentinel& __y)
569  { return __y._M_equal(__x); }
570 
571  friend constexpr iter_difference_t<_Winc>
572  operator-(const _Iterator& __x, const _Sentinel& __y)
573  requires sized_sentinel_for<_Bound, _Winc>
574  { return -__y._M_distance_from(__x); }
575 
576  friend constexpr iter_difference_t<_Winc>
577  operator-(const _Sentinel& __x, const _Iterator& __y)
578  requires sized_sentinel_for<_Bound, _Winc>
579  { return __x._M_distance_from(__y); }
580 
581  friend iota_view;
582  };
583 
584  _Winc _M_value = _Winc();
585  [[no_unique_address]] _Bound _M_bound = _Bound();
586 
587  public:
588  iota_view() requires default_initializable<_Winc> = default;
589 
590  constexpr explicit
591  iota_view(_Winc __value)
592  : _M_value(__value)
593  { }
594 
595  constexpr
596  iota_view(type_identity_t<_Winc> __value,
597  type_identity_t<_Bound> __bound)
598  : _M_value(__value), _M_bound(__bound)
599  {
600  if constexpr (totally_ordered_with<_Winc, _Bound>)
601  __glibcxx_assert( bool(__value <= __bound) );
602  }
603 
604  constexpr
605  iota_view(_Iterator __first, _Iterator __last)
606  requires same_as<_Winc, _Bound>
607  : iota_view(__first._M_value, __last._M_value)
608  { }
609 
610  constexpr
611  iota_view(_Iterator __first, unreachable_sentinel_t __last)
612  requires same_as<_Bound, unreachable_sentinel_t>
613  : iota_view(__first._M_value, __last)
614  { }
615 
616  constexpr
617  iota_view(_Iterator __first, _Sentinel __last)
618  requires (!same_as<_Winc, _Bound>) && (!same_as<_Bound, unreachable_sentinel_t>)
619  : iota_view(__first._M_value, __last._M_bound)
620  { }
621 
622  constexpr _Iterator
623  begin() const { return _Iterator{_M_value}; }
624 
625  constexpr auto
626  end() const
627  {
628  if constexpr (same_as<_Bound, unreachable_sentinel_t>)
629  return unreachable_sentinel;
630  else
631  return _Sentinel{_M_bound};
632  }
633 
634  constexpr _Iterator
635  end() const requires same_as<_Winc, _Bound>
636  { return _Iterator{_M_bound}; }
637 
638  constexpr auto
639  size() const
640  requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>)
641  || (integral<_Winc> && integral<_Bound>)
642  || sized_sentinel_for<_Bound, _Winc>
643  {
644  using __detail::__is_integer_like;
645  using __detail::__to_unsigned_like;
646  if constexpr (integral<_Winc> && integral<_Bound>)
647  {
648  using _Up = make_unsigned_t<decltype(_M_bound - _M_value)>;
649  return _Up(_M_bound) - _Up(_M_value);
650  }
651  else if constexpr (__is_integer_like<_Winc>)
652  return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value);
653  else
654  return __to_unsigned_like(_M_bound - _M_value);
655  }
656  };
657 
658  template<typename _Winc, typename _Bound>
659  requires (!__detail::__is_integer_like<_Winc>
660  || !__detail::__is_integer_like<_Bound>
661  || (__detail::__is_signed_integer_like<_Winc>
662  == __detail::__is_signed_integer_like<_Bound>))
663  iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>;
664 
665  template<typename _Winc, typename _Bound>
666  inline constexpr bool
667  enable_borrowed_range<iota_view<_Winc, _Bound>> = true;
668 
669 namespace views
670 {
671  template<typename _Tp>
672  inline constexpr empty_view<_Tp> empty{};
673 
674  struct _Single
675  {
676  template<typename _Tp>
677  [[nodiscard]]
678  constexpr auto
679  operator()(_Tp&& __e) const
680  noexcept(noexcept(single_view<decay_t<_Tp>>(std::forward<_Tp>(__e))))
681  { return single_view<decay_t<_Tp>>(std::forward<_Tp>(__e)); }
682  };
683 
684  inline constexpr _Single single{};
685 
686  struct _Iota
687  {
688  template<typename _Tp>
689  [[nodiscard]]
690  constexpr auto
691  operator()(_Tp&& __e) const
692  { return iota_view(std::forward<_Tp>(__e)); }
693 
694  template<typename _Tp, typename _Up>
695  [[nodiscard]]
696  constexpr auto
697  operator()(_Tp&& __e, _Up&& __f) const
698  { return iota_view(std::forward<_Tp>(__e), std::forward<_Up>(__f)); }
699  };
700 
701  inline constexpr _Iota iota{};
702 } // namespace views
703 
704  namespace __detail
705  {
706  template<typename _Val, typename _CharT, typename _Traits>
707  concept __stream_extractable
708  = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; };
709  } // namespace __detail
710 
711  template<movable _Val, typename _CharT,
712  typename _Traits = char_traits<_CharT>>
713  requires default_initializable<_Val>
714  && __detail::__stream_extractable<_Val, _CharT, _Traits>
715  class basic_istream_view
716  : public view_interface<basic_istream_view<_Val, _CharT, _Traits>>
717  {
718  public:
719  constexpr explicit
720  basic_istream_view(basic_istream<_CharT, _Traits>& __stream)
721  : _M_stream(std::__addressof(__stream))
722  { }
723 
724  constexpr auto
725  begin()
726  {
727  *_M_stream >> _M_object;
728  return _Iterator{this};
729  }
730 
731  constexpr default_sentinel_t
732  end() const noexcept
733  { return default_sentinel; }
734 
735  private:
736  basic_istream<_CharT, _Traits>* _M_stream;
737  _Val _M_object = _Val();
738 
739  struct _Iterator
740  {
741  public:
742  using iterator_concept = input_iterator_tag;
743  using difference_type = ptrdiff_t;
744  using value_type = _Val;
745 
746  constexpr explicit
747  _Iterator(basic_istream_view* __parent) noexcept
748  : _M_parent(__parent)
749  { }
750 
751  _Iterator(const _Iterator&) = delete;
752  _Iterator(_Iterator&&) = default;
753  _Iterator& operator=(const _Iterator&) = delete;
754  _Iterator& operator=(_Iterator&&) = default;
755 
756  _Iterator&
757  operator++()
758  {
759  *_M_parent->_M_stream >> _M_parent->_M_object;
760  return *this;
761  }
762 
763  void
764  operator++(int)
765  { ++*this; }
766 
767  _Val&
768  operator*() const
769  { return _M_parent->_M_object; }
770 
771  friend bool
772  operator==(const _Iterator& __x, default_sentinel_t)
773  { return __x._M_at_end(); }
774 
775  private:
776  basic_istream_view* _M_parent;
777 
778  bool
779  _M_at_end() const
780  { return !*_M_parent->_M_stream; }
781  };
782 
783  friend _Iterator;
784  };
785 
786  template<typename _Val>
787  using istream_view = basic_istream_view<_Val, char>;
788 
789  template<typename _Val>
790  using wistream_view = basic_istream_view<_Val, wchar_t>;
791 
792 namespace views
793 {
794  template<typename _Tp>
795  struct _Istream
796  {
797  template<typename _CharT, typename _Traits>
798  [[nodiscard]]
799  constexpr auto
800  operator()(basic_istream<_CharT, _Traits>& __e) const
801  { return basic_istream_view<_Tp, _CharT, _Traits>(__e); }
802  };
803 
804  template<typename _Tp>
805  inline constexpr _Istream<_Tp> istream;
806 }
807 
808  // C++20 24.7 [range.adaptors] Range adaptors
809 
810 namespace __detail
811 {
812  struct _Empty { };
813 
814  // Alias for a type that is conditionally present
815  // (and is an empty type otherwise).
816  // Data members using this alias should use [[no_unique_address]] so that
817  // they take no space when not needed.
818  template<bool _Present, typename _Tp>
819  using __maybe_present_t = __conditional_t<_Present, _Tp, _Empty>;
820 
821  // Alias for a type that is conditionally const.
822  template<bool _Const, typename _Tp>
823  using __maybe_const_t = __conditional_t<_Const, const _Tp, _Tp>;
824 
825 } // namespace __detail
826 
827 namespace views::__adaptor
828 {
829  // True if the range adaptor _Adaptor can be applied with _Args.
830  template<typename _Adaptor, typename... _Args>
831  concept __adaptor_invocable
832  = requires { std::declval<_Adaptor>()(declval<_Args>()...); };
833 
834  // True if the range adaptor non-closure _Adaptor can be partially applied
835  // with _Args.
836  template<typename _Adaptor, typename... _Args>
837  concept __adaptor_partial_app_viable = (_Adaptor::_S_arity > 1)
838  && (sizeof...(_Args) == _Adaptor::_S_arity - 1)
839  && (constructible_from<decay_t<_Args>, _Args> && ...);
840 
841  template<typename _Adaptor, typename... _Args>
842  struct _Partial;
843 
844  template<typename _Lhs, typename _Rhs>
845  struct _Pipe;
846 
847  // The base class of every range adaptor closure.
848  //
849  // The derived class should define the optional static data member
850  // _S_has_simple_call_op to true if the behavior of this adaptor is
851  // independent of the constness/value category of the adaptor object.
852  struct _RangeAdaptorClosure
853  {
854  // range | adaptor is equivalent to adaptor(range).
855  template<typename _Self, typename _Range>
856  requires derived_from<remove_cvref_t<_Self>, _RangeAdaptorClosure>
857  && __adaptor_invocable<_Self, _Range>
858  friend constexpr auto
859  operator|(_Range&& __r, _Self&& __self)
860  { return std::forward<_Self>(__self)(std::forward<_Range>(__r)); }
861 
862  // Compose the adaptors __lhs and __rhs into a pipeline, returning
863  // another range adaptor closure object.
864  template<typename _Lhs, typename _Rhs>
865  requires derived_from<_Lhs, _RangeAdaptorClosure>
866  && derived_from<_Rhs, _RangeAdaptorClosure>
867  friend constexpr auto
868  operator|(_Lhs __lhs, _Rhs __rhs)
869  { return _Pipe<_Lhs, _Rhs>{std::move(__lhs), std::move(__rhs)}; }
870  };
871 
872  // The base class of every range adaptor non-closure.
873  //
874  // The static data member _Derived::_S_arity must contain the total number of
875  // arguments that the adaptor takes, and the class _Derived must introduce
876  // _RangeAdaptor::operator() into the class scope via a using-declaration.
877  //
878  // The optional static data member _Derived::_S_has_simple_extra_args should
879  // be defined to true if the behavior of this adaptor is independent of the
880  // constness/value category of the extra arguments. This data member could
881  // also be defined as a variable template parameterized by the types of the
882  // extra arguments.
883  template<typename _Derived>
884  struct _RangeAdaptor
885  {
886  // Partially apply the arguments __args to the range adaptor _Derived,
887  // returning a range adaptor closure object.
888  template<typename... _Args>
889  requires __adaptor_partial_app_viable<_Derived, _Args...>
890  constexpr auto
891  operator()(_Args&&... __args) const
892  {
893  return _Partial<_Derived, decay_t<_Args>...>{std::forward<_Args>(__args)...};
894  }
895  };
896 
897  // True if the range adaptor closure _Adaptor has a simple operator(), i.e.
898  // one that's not overloaded according to constness or value category of the
899  // _Adaptor object.
900  template<typename _Adaptor>
901  concept __closure_has_simple_call_op = _Adaptor::_S_has_simple_call_op;
902 
903  // True if the behavior of the range adaptor non-closure _Adaptor is
904  // independent of the value category of its extra arguments _Args.
905  template<typename _Adaptor, typename... _Args>
906  concept __adaptor_has_simple_extra_args = _Adaptor::_S_has_simple_extra_args
907  || _Adaptor::template _S_has_simple_extra_args<_Args...>;
908 
909  // A range adaptor closure that represents partial application of
910  // the range adaptor _Adaptor with arguments _Args.
911  template<typename _Adaptor, typename... _Args>
912  struct _Partial : _RangeAdaptorClosure
913  {
914  tuple<_Args...> _M_args;
915 
916  constexpr
917  _Partial(_Args... __args)
918  : _M_args(std::move(__args)...)
919  { }
920 
921  // Invoke _Adaptor with arguments __r, _M_args... according to the
922  // value category of this _Partial object.
923  template<typename _Range>
924  requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
925  constexpr auto
926  operator()(_Range&& __r) const &
927  {
928  auto __forwarder = [&__r] (const auto&... __args) {
929  return _Adaptor{}(std::forward<_Range>(__r), __args...);
930  };
931  return std::apply(__forwarder, _M_args);
932  }
933 
934  template<typename _Range>
935  requires __adaptor_invocable<_Adaptor, _Range, _Args...>
936  constexpr auto
937  operator()(_Range&& __r) &&
938  {
939  auto __forwarder = [&__r] (auto&... __args) {
940  return _Adaptor{}(std::forward<_Range>(__r), std::move(__args)...);
941  };
942  return std::apply(__forwarder, _M_args);
943  }
944 
945  template<typename _Range>
946  constexpr auto
947  operator()(_Range&& __r) const && = delete;
948  };
949 
950  // A lightweight specialization of the above primary template for
951  // the common case where _Adaptor accepts a single extra argument.
952  template<typename _Adaptor, typename _Arg>
953  struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
954  {
955  _Arg _M_arg;
956 
957  constexpr
958  _Partial(_Arg __arg)
959  : _M_arg(std::move(__arg))
960  { }
961 
962  template<typename _Range>
963  requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
964  constexpr auto
965  operator()(_Range&& __r) const &
966  { return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
967 
968  template<typename _Range>
969  requires __adaptor_invocable<_Adaptor, _Range, _Arg>
970  constexpr auto
971  operator()(_Range&& __r) &&
972  { return _Adaptor{}(std::forward<_Range>(__r), std::move(_M_arg)); }
973 
974  template<typename _Range>
975  constexpr auto
976  operator()(_Range&& __r) const && = delete;
977  };
978 
979  // Partial specialization of the primary template for the case where the extra
980  // arguments of the adaptor can always be safely and efficiently forwarded by
981  // const reference. This lets us get away with a single operator() overload,
982  // which makes overload resolution failure diagnostics more concise.
983  template<typename _Adaptor, typename... _Args>
984  requires __adaptor_has_simple_extra_args<_Adaptor, _Args...>
985  && (is_trivially_copyable_v<_Args> && ...)
986  struct _Partial<_Adaptor, _Args...> : _RangeAdaptorClosure
987  {
988  tuple<_Args...> _M_args;
989 
990  constexpr
991  _Partial(_Args... __args)
992  : _M_args(std::move(__args)...)
993  { }
994 
995  // Invoke _Adaptor with arguments __r, const _M_args&... regardless
996  // of the value category of this _Partial object.
997  template<typename _Range>
998  requires __adaptor_invocable<_Adaptor, _Range, const _Args&...>
999  constexpr auto
1000  operator()(_Range&& __r) const
1001  {
1002  auto __forwarder = [&__r] (const auto&... __args) {
1003  return _Adaptor{}(std::forward<_Range>(__r), __args...);
1004  };
1005  return std::apply(__forwarder, _M_args);
1006  }
1007 
1008  static constexpr bool _S_has_simple_call_op = true;
1009  };
1010 
1011  // A lightweight specialization of the above template for the common case
1012  // where _Adaptor accepts a single extra argument.
1013  template<typename _Adaptor, typename _Arg>
1014  requires __adaptor_has_simple_extra_args<_Adaptor, _Arg>
1015  && is_trivially_copyable_v<_Arg>
1016  struct _Partial<_Adaptor, _Arg> : _RangeAdaptorClosure
1017  {
1018  _Arg _M_arg;
1019 
1020  constexpr
1021  _Partial(_Arg __arg)
1022  : _M_arg(std::move(__arg))
1023  { }
1024 
1025  template<typename _Range>
1026  requires __adaptor_invocable<_Adaptor, _Range, const _Arg&>
1027  constexpr auto
1028  operator()(_Range&& __r) const
1029  { return _Adaptor{}(std::forward<_Range>(__r), _M_arg); }
1030 
1031  static constexpr bool _S_has_simple_call_op = true;
1032  };
1033 
1034  template<typename _Lhs, typename _Rhs, typename _Range>
1035  concept __pipe_invocable
1036  = requires { std::declval<_Rhs>()(std::declval<_Lhs>()(std::declval<_Range>())); };
1037 
1038  // A range adaptor closure that represents composition of the range
1039  // adaptor closures _Lhs and _Rhs.
1040  template<typename _Lhs, typename _Rhs>
1041  struct _Pipe : _RangeAdaptorClosure
1042  {
1043  [[no_unique_address]] _Lhs _M_lhs;
1044  [[no_unique_address]] _Rhs _M_rhs;
1045 
1046  constexpr
1047  _Pipe(_Lhs __lhs, _Rhs __rhs)
1048  : _M_lhs(std::move(__lhs)), _M_rhs(std::move(__rhs))
1049  { }
1050 
1051  // Invoke _M_rhs(_M_lhs(__r)) according to the value category of this
1052  // range adaptor closure object.
1053  template<typename _Range>
1054  requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1055  constexpr auto
1056  operator()(_Range&& __r) const &
1057  { return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1058 
1059  template<typename _Range>
1060  requires __pipe_invocable<_Lhs, _Rhs, _Range>
1061  constexpr auto
1062  operator()(_Range&& __r) &&
1063  { return std::move(_M_rhs)(std::move(_M_lhs)(std::forward<_Range>(__r))); }
1064 
1065  template<typename _Range>
1066  constexpr auto
1067  operator()(_Range&& __r) const && = delete;
1068  };
1069 
1070  // A partial specialization of the above primary template for the case where
1071  // both adaptor operands have a simple operator(). This in turn lets us
1072  // implement composition using a single simple operator(), which makes
1073  // overload resolution failure diagnostics more concise.
1074  template<typename _Lhs, typename _Rhs>
1075  requires __closure_has_simple_call_op<_Lhs>
1076  && __closure_has_simple_call_op<_Rhs>
1077  struct _Pipe<_Lhs, _Rhs> : _RangeAdaptorClosure
1078  {
1079  [[no_unique_address]] _Lhs _M_lhs;
1080  [[no_unique_address]] _Rhs _M_rhs;
1081 
1082  constexpr
1083  _Pipe(_Lhs __lhs, _Rhs __rhs)
1084  : _M_lhs(std::move(__lhs)), _M_rhs(std::move(__rhs))
1085  { }
1086 
1087  template<typename _Range>
1088  requires __pipe_invocable<const _Lhs&, const _Rhs&, _Range>
1089  constexpr auto
1090  operator()(_Range&& __r) const
1091  { return _M_rhs(_M_lhs(std::forward<_Range>(__r))); }
1092 
1093  static constexpr bool _S_has_simple_call_op = true;
1094  };
1095 } // namespace views::__adaptor
1096 
1097  template<range _Range> requires is_object_v<_Range>
1098  class ref_view : public view_interface<ref_view<_Range>>
1099  {
1100  private:
1101  _Range* _M_r;
1102 
1103  static void _S_fun(_Range&); // not defined
1104  static void _S_fun(_Range&&) = delete;
1105 
1106  public:
1107  template<__detail::__different_from<ref_view> _Tp>
1108  requires convertible_to<_Tp, _Range&>
1109  && requires { _S_fun(declval<_Tp>()); }
1110  constexpr
1111  ref_view(_Tp&& __t)
1112  noexcept(noexcept(static_cast<_Range&>(std::declval<_Tp>())))
1113  : _M_r(std::__addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))
1114  { }
1115 
1116  constexpr _Range&
1117  base() const
1118  { return *_M_r; }
1119 
1120  constexpr iterator_t<_Range>
1121  begin() const
1122  { return ranges::begin(*_M_r); }
1123 
1124  constexpr sentinel_t<_Range>
1125  end() const
1126  { return ranges::end(*_M_r); }
1127 
1128  constexpr bool
1129  empty() const requires requires { ranges::empty(*_M_r); }
1130  { return ranges::empty(*_M_r); }
1131 
1132  constexpr auto
1133  size() const requires sized_range<_Range>
1134  { return ranges::size(*_M_r); }
1135 
1136  constexpr auto
1137  data() const requires contiguous_range<_Range>
1138  { return ranges::data(*_M_r); }
1139  };
1140 
1141  template<typename _Range>
1142  ref_view(_Range&) -> ref_view<_Range>;
1143 
1144  template<typename _Tp>
1145  inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
1146 
1147  namespace views
1148  {
1149  namespace __detail
1150  {
1151  template<typename _Range>
1152  concept __can_ref_view = requires { ref_view{std::declval<_Range>()}; };
1153 
1154  template<typename _Range>
1155  concept __can_subrange = requires { subrange{std::declval<_Range>()}; };
1156  } // namespace __detail
1157 
1158  struct _All : __adaptor::_RangeAdaptorClosure
1159  {
1160  template<typename _Range>
1161  static constexpr bool
1162  _S_noexcept()
1163  {
1164  if constexpr (view<decay_t<_Range>>)
1165  return is_nothrow_constructible_v<decay_t<_Range>, _Range>;
1166  else if constexpr (__detail::__can_ref_view<_Range>)
1167  return true;
1168  else
1169  return noexcept(subrange{std::declval<_Range>()});
1170  }
1171 
1172  template<viewable_range _Range>
1173  requires view<decay_t<_Range>>
1174  || __detail::__can_ref_view<_Range>
1175  || __detail::__can_subrange<_Range>
1176  constexpr auto
1177  operator() [[nodiscard]] (_Range&& __r) const
1178  noexcept(_S_noexcept<_Range>())
1179  {
1180  if constexpr (view<decay_t<_Range>>)
1181  return std::forward<_Range>(__r);
1182  else if constexpr (__detail::__can_ref_view<_Range>)
1183  return ref_view{std::forward<_Range>(__r)};
1184  else
1185  return subrange{std::forward<_Range>(__r)};
1186  }
1187 
1188  static constexpr bool _S_has_simple_call_op = true;
1189  };
1190 
1191  inline constexpr _All all;
1192 
1193  template<viewable_range _Range>
1194  using all_t = decltype(all(std::declval<_Range>()));
1195  } // namespace views
1196 
1197  namespace __detail
1198  {
1199  template<typename _Tp>
1200  struct __non_propagating_cache
1201  {
1202  // When _Tp is not an object type (e.g. is a reference type), we make
1203  // __non_propagating_cache<_Tp> empty rather than ill-formed so that
1204  // users can easily conditionally declare data members with this type
1205  // (such as join_view::_M_inner).
1206  };
1207 
1208  template<typename _Tp>
1209  requires is_object_v<_Tp>
1210  struct __non_propagating_cache<_Tp>
1211  : protected _Optional_base<_Tp>
1212  {
1213  __non_propagating_cache() = default;
1214 
1215  constexpr
1216  __non_propagating_cache(const __non_propagating_cache&) noexcept
1217  { }
1218 
1219  constexpr
1220  __non_propagating_cache(__non_propagating_cache&& __other) noexcept
1221  { __other._M_reset(); }
1222 
1223  constexpr __non_propagating_cache&
1224  operator=(const __non_propagating_cache& __other) noexcept
1225  {
1226  if (std::__addressof(__other) != this)
1227  this->_M_reset();
1228  return *this;
1229  }
1230 
1231  constexpr __non_propagating_cache&
1232  operator=(__non_propagating_cache&& __other) noexcept
1233  {
1234  this->_M_reset();
1235  __other._M_reset();
1236  return *this;
1237  }
1238 
1239  constexpr __non_propagating_cache&
1240  operator=(_Tp __val)
1241  {
1242  this->_M_reset();
1243  this->_M_payload._M_construct(std::move(__val));
1244  return *this;
1245  }
1246 
1247  constexpr explicit
1248  operator bool() const noexcept
1249  { return this->_M_is_engaged(); }
1250 
1251  constexpr _Tp&
1252  operator*() noexcept
1253  { return this->_M_get(); }
1254 
1255  constexpr const _Tp&
1256  operator*() const noexcept
1257  { return this->_M_get(); }
1258 
1259  template<typename _Iter>
1260  constexpr _Tp&
1261  _M_emplace_deref(const _Iter& __i)
1262  {
1263  this->_M_reset();
1264  auto __f = [] (auto& __x) { return *__x; };
1265  this->_M_payload._M_apply(_Optional_func{__f}, __i);
1266  return this->_M_get();
1267  }
1268  };
1269 
1270  template<range _Range>
1271  struct _CachedPosition
1272  {
1273  constexpr bool
1274  _M_has_value() const
1275  { return false; }
1276 
1277  constexpr iterator_t<_Range>
1278  _M_get(const _Range&) const
1279  {
1280  __glibcxx_assert(false);
1281  __builtin_unreachable();
1282  }
1283 
1284  constexpr void
1285  _M_set(const _Range&, const iterator_t<_Range>&) const
1286  { }
1287  };
1288 
1289  template<forward_range _Range>
1290  struct _CachedPosition<_Range>
1291  : protected __non_propagating_cache<iterator_t<_Range>>
1292  {
1293  constexpr bool
1294  _M_has_value() const
1295  { return this->_M_is_engaged(); }
1296 
1297  constexpr iterator_t<_Range>
1298  _M_get(const _Range&) const
1299  {
1300  __glibcxx_assert(_M_has_value());
1301  return **this;
1302  }
1303 
1304  constexpr void
1305  _M_set(const _Range&, const iterator_t<_Range>& __it)
1306  {
1307  __glibcxx_assert(!_M_has_value());
1308  std::construct_at(std::__addressof(this->_M_payload._M_payload),
1309  in_place, __it);
1310  this->_M_payload._M_engaged = true;
1311  }
1312  };
1313 
1314  template<random_access_range _Range>
1315  requires (sizeof(range_difference_t<_Range>)
1316  <= sizeof(iterator_t<_Range>))
1317  struct _CachedPosition<_Range>
1318  {
1319  private:
1320  range_difference_t<_Range> _M_offset = -1;
1321 
1322  public:
1323  _CachedPosition() = default;
1324 
1325  constexpr
1326  _CachedPosition(const _CachedPosition&) = default;
1327 
1328  constexpr
1329  _CachedPosition(_CachedPosition&& __other) noexcept
1330  { *this = std::move(__other); }
1331 
1332  constexpr _CachedPosition&
1333  operator=(const _CachedPosition&) = default;
1334 
1335  constexpr _CachedPosition&
1336  operator=(_CachedPosition&& __other) noexcept
1337  {
1338  // Propagate the cached offset, but invalidate the source.
1339  _M_offset = __other._M_offset;
1340  __other._M_offset = -1;
1341  return *this;
1342  }
1343 
1344  constexpr bool
1345  _M_has_value() const
1346  { return _M_offset >= 0; }
1347 
1348  constexpr iterator_t<_Range>
1349  _M_get(_Range& __r) const
1350  {
1351  __glibcxx_assert(_M_has_value());
1352  return ranges::begin(__r) + _M_offset;
1353  }
1354 
1355  constexpr void
1356  _M_set(_Range& __r, const iterator_t<_Range>& __it)
1357  {
1358  __glibcxx_assert(!_M_has_value());
1359  _M_offset = __it - ranges::begin(__r);
1360  }
1361  };
1362  } // namespace __detail
1363 
1364  namespace __detail
1365  {
1366  template<typename _Base>
1367  struct __filter_view_iter_cat
1368  { };
1369 
1370  template<forward_range _Base>
1371  struct __filter_view_iter_cat<_Base>
1372  {
1373  private:
1374  static auto
1375  _S_iter_cat()
1376  {
1377  using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1378  if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
1379  return bidirectional_iterator_tag{};
1380  else if constexpr (derived_from<_Cat, forward_iterator_tag>)
1381  return forward_iterator_tag{};
1382  else
1383  return _Cat{};
1384  }
1385  public:
1386  using iterator_category = decltype(_S_iter_cat());
1387  };
1388  } // namespace __detail
1389 
1390  template<input_range _Vp,
1391  indirect_unary_predicate<iterator_t<_Vp>> _Pred>
1392  requires view<_Vp> && is_object_v<_Pred>
1393  class filter_view : public view_interface<filter_view<_Vp, _Pred>>
1394  {
1395  private:
1396  struct _Sentinel;
1397 
1398  struct _Iterator : __detail::__filter_view_iter_cat<_Vp>
1399  {
1400  private:
1401  static constexpr auto
1402  _S_iter_concept()
1403  {
1404  if constexpr (bidirectional_range<_Vp>)
1405  return bidirectional_iterator_tag{};
1406  else if constexpr (forward_range<_Vp>)
1407  return forward_iterator_tag{};
1408  else
1409  return input_iterator_tag{};
1410  }
1411 
1412  friend filter_view;
1413 
1414  using _Vp_iter = iterator_t<_Vp>;
1415 
1416  _Vp_iter _M_current = _Vp_iter();
1417  filter_view* _M_parent = nullptr;
1418 
1419  public:
1420  using iterator_concept = decltype(_S_iter_concept());
1421  // iterator_category defined in __filter_view_iter_cat
1422  using value_type = range_value_t<_Vp>;
1423  using difference_type = range_difference_t<_Vp>;
1424 
1425  _Iterator() requires default_initializable<_Vp_iter> = default;
1426 
1427  constexpr
1428  _Iterator(filter_view* __parent, _Vp_iter __current)
1429  : _M_current(std::move(__current)),
1430  _M_parent(__parent)
1431  { }
1432 
1433  constexpr const _Vp_iter&
1434  base() const & noexcept
1435  { return _M_current; }
1436 
1437  constexpr _Vp_iter
1438  base() &&
1439  { return std::move(_M_current); }
1440 
1441  constexpr range_reference_t<_Vp>
1442  operator*() const
1443  { return *_M_current; }
1444 
1445  constexpr _Vp_iter
1446  operator->() const
1447  requires __detail::__has_arrow<_Vp_iter>
1448  && copyable<_Vp_iter>
1449  { return _M_current; }
1450 
1451  constexpr _Iterator&
1452  operator++()
1453  {
1454  _M_current = ranges::find_if(std::move(++_M_current),
1455  ranges::end(_M_parent->_M_base),
1456  std::ref(*_M_parent->_M_pred));
1457  return *this;
1458  }
1459 
1460  constexpr void
1461  operator++(int)
1462  { ++*this; }
1463 
1464  constexpr _Iterator
1465  operator++(int) requires forward_range<_Vp>
1466  {
1467  auto __tmp = *this;
1468  ++*this;
1469  return __tmp;
1470  }
1471 
1472  constexpr _Iterator&
1473  operator--() requires bidirectional_range<_Vp>
1474  {
1475  do
1476  --_M_current;
1477  while (!std::__invoke(*_M_parent->_M_pred, *_M_current));
1478  return *this;
1479  }
1480 
1481  constexpr _Iterator
1482  operator--(int) requires bidirectional_range<_Vp>
1483  {
1484  auto __tmp = *this;
1485  --*this;
1486  return __tmp;
1487  }
1488 
1489  friend constexpr bool
1490  operator==(const _Iterator& __x, const _Iterator& __y)
1491  requires equality_comparable<_Vp_iter>
1492  { return __x._M_current == __y._M_current; }
1493 
1494  friend constexpr range_rvalue_reference_t<_Vp>
1495  iter_move(const _Iterator& __i)
1496  noexcept(noexcept(ranges::iter_move(__i._M_current)))
1497  { return ranges::iter_move(__i._M_current); }
1498 
1499  friend constexpr void
1500  iter_swap(const _Iterator& __x, const _Iterator& __y)
1501  noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1502  requires indirectly_swappable<_Vp_iter>
1503  { ranges::iter_swap(__x._M_current, __y._M_current); }
1504  };
1505 
1506  struct _Sentinel
1507  {
1508  private:
1509  sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
1510 
1511  constexpr bool
1512  __equal(const _Iterator& __i) const
1513  { return __i._M_current == _M_end; }
1514 
1515  public:
1516  _Sentinel() = default;
1517 
1518  constexpr explicit
1519  _Sentinel(filter_view* __parent)
1520  : _M_end(ranges::end(__parent->_M_base))
1521  { }
1522 
1523  constexpr sentinel_t<_Vp>
1524  base() const
1525  { return _M_end; }
1526 
1527  friend constexpr bool
1528  operator==(const _Iterator& __x, const _Sentinel& __y)
1529  { return __y.__equal(__x); }
1530  };
1531 
1532  _Vp _M_base = _Vp();
1533  [[no_unique_address]] __detail::__box<_Pred> _M_pred;
1534  [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
1535 
1536  public:
1537  filter_view() requires (default_initializable<_Vp>
1538  && default_initializable<_Pred>)
1539  = default;
1540 
1541  constexpr
1542  filter_view(_Vp __base, _Pred __pred)
1543  : _M_base(std::move(__base)), _M_pred(std::move(__pred))
1544  { }
1545 
1546  constexpr _Vp
1547  base() const& requires copy_constructible<_Vp>
1548  { return _M_base; }
1549 
1550  constexpr _Vp
1551  base() &&
1552  { return std::move(_M_base); }
1553 
1554  constexpr const _Pred&
1555  pred() const
1556  { return *_M_pred; }
1557 
1558  constexpr _Iterator
1559  begin()
1560  {
1561  if (_M_cached_begin._M_has_value())
1562  return {this, _M_cached_begin._M_get(_M_base)};
1563 
1564  __glibcxx_assert(_M_pred.has_value());
1565  auto __it = ranges::find_if(ranges::begin(_M_base),
1566  ranges::end(_M_base),
1567  std::ref(*_M_pred));
1568  _M_cached_begin._M_set(_M_base, __it);
1569  return {this, std::move(__it)};
1570  }
1571 
1572  constexpr auto
1573  end()
1574  {
1575  if constexpr (common_range<_Vp>)
1576  return _Iterator{this, ranges::end(_M_base)};
1577  else
1578  return _Sentinel{this};
1579  }
1580  };
1581 
1582  template<typename _Range, typename _Pred>
1583  filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
1584 
1585  namespace views
1586  {
1587  namespace __detail
1588  {
1589  template<typename _Range, typename _Pred>
1590  concept __can_filter_view
1591  = requires { filter_view(std::declval<_Range>(), std::declval<_Pred>()); };
1592  } // namespace __detail
1593 
1594  struct _Filter : __adaptor::_RangeAdaptor<_Filter>
1595  {
1596  template<viewable_range _Range, typename _Pred>
1597  requires __detail::__can_filter_view<_Range, _Pred>
1598  constexpr auto
1599  operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
1600  {
1601  return filter_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
1602  }
1603 
1604  using _RangeAdaptor<_Filter>::operator();
1605  static constexpr int _S_arity = 2;
1606  static constexpr bool _S_has_simple_extra_args = true;
1607  };
1608 
1609  inline constexpr _Filter filter;
1610  } // namespace views
1611 
1612  template<input_range _Vp, copy_constructible _Fp>
1613  requires view<_Vp> && is_object_v<_Fp>
1614  && regular_invocable<_Fp&, range_reference_t<_Vp>>
1615  && std::__detail::__can_reference<invoke_result_t<_Fp&,
1616  range_reference_t<_Vp>>>
1617  class transform_view : public view_interface<transform_view<_Vp, _Fp>>
1618  {
1619  private:
1620  template<bool _Const>
1621  using _Base = __detail::__maybe_const_t<_Const, _Vp>;
1622 
1623  template<bool _Const>
1624  struct __iter_cat
1625  { };
1626 
1627  template<bool _Const>
1628  requires forward_range<_Base<_Const>>
1629  struct __iter_cat<_Const>
1630  {
1631  private:
1632  static auto
1633  _S_iter_cat()
1634  {
1635  using _Base = transform_view::_Base<_Const>;
1636  using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>;
1637  if constexpr (is_lvalue_reference_v<_Res>)
1638  {
1639  using _Cat
1640  = typename iterator_traits<iterator_t<_Base>>::iterator_category;
1641  if constexpr (derived_from<_Cat, contiguous_iterator_tag>)
1642  return random_access_iterator_tag{};
1643  else
1644  return _Cat{};
1645  }
1646  else
1647  return input_iterator_tag{};
1648  }
1649  public:
1650  using iterator_category = decltype(_S_iter_cat());
1651  };
1652 
1653  template<bool _Const>
1654  struct _Sentinel;
1655 
1656  template<bool _Const>
1657  struct _Iterator : __iter_cat<_Const>
1658  {
1659  private:
1660  using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1661  using _Base = transform_view::_Base<_Const>;
1662 
1663  static auto
1664  _S_iter_concept()
1665  {
1666  if constexpr (random_access_range<_Base>)
1667  return random_access_iterator_tag{};
1668  else if constexpr (bidirectional_range<_Base>)
1669  return bidirectional_iterator_tag{};
1670  else if constexpr (forward_range<_Base>)
1671  return forward_iterator_tag{};
1672  else
1673  return input_iterator_tag{};
1674  }
1675 
1676  using _Base_iter = iterator_t<_Base>;
1677 
1678  _Base_iter _M_current = _Base_iter();
1679  _Parent* _M_parent = nullptr;
1680 
1681  public:
1682  using iterator_concept = decltype(_S_iter_concept());
1683  // iterator_category defined in __transform_view_iter_cat
1684  using value_type
1685  = remove_cvref_t<invoke_result_t<_Fp&, range_reference_t<_Base>>>;
1686  using difference_type = range_difference_t<_Base>;
1687 
1688  _Iterator() requires default_initializable<_Base_iter> = default;
1689 
1690  constexpr
1691  _Iterator(_Parent* __parent, _Base_iter __current)
1692  : _M_current(std::move(__current)),
1693  _M_parent(__parent)
1694  { }
1695 
1696  constexpr
1697  _Iterator(_Iterator<!_Const> __i)
1698  requires _Const
1699  && convertible_to<iterator_t<_Vp>, _Base_iter>
1700  : _M_current(std::move(__i._M_current)), _M_parent(__i._M_parent)
1701  { }
1702 
1703  constexpr const _Base_iter&
1704  base() const & noexcept
1705  { return _M_current; }
1706 
1707  constexpr _Base_iter
1708  base() &&
1709  { return std::move(_M_current); }
1710 
1711  constexpr decltype(auto)
1712  operator*() const
1713  noexcept(noexcept(std::__invoke(*_M_parent->_M_fun, *_M_current)))
1714  { return std::__invoke(*_M_parent->_M_fun, *_M_current); }
1715 
1716  constexpr _Iterator&
1717  operator++()
1718  {
1719  ++_M_current;
1720  return *this;
1721  }
1722 
1723  constexpr void
1724  operator++(int)
1725  { ++_M_current; }
1726 
1727  constexpr _Iterator
1728  operator++(int) requires forward_range<_Base>
1729  {
1730  auto __tmp = *this;
1731  ++*this;
1732  return __tmp;
1733  }
1734 
1735  constexpr _Iterator&
1736  operator--() requires bidirectional_range<_Base>
1737  {
1738  --_M_current;
1739  return *this;
1740  }
1741 
1742  constexpr _Iterator
1743  operator--(int) requires bidirectional_range<_Base>
1744  {
1745  auto __tmp = *this;
1746  --*this;
1747  return __tmp;
1748  }
1749 
1750  constexpr _Iterator&
1751  operator+=(difference_type __n) requires random_access_range<_Base>
1752  {
1753  _M_current += __n;
1754  return *this;
1755  }
1756 
1757  constexpr _Iterator&
1758  operator-=(difference_type __n) requires random_access_range<_Base>
1759  {
1760  _M_current -= __n;
1761  return *this;
1762  }
1763 
1764  constexpr decltype(auto)
1765  operator[](difference_type __n) const
1766  requires random_access_range<_Base>
1767  { return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); }
1768 
1769  friend constexpr bool
1770  operator==(const _Iterator& __x, const _Iterator& __y)
1771  requires equality_comparable<_Base_iter>
1772  { return __x._M_current == __y._M_current; }
1773 
1774  friend constexpr bool
1775  operator<(const _Iterator& __x, const _Iterator& __y)
1776  requires random_access_range<_Base>
1777  { return __x._M_current < __y._M_current; }
1778 
1779  friend constexpr bool
1780  operator>(const _Iterator& __x, const _Iterator& __y)
1781  requires random_access_range<_Base>
1782  { return __y < __x; }
1783 
1784  friend constexpr bool
1785  operator<=(const _Iterator& __x, const _Iterator& __y)
1786  requires random_access_range<_Base>
1787  { return !(__y < __x); }
1788 
1789  friend constexpr bool
1790  operator>=(const _Iterator& __x, const _Iterator& __y)
1791  requires random_access_range<_Base>
1792  { return !(__x < __y); }
1793 
1794 #ifdef __cpp_lib_three_way_comparison
1795  friend constexpr auto
1796  operator<=>(const _Iterator& __x, const _Iterator& __y)
1797  requires random_access_range<_Base>
1798  && three_way_comparable<_Base_iter>
1799  { return __x._M_current <=> __y._M_current; }
1800 #endif
1801 
1802  friend constexpr _Iterator
1803  operator+(_Iterator __i, difference_type __n)
1804  requires random_access_range<_Base>
1805  { return {__i._M_parent, __i._M_current + __n}; }
1806 
1807  friend constexpr _Iterator
1808  operator+(difference_type __n, _Iterator __i)
1809  requires random_access_range<_Base>
1810  { return {__i._M_parent, __i._M_current + __n}; }
1811 
1812  friend constexpr _Iterator
1813  operator-(_Iterator __i, difference_type __n)
1814  requires random_access_range<_Base>
1815  { return {__i._M_parent, __i._M_current - __n}; }
1816 
1817  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1818  // 3483. transform_view::iterator's difference is overconstrained
1819  friend constexpr difference_type
1820  operator-(const _Iterator& __x, const _Iterator& __y)
1821  requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
1822  { return __x._M_current - __y._M_current; }
1823 
1824  friend constexpr decltype(auto)
1825  iter_move(const _Iterator& __i) noexcept(noexcept(*__i))
1826  {
1827  if constexpr (is_lvalue_reference_v<decltype(*__i)>)
1828  return std::move(*__i);
1829  else
1830  return *__i;
1831  }
1832 
1833  friend _Iterator<!_Const>;
1834  template<bool> friend struct _Sentinel;
1835  };
1836 
1837  template<bool _Const>
1838  struct _Sentinel
1839  {
1840  private:
1841  using _Parent = __detail::__maybe_const_t<_Const, transform_view>;
1842  using _Base = transform_view::_Base<_Const>;
1843 
1844  template<bool _Const2>
1845  constexpr auto
1846  __distance_from(const _Iterator<_Const2>& __i) const
1847  { return _M_end - __i._M_current; }
1848 
1849  template<bool _Const2>
1850  constexpr bool
1851  __equal(const _Iterator<_Const2>& __i) const
1852  { return __i._M_current == _M_end; }
1853 
1854  sentinel_t<_Base> _M_end = sentinel_t<_Base>();
1855 
1856  public:
1857  _Sentinel() = default;
1858 
1859  constexpr explicit
1860  _Sentinel(sentinel_t<_Base> __end)
1861  : _M_end(__end)
1862  { }
1863 
1864  constexpr
1865  _Sentinel(_Sentinel<!_Const> __i)
1866  requires _Const
1867  && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
1868  : _M_end(std::move(__i._M_end))
1869  { }
1870 
1871  constexpr sentinel_t<_Base>
1872  base() const
1873  { return _M_end; }
1874 
1875  template<bool _Const2>
1876  requires sentinel_for<sentinel_t<_Base>,
1877  iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
1878  friend constexpr bool
1879  operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
1880  { return __y.__equal(__x); }
1881 
1882  template<bool _Const2,
1883  typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1884  requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1885  friend constexpr range_difference_t<_Base2>
1886  operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
1887  { return -__y.__distance_from(__x); }
1888 
1889  template<bool _Const2,
1890  typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
1891  requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
1892  friend constexpr range_difference_t<_Base2>
1893  operator-(const _Sentinel& __y, const _Iterator<_Const2>& __x)
1894  { return __y.__distance_from(__x); }
1895 
1896  friend _Sentinel<!_Const>;
1897  };
1898 
1899  _Vp _M_base = _Vp();
1900  [[no_unique_address]] __detail::__box<_Fp> _M_fun;
1901 
1902  public:
1903  transform_view() requires (default_initializable<_Vp>
1904  && default_initializable<_Fp>)
1905  = default;
1906 
1907  constexpr
1908  transform_view(_Vp __base, _Fp __fun)
1909  : _M_base(std::move(__base)), _M_fun(std::move(__fun))
1910  { }
1911 
1912  constexpr _Vp
1913  base() const& requires copy_constructible<_Vp>
1914  { return _M_base ; }
1915 
1916  constexpr _Vp
1917  base() &&
1918  { return std::move(_M_base); }
1919 
1920  constexpr _Iterator<false>
1921  begin()
1922  { return _Iterator<false>{this, ranges::begin(_M_base)}; }
1923 
1924  constexpr _Iterator<true>
1925  begin() const
1926  requires range<const _Vp>
1927  && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1928  { return _Iterator<true>{this, ranges::begin(_M_base)}; }
1929 
1930  constexpr _Sentinel<false>
1931  end()
1932  { return _Sentinel<false>{ranges::end(_M_base)}; }
1933 
1934  constexpr _Iterator<false>
1935  end() requires common_range<_Vp>
1936  { return _Iterator<false>{this, ranges::end(_M_base)}; }
1937 
1938  constexpr _Sentinel<true>
1939  end() const
1940  requires range<const _Vp>
1941  && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1942  { return _Sentinel<true>{ranges::end(_M_base)}; }
1943 
1944  constexpr _Iterator<true>
1945  end() const
1946  requires common_range<const _Vp>
1947  && regular_invocable<const _Fp&, range_reference_t<const _Vp>>
1948  { return _Iterator<true>{this, ranges::end(_M_base)}; }
1949 
1950  constexpr auto
1951  size() requires sized_range<_Vp>
1952  { return ranges::size(_M_base); }
1953 
1954  constexpr auto
1955  size() const requires sized_range<const _Vp>
1956  { return ranges::size(_M_base); }
1957  };
1958 
1959  template<typename _Range, typename _Fp>
1960  transform_view(_Range&&, _Fp) -> transform_view<views::all_t<_Range>, _Fp>;
1961 
1962  namespace views
1963  {
1964  namespace __detail
1965  {
1966  template<typename _Range, typename _Fp>
1967  concept __can_transform_view
1968  = requires { transform_view(std::declval<_Range>(), std::declval<_Fp>()); };
1969  } // namespace __detail
1970 
1971  struct _Transform : __adaptor::_RangeAdaptor<_Transform>
1972  {
1973  template<viewable_range _Range, typename _Fp>
1974  requires __detail::__can_transform_view<_Range, _Fp>
1975  constexpr auto
1976  operator() [[nodiscard]] (_Range&& __r, _Fp&& __f) const
1977  {
1978  return transform_view(std::forward<_Range>(__r), std::forward<_Fp>(__f));
1979  }
1980 
1981  using _RangeAdaptor<_Transform>::operator();
1982  static constexpr int _S_arity = 2;
1983  static constexpr bool _S_has_simple_extra_args = true;
1984  };
1985 
1986  inline constexpr _Transform transform;
1987  } // namespace views
1988 
1989  template<view _Vp>
1990  class take_view : public view_interface<take_view<_Vp>>
1991  {
1992  private:
1993  template<bool _Const>
1994  using _CI = counted_iterator<
1995  iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>;
1996 
1997  template<bool _Const>
1998  struct _Sentinel
1999  {
2000  private:
2001  using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2002  sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2003 
2004  public:
2005  _Sentinel() = default;
2006 
2007  constexpr explicit
2008  _Sentinel(sentinel_t<_Base> __end)
2009  : _M_end(__end)
2010  { }
2011 
2012  constexpr
2013  _Sentinel(_Sentinel<!_Const> __s)
2014  requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2015  : _M_end(std::move(__s._M_end))
2016  { }
2017 
2018  constexpr sentinel_t<_Base>
2019  base() const
2020  { return _M_end; }
2021 
2022  friend constexpr bool
2023  operator==(const _CI<_Const>& __y, const _Sentinel& __x)
2024  { return __y.count() == 0 || __y.base() == __x._M_end; }
2025 
2026  template<bool _OtherConst = !_Const,
2027  typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2028  requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2029  friend constexpr bool
2030  operator==(const _CI<_OtherConst>& __y, const _Sentinel& __x)
2031  { return __y.count() == 0 || __y.base() == __x._M_end; }
2032 
2033  friend _Sentinel<!_Const>;
2034  };
2035 
2036  _Vp _M_base = _Vp();
2037  range_difference_t<_Vp> _M_count = 0;
2038 
2039  public:
2040  take_view() requires default_initializable<_Vp> = default;
2041 
2042  constexpr
2043  take_view(_Vp base, range_difference_t<_Vp> __count)
2044  : _M_base(std::move(base)), _M_count(std::move(__count))
2045  { }
2046 
2047  constexpr _Vp
2048  base() const& requires copy_constructible<_Vp>
2049  { return _M_base; }
2050 
2051  constexpr _Vp
2052  base() &&
2053  { return std::move(_M_base); }
2054 
2055  constexpr auto
2056  begin() requires (!__detail::__simple_view<_Vp>)
2057  {
2058  if constexpr (sized_range<_Vp>)
2059  {
2060  if constexpr (random_access_range<_Vp>)
2061  return ranges::begin(_M_base);
2062  else
2063  {
2064  auto __sz = size();
2065  return counted_iterator(ranges::begin(_M_base), __sz);
2066  }
2067  }
2068  else
2069  return counted_iterator(ranges::begin(_M_base), _M_count);
2070  }
2071 
2072  constexpr auto
2073  begin() const requires range<const _Vp>
2074  {
2075  if constexpr (sized_range<const _Vp>)
2076  {
2077  if constexpr (random_access_range<const _Vp>)
2078  return ranges::begin(_M_base);
2079  else
2080  {
2081  auto __sz = size();
2082  return counted_iterator(ranges::begin(_M_base), __sz);
2083  }
2084  }
2085  else
2086  return counted_iterator(ranges::begin(_M_base), _M_count);
2087  }
2088 
2089  constexpr auto
2090  end() requires (!__detail::__simple_view<_Vp>)
2091  {
2092  if constexpr (sized_range<_Vp>)
2093  {
2094  if constexpr (random_access_range<_Vp>)
2095  return ranges::begin(_M_base) + size();
2096  else
2097  return default_sentinel;
2098  }
2099  else
2100  return _Sentinel<false>{ranges::end(_M_base)};
2101  }
2102 
2103  constexpr auto
2104  end() const requires range<const _Vp>
2105  {
2106  if constexpr (sized_range<const _Vp>)
2107  {
2108  if constexpr (random_access_range<const _Vp>)
2109  return ranges::begin(_M_base) + size();
2110  else
2111  return default_sentinel;
2112  }
2113  else
2114  return _Sentinel<true>{ranges::end(_M_base)};
2115  }
2116 
2117  constexpr auto
2118  size() requires sized_range<_Vp>
2119  {
2120  auto __n = ranges::size(_M_base);
2121  return std::min(__n, static_cast<decltype(__n)>(_M_count));
2122  }
2123 
2124  constexpr auto
2125  size() const requires sized_range<const _Vp>
2126  {
2127  auto __n = ranges::size(_M_base);
2128  return std::min(__n, static_cast<decltype(__n)>(_M_count));
2129  }
2130  };
2131 
2132  // _GLIBCXX_RESOLVE_LIB_DEFECTS
2133  // 3447. Deduction guides for take_view and drop_view have different
2134  // constraints
2135  template<typename _Range>
2136  take_view(_Range&&, range_difference_t<_Range>)
2137  -> take_view<views::all_t<_Range>>;
2138 
2139  template<typename _Tp>
2140  inline constexpr bool enable_borrowed_range<take_view<_Tp>>
2141  = enable_borrowed_range<_Tp>;
2142 
2143  namespace views
2144  {
2145  namespace __detail
2146  {
2147  template<typename _Range>
2148  inline constexpr bool __is_empty_view = false;
2149 
2150  template<typename _Tp>
2151  inline constexpr bool __is_empty_view<empty_view<_Tp>> = true;
2152 
2153  template<typename _Range>
2154  inline constexpr bool __is_basic_string_view = false;
2155 
2156  template<typename _CharT, typename _Traits>
2157  inline constexpr bool __is_basic_string_view<basic_string_view<_CharT, _Traits>>
2158  = true;
2159 
2160  template<typename _Range>
2161  inline constexpr bool __is_subrange = false;
2162 
2163  template<typename _Iter, typename _Sent, subrange_kind _Kind>
2164  inline constexpr bool __is_subrange<subrange<_Iter, _Sent, _Kind>> = true;
2165 
2166  template<typename _Range>
2167  inline constexpr bool __is_iota_view = false;
2168 
2169  template<typename _Winc, typename _Bound>
2170  inline constexpr bool __is_iota_view<iota_view<_Winc, _Bound>> = true;
2171 
2172  template<typename _Range, typename _Dp>
2173  concept __can_take_view
2174  = requires { take_view(std::declval<_Range>(), std::declval<_Dp>()); };
2175  } // namespace __detail
2176 
2177  struct _Take : __adaptor::_RangeAdaptor<_Take>
2178  {
2179  template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
2180  requires __detail::__can_take_view<_Range, _Dp>
2181  constexpr auto
2182  operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
2183  {
2184  using _Tp = remove_cvref_t<_Range>;
2185  if constexpr (__detail::__is_empty_view<_Tp>)
2186  return _Tp();
2187  else if constexpr (random_access_range<_Tp>
2188  && sized_range<_Tp>
2189  && (std::__detail::__is_span<_Tp>
2190  || __detail::__is_basic_string_view<_Tp>
2191  || __detail::__is_subrange<_Tp>
2192  || __detail::__is_iota_view<_Tp>))
2193  {
2194  __n = std::min<_Dp>(ranges::distance(__r), __n);
2195  auto __begin = ranges::begin(__r);
2196  auto __end = __begin + __n;
2197  if constexpr (std::__detail::__is_span<_Tp>)
2198  return span<typename _Tp::element_type>(__begin, __end);
2199  else if constexpr (__detail::__is_basic_string_view<_Tp>)
2200  return _Tp(__begin, __end);
2201  else if constexpr (__detail::__is_subrange<_Tp>)
2202  return subrange<iterator_t<_Tp>>(__begin, __end);
2203  else
2204  return iota_view(*__begin, *__end);
2205  }
2206  else
2207  return take_view(std::forward<_Range>(__r), __n);
2208  }
2209 
2210  using _RangeAdaptor<_Take>::operator();
2211  static constexpr int _S_arity = 2;
2212  // The count argument of views::take is not always simple -- it can be
2213  // e.g. a move-only class that's implicitly convertible to the difference
2214  // type. But an integer-like count argument is surely simple.
2215  template<typename _Tp>
2216  static constexpr bool _S_has_simple_extra_args
2217  = ranges::__detail::__is_integer_like<_Tp>;
2218  };
2219 
2220  inline constexpr _Take take;
2221  } // namespace views
2222 
2223  template<view _Vp, typename _Pred>
2224  requires input_range<_Vp> && is_object_v<_Pred>
2225  && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2226  class take_while_view : public view_interface<take_while_view<_Vp, _Pred>>
2227  {
2228  template<bool _Const>
2229  struct _Sentinel
2230  {
2231  private:
2232  using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2233 
2234  sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2235  const _Pred* _M_pred = nullptr;
2236 
2237  public:
2238  _Sentinel() = default;
2239 
2240  constexpr explicit
2241  _Sentinel(sentinel_t<_Base> __end, const _Pred* __pred)
2242  : _M_end(__end), _M_pred(__pred)
2243  { }
2244 
2245  constexpr
2246  _Sentinel(_Sentinel<!_Const> __s)
2247  requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2248  : _M_end(__s._M_end), _M_pred(__s._M_pred)
2249  { }
2250 
2251  constexpr sentinel_t<_Base>
2252  base() const { return _M_end; }
2253 
2254  friend constexpr bool
2255  operator==(const iterator_t<_Base>& __x, const _Sentinel& __y)
2256  { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2257 
2258  template<bool _OtherConst = !_Const,
2259  typename _Base2 = __detail::__maybe_const_t<_OtherConst, _Vp>>
2260  requires sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
2261  friend constexpr bool
2262  operator==(const iterator_t<_Base2>& __x, const _Sentinel& __y)
2263  { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); }
2264 
2265  friend _Sentinel<!_Const>;
2266  };
2267 
2268  _Vp _M_base = _Vp();
2269  [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2270 
2271  public:
2272  take_while_view() requires (default_initializable<_Vp>
2273  && default_initializable<_Pred>)
2274  = default;
2275 
2276  constexpr
2277  take_while_view(_Vp base, _Pred __pred)
2278  : _M_base(std::move(base)), _M_pred(std::move(__pred))
2279  { }
2280 
2281  constexpr _Vp
2282  base() const& requires copy_constructible<_Vp>
2283  { return _M_base; }
2284 
2285  constexpr _Vp
2286  base() &&
2287  { return std::move(_M_base); }
2288 
2289  constexpr const _Pred&
2290  pred() const
2291  { return *_M_pred; }
2292 
2293  constexpr auto
2294  begin() requires (!__detail::__simple_view<_Vp>)
2295  { return ranges::begin(_M_base); }
2296 
2297  constexpr auto
2298  begin() const requires range<const _Vp>
2299  && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2300  { return ranges::begin(_M_base); }
2301 
2302  constexpr auto
2303  end() requires (!__detail::__simple_view<_Vp>)
2304  { return _Sentinel<false>(ranges::end(_M_base),
2305  std::__addressof(*_M_pred)); }
2306 
2307  constexpr auto
2308  end() const requires range<const _Vp>
2309  && indirect_unary_predicate<const _Pred, iterator_t<const _Vp>>
2310  { return _Sentinel<true>(ranges::end(_M_base),
2311  std::__addressof(*_M_pred)); }
2312  };
2313 
2314  template<typename _Range, typename _Pred>
2315  take_while_view(_Range&&, _Pred)
2316  -> take_while_view<views::all_t<_Range>, _Pred>;
2317 
2318  namespace views
2319  {
2320  namespace __detail
2321  {
2322  template<typename _Range, typename _Pred>
2323  concept __can_take_while_view
2324  = requires { take_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2325  } // namespace __detail
2326 
2327  struct _TakeWhile : __adaptor::_RangeAdaptor<_TakeWhile>
2328  {
2329  template<viewable_range _Range, typename _Pred>
2330  requires __detail::__can_take_while_view<_Range, _Pred>
2331  constexpr auto
2332  operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
2333  {
2334  return take_while_view(std::forward<_Range>(__r), std::forward<_Pred>(__p));
2335  }
2336 
2337  using _RangeAdaptor<_TakeWhile>::operator();
2338  static constexpr int _S_arity = 2;
2339  static constexpr bool _S_has_simple_extra_args = true;
2340  };
2341 
2342  inline constexpr _TakeWhile take_while;
2343  } // namespace views
2344 
2345  template<view _Vp>
2346  class drop_view : public view_interface<drop_view<_Vp>>
2347  {
2348  private:
2349  _Vp _M_base = _Vp();
2350  range_difference_t<_Vp> _M_count = 0;
2351 
2352  // ranges::next(begin(base), count, end(base)) is O(1) if _Vp satisfies
2353  // both random_access_range and sized_range. Otherwise, cache its result.
2354  static constexpr bool _S_needs_cached_begin
2355  = !(random_access_range<const _Vp> && sized_range<const _Vp>);
2356  [[no_unique_address]]
2357  __detail::__maybe_present_t<_S_needs_cached_begin,
2358  __detail::_CachedPosition<_Vp>>
2359  _M_cached_begin;
2360 
2361  public:
2362  drop_view() requires default_initializable<_Vp> = default;
2363 
2364  constexpr
2365  drop_view(_Vp __base, range_difference_t<_Vp> __count)
2366  : _M_base(std::move(__base)), _M_count(__count)
2367  { __glibcxx_assert(__count >= 0); }
2368 
2369  constexpr _Vp
2370  base() const& requires copy_constructible<_Vp>
2371  { return _M_base; }
2372 
2373  constexpr _Vp
2374  base() &&
2375  { return std::move(_M_base); }
2376 
2377  // This overload is disabled for simple views with constant-time begin().
2378  constexpr auto
2379  begin()
2380  requires (!(__detail::__simple_view<_Vp>
2381  && random_access_range<const _Vp>
2382  && sized_range<const _Vp>))
2383  {
2384  if constexpr (_S_needs_cached_begin)
2385  if (_M_cached_begin._M_has_value())
2386  return _M_cached_begin._M_get(_M_base);
2387 
2388  auto __it = ranges::next(ranges::begin(_M_base),
2389  _M_count, ranges::end(_M_base));
2390  if constexpr (_S_needs_cached_begin)
2391  _M_cached_begin._M_set(_M_base, __it);
2392  return __it;
2393  }
2394 
2395  // _GLIBCXX_RESOLVE_LIB_DEFECTS
2396  // 3482. drop_view's const begin should additionally require sized_range
2397  constexpr auto
2398  begin() const
2399  requires random_access_range<const _Vp> && sized_range<const _Vp>
2400  {
2401  return ranges::next(ranges::begin(_M_base), _M_count,
2402  ranges::end(_M_base));
2403  }
2404 
2405  constexpr auto
2406  end() requires (!__detail::__simple_view<_Vp>)
2407  { return ranges::end(_M_base); }
2408 
2409  constexpr auto
2410  end() const requires range<const _Vp>
2411  { return ranges::end(_M_base); }
2412 
2413  constexpr auto
2414  size() requires sized_range<_Vp>
2415  {
2416  const auto __s = ranges::size(_M_base);
2417  const auto __c = static_cast<decltype(__s)>(_M_count);
2418  return __s < __c ? 0 : __s - __c;
2419  }
2420 
2421  constexpr auto
2422  size() const requires sized_range<const _Vp>
2423  {
2424  const auto __s = ranges::size(_M_base);
2425  const auto __c = static_cast<decltype(__s)>(_M_count);
2426  return __s < __c ? 0 : __s - __c;
2427  }
2428  };
2429 
2430  template<typename _Range>
2431  drop_view(_Range&&, range_difference_t<_Range>)
2432  -> drop_view<views::all_t<_Range>>;
2433 
2434  template<typename _Tp>
2435  inline constexpr bool enable_borrowed_range<drop_view<_Tp>>
2436  = enable_borrowed_range<_Tp>;
2437 
2438  namespace views
2439  {
2440  namespace __detail
2441  {
2442  template<typename _Range, typename _Dp>
2443  concept __can_drop_view
2444  = requires { drop_view(std::declval<_Range>(), std::declval<_Dp>()); };
2445  } // namespace __detail
2446 
2447  struct _Drop : __adaptor::_RangeAdaptor<_Drop>
2448  {
2449  template<viewable_range _Range, typename _Dp = range_difference_t<_Range>>
2450  requires __detail::__can_drop_view<_Range, _Dp>
2451  constexpr auto
2452  operator() [[nodiscard]] (_Range&& __r, type_identity_t<_Dp> __n) const
2453  {
2454  using _Tp = remove_cvref_t<_Range>;
2455  if constexpr (__detail::__is_empty_view<_Tp>)
2456  return _Tp();
2457  else if constexpr (random_access_range<_Tp>
2458  && sized_range<_Tp>
2459  && (std::__detail::__is_span<_Tp>
2460  || __detail::__is_basic_string_view<_Tp>
2461  || __detail::__is_iota_view<_Tp>
2462  || __detail::__is_subrange<_Tp>))
2463  {
2464  __n = std::min<_Dp>(ranges::distance(__r), __n);
2465  auto __begin = ranges::begin(__r) + __n;
2466  auto __end = ranges::end(__r);
2467  if constexpr (std::__detail::__is_span<_Tp>)
2468  return span<typename _Tp::element_type>(__begin, __end);
2469  else if constexpr (__detail::__is_subrange<_Tp>)
2470  {
2471  if constexpr (_Tp::_S_store_size)
2472  {
2473  using ranges::__detail::__to_unsigned_like;
2474  auto __m = ranges::distance(__r) - __n;
2475  return _Tp(__begin, __end, __to_unsigned_like(__m));
2476  }
2477  else
2478  return _Tp(__begin, __end);
2479  }
2480  else
2481  return _Tp(__begin, __end);
2482  }
2483  else
2484  return drop_view(std::forward<_Range>(__r), __n);
2485  }
2486 
2487  using _RangeAdaptor<_Drop>::operator();
2488  static constexpr int _S_arity = 2;
2489  template<typename _Tp>
2490  static constexpr bool _S_has_simple_extra_args
2491  = _Take::_S_has_simple_extra_args<_Tp>;
2492  };
2493 
2494  inline constexpr _Drop drop;
2495  } // namespace views
2496 
2497  template<view _Vp, typename _Pred>
2498  requires input_range<_Vp> && is_object_v<_Pred>
2499  && indirect_unary_predicate<const _Pred, iterator_t<_Vp>>
2500  class drop_while_view : public view_interface<drop_while_view<_Vp, _Pred>>
2501  {
2502  private:
2503  _Vp _M_base = _Vp();
2504  [[no_unique_address]] __detail::__box<_Pred> _M_pred;
2505  [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
2506 
2507  public:
2508  drop_while_view() requires (default_initializable<_Vp>
2509  && default_initializable<_Pred>)
2510  = default;
2511 
2512  constexpr
2513  drop_while_view(_Vp __base, _Pred __pred)
2514  : _M_base(std::move(__base)), _M_pred(std::move(__pred))
2515  { }
2516 
2517  constexpr _Vp
2518  base() const& requires copy_constructible<_Vp>
2519  { return _M_base; }
2520 
2521  constexpr _Vp
2522  base() &&
2523  { return std::move(_M_base); }
2524 
2525  constexpr const _Pred&
2526  pred() const
2527  { return *_M_pred; }
2528 
2529  constexpr auto
2530  begin()
2531  {
2532  if (_M_cached_begin._M_has_value())
2533  return _M_cached_begin._M_get(_M_base);
2534 
2535  __glibcxx_assert(_M_pred.has_value());
2536  auto __it = ranges::find_if_not(ranges::begin(_M_base),
2537  ranges::end(_M_base),
2538  std::cref(*_M_pred));
2539  _M_cached_begin._M_set(_M_base, __it);
2540  return __it;
2541  }
2542 
2543  constexpr auto
2544  end()
2545  { return ranges::end(_M_base); }
2546  };
2547 
2548  template<typename _Range, typename _Pred>
2549  drop_while_view(_Range&&, _Pred)
2550  -> drop_while_view<views::all_t<_Range>, _Pred>;
2551 
2552  template<typename _Tp, typename _Pred>
2553  inline constexpr bool enable_borrowed_range<drop_while_view<_Tp, _Pred>>
2554  = enable_borrowed_range<_Tp>;
2555 
2556  namespace views
2557  {
2558  namespace __detail
2559  {
2560  template<typename _Range, typename _Pred>
2561  concept __can_drop_while_view
2562  = requires { drop_while_view(std::declval<_Range>(), std::declval<_Pred>()); };
2563  } // namespace __detail
2564 
2565  struct _DropWhile : __adaptor::_RangeAdaptor<_DropWhile>
2566  {
2567  template<viewable_range _Range, typename _Pred>
2568  requires __detail::__can_drop_while_view<_Range, _Pred>
2569  constexpr auto
2570  operator() [[nodiscard]] (_Range&& __r, _Pred&& __p) const
2571  {
2572  return drop_while_view(std::forward<_Range>(__r),
2573  std::forward<_Pred>(__p));
2574  }
2575 
2576  using _RangeAdaptor<_DropWhile>::operator();
2577  static constexpr int _S_arity = 2;
2578  static constexpr bool _S_has_simple_extra_args = true;
2579  };
2580 
2581  inline constexpr _DropWhile drop_while;
2582  } // namespace views
2583 
2584  template<input_range _Vp>
2585  requires view<_Vp> && input_range<range_reference_t<_Vp>>
2586  class join_view : public view_interface<join_view<_Vp>>
2587  {
2588  private:
2589  using _InnerRange = range_reference_t<_Vp>;
2590 
2591  template<bool _Const>
2592  using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2593 
2594  template<bool _Const>
2595  using _Outer_iter = iterator_t<_Base<_Const>>;
2596 
2597  template<bool _Const>
2598  using _Inner_iter = iterator_t<range_reference_t<_Base<_Const>>>;
2599 
2600  template<bool _Const>
2601  static constexpr bool _S_ref_is_glvalue
2602  = is_reference_v<range_reference_t<_Base<_Const>>>;
2603 
2604  template<bool _Const>
2605  struct __iter_cat
2606  { };
2607 
2608  template<bool _Const>
2609  requires _S_ref_is_glvalue<_Const>
2610  && forward_range<_Base<_Const>>
2611  && forward_range<range_reference_t<_Base<_Const>>>
2612  struct __iter_cat<_Const>
2613  {
2614  private:
2615  static constexpr auto
2616  _S_iter_cat()
2617  {
2618  using _Outer_iter = join_view::_Outer_iter<_Const>;
2619  using _Inner_iter = join_view::_Inner_iter<_Const>;
2620  using _OuterCat = typename iterator_traits<_Outer_iter>::iterator_category;
2621  using _InnerCat = typename iterator_traits<_Inner_iter>::iterator_category;
2622  if constexpr (derived_from<_OuterCat, bidirectional_iterator_tag>
2623  && derived_from<_InnerCat, bidirectional_iterator_tag>
2624  && common_range<range_reference_t<_Base<_Const>>>)
2625  return bidirectional_iterator_tag{};
2626  else if constexpr (derived_from<_OuterCat, forward_iterator_tag>
2627  && derived_from<_InnerCat, forward_iterator_tag>)
2628  return forward_iterator_tag{};
2629  else
2630  return input_iterator_tag{};
2631  }
2632  public:
2633  using iterator_category = decltype(_S_iter_cat());
2634  };
2635 
2636  template<bool _Const>
2637  struct _Sentinel;
2638 
2639  template<bool _Const>
2640  struct _Iterator : __iter_cat<_Const>
2641  {
2642  private:
2643  using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2644  using _Base = join_view::_Base<_Const>;
2645 
2646  static constexpr bool _S_ref_is_glvalue
2647  = join_view::_S_ref_is_glvalue<_Const>;
2648 
2649  constexpr void
2650  _M_satisfy()
2651  {
2652  auto __update_inner = [this] (const iterator_t<_Base>& __x) -> auto&& {
2653  if constexpr (_S_ref_is_glvalue)
2654  return *__x;
2655  else
2656  return _M_parent->_M_inner._M_emplace_deref(__x);
2657  };
2658 
2659  for (; _M_outer != ranges::end(_M_parent->_M_base); ++_M_outer)
2660  {
2661  auto&& __inner = __update_inner(_M_outer);
2662  _M_inner = ranges::begin(__inner);
2663  if (_M_inner != ranges::end(__inner))
2664  return;
2665  }
2666 
2667  if constexpr (_S_ref_is_glvalue)
2668  _M_inner = _Inner_iter();
2669  }
2670 
2671  static constexpr auto
2672  _S_iter_concept()
2673  {
2674  if constexpr (_S_ref_is_glvalue
2675  && bidirectional_range<_Base>
2676  && bidirectional_range<range_reference_t<_Base>>
2677  && common_range<range_reference_t<_Base>>)
2678  return bidirectional_iterator_tag{};
2679  else if constexpr (_S_ref_is_glvalue
2680  && forward_range<_Base>
2681  && forward_range<range_reference_t<_Base>>)
2682  return forward_iterator_tag{};
2683  else
2684  return input_iterator_tag{};
2685  }
2686 
2687  using _Outer_iter = join_view::_Outer_iter<_Const>;
2688  using _Inner_iter = join_view::_Inner_iter<_Const>;
2689 
2690  _Outer_iter _M_outer = _Outer_iter();
2691  _Inner_iter _M_inner = _Inner_iter();
2692  _Parent* _M_parent = nullptr;
2693 
2694  public:
2695  using iterator_concept = decltype(_S_iter_concept());
2696  // iterator_category defined in __join_view_iter_cat
2697  using value_type = range_value_t<range_reference_t<_Base>>;
2698  using difference_type
2699  = common_type_t<range_difference_t<_Base>,
2700  range_difference_t<range_reference_t<_Base>>>;
2701 
2702  _Iterator() requires (default_initializable<_Outer_iter>
2703  && default_initializable<_Inner_iter>)
2704  = default;
2705 
2706  constexpr
2707  _Iterator(_Parent* __parent, _Outer_iter __outer)
2708  : _M_outer(std::move(__outer)),
2709  _M_parent(__parent)
2710  { _M_satisfy(); }
2711 
2712  constexpr
2713  _Iterator(_Iterator<!_Const> __i)
2714  requires _Const
2715  && convertible_to<iterator_t<_Vp>, _Outer_iter>
2716  && convertible_to<iterator_t<_InnerRange>, _Inner_iter>
2717  : _M_outer(std::move(__i._M_outer)), _M_inner(std::move(__i._M_inner)),
2718  _M_parent(__i._M_parent)
2719  { }
2720 
2721  constexpr decltype(auto)
2722  operator*() const
2723  { return *_M_inner; }
2724 
2725  // _GLIBCXX_RESOLVE_LIB_DEFECTS
2726  // 3500. join_view::iterator::operator->() is bogus
2727  constexpr _Inner_iter
2728  operator->() const
2729  requires __detail::__has_arrow<_Inner_iter>
2730  && copyable<_Inner_iter>
2731  { return _M_inner; }
2732 
2733  constexpr _Iterator&
2734  operator++()
2735  {
2736  auto&& __inner_range = [this] () -> auto&& {
2737  if constexpr (_S_ref_is_glvalue)
2738  return *_M_outer;
2739  else
2740  return *_M_parent->_M_inner;
2741  }();
2742  if (++_M_inner == ranges::end(__inner_range))
2743  {
2744  ++_M_outer;
2745  _M_satisfy();
2746  }
2747  return *this;
2748  }
2749 
2750  constexpr void
2751  operator++(int)
2752  { ++*this; }
2753 
2754  constexpr _Iterator
2755  operator++(int)
2756  requires _S_ref_is_glvalue && forward_range<_Base>
2757  && forward_range<range_reference_t<_Base>>
2758  {
2759  auto __tmp = *this;
2760  ++*this;
2761  return __tmp;
2762  }
2763 
2764  constexpr _Iterator&
2765  operator--()
2766  requires _S_ref_is_glvalue && bidirectional_range<_Base>
2767  && bidirectional_range<range_reference_t<_Base>>
2768  && common_range<range_reference_t<_Base>>
2769  {
2770  if (_M_outer == ranges::end(_M_parent->_M_base))
2771  _M_inner = ranges::end(*--_M_outer);
2772  while (_M_inner == ranges::begin(*_M_outer))
2773  _M_inner = ranges::end(*--_M_outer);
2774  --_M_inner;
2775  return *this;
2776  }
2777 
2778  constexpr _Iterator
2779  operator--(int)
2780  requires _S_ref_is_glvalue && bidirectional_range<_Base>
2781  && bidirectional_range<range_reference_t<_Base>>
2782  && common_range<range_reference_t<_Base>>
2783  {
2784  auto __tmp = *this;
2785  --*this;
2786  return __tmp;
2787  }
2788 
2789  friend constexpr bool
2790  operator==(const _Iterator& __x, const _Iterator& __y)
2791  requires _S_ref_is_glvalue
2792  && equality_comparable<_Outer_iter>
2793  && equality_comparable<_Inner_iter>
2794  {
2795  return (__x._M_outer == __y._M_outer
2796  && __x._M_inner == __y._M_inner);
2797  }
2798 
2799  friend constexpr decltype(auto)
2800  iter_move(const _Iterator& __i)
2801  noexcept(noexcept(ranges::iter_move(__i._M_inner)))
2802  { return ranges::iter_move(__i._M_inner); }
2803 
2804  friend constexpr void
2805  iter_swap(const _Iterator& __x, const _Iterator& __y)
2806  noexcept(noexcept(ranges::iter_swap(__x._M_inner, __y._M_inner)))
2807  requires indirectly_swappable<_Inner_iter>
2808  { return ranges::iter_swap(__x._M_inner, __y._M_inner); }
2809 
2810  friend _Iterator<!_Const>;
2811  template<bool> friend struct _Sentinel;
2812  };
2813 
2814  template<bool _Const>
2815  struct _Sentinel
2816  {
2817  private:
2818  using _Parent = __detail::__maybe_const_t<_Const, join_view>;
2819  using _Base = join_view::_Base<_Const>;
2820 
2821  template<bool _Const2>
2822  constexpr bool
2823  __equal(const _Iterator<_Const2>& __i) const
2824  { return __i._M_outer == _M_end; }
2825 
2826  sentinel_t<_Base> _M_end = sentinel_t<_Base>();
2827 
2828  public:
2829  _Sentinel() = default;
2830 
2831  constexpr explicit
2832  _Sentinel(_Parent* __parent)
2833  : _M_end(ranges::end(__parent->_M_base))
2834  { }
2835 
2836  constexpr
2837  _Sentinel(_Sentinel<!_Const> __s)
2838  requires _Const && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
2839  : _M_end(std::move(__s._M_end))
2840  { }
2841 
2842  template<bool _Const2>
2843  requires sentinel_for<sentinel_t<_Base>,
2844  iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
2845  friend constexpr bool
2846  operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
2847  { return __y.__equal(__x); }
2848 
2849  friend _Sentinel<!_Const>;
2850  };
2851 
2852  _Vp _M_base = _Vp();
2853  [[no_unique_address]]
2854  __detail::__non_propagating_cache<remove_cv_t<_InnerRange>> _M_inner;
2855 
2856  public:
2857  join_view() requires default_initializable<_Vp> = default;
2858 
2859  constexpr explicit
2860  join_view(_Vp __base)
2861  : _M_base(std::move(__base))
2862  { }
2863 
2864  constexpr _Vp
2865  base() const& requires copy_constructible<_Vp>
2866  { return _M_base; }
2867 
2868  constexpr _Vp
2869  base() &&
2870  { return std::move(_M_base); }
2871 
2872  constexpr auto
2873  begin()
2874  {
2875  constexpr bool __use_const
2876  = (__detail::__simple_view<_Vp>
2877  && is_reference_v<range_reference_t<_Vp>>);
2878  return _Iterator<__use_const>{this, ranges::begin(_M_base)};
2879  }
2880 
2881  constexpr auto
2882  begin() const
2883  requires input_range<const _Vp>
2884  && is_reference_v<range_reference_t<const _Vp>>
2885  {
2886  return _Iterator<true>{this, ranges::begin(_M_base)};
2887  }
2888 
2889  constexpr auto
2890  end()
2891  {
2892  if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange>
2893  && forward_range<_InnerRange>
2894  && common_range<_Vp> && common_range<_InnerRange>)
2895  return _Iterator<__detail::__simple_view<_Vp>>{this,
2896  ranges::end(_M_base)};
2897  else
2898  return _Sentinel<__detail::__simple_view<_Vp>>{this};
2899  }
2900 
2901  constexpr auto
2902  end() const
2903  requires input_range<const _Vp>
2904  && is_reference_v<range_reference_t<const _Vp>>
2905  {
2906  if constexpr (forward_range<const _Vp>
2907  && is_reference_v<range_reference_t<const _Vp>>
2908  && forward_range<range_reference_t<const _Vp>>
2909  && common_range<const _Vp>
2910  && common_range<range_reference_t<const _Vp>>)
2911  return _Iterator<true>{this, ranges::end(_M_base)};
2912  else
2913  return _Sentinel<true>{this};
2914  }
2915  };
2916 
2917  template<typename _Range>
2918  explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
2919 
2920  namespace views
2921  {
2922  namespace __detail
2923  {
2924  template<typename _Range>
2925  concept __can_join_view
2926  = requires { join_view<all_t<_Range>>{std::declval<_Range>()}; };
2927  } // namespace __detail
2928 
2929  struct _Join : __adaptor::_RangeAdaptorClosure
2930  {
2931  template<viewable_range _Range>
2932  requires __detail::__can_join_view<_Range>
2933  constexpr auto
2934  operator() [[nodiscard]] (_Range&& __r) const
2935  {
2936  // _GLIBCXX_RESOLVE_LIB_DEFECTS
2937  // 3474. Nesting join_views is broken because of CTAD
2938  return join_view<all_t<_Range>>{std::forward<_Range>(__r)};
2939  }
2940 
2941  static constexpr bool _S_has_simple_call_op = true;
2942  };
2943 
2944  inline constexpr _Join join;
2945  } // namespace views
2946 
2947  namespace __detail
2948  {
2949  template<auto>
2950  struct __require_constant;
2951 
2952  template<typename _Range>
2953  concept __tiny_range = sized_range<_Range>
2954  && requires
2955  { typename __require_constant<remove_reference_t<_Range>::size()>; }
2956  && (remove_reference_t<_Range>::size() <= 1);
2957 
2958  template<typename _Base>
2959  struct __lazy_split_view_outer_iter_cat
2960  { };
2961 
2962  template<forward_range _Base>
2963  struct __lazy_split_view_outer_iter_cat<_Base>
2964  { using iterator_category = input_iterator_tag; };
2965 
2966  template<typename _Base>
2967  struct __lazy_split_view_inner_iter_cat
2968  { };
2969 
2970  template<forward_range _Base>
2971  struct __lazy_split_view_inner_iter_cat<_Base>
2972  {
2973  private:
2974  static constexpr auto
2975  _S_iter_cat()
2976  {
2977  using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
2978  if constexpr (derived_from<_Cat, forward_iterator_tag>)
2979  return forward_iterator_tag{};
2980  else
2981  return _Cat{};
2982  }
2983  public:
2984  using iterator_category = decltype(_S_iter_cat());
2985  };
2986  }
2987 
2988  template<input_range _Vp, forward_range _Pattern>
2989  requires view<_Vp> && view<_Pattern>
2990  && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
2991  ranges::equal_to>
2992  && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>)
2993  class lazy_split_view : public view_interface<lazy_split_view<_Vp, _Pattern>>
2994  {
2995  private:
2996  template<bool _Const>
2997  using _Base = __detail::__maybe_const_t<_Const, _Vp>;
2998 
2999  template<bool _Const>
3000  struct _InnerIter;
3001 
3002  template<bool _Const>
3003  struct _OuterIter
3004  : __detail::__lazy_split_view_outer_iter_cat<_Base<_Const>>
3005  {
3006  private:
3007  using _Parent = __detail::__maybe_const_t<_Const, lazy_split_view>;
3008  using _Base = lazy_split_view::_Base<_Const>;
3009 
3010  constexpr bool
3011  __at_end() const
3012  { return __current() == ranges::end(_M_parent->_M_base) && !_M_trailing_empty; }
3013 
3014  // [range.lazy.split.outer] p1
3015  // Many of the following specifications refer to the notional member
3016  // current of outer-iterator. current is equivalent to current_ if
3017  // V models forward_range, and parent_->current_ otherwise.
3018  constexpr auto&
3019  __current() noexcept
3020  {
3021  if constexpr (forward_range<_Vp>)
3022  return _M_current;
3023  else
3024  return *_M_parent->_M_current;
3025  }
3026 
3027  constexpr auto&
3028  __current() const noexcept
3029  {
3030  if constexpr (forward_range<_Vp>)
3031  return _M_current;
3032  else
3033  return *_M_parent->_M_current;
3034  }
3035 
3036  _Parent* _M_parent = nullptr;
3037 
3038  // XXX: _M_current is present only if "V models forward_range"
3039  [[no_unique_address]]
3040  __detail::__maybe_present_t<forward_range<_Vp>,
3041  iterator_t<_Base>> _M_current;
3042  bool _M_trailing_empty = false;
3043 
3044  public:
3045  using iterator_concept = __conditional_t<forward_range<_Base>,
3046  forward_iterator_tag,
3047  input_iterator_tag>;
3048  // iterator_category defined in __lazy_split_view_outer_iter_cat
3049  using difference_type = range_difference_t<_Base>;
3050 
3051  struct value_type : view_interface<value_type>
3052  {
3053  private:
3054  _OuterIter _M_i = _OuterIter();
3055 
3056  public:
3057  value_type() = default;
3058 
3059  constexpr explicit
3060  value_type(_OuterIter __i)
3061  : _M_i(std::move(__i))
3062  { }
3063 
3064  constexpr _InnerIter<_Const>
3065  begin() const
3066  { return _InnerIter<_Const>{_M_i}; }
3067 
3068  constexpr default_sentinel_t
3069  end() const noexcept
3070  { return default_sentinel; }
3071  };
3072 
3073  _OuterIter() = default;
3074 
3075  constexpr explicit
3076  _OuterIter(_Parent* __parent) requires (!forward_range<_Base>)
3077  : _M_parent(__parent)
3078  { }
3079 
3080  constexpr
3081  _OuterIter(_Parent* __parent, iterator_t<_Base> __current)
3082  requires forward_range<_Base>
3083  : _M_parent(__parent),
3084  _M_current(std::move(__current))
3085  { }
3086 
3087  constexpr
3088  _OuterIter(_OuterIter<!_Const> __i)
3089  requires _Const
3090  && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
3091  : _M_parent(__i._M_parent), _M_current(std::move(__i._M_current))
3092  { }
3093 
3094  constexpr value_type
3095  operator*() const
3096  { return value_type{*this}; }
3097 
3098  constexpr _OuterIter&
3099  operator++()
3100  {
3101  // _GLIBCXX_RESOLVE_LIB_DEFECTS
3102  // 3505. lazy_split_view::outer-iterator::operator++ misspecified
3103  const auto __end = ranges::end(_M_parent->_M_base);
3104  if (__current() == __end)
3105  {
3106  _M_trailing_empty = false;
3107  return *this;
3108  }
3109  const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern};
3110  if (__pbegin == __pend)
3111  ++__current();
3112  else if constexpr (__detail::__tiny_range<_Pattern>)
3113  {
3114  __current() = ranges::find(std::move(__current()), __end,
3115  *__pbegin);
3116  if (__current() != __end)
3117  {
3118  ++__current();
3119  if (__current() == __end)
3120  _M_trailing_empty = true;
3121  }
3122  }
3123  else
3124  do
3125  {
3126  auto [__b, __p]
3127  = ranges::mismatch(__current(), __end, __pbegin, __pend);
3128  if (__p == __pend)
3129  {
3130  __current() = __b;
3131  if (__current() == __end)
3132  _M_trailing_empty = true;
3133  break;
3134  }
3135  } while (++__current() != __end);
3136  return *this;
3137  }
3138 
3139  constexpr decltype(auto)
3140  operator++(int)
3141  {
3142  if constexpr (forward_range<_Base>)
3143  {
3144  auto __tmp = *this;
3145  ++*this;
3146  return __tmp;
3147  }
3148  else
3149  ++*this;
3150  }
3151 
3152  friend constexpr bool
3153  operator==(const _OuterIter& __x, const _OuterIter& __y)
3154  requires forward_range<_Base>
3155  {
3156  return __x._M_current == __y._M_current
3157  && __x._M_trailing_empty == __y._M_trailing_empty;
3158  }
3159 
3160  friend constexpr bool
3161  operator==(const _OuterIter& __x, default_sentinel_t)
3162  { return __x.__at_end(); };
3163 
3164  friend _OuterIter<!_Const>;
3165  friend _InnerIter<_Const>;
3166  };
3167 
3168  template<bool _Const>
3169  struct _InnerIter
3170  : __detail::__lazy_split_view_inner_iter_cat<_Base<_Const>>
3171  {
3172  private:
3173  using _Base = lazy_split_view::_Base<_Const>;
3174 
3175  constexpr bool
3176  __at_end() const
3177  {
3178  auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern};
3179  auto __end = ranges::end(_M_i._M_parent->_M_base);
3180  if constexpr (__detail::__tiny_range<_Pattern>)
3181  {
3182  const auto& __cur = _M_i_current();
3183  if (__cur == __end)
3184  return true;
3185  if (__pcur == __pend)
3186  return _M_incremented;
3187  return *__cur == *__pcur;
3188  }
3189  else
3190  {
3191  auto __cur = _M_i_current();
3192  if (__cur == __end)
3193  return true;
3194  if (__pcur == __pend)
3195  return _M_incremented;
3196  do
3197  {
3198  if (*__cur != *__pcur)
3199  return false;
3200  if (++__pcur == __pend)
3201  return true;
3202  } while (++__cur != __end);
3203  return false;
3204  }
3205  }
3206 
3207  constexpr auto&
3208  _M_i_current() noexcept
3209  { return _M_i.__current(); }
3210 
3211  constexpr auto&
3212  _M_i_current() const noexcept
3213  { return _M_i.__current(); }
3214 
3215  _OuterIter<_Const> _M_i = _OuterIter<_Const>();
3216  bool _M_incremented = false;
3217 
3218  public:
3219  using iterator_concept
3220  = typename _OuterIter<_Const>::iterator_concept;
3221  // iterator_category defined in __lazy_split_view_inner_iter_cat
3222  using value_type = range_value_t<_Base>;
3223  using difference_type = range_difference_t<_Base>;
3224 
3225  _InnerIter() = default;
3226 
3227  constexpr explicit
3228  _InnerIter(_OuterIter<_Const> __i)
3229  : _M_i(std::move(__i))
3230  { }
3231 
3232  constexpr const iterator_t<_Base>&
3233  base() const& noexcept
3234  { return _M_i_current(); }
3235 
3236  constexpr iterator_t<_Base>
3237  base() && requires forward_range<_Vp>
3238  { return std::move(_M_i_current()); }
3239 
3240  constexpr decltype(auto)
3241  operator*() const
3242  { return *_M_i_current(); }
3243 
3244  constexpr _InnerIter&
3245  operator++()
3246  {
3247  _M_incremented = true;
3248  if constexpr (!forward_range<_Base>)
3249  if constexpr (_Pattern::size() == 0)
3250  return *this;
3251  ++_M_i_current();
3252  return *this;
3253  }
3254 
3255  constexpr decltype(auto)
3256  operator++(int)
3257  {
3258  if constexpr (forward_range<_Base>)
3259  {
3260  auto __tmp = *this;
3261  ++*this;
3262  return __tmp;
3263  }
3264  else
3265  ++*this;
3266  }
3267 
3268  friend constexpr bool
3269  operator==(const _InnerIter& __x, const _InnerIter& __y)
3270  requires forward_range<_Base>
3271  { return __x._M_i == __y._M_i; }
3272 
3273  friend constexpr bool
3274  operator==(const _InnerIter& __x, default_sentinel_t)
3275  { return __x.__at_end(); }
3276 
3277  friend constexpr decltype(auto)
3278  iter_move(const _InnerIter& __i)
3279  noexcept(noexcept(ranges::iter_move(__i._M_i_current())))
3280  { return ranges::iter_move(__i._M_i_current()); }
3281 
3282  friend constexpr void
3283  iter_swap(const _InnerIter& __x, const _InnerIter& __y)
3284  noexcept(noexcept(ranges::iter_swap(__x._M_i_current(),
3285  __y._M_i_current())))
3286  requires indirectly_swappable<iterator_t<_Base>>
3287  { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); }
3288  };
3289 
3290  _Vp _M_base = _Vp();
3291  _Pattern _M_pattern = _Pattern();
3292  // XXX: _M_current is "present only if !forward_range<V>"
3293  [[no_unique_address]]
3294  __detail::__maybe_present_t<!forward_range<_Vp>,
3295  __detail::__non_propagating_cache<iterator_t<_Vp>>> _M_current;
3296 
3297 
3298  public:
3299  lazy_split_view() requires (default_initializable<_Vp>
3300  && default_initializable<_Pattern>)
3301  = default;
3302 
3303  constexpr
3304  lazy_split_view(_Vp __base, _Pattern __pattern)
3305  : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
3306  { }
3307 
3308  template<input_range _Range>
3309  requires constructible_from<_Vp, views::all_t<_Range>>
3310  && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3311  constexpr
3312  lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
3313  : _M_base(views::all(std::forward<_Range>(__r))),
3314  _M_pattern(views::single(std::move(__e)))
3315  { }
3316 
3317  constexpr _Vp
3318  base() const& requires copy_constructible<_Vp>
3319  { return _M_base; }
3320 
3321  constexpr _Vp
3322  base() &&
3323  { return std::move(_M_base); }
3324 
3325  constexpr auto
3326  begin()
3327  {
3328  if constexpr (forward_range<_Vp>)
3329  {
3330  constexpr bool __simple
3331  = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3332  return _OuterIter<__simple>{this, ranges::begin(_M_base)};
3333  }
3334  else
3335  {
3336  _M_current = ranges::begin(_M_base);
3337  return _OuterIter<false>{this};
3338  }
3339  }
3340 
3341  constexpr auto
3342  begin() const requires forward_range<_Vp> && forward_range<const _Vp>
3343  {
3344  return _OuterIter<true>{this, ranges::begin(_M_base)};
3345  }
3346 
3347  constexpr auto
3348  end() requires forward_range<_Vp> && common_range<_Vp>
3349  {
3350  constexpr bool __simple
3351  = __detail::__simple_view<_Vp> && __detail::__simple_view<_Pattern>;
3352  return _OuterIter<__simple>{this, ranges::end(_M_base)};
3353  }
3354 
3355  constexpr auto
3356  end() const
3357  {
3358  if constexpr (forward_range<_Vp>
3359  && forward_range<const _Vp>
3360  && common_range<const _Vp>)
3361  return _OuterIter<true>{this, ranges::end(_M_base)};
3362  else
3363  return default_sentinel;
3364  }
3365  };
3366 
3367  template<typename _Range, typename _Pattern>
3368  lazy_split_view(_Range&&, _Pattern&&)
3369  -> lazy_split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3370 
3371  template<input_range _Range>
3372  lazy_split_view(_Range&&, range_value_t<_Range>)
3373  -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3374 
3375  namespace views
3376  {
3377  namespace __detail
3378  {
3379  template<typename _Range, typename _Pattern>
3380  concept __can_lazy_split_view
3381  = requires { lazy_split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3382  } // namespace __detail
3383 
3384  struct _LazySplit : __adaptor::_RangeAdaptor<_LazySplit>
3385  {
3386  template<viewable_range _Range, typename _Pattern>
3387  requires __detail::__can_lazy_split_view<_Range, _Pattern>
3388  constexpr auto
3389  operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
3390  {
3391  return lazy_split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3392  }
3393 
3394  using _RangeAdaptor<_LazySplit>::operator();
3395  static constexpr int _S_arity = 2;
3396  // The pattern argument of views::lazy_split is not always simple -- it can be
3397  // a non-view range, the value category of which affects whether the call
3398  // is well-formed. But a scalar or a view pattern argument is surely
3399  // simple.
3400  template<typename _Pattern>
3401  static constexpr bool _S_has_simple_extra_args
3402  = is_scalar_v<_Pattern> || (view<_Pattern>
3403  && copy_constructible<_Pattern>);
3404  };
3405 
3406  inline constexpr _LazySplit lazy_split;
3407  } // namespace views
3408 
3409  template<forward_range _Vp, forward_range _Pattern>
3410  requires view<_Vp> && view<_Pattern>
3411  && indirectly_comparable<iterator_t<_Vp>, iterator_t<_Pattern>,
3412  ranges::equal_to>
3413  class split_view : public view_interface<split_view<_Vp, _Pattern>>
3414  {
3415  private:
3416  _Vp _M_base = _Vp();
3417  _Pattern _M_pattern = _Pattern();
3418  __detail::__non_propagating_cache<subrange<iterator_t<_Vp>>> _M_cached_begin;
3419 
3420  struct _Iterator;
3421  struct _Sentinel;
3422 
3423  public:
3424  split_view() requires (default_initializable<_Vp>
3425  && default_initializable<_Pattern>)
3426  = default;
3427 
3428  constexpr
3429  split_view(_Vp __base, _Pattern __pattern)
3430  : _M_base(std::move(__base)), _M_pattern(std::move(__pattern))
3431  { }
3432 
3433  template<forward_range _Range>
3434  requires constructible_from<_Vp, views::all_t<_Range>>
3435  && constructible_from<_Pattern, single_view<range_value_t<_Range>>>
3436  constexpr
3437  split_view(_Range&& __r, range_value_t<_Range> __e)
3438  : _M_base(views::all(std::forward<_Range>(__r))),
3439  _M_pattern(views::single(std::move(__e)))
3440  { }
3441 
3442  constexpr _Vp
3443  base() const& requires copy_constructible<_Vp>
3444  { return _M_base; }
3445 
3446  constexpr _Vp
3447  base() &&
3448  { return std::move(_M_base); }
3449 
3450  constexpr _Iterator
3451  begin()
3452  {
3453  if (!_M_cached_begin)
3454  _M_cached_begin = _M_find_next(ranges::begin(_M_base));
3455  return {this, ranges::begin(_M_base), *_M_cached_begin};
3456  }
3457 
3458  constexpr auto
3459  end()
3460  {
3461  if constexpr (common_range<_Vp>)
3462  return _Iterator{this, ranges::end(_M_base), {}};
3463  else
3464  return _Sentinel{this};
3465  }
3466 
3467  constexpr subrange<iterator_t<_Vp>>
3468  _M_find_next(iterator_t<_Vp> __it)
3469  {
3470  auto [__b, __e] = ranges::search(subrange(__it, ranges::end(_M_base)), _M_pattern);
3471  if (__b != ranges::end(_M_base) && ranges::empty(_M_pattern))
3472  {
3473  ++__b;
3474  ++__e;
3475  }
3476  return {__b, __e};
3477  }
3478 
3479  private:
3480  struct _Iterator
3481  {
3482  private:
3483  split_view* _M_parent = nullptr;
3484  iterator_t<_Vp> _M_cur = iterator_t<_Vp>();
3485  subrange<iterator_t<_Vp>> _M_next = subrange<iterator_t<_Vp>>();
3486  bool _M_trailing_empty = false;
3487 
3488  friend struct _Sentinel;
3489 
3490  public:
3491  using iterator_concept = forward_iterator_tag;
3492  using iterator_category = input_iterator_tag;
3493  using value_type = subrange<iterator_t<_Vp>>;
3494  using difference_type = range_difference_t<_Vp>;
3495 
3496  _Iterator() = default;
3497 
3498  constexpr
3499  _Iterator(split_view* __parent,
3500  iterator_t<_Vp> __current,
3501  subrange<iterator_t<_Vp>> __next)
3502  : _M_parent(__parent),
3503  _M_cur(std::move(__current)),
3504  _M_next(std::move(__next))
3505  { }
3506 
3507  constexpr iterator_t<_Vp>
3508  base() const
3509  { return _M_cur; }
3510 
3511  constexpr value_type
3512  operator*() const
3513  { return {_M_cur, _M_next.begin()}; }
3514 
3515  constexpr _Iterator&
3516  operator++()
3517  {
3518  _M_cur = _M_next.begin();
3519  if (_M_cur != ranges::end(_M_parent->_M_base))
3520  {
3521  _M_cur = _M_next.end();
3522  if (_M_cur == ranges::end(_M_parent->_M_base))
3523  {
3524  _M_trailing_empty = true;
3525  _M_next = {_M_cur, _M_cur};
3526  }
3527  else
3528  _M_next = _M_parent->_M_find_next(_M_cur);
3529  }
3530  else
3531  _M_trailing_empty = false;
3532  return *this;
3533  }
3534 
3535  constexpr _Iterator
3536  operator++(int)
3537  {
3538  auto __tmp = *this;
3539  ++*this;
3540  return __tmp;
3541  }
3542 
3543  friend constexpr bool
3544  operator==(const _Iterator& __x, const _Iterator& __y)
3545  {
3546  return __x._M_cur == __y._M_cur
3547  && __x._M_trailing_empty == __y._M_trailing_empty;
3548  }
3549  };
3550 
3551  struct _Sentinel
3552  {
3553  private:
3554  sentinel_t<_Vp> _M_end = sentinel_t<_Vp>();
3555 
3556  constexpr bool
3557  _M_equal(const _Iterator& __x) const
3558  { return __x._M_cur == _M_end && !__x._M_trailing_empty; }
3559 
3560  public:
3561  _Sentinel() = default;
3562 
3563  constexpr explicit
3564  _Sentinel(split_view* __parent)
3565  : _M_end(ranges::end(__parent->_M_base))
3566  { }
3567 
3568  friend constexpr bool
3569  operator==(const _Iterator& __x, const _Sentinel& __y)
3570  { return __y._M_equal(__x); }
3571  };
3572  };
3573 
3574  template<typename _Range, typename _Pattern>
3575  split_view(_Range&&, _Pattern&&)
3576  -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
3577 
3578  template<forward_range _Range>
3579  split_view(_Range&&, range_value_t<_Range>)
3580  -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
3581 
3582  namespace views
3583  {
3584  namespace __detail
3585  {
3586  template<typename _Range, typename _Pattern>
3587  concept __can_split_view
3588  = requires { split_view(std::declval<_Range>(), std::declval<_Pattern>()); };
3589  } // namespace __detail
3590 
3591  struct _Split : __adaptor::_RangeAdaptor<_Split>
3592  {
3593  template<viewable_range _Range, typename _Pattern>
3594  requires __detail::__can_split_view<_Range, _Pattern>
3595  constexpr auto
3596  operator() [[nodiscard]] (_Range&& __r, _Pattern&& __f) const
3597  {
3598  return split_view(std::forward<_Range>(__r), std::forward<_Pattern>(__f));
3599  }
3600 
3601  using _RangeAdaptor<_Split>::operator();
3602  static constexpr int _S_arity = 2;
3603  template<typename _Pattern>
3604  static constexpr bool _S_has_simple_extra_args
3605  = _LazySplit::_S_has_simple_extra_args<_Pattern>;
3606  };
3607 
3608  inline constexpr _Split split;
3609  } // namespace views
3610 
3611  namespace views
3612  {
3613  struct _Counted
3614  {
3615  template<input_or_output_iterator _Iter>
3616  constexpr auto
3617  operator() [[nodiscard]] (_Iter __i, iter_difference_t<_Iter> __n) const
3618  {
3619  if constexpr (contiguous_iterator<_Iter>)
3620  return span(std::__to_address(__i), __n);
3621  else if constexpr (random_access_iterator<_Iter>)
3622  return subrange(__i, __i + __n);
3623  else
3624  return subrange(counted_iterator(std::move(__i), __n),
3625  default_sentinel);
3626  }
3627  };
3628 
3629  inline constexpr _Counted counted{};
3630  } // namespace views
3631 
3632  template<view _Vp>
3633  requires (!common_range<_Vp>) && copyable<iterator_t<_Vp>>
3634  class common_view : public view_interface<common_view<_Vp>>
3635  {
3636  private:
3637  _Vp _M_base = _Vp();
3638 
3639  public:
3640  common_view() requires default_initializable<_Vp> = default;
3641 
3642  constexpr explicit
3643  common_view(_Vp __r)
3644  : _M_base(std::move(__r))
3645  { }
3646 
3647  /* XXX: LWG 3280 didn't remove this constructor, but I think it should?
3648  template<viewable_range _Range>
3649  requires (!common_range<_Range>)
3650  && constructible_from<_Vp, views::all_t<_Range>>
3651  constexpr explicit
3652  common_view(_Range&& __r)
3653  : _M_base(views::all(std::forward<_Range>(__r)))
3654  { }
3655  */
3656 
3657  constexpr _Vp
3658  base() const& requires copy_constructible<_Vp>
3659  { return _M_base; }
3660 
3661  constexpr _Vp
3662  base() &&
3663  { return std::move(_M_base); }
3664 
3665  constexpr auto
3666  begin()
3667  {
3668  if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3669  return ranges::begin(_M_base);
3670  else
3671  return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3672  (ranges::begin(_M_base));
3673  }
3674 
3675  constexpr auto
3676  begin() const requires range<const _Vp>
3677  {
3678  if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3679  return ranges::begin(_M_base);
3680  else
3681  return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3682  (ranges::begin(_M_base));
3683  }
3684 
3685  constexpr auto
3686  end()
3687  {
3688  if constexpr (random_access_range<_Vp> && sized_range<_Vp>)
3689  return ranges::begin(_M_base) + ranges::size(_M_base);
3690  else
3691  return common_iterator<iterator_t<_Vp>, sentinel_t<_Vp>>
3692  (ranges::end(_M_base));
3693  }
3694 
3695  constexpr auto
3696  end() const requires range<const _Vp>
3697  {
3698  if constexpr (random_access_range<const _Vp> && sized_range<const _Vp>)
3699  return ranges::begin(_M_base) + ranges::size(_M_base);
3700  else
3701  return common_iterator<iterator_t<const _Vp>, sentinel_t<const _Vp>>
3702  (ranges::end(_M_base));
3703  }
3704 
3705  constexpr auto
3706  size() requires sized_range<_Vp>
3707  { return ranges::size(_M_base); }
3708 
3709  constexpr auto
3710  size() const requires sized_range<const _Vp>
3711  { return ranges::size(_M_base); }
3712  };
3713 
3714  template<typename _Range>
3715  common_view(_Range&&) -> common_view<views::all_t<_Range>>;
3716 
3717  template<typename _Tp>
3718  inline constexpr bool enable_borrowed_range<common_view<_Tp>>
3719  = enable_borrowed_range<_Tp>;
3720 
3721  namespace views
3722  {
3723  namespace __detail
3724  {
3725  template<typename _Range>
3726  concept __already_common = common_range<_Range>
3727  && requires { views::all(std::declval<_Range>()); };
3728 
3729  template<typename _Range>
3730  concept __can_common_view
3731  = requires { common_view{std::declval<_Range>()}; };
3732  } // namespace __detail
3733 
3734  struct _Common : __adaptor::_RangeAdaptorClosure
3735  {
3736  template<viewable_range _Range>
3737  requires __detail::__already_common<_Range>
3738  || __detail::__can_common_view<_Range>
3739  constexpr auto
3740  operator() [[nodiscard]] (_Range&& __r) const
3741  {
3742  if constexpr (__detail::__already_common<_Range>)
3743  return views::all(std::forward<_Range>(__r));
3744  else
3745  return common_view{std::forward<_Range>(__r)};
3746  }
3747 
3748  static constexpr bool _S_has_simple_call_op = true;
3749  };
3750 
3751  inline constexpr _Common common;
3752  } // namespace views
3753 
3754  template<view _Vp>
3755  requires bidirectional_range<_Vp>
3756  class reverse_view : public view_interface<reverse_view<_Vp>>
3757  {
3758  private:
3759  static constexpr bool _S_needs_cached_begin
3760  = !common_range<_Vp> && !(random_access_range<_Vp>
3761  && sized_sentinel_for<sentinel_t<_Vp>,
3762  iterator_t<_Vp>>);
3763 
3764  _Vp _M_base = _Vp();
3765  [[no_unique_address]]
3766  __detail::__maybe_present_t<_S_needs_cached_begin,
3767  __detail::_CachedPosition<_Vp>>
3768  _M_cached_begin;
3769 
3770  public:
3771  reverse_view() requires default_initializable<_Vp> = default;
3772 
3773  constexpr explicit
3774  reverse_view(_Vp __r)
3775  : _M_base(std::move(__r))
3776  { }
3777 
3778  constexpr _Vp
3779  base() const& requires copy_constructible<_Vp>
3780  { return _M_base; }
3781 
3782  constexpr _Vp
3783  base() &&
3784  { return std::move(_M_base); }
3785 
3786  constexpr reverse_iterator<iterator_t<_Vp>>
3787  begin()
3788  {
3789  if constexpr (_S_needs_cached_begin)
3790  if (_M_cached_begin._M_has_value())
3791  return std::make_reverse_iterator(_M_cached_begin._M_get(_M_base));
3792 
3793  auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base));
3794  if constexpr (_S_needs_cached_begin)
3795  _M_cached_begin._M_set(_M_base, __it);
3796  return std::make_reverse_iterator(std::move(__it));
3797  }
3798 
3799  constexpr auto
3800  begin() requires common_range<_Vp>
3801  { return std::make_reverse_iterator(ranges::end(_M_base)); }
3802 
3803  constexpr auto
3804  begin() const requires common_range<const _Vp>
3805  { return std::make_reverse_iterator(ranges::end(_M_base)); }
3806 
3807  constexpr reverse_iterator<iterator_t<_Vp>>
3808  end()
3809  { return std::make_reverse_iterator(ranges::begin(_M_base)); }
3810 
3811  constexpr auto
3812  end() const requires common_range<const _Vp>
3813  { return std::make_reverse_iterator(ranges::begin(_M_base)); }
3814 
3815  constexpr auto
3816  size() requires sized_range<_Vp>
3817  { return ranges::size(_M_base); }
3818 
3819  constexpr auto
3820  size() const requires sized_range<const _Vp>
3821  { return ranges::size(_M_base); }
3822  };
3823 
3824  template<typename _Range>
3825  reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
3826 
3827  template<typename _Tp>
3828  inline constexpr bool enable_borrowed_range<reverse_view<_Tp>>
3829  = enable_borrowed_range<_Tp>;
3830 
3831  namespace views
3832  {
3833  namespace __detail
3834  {
3835  template<typename>
3836  inline constexpr bool __is_reversible_subrange = false;
3837 
3838  template<typename _Iter, subrange_kind _Kind>
3839  inline constexpr bool
3840  __is_reversible_subrange<subrange<reverse_iterator<_Iter>,
3841  reverse_iterator<_Iter>,
3842  _Kind>> = true;
3843 
3844  template<typename>
3845  inline constexpr bool __is_reverse_view = false;
3846 
3847  template<typename _Vp>
3848  inline constexpr bool __is_reverse_view<reverse_view<_Vp>> = true;
3849 
3850  template<typename _Range>
3851  concept __can_reverse_view
3852  = requires { reverse_view{std::declval<_Range>()}; };
3853  } // namespace __detail
3854 
3855  struct _Reverse : __adaptor::_RangeAdaptorClosure
3856  {
3857  template<viewable_range _Range>
3858  requires __detail::__is_reverse_view<remove_cvref_t<_Range>>
3859  || __detail::__is_reversible_subrange<remove_cvref_t<_Range>>
3860  || __detail::__can_reverse_view<_Range>
3861  constexpr auto
3862  operator() [[nodiscard]] (_Range&& __r) const
3863  {
3864  using _Tp = remove_cvref_t<_Range>;
3865  if constexpr (__detail::__is_reverse_view<_Tp>)
3866  return std::forward<_Range>(__r).base();
3867  else if constexpr (__detail::__is_reversible_subrange<_Tp>)
3868  {
3869  using _Iter = decltype(ranges::begin(__r).base());
3870  if constexpr (sized_range<_Tp>)
3871  return subrange<_Iter, _Iter, subrange_kind::sized>
3872  {__r.end().base(), __r.begin().base(), __r.size()};
3873  else
3874  return subrange<_Iter, _Iter, subrange_kind::unsized>
3875  {__r.end().base(), __r.begin().base()};
3876  }
3877  else
3878  return reverse_view{std::forward<_Range>(__r)};
3879  }
3880 
3881  static constexpr bool _S_has_simple_call_op = true;
3882  };
3883 
3884  inline constexpr _Reverse reverse;
3885  } // namespace views
3886 
3887  namespace __detail
3888  {
3889  template<typename _Tp, size_t _Nm>
3890  concept __has_tuple_element = requires(_Tp __t)
3891  {
3892  typename tuple_size<_Tp>::type;
3893  requires _Nm < tuple_size_v<_Tp>;
3894  typename tuple_element_t<_Nm, _Tp>;
3895  { std::get<_Nm>(__t) }
3896  -> convertible_to<const tuple_element_t<_Nm, _Tp>&>;
3897  };
3898 
3899  template<typename _Tp, size_t _Nm>
3900  concept __returnable_element
3901  = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Nm, _Tp>>;
3902  }
3903 
3904  template<input_range _Vp, size_t _Nm>
3905  requires view<_Vp>
3906  && __detail::__has_tuple_element<range_value_t<_Vp>, _Nm>
3907  && __detail::__has_tuple_element<remove_reference_t<range_reference_t<_Vp>>,
3908  _Nm>
3909  && __detail::__returnable_element<range_reference_t<_Vp>, _Nm>
3910  class elements_view : public view_interface<elements_view<_Vp, _Nm>>
3911  {
3912  public:
3913  elements_view() requires default_initializable<_Vp> = default;
3914 
3915  constexpr explicit
3916  elements_view(_Vp base)
3917  : _M_base(std::move(base))
3918  { }
3919 
3920  constexpr _Vp
3921  base() const& requires copy_constructible<_Vp>
3922  { return _M_base; }
3923 
3924  constexpr _Vp
3925  base() &&
3926  { return std::move(_M_base); }
3927 
3928  constexpr auto
3929  begin() requires (!__detail::__simple_view<_Vp>)
3930  { return _Iterator<false>(ranges::begin(_M_base)); }
3931 
3932  constexpr auto
3933  begin() const requires range<const _Vp>
3934  { return _Iterator<true>(ranges::begin(_M_base)); }
3935 
3936  constexpr auto
3937  end() requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>)
3938  { return _Sentinel<false>{ranges::end(_M_base)}; }
3939 
3940  constexpr auto
3941  end() requires (!__detail::__simple_view<_Vp> && common_range<_Vp>)
3942  { return _Iterator<false>{ranges::end(_M_base)}; }
3943 
3944  constexpr auto
3945  end() const requires range<const _Vp>
3946  { return _Sentinel<true>{ranges::end(_M_base)}; }
3947 
3948  constexpr auto
3949  end() const requires common_range<const _Vp>
3950  { return _Iterator<true>{ranges::end(_M_base)}; }
3951 
3952  constexpr auto
3953  size() requires sized_range<_Vp>
3954  { return ranges::size(_M_base); }
3955 
3956  constexpr auto
3957  size() const requires sized_range<const _Vp>
3958  { return ranges::size(_M_base); }
3959 
3960  private:
3961  template<bool _Const>
3962  using _Base = __detail::__maybe_const_t<_Const, _Vp>;
3963 
3964  template<bool _Const>
3965  struct __iter_cat
3966  { };
3967 
3968  template<bool _Const>
3969  requires forward_range<_Base<_Const>>
3970  struct __iter_cat<_Const>
3971  {
3972  private:
3973  static auto _S_iter_cat()
3974  {
3975  using _Base = elements_view::_Base<_Const>;
3976  using _Cat = typename iterator_traits<iterator_t<_Base>>::iterator_category;
3977  using _Res = decltype((std::get<_Nm>(*std::declval<iterator_t<_Base>>())));
3978  if constexpr (!is_lvalue_reference_v<_Res>)
3979  return input_iterator_tag{};
3980  else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
3981  return random_access_iterator_tag{};
3982  else
3983  return _Cat{};
3984  }
3985  public:
3986  using iterator_category = decltype(_S_iter_cat());
3987  };
3988 
3989  template<bool _Const>
3990  struct _Sentinel;
3991 
3992  template<bool _Const>
3993  struct _Iterator : __iter_cat<_Const>
3994  {
3995  private:
3996  using _Base = elements_view::_Base<_Const>;
3997 
3998  iterator_t<_Base> _M_current = iterator_t<_Base>();
3999 
4000  static constexpr decltype(auto)
4001  _S_get_element(const iterator_t<_Base>& __i)
4002  {
4003  if constexpr (is_reference_v<range_reference_t<_Base>>)
4004  return std::get<_Nm>(*__i);
4005  else
4006  {
4007  using _Et = remove_cv_t<tuple_element_t<_Nm, range_reference_t<_Base>>>;
4008  return static_cast<_Et>(std::get<_Nm>(*__i));
4009  }
4010  }
4011 
4012  static auto
4013  _S_iter_concept()
4014  {
4015  if constexpr (random_access_range<_Base>)
4016  return random_access_iterator_tag{};
4017  else if constexpr (bidirectional_range<_Base>)
4018  return bidirectional_iterator_tag{};
4019  else if constexpr (forward_range<_Base>)
4020  return forward_iterator_tag{};
4021  else
4022  return input_iterator_tag{};
4023  }
4024 
4025  friend _Iterator<!_Const>;
4026 
4027  public:
4028  using iterator_concept = decltype(_S_iter_concept());
4029  // iterator_category defined in elements_view::__iter_cat
4030  using value_type
4031  = remove_cvref_t<tuple_element_t<_Nm, range_value_t<_Base>>>;
4032  using difference_type = range_difference_t<_Base>;
4033 
4034  _Iterator() requires default_initializable<iterator_t<_Base>> = default;
4035 
4036  constexpr explicit
4037  _Iterator(iterator_t<_Base> current)
4038  : _M_current(std::move(current))
4039  { }
4040 
4041  constexpr
4042  _Iterator(_Iterator<!_Const> i)
4043  requires _Const && convertible_to<iterator_t<_Vp>, iterator_t<_Base>>
4044  : _M_current(std::move(i._M_current))
4045  { }
4046 
4047  constexpr const iterator_t<_Base>&
4048  base() const& noexcept
4049  { return _M_current; }
4050 
4051  constexpr iterator_t<_Base>
4052  base() &&
4053  { return std::move(_M_current); }
4054 
4055  constexpr decltype(auto)
4056  operator*() const
4057  { return _S_get_element(_M_current); }
4058 
4059  constexpr _Iterator&
4060  operator++()
4061  {
4062  ++_M_current;
4063  return *this;
4064  }
4065 
4066  constexpr void
4067  operator++(int)
4068  { ++_M_current; }
4069 
4070  constexpr _Iterator
4071  operator++(int) requires forward_range<_Base>
4072  {
4073  auto __tmp = *this;
4074  ++_M_current;
4075  return __tmp;
4076  }
4077 
4078  constexpr _Iterator&
4079  operator--() requires bidirectional_range<_Base>
4080  {
4081  --_M_current;
4082  return *this;
4083  }
4084 
4085  constexpr _Iterator
4086  operator--(int) requires bidirectional_range<_Base>
4087  {
4088  auto __tmp = *this;
4089  --_M_current;
4090  return __tmp;
4091  }
4092 
4093  constexpr _Iterator&
4094  operator+=(difference_type __n)
4095  requires random_access_range<_Base>
4096  {
4097  _M_current += __n;
4098  return *this;
4099  }
4100 
4101  constexpr _Iterator&
4102  operator-=(difference_type __n)
4103  requires random_access_range<_Base>
4104  {
4105  _M_current -= __n;
4106  return *this;
4107  }
4108 
4109  constexpr decltype(auto)
4110  operator[](difference_type __n) const
4111  requires random_access_range<_Base>
4112  { return _S_get_element(_M_current + __n); }
4113 
4114  friend constexpr bool
4115  operator==(const _Iterator& __x, const _Iterator& __y)
4116  requires equality_comparable<iterator_t<_Base>>
4117  { return __x._M_current == __y._M_current; }
4118 
4119  friend constexpr bool
4120  operator<(const _Iterator& __x, const _Iterator& __y)
4121  requires random_access_range<_Base>
4122  { return __x._M_current < __y._M_current; }
4123 
4124  friend constexpr bool
4125  operator>(const _Iterator& __x, const _Iterator& __y)
4126  requires random_access_range<_Base>
4127  { return __y._M_current < __x._M_current; }
4128 
4129  friend constexpr bool
4130  operator<=(const _Iterator& __x, const _Iterator& __y)
4131  requires random_access_range<_Base>
4132  { return !(__y._M_current > __x._M_current); }
4133 
4134  friend constexpr bool
4135  operator>=(const _Iterator& __x, const _Iterator& __y)
4136  requires random_access_range<_Base>
4137  { return !(__x._M_current > __y._M_current); }
4138 
4139 #ifdef __cpp_lib_three_way_comparison
4140  friend constexpr auto
4141  operator<=>(const _Iterator& __x, const _Iterator& __y)
4142  requires random_access_range<_Base>
4143  && three_way_comparable<iterator_t<_Base>>
4144  { return __x._M_current <=> __y._M_current; }
4145 #endif
4146 
4147  friend constexpr _Iterator
4148  operator+(const _Iterator& __x, difference_type __y)
4149  requires random_access_range<_Base>
4150  { return _Iterator{__x} += __y; }
4151 
4152  friend constexpr _Iterator
4153  operator+(difference_type __x, const _Iterator& __y)
4154  requires random_access_range<_Base>
4155  { return __y + __x; }
4156 
4157  friend constexpr _Iterator
4158  operator-(const _Iterator& __x, difference_type __y)
4159  requires random_access_range<_Base>
4160  { return _Iterator{__x} -= __y; }
4161 
4162  // _GLIBCXX_RESOLVE_LIB_DEFECTS
4163  // 3483. transform_view::iterator's difference is overconstrained
4164  friend constexpr difference_type
4165  operator-(const _Iterator& __x, const _Iterator& __y)
4166  requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
4167  { return __x._M_current - __y._M_current; }
4168 
4169  template <bool> friend struct _Sentinel;
4170  };
4171 
4172  template<bool _Const>
4173  struct _Sentinel
4174  {
4175  private:
4176  template<bool _Const2>
4177  constexpr bool
4178  _M_equal(const _Iterator<_Const2>& __x) const
4179  { return __x._M_current == _M_end; }
4180 
4181  template<bool _Const2>
4182  constexpr auto
4183  _M_distance_from(const _Iterator<_Const2>& __i) const
4184  { return _M_end - __i._M_current; }
4185 
4186  using _Base = elements_view::_Base<_Const>;
4187  sentinel_t<_Base> _M_end = sentinel_t<_Base>();
4188 
4189  public:
4190  _Sentinel() = default;
4191 
4192  constexpr explicit
4193  _Sentinel(sentinel_t<_Base> __end)
4194  : _M_end(std::move(__end))
4195  { }
4196 
4197  constexpr
4198  _Sentinel(_Sentinel<!_Const> __other)
4199  requires _Const
4200  && convertible_to<sentinel_t<_Vp>, sentinel_t<_Base>>
4201  : _M_end(std::move(__other._M_end))
4202  { }
4203 
4204  constexpr sentinel_t<_Base>
4205  base() const
4206  { return _M_end; }
4207 
4208  template<bool _Const2>
4209  requires sentinel_for<sentinel_t<_Base>,
4210  iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>>
4211  friend constexpr bool
4212  operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y)
4213  { return __y._M_equal(__x); }
4214 
4215  template<bool _Const2,
4216  typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4217  requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4218  friend constexpr range_difference_t<_Base2>
4219  operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y)
4220  { return -__y._M_distance_from(__x); }
4221 
4222  template<bool _Const2,
4223  typename _Base2 = __detail::__maybe_const_t<_Const2, _Vp>>
4224  requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base2>>
4225  friend constexpr range_difference_t<_Base2>
4226  operator-(const _Sentinel& __x, const _Iterator<_Const2>& __y)
4227  { return __x._M_distance_from(__y); }
4228 
4229  friend _Sentinel<!_Const>;
4230  };
4231 
4232  _Vp _M_base = _Vp();
4233  };
4234 
4235  template<typename _Tp, size_t _Nm>
4236  inline constexpr bool enable_borrowed_range<elements_view<_Tp, _Nm>>
4237  = enable_borrowed_range<_Tp>;
4238 
4239  template<typename _Range>
4240  using keys_view = elements_view<views::all_t<_Range>, 0>;
4241 
4242  template<typename _Range>
4243  using values_view = elements_view<views::all_t<_Range>, 1>;
4244 
4245  namespace views
4246  {
4247  namespace __detail
4248  {
4249  template<size_t _Nm, typename _Range>
4250  concept __can_elements_view
4251  = requires { elements_view<all_t<_Range>, _Nm>{std::declval<_Range>()}; };
4252  } // namespace __detail
4253 
4254  template<size_t _Nm>
4255  struct _Elements : __adaptor::_RangeAdaptorClosure
4256  {
4257  template<viewable_range _Range>
4258  requires __detail::__can_elements_view<_Nm, _Range>
4259  constexpr auto
4260  operator() [[nodiscard]] (_Range&& __r) const
4261  {
4262  return elements_view<all_t<_Range>, _Nm>{std::forward<_Range>(__r)};
4263  }
4264 
4265  static constexpr bool _S_has_simple_call_op = true;
4266  };
4267 
4268  template<size_t _Nm>
4269  inline constexpr _Elements<_Nm> elements;
4270  inline constexpr auto keys = elements<0>;
4271  inline constexpr auto values = elements<1>;
4272  } // namespace views
4273 
4274 } // namespace ranges
4275 
4276  namespace views = ranges::views;
4277 
4278 _GLIBCXX_END_NAMESPACE_VERSION
4279 } // namespace
4280 #endif // library concepts
4281 #endif // C++2a
4282 #endif /* _GLIBCXX_RANGES */