Namespaces
Variants

Standard library header <ranges> (C++20)

From cppreference.net
C++
Standard library headers

Этот заголовок является частью ranges библиотеки.

Содержание

Псевдонимы пространств имён

namespace std {

namespace views = ranges :: views ;

}
**Примечание:** В данном HTML-фрагменте весь текст уже является C++ кодом внутри тегов ` `, поэтому согласно требованиям переводу не подлежит. HTML-структура и атрибуты сохранены без изменений.

Псевдоним пространства имён std::views предоставляется как сокращение для std::ranges::views .

Включения

(C++20)
Поддержка оператора трёхстороннего сравнения
(C++11)
std::initializer_list шаблон класса
Итераторы диапазонов

Концепции

Концепции диапазонов
Определено в пространстве имён std::ranges
(C++20)
указывает, что тип является диапазоном, то есть предоставляет begin итератор и end cентинел
(концепт)
(C++20)
определяет, что тип является range и итераторы, полученные из его выражения, могут быть безопасно возвращены без риска висячих ссылок
(концепт)
(C++26)
указывает, что диапазон может оценить свой размер за постоянное время
(концепт)
(C++20)
определяет, что диапазон знает свой размер за постоянное время
(концепт)
(C++20)
указывает, что диапазон является представлением, то есть имеет постоянное время копирования/перемещения/присваивания
(концепт)
(C++20)
определяет диапазон, тип итератора которого удовлетворяет input_iterator
(концепт)
(C++20)
определяет диапазон, тип итератора которого удовлетворяет output_iterator
(концепт)
(C++20)
определяет диапазон, тип итератора которого удовлетворяет forward_iterator
(концепт)
(C++20)
определяет диапазон, тип итератора которого удовлетворяет bidirectional_iterator
(концепт)
(C++20)
задаёт диапазон, тип итератора которого удовлетворяет random_access_iterator
(концепт)
(C++20)
задаёт диапазон, тип итератора которого удовлетворяет contiguous_iterator
(концепт)
(C++20)
определяет, что диапазон имеет идентичные типы итератора и сторожащего элемента
(концепт)
(C++20)
определяет требования для range для безопасного преобразования в view
(концепт)
(C++23)
определяет, что диапазон имеет элементы только для чтения
(концепт)

Функции

Преобразования диапазонов
Определено в пространстве имён std::ranges
(C++23)
создаёт новый объект, не являющийся представлением, из входного диапазона
(шаблон функции)

Классы

Примитивы диапазонов
Определено в пространстве имён std::ranges
(C++20) (C++23) (C++20) (C++23)
получает типы итератора и сторожа диапазона
(псевдоним шаблона)
(C++20) (C++20) (C++20)
получает типы размера, разности и значения диапазона
(псевдоним шаблона)
(C++20) (C++23) (C++20) (C++20)
получает ссылочные типы диапазона
(псевдоним шаблона)
Представления
Определено в пространстве имён std::ranges
(C++20)
вспомогательный шаблон класса для определения view , использующий шаблонный паттерн CRTP (Curiously Recurring Template Pattern)
(шаблон класса)
(C++20)
объединяет пару итератор-страж в view
(шаблон класса)
Обработка висячих итераторов
Определено в пространстве имён std::ranges
(C++20)
тип-заполнитель, указывающий, что итератор или subrange не должен возвращаться, так как он будет висячим
(класс)
(C++20)
получает тип итератора или subrange типа для borrowed_range
(псевдоним шаблона)
Другие утилиты
Определено в пространстве имён std::ranges
(C++23)
помечает диапазон для обработки как последовательности, а не как одиночного значения
(шаблон класса)
Фабрики
Определено в пространстве имён std::ranges
(C++20)
пустой view без элементов
(шаблон класса) (шаблон переменной)
(C++20)
представление, которое содержит один элемент указанного значения
(шаблон класса) (объект точки кастомизации)
(C++20)
представление, view состоящее из последовательности, генерируемой повторным инкрементированием начального значения
(шаблон класса) (объект точки кастомизации)
(C++23)
представление, view состоящее из генерируемой последовательности путем многократного воспроизведения одного и того же значения
(шаблон класса) (объект точки кастомизации)
(C++20)
представление, view состоящее из элементов, полученных последовательным применением operator>> к связанному входному потоку
(шаблон класса) (объект точки кастомизации)
Адаптеры
Определено в пространстве имён std::ranges
(C++23)
вспомогательный базовый класс-шаблон для определения объекта замыкания адаптера диапазона
(шаблон класса)
(C++20)
представление view , которое включает все элементы range
(псевдоним шаблона) (объект адаптера диапазона)
(C++20)
представление view элементов некоторого другого range
(шаблон класса)
(C++20)
представление view с эксклюзивным владением некоторого range
(шаблон класса)
(C++23)
представление view последовательности, которое преобразует каждый элемент в rvalue
(шаблон класса) (объект адаптера диапазона)
(C++20)
представление, view состоящее из элементов range удовлетворяющих предикату
(шаблон класса) (объект адаптера диапазона)
(C++20)
представление view последовательности, которое применяет функцию преобразования к каждому элементу
(шаблон класса) (объект адаптера диапазона)
(C++20)
представление, view состоящее из первых N элементов другого view
(шаблон класса) (объект адаптера диапазона)
(C++20)
представление, view состоящее из начальных элементов другого view , до первого элемента, для которого предикат возвращает false
(шаблон класса) (объект адаптера диапазона)
(C++20)
представление, view состоящее из элементов другого view , пропускающее первые N элементов
(шаблон класса) (объект адаптера диапазона)
(C++20)
представление, view состоящее из элементов другого view , пропускающее начальную подпоследовательность элементов до первого элемента, где предикат возвращает false
(шаблон класса) (объект адаптера диапазона)
(C++20)
представление, view состоящее из последовательности, полученной путём выравнивания view из range s
(шаблон класса) (объект адаптера диапазона)
(C++23)
представление, view состоящее из последовательности, полученной путём выравнивания представления диапазонов, с разделителем между элементами
(шаблон класса) (объект адаптера диапазона)
(C++20)
представление view над поддиапазонами, полученными при разделении другого view с использованием разделителя
(шаблон класса) (объект адаптера диапазона)
(C++20)
представление view над поддиапазонами, полученными при разделении другого view с использованием разделителя
(шаблон класса) (объект адаптера диапазона)
(C++26)
представление, view состоящее из конкатенации адаптированных представлений
(шаблон класса) (объект точки кастомизации)
(C++20)
создает поддиапазон из итератора и счетчика
(объект точки кастомизации)
(C++20)
преобразует view в common_range
(шаблон класса) (объект адаптера диапазона)
(C++20)
представление view , которое итерирует по элементам другого двунаправленного представления в обратном порядке
(шаблон класса) (объект адаптера диапазона)
(C++23)
преобразует view в constant_range
(шаблон класса) (объект адаптера диапазона)
(C++20)
принимает view состоящий из tuple-like значений и число N, и создаёт view N th элемента каждого кортежа
(шаблон класса) (объект адаптера диапазона)
(C++20)
принимает view состоящий из пароподобных значений и создаёт view первых элементов каждой пары
(шаблон класса) (объект адаптера диапазона)
(C++20)
принимает view состоящий из пароподобных значений и создаёт view вторых элементов каждой пары
(шаблон класса) (объект адаптера диапазона)
(C++23)
представление, view которое отображает каждый элемент адаптированной последовательности в кортеж, содержащий как позицию элемента, так и его значение
(шаблон класса) (объект адаптера диапазона)
(C++23)
представление, view состоящее из кортежей ссылок на соответствующие элементы адаптированных представлений
(шаблон класса) (объект точки кастомизации)
(C++23)
представление view состоящее из результатов применения функции преобразования к соответствующим элементам адаптированных представлений
(шаблон класса) (объект точки настройки)
(C++23)
представление, view состоящее из кортежей ссылок на смежные элементы адаптированного представления
(шаблон класса) (объект адаптера диапазона)
(C++23)
представление view , состоящее из результатов применения функции преобразования к смежным элементам адаптированного представления
(шаблон класса) (объект адаптера диапазона)
(C++23)
диапазон view s , которые представляют собой N -размерные неперекрывающиеся последовательные фрагменты элементов другого view
(шаблон класса) (объект адаптера диапазона)
(C++23)
представление, view чей M й элемент является view над M м по (M + N - 1) й элементы другого view
(шаблон класса) (объект адаптера диапазона)
(C++23)
разделяет view на поддиапазоны между каждой парой смежных элементов, для которых заданный предикат возвращает false
(шаблон класса) (объект адаптера диапазона)
(C++23)
представление, view состоящее из элементов другого view , продвигающееся по N элементов за раз
(шаблон класса) (объект адаптера диапазона)
(C++23)
представление, view состоящее из кортежей результатов, вычисленных с помощью n-арного декартова произведения адаптированных представлений
(шаблон класса) (объект точки настройки)
(C++26)
представление view , которое кэширует последний доступный элемент своей базовой последовательности
(шаблон класса) (объект адаптера диапазона)
(C++26)
преобразует view в диапазон, который является input_range -только и не является common_range
(шаблон класса) (объект адаптера диапазона)

Объекты точек кастомизации

Доступ к диапазону
Определено в пространстве имён std::ranges
(C++20)
возвращает итератор на начало диапазона
(объект точки кастомизации)
(C++20)
возвращает sentinel, указывающий на конец диапазона
(объект точки кастомизации)
(C++20)
возвращает итератор на начало диапазона только для чтения
(объект точки настройки)
(C++20)
возвращает sentinel, указывающий на конец диапазона только для чтения
(объект точки кастомизации)
(C++20)
возвращает обратный итератор для диапазона
(объект точки кастомизации)
(C++20)
возвращает обратный конечный итератор для диапазона
(объект точки кастомизации)
(C++20)
возвращает обратный итератор для диапазона только для чтения
(объект точки кастомизации)
(C++20)
возвращает обратный конечный итератор для диапазона только для чтения
(объект точки кастомизации)
(C++26)
возвращает целое число, равное подсказке резервирования, предоставленной диапазоном
(объект точки кастомизации)
(C++20)
возвращает целое число, равное размеру диапазона
(объект точки кастомизации)
(C++20)
возвращает знаковое целое число, равное размеру диапазона
(объект точки кастомизации)
(C++20)
проверяет, является ли диапазон пустым
(объект точки кастомизации)
(C++20)
получает указатель на начало непрерывного диапазона
(объект точки кастомизации)
(C++20)
получает указатель на начало диапазона только для чтения с непрерывным расположением элементов
(объект точки настройки)

Перечисления

Определено в пространстве имён std::ranges
(C++20)
определяет, моделирует ли std::ranges::subrange концепцию std::ranges::sized_range
(перечисление)

Вспомогательные средства

(C++20)
получает размер std::ranges::subrange
(специализация шаблона класса)
(C++20)
получает тип итератора или сторожа std::ranges::subrange
(специализация шаблона класса)
(C++20)
получает итератор или страж из std::ranges::subrange
(шаблон функции)
(C++23)
тег from-range конструктора
(тег)

Синопсис 

// преимущественно независимая
#include <compare>
#include <initializer_list>
#include <iterator>
namespace std::ranges {
  inline namespace /* не указано */ {
    // доступ к диапазону
    inline constexpr /* не указано */ begin        = /* не указано */;
    inline constexpr /* не указано */ end          = /* не указано */;
    inline constexpr /* не указано */ cbegin       = /* не указано */;
    inline constexpr /* не указано */ cend         = /* не указано */;
    inline constexpr /* не указано */ rbegin       = /* не указано */;
    inline constexpr /* не указано */ rend         = /* не указано */;
    inline constexpr /* не указано */ crbegin      = /* не указано */;
    inline constexpr /* не указано */ crend        = /* не указано */;
    inline constexpr /* не указано */ size         = /* не указано */;
    inline constexpr /* не указано */ reserve_hint = /* не указано */;
    inline constexpr /* не указано */ ssize        = /* не указано */;
    inline constexpr /* не указано */ empty        = /* не указано */;
    inline constexpr /* не указано */ data         = /* не указано */;
    inline constexpr /* не указано */ cdata        = /* не указано */;
  }
  // диапазоны
  template<class T>
  concept range = /* см. описание */;
  template<class T>
  constexpr bool enable_borrowed_range = false;
  template<class T>
  concept borrowed_range = /* см. описание */;
  template<class T>
  using iterator_t = decltype(ranges::begin(declval<T&>()));
  template<range R>
  using sentinel_t = decltype(ranges::end(declval<R&>()));
  template<range R>
  using const_iterator_t = decltype(ranges::cbegin(declval<R&>()));
  template<range R>
  using const_sentinel_t = decltype(ranges::cend(declval<R&>()));
  template<range R>
  using range_difference_t = iter_difference_t<iterator_t<R>>;
  template<sized_range R>
  using range_size_t = decltype(ranges::size(declval<R&>()));
  template<range R>
  using range_value_t = iter_value_t<iterator_t<R>>;
  template<range R>
  using range_reference_t = iter_reference_t<iterator_t<R>>;
  template<range R>
  using range_const_reference_t = iter_const_reference_t<iterator_t<R>>;
  template<range R>
  using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;
  template<range R>
  using range_common_reference_t = iter_common_reference_t<iterator_t<R>>;
  // sized ranges
  template<class>
  constexpr bool disable_sized_range = false;
  template<class T>
  concept approximately_sized_range = /* см. описание */;
  template<class T>
  concept sized_range = /* см. описание */;
  // представления
  template<class T>
  constexpr bool enable_view = /* см. описание */;
  struct view_base
  {};
  template<class T>
  concept view = /* см. описание */;
  // другие уточнения диапазона
  template<class R, class T>
  concept output_range = /* см. описание */;
  template<class T>
  concept input_range = /* см. описание */;
  template<class T>
  concept forward_range = /* см. описание */;
  template<class T>
  concept bidirectional_range = /* см. описание */;
  template<class T>
  concept random_access_range = /* см. описание */;
  template<class T>
  concept contiguous_range = /* см. описание */;
  template<class T>
  concept common_range = /* см. описание */;
  template<class T>
  concept viewable_range = /* см. описание */;
  template<class T>
  concept constant_range = /* см. описание */;
  // шаблон класса view_interface
  template<class D>
    requires is_class_v<D> && same_as<D, remove_cv_t<D>>
  class view_interface;
  // поддиапазоны
  enum class subrange_kind : bool
  {
    unsized,
    sized
  };
  template<input_or_output_iterator I, sentinel_for<I> S = I, subrange_kind K =
             /* см. описание */>
    requires(K == subrange_kind::размерный || !sized_sentinel_for<S, I>)
  class subrange;
  template<class I, class S, subrange_kind K>
  constexpr bool enable_borrowed_range<subrange<I, S, K>> = true;
  template<size_t N, class I, class S, subrange_kind K>
    requires((N == 0 && copyable<I>) || N == 1)
  constexpr auto get(const subrange<I, S, K>& r);
  template<size_t N, class I, class S, subrange_kind K>
    requires(N < 2)
  constexpr auto get(subrange<I, S, K>&& r);
}
namespace std {
  using ranges::get;
}
namespace std::ranges {
  // обработка висячих итераторов
  struct dangling;
  // шаблон класса elements_of
  template<range R, class Allocator = allocator<byte>>
  struct elements_of; // размещенная
  template<range R>
  using borrowed_iterator_t = /* см. описание */;
  template<range R>
  using borrowed_subrange_t = /* см. описание */;
  // преобразования диапазонов
  template<class C, input_range R, class... Args>
    requires(!view<C>)
  constexpr C to(R&& r, Args&&... args);
  template<template<class...> class C, input_range R, class... Args>
  constexpr auto to(R&& r, Args&&... args);
  template<class C, class... Args>
    requires(!view<C>)
  constexpr auto to(Args&&... args);
  template<template<class...> class C, class... Args>
  constexpr auto to(Args&&... args);
  // пустое представление
  template<class T>
    requires is_object_v<T>
  class empty_view;
  template<class T>
  constexpr bool enable_borrowed_range<empty_view<T>> = true;
  namespace views {
    template<class T>
    constexpr empty_view<T> empty{};
  }
  // одиночное представление
  template<move_constructible T>
    requires is_object_v<T>
  class single_view;
  namespace views {
    inline constexpr /* не указано */ single = /* не указано */;
  }
  template<bool Const, class T>
  using /*возможно-константа*/ = conditional_t<Const, const T, T>; // exposition-only
  // представление iota
  template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
    requires /*weakly-equality-comparable-with*/<W, Bound> && copyable<W>
  class iota_view;
  template<class W, class Bound>
  constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true;
  namespace views {
    inline constexpr /* не указано */ iota = /* не указано */;
  }
  // повторное представление
  template<move_constructible T, semiregular Bound = unreachable_sentinel_t>
    requires /* см. описание */
  class repeat_view;
  namespace views {
    inline constexpr /* не указано */ repeat = /* не указано */;
  }
  // представление istream
  template<movable Val, class CharT, class Traits = char_traits<CharT>>
    requires                /* см. описание */
  class basic_istream_view; // размещённая
  template<class Val>
  using istream_view = basic_istream_view<Val, char>; // размещенная
  template<class Val>
  using wistream_view = basic_istream_view<Val, wchar_t>; // размещенная
  namespace views {
    template<class T>
    constexpr /* не указано */ istream = /* не указано */; // размещаемая
  }
  // объекты адаптеров диапазонов
  template<class D>
    requires is_class_v<D> && same_as<D, remove_cv_t<D>>
  class range_adaptor_closure
  {};
  // все представление
  namespace views {
    inline constexpr /* не указано */ all = /* не указано */;
    template<viewable_range R>
    using all_t = decltype(all(declval<R>()));
  }
  // представление ссылки
  template<range R>
    requires is_object_v<R>
  class ref_view;
  template<class T>
  constexpr bool enable_borrowed_range<ref_view<T>> = true;
  // владеющее представление
  template<range R>
    requires /* см. описание */
  class owning_view;
  template<class T>
  constexpr bool enable_borrowed_range<owning_view<T>> = enable_borrowed_range<T>;
  // как rvalue представление
  template<view V>
    requires input_range<V>
  class as_rvalue_view;
  template<class T>
  constexpr bool enable_borrowed_range<as_rvalue_view<T>> = enable_borrowed_range<T>;
  namespace views {
    inline constexpr /* не указано */ as_rvalue = /* не указано */;
  }
  // представление фильтра
  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
    requires view<V> && is_object_v<Pred>
  class filter_view;
  namespace views {
    inline constexpr /* не указано */ filter = /* не указано */;
  }
  // представление преобразования
  template<input_range V, move_constructible F>
    requires view<V> && is_object_v<F> && regular_invocable<F&, range_reference_t<V>> &&
             /*может ссылаться*/<invoke_result_t<F&, range_reference_t<V>>>
  class transform_view;
  namespace views {
    inline constexpr /* не указано */ transform = /* не указано */;
  }
  // получить представление
  template<view>
  class take_view;
  template<class T>
  constexpr bool enable_borrowed_range<take_view<T>> = enable_borrowed_range<T>;
  namespace views {
    inline constexpr /* не указано */ take = /* не указано */;
  }
  // представление take while
  template<view V, class Pred>
    requires input_range<V> && is_object_v<Pred> &&
             indirect_unary_predicate<const Pred, iterator_t<V>>
  class take_while_view;
  namespace views {
    inline constexpr /* не указано */ take_while = /* не указано */;
  }
  // удалить представление
  template<view V>
  class drop_view;
  template<class T>
  constexpr bool enable_borrowed_range<drop_view<T>> = enable_borrowed_range<T>;
  namespace views {
    inline constexpr /* не указано */ drop = /* не указано */;
  }
  // представление drop while
  template<view V, class Pred>
    requires input_range<V> && is_object_v<Pred> &&
             indirect_unary_predicate<const Pred, iterator_t<V>>
  class drop_while_view;
  template<class T, class Pred>
  constexpr bool enable_borrowed_range<drop_while_view<T, Pred>> =
    enable_borrowed_range<T>;
  namespace views {
    inline constexpr /* не указано */ drop_while = /* не указано */;
  }
  // представление join
  template<input_range V>
    requires view<V> && input_range<range_reference_t<V>>
  class join_view;
  namespace views {
    inline constexpr /* не указано */ join = /* не указано */;
  }
  // объединение с представлением
  template<input_range V, forward_range Pattern>
    requires /* см. описание */
  class join_with_view;
  namespace views {
    inline constexpr /* не указано */ join_with = /* не указано */;
  }
  // ленивое представление разделения
  template<class R>
  concept /*tiny-range*/ = /* см. описание */; // exposition-only
  template<input_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
             indirectly_comparable<iterator_t<V>,
                                   iterator_t<Pattern>,
                                   ranges::equal_to> &&
             (forward_range<V> || /*tiny-range*/<Pattern>)
  class lazy_split_view;
  // разделённое представление
  template<forward_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>
  class split_view;
  namespace views {
    inline constexpr /* не указано */ lazy_split = /* не указано */;
    inline constexpr /* не указано */ split      = /* не указано */;
  }
  // представление конкатенации
  template<input_range... Просмотры>
    requires /* см. описание */
  class concat_view;
  namespace views {
    inline constexpr /* не указано */ concat = /* не указано */;
  }
  // counted view
  namespace views {
    inline constexpr /* не указано */ counted = /* не указано */;
  }
  // общий вид
  template<view V>
    requires(!common_range<V> && copyable<iterator_t<V>>)
  class common_view;
  template<class T>
  constexpr bool enable_borrowed_range<common_view<T>> = enable_borrowed_range<T>;
  namespace views {
    inline constexpr /* не указано */ common = /* не указано */;
  }
  // обратное представление
  template<view V>
    requires bidirectional_range<V>
  class reverse_view;
  template<class T>
  constexpr bool enable_borrowed_range<reverse_view<T>> = enable_borrowed_range<T>;
  namespace views {
    inline constexpr /* не указано */ reverse = /* не указано */;
  }
  // как константное представление
  template<input_range R>
  constexpr auto& /*возможно-константный-диапазон*/(R& r) noexcept
  { // exposition-only
    if constexpr (input_range<const R>) {
      return const_cast<const R&>(r);
    } else {
      return r;
    }
  }
  template<view V>
    requires input_range<V>
  class as_const_view;
  template<class T>
  constexpr bool enable_borrowed_range<as_const_view<T>> = enable_borrowed_range<T>;
  namespace views {
    inline constexpr /* не указано */ as_const = /* не указано */;
  }
  // представление элементов
  template<input_range V, size_t N>
    requires /* см. описание */
  class elements_view;
  template<class T, size_t N>
  constexpr bool enable_borrowed_range<elements_view<T, N>> = enable_borrowed_range<T>;
  template<class R>
  using keys_view = elements_view<R, 0>;
  template<class R>
  using values_view = elements_view<R, 1>;
  namespace views {
    template<size_t N>
    constexpr /* не указано */ elements = /* не указано */;
    inline constexpr auto keys           = elements<0>;
    inline constexpr auto values         = elements<1>;
  }
  // перечисление представления
  template<view V>
    requires /* см. описание */
  class enumerate_view;
  template<class View>
  constexpr bool enable_borrowed_range<enumerate_view<View>> =
    enable_borrowed_range<View>;
  namespace views {
    inline constexpr /* не указано */ enumerate = /* не указано */;
  }
  // zip view
  template<input_range... Просмотры>
    requires(view<Views> && ...) && (sizeof...(Views) > 0)
  class zip_view;
  template<class... Просмотры>
  constexpr bool enable_borrowed_range<zip_view<Views...>> =
    (enable_borrowed_range<Views> && ...);
  namespace views {
    inline constexpr /* не указано */ zip = /* не указано */;
  }
  // представление zip transform
  template<move_constructible F, input_range... Просмотры>
    requires(view<Views> && ...) && (sizeof...(Views) > 0) && is_object_v<F> &&
            regular_invocable<F&, range_reference_t<Views>...> &&
            /*может ссылаться*/<invoke_result_t<F&, range_reference_t<Views>...>>
  class zip_transform_view;
  namespace views {
    inline constexpr /* не указано */ zip_transform = /* не указано */;
  }
  // смежное представление
  template<forward_range V, size_t N>
    requires view<V> && (N > 0)
  class adjacent_view;
  template<class V, size_t N>
  constexpr bool enable_borrowed_range<adjacent_view<V, N>> = enable_borrowed_range<V>;
  namespace views {
    template<size_t N>
    constexpr /* не указано */ adjacent = /* не указано */;
    inline constexpr auto pairwise       = adjacent<2>;
  }
  // adjacent transform view
  template<forward_range V, move_constructible F, size_t N>
    requires /* см. описание */
  class adjacent_transform_view;
  namespace views {
    template<size_t N>
    constexpr /* не указано */ adjacent_transform = /* не указано */;
    inline constexpr auto pairwise_transform       = adjacent_transform<2>;
  }
  // представление чанка
  template<view V>
    requires input_range<V>
  class chunk_view;
  template<view V>
    requires forward_range<V>
  class chunk_view<V>;
  template<class V>
  constexpr bool enable_borrowed_range<chunk_view<V>> =
    forward_range<V> && enable_borrowed_range<V>;
  namespace views {
    inline constexpr /* не указано */ chunk = /* не указано */;
  }
  // представление слайда
  template<forward_range V>
    requires view<V>
  class slide_view;
  template<class V>
  constexpr bool enable_borrowed_range<slide_view<V>> = enable_borrowed_range<V>;
  namespace views {
    inline constexpr /* не указано */ slide = /* не указано */;
  }
  // chunk by view
  template<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred>
    requires view<V> && is_object_v<Pred>
  class chunk_by_view;
  namespace views {
    inline constexpr /* не указано */ chunk_by = /* не указано */;
  }
  // представление с шагом
  template<input_range V>
    requires view<V>
  class stride_view;
  template<class V>
  constexpr bool enable_borrowed_range<stride_view<V>> = enable_borrowed_range<V>;
  namespace views {
    inline constexpr /* не указано */ stride = /* не указано */;
  }
  // декартово произведение представлений
  template<input_range First, forward_range... Vs>
    requires(view<First> && ... && view<Vs>)
  class cartesian_product_view;
  namespace views {
    inline constexpr /* не указано */ cartesian_product = /* не указано */;
  }
  // кэшировать последнее представление
  template<input_range V>
    requires view<V>
  class cache_latest_view;
  namespace views {
    inline constexpr /* не указано */ cache_latest = /* не указано */;
  }
  // к представлению ввода
  template<input_range V>
    requires view<V>
  class to_input_view;
  template<class V>
  constexpr bool enable_borrowed_range<to_input_view<V>> = enable_borrowed_range<V>;
  namespace views {
    inline constexpr /* не указано */ to_input = /* не указано */;
  }
}
namespace std {
  namespace views = ranges::просмотры;
  template<class T>
  struct tuple_size;
  template<size_t I, class T>
  struct tuple_element;
  template<class I, class S, ranges::subrange_kind K>
  struct tuple_size<ranges::subrange<I, S, K>> : integral_constant<size_t, 2>
  {};
  template<class I, class S, ranges::subrange_kind K>
  struct tuple_element<0, ranges::subrange<I, S, K>>
  {
    using type = I;
  };
  template<class I, class S, ranges::subrange_kind K>
  struct tuple_element<1, ranges::subrange<I, S, K>>
  {
    using type = S;
  };
  template<class I, class S, ranges::subrange_kind K>
  struct tuple_element<0, const ranges::subrange<I, S, K>>
  {
    using type = I;
  };
  template<class I, class S, ranges::subrange_kind K>
  struct tuple_element<1, const ranges::subrange<I, S, K>>
  {
    using type = S;
  };
  struct from_range_t
  {
    explicit from_range_t() = default;
  };
  inline constexpr from_range_t from_range{};
}

Концепт range 

namespace std::ranges {
  template<class T>
  concept range = requires(T& t) {
    ranges::begin(t); // иногда сохраняющий равенство (см. описание)
    ranges::end(t);
  };
}

Концепт borrowed_range 

namespace std::ranges {
  template<class T>
  concept borrowed_range =
    range<T> && (is_lvalue_reference_v<T> || enable_borrowed_range<remove_cvref_t<T>>);
}

Концепт approximately_sized_range 

namespace std::ranges {
  template<class T>
  concept approximately_sized_range = range<T> && requires(T& t) {
    ranges::reserve_hint(t);
  };
}

Концепт sized_range 

namespace std::ranges {
  template<class T>
  concept sized_range = approximately_sized_range<T> && requires(T& t) {
    ranges::size(t);
  };
}

Концепт view 

namespace std::ranges {
  template<class T>
  constexpr bool /*is-derived-from-view-interface*/ =
    /* см. описание */; // только для экспозиции
  template<class T>
  constexpr bool enable_view =
    derived_from<T, view_base> || /*is-derived-from-view-interface*/<T>;
  template<class T>
  concept view = range<T> && movable<T> && enable_view<T>;
}

Концепт output_range 

namespace std::ranges {
  template<class R, class T>
  concept output_range = range<R> && output_iterator<iterator_t<R>, T>;
}

Концепт input_range 

namespace std::ranges {
  template<class T>
  concept input_range = range<T> && input_iterator<iterator_t<T>>;
}
**Перевод текста на веб-странице:** Пространство имен `std::ranges` определяет концепт `input_range`, который требует, чтобы тип `T` был диапазоном (`range `) и чтобы его тип итератора (`iterator_t `) удовлетворял концепту `input_iterator`.

Концепт forward_range 

namespace std::ranges {
  template<class T>
  concept forward_range = input_range<T> && forward_iterator<iterator_t<T>>;
}

Концепт bidirectional_range 

namespace std::ranges {
  template<class T>
  concept bidirectional_range = forward_range<T> && bidirectional_iterator<iterator_t<T>>;
}
**Примечание:** Весь код C++ внутри тегов ` 
` и `` оставлен без изменений, как и требовалось. HTML-разметка и атрибуты также сохранены в оригинальном виде.

Концепт random_access_range 

namespace std::ranges {
  template<class T>
  concept random_access_range =
    bidirectional_range<T> && random_access_iterator<iterator_t<T>>;
}

Концепт contiguous_range 

namespace std::ranges {
  template<class T>
  concept contiguous_range =
    random_access_range<T> && contiguous_iterator<iterator_t<T>> && requires(T& t) {
      {
        ranges::data(t)
      } -> same_as<add_pointer_t<range_reference_t<T>>>;
    };
}

Концепт common_range 

namespace std::ranges {
  template<class T>
  concept common_range = range<T> && same_as<iterator_t<T>, sentinel_t<T>>;
}

Концепт viewable_range 

namespace std::ranges {
  template<class T>
  concept viewable_range =
    range<T> && ((view<remove_cvref_t<T>> && constructible_from<remove_cvref_t<T>, T>) ||
                 (!view<remove_cvref_t<T>> &&
                  (is_lvalue_reference_v<T> ||
                   (movable<remove_reference_t<T>> && !/*is-initializer-list*/<T>))));
}

Концепт constant_range 

namespace std::ranges {
  template<class T>
  concept constant_range = input_range<T> && /*constant-iterator*/<iterator_t<T>>;
}

Вспомогательные концепции

Примечание: Концепции в этом разделе приведены только для пояснения и не являются частью интерфейса. 

namespace std::ranges { // не указано, только для поиска по имени
  template<class R>
  concept /*simple-view*/ = // только для экспозиции
    view<R> && range<const R> && same_as<iterator_t<R>, iterator_t<const R>> &&
    same_as<sentinel_t<R>, sentinel_t<const R>>;
  template<class I>
  concept /*has-arrow*/ = // только для экспозиции
    input_iterator<I> && (is_pointer_v<I> || requires(const I i) { i.operator->(); });
  template<class T, class U>
  concept /*different-from*/ = // только для экспозиции
    !same_as<remove_cvref_t<T>, remove_cvref_t<U>>;
  template<class R>
  concept /*range-with-movable-references*/ = // только для экспозиции
    input_range<R> && move_constructible<range_reference_t<R>> &&
    move_constructible<range_rvalue_reference_t<R>>;
  template<class R>
  constexpr bool /*is-initializer-list*/ = /* см. описание */; // только для экспозиции
  template<class T>
  constexpr auto
  /*as-const-pointer*/(const T* p) noexcept
  {
    return p;
  } // только для экспозиции
}

Шаблон класса std::ranges::view_interface 

namespace std::ranges {
  template<class D>
    requires is_class_v<D> && same_as<D, remove_cv_t<D>>
  class view_interface
  {
  private:
    constexpr D& /*производный*/() noexcept
    { // только для экспозиции
      return static_cast<D&>(*this);
    }
    constexpr const D& /*производный*/() const noexcept
    { // exposition-only
      return static_cast<const D&>(*this);
    }
  public:
    constexpr bool empty()
      requires sized_range<D> || forward_range<D>
    {
      if constexpr (sized_range<D>)
        return ranges::size(/*производный*/()) == 0;
      else
        return ranges::begin(/*производный*/()) == ranges::end(/*производный*/());
    }
    constexpr bool empty() const
      requires sized_range<const D> || forward_range<const D>
    {
      if constexpr (sized_range<const D>)
        return ranges::size(/*производный*/()) == 0;
      else
        return ranges::begin(/*производный*/()) == ranges::end(/*производный*/());
    }
    constexpr auto cbegin()
      requires input_range<D>
    {
      return ranges::cbegin(/*производный*/());
    }
    constexpr auto cbegin() const
      requires input_range<const D>
    {
      return ranges::cbegin(/*производный*/());
    }
    constexpr auto cend()
      requires input_range<D>
    {
      return ranges::cend(/*производный*/());
    }
    constexpr auto cend() const
      requires input_range<const D>
    {
      return ranges::cend(/*производный*/());
    }
    constexpr explicit operator bool()
      requires requires { ranges::empty(/*производный*/()); }
    {
      return !ranges::empty(/*производный*/());
    }
    constexpr explicit operator bool() const
      requires requires { ranges::empty(/*производный*/()); }
    {
      return !ranges::empty(/*производный*/());
    }
    constexpr auto data()
      requires contiguous_iterator<iterator_t<D>>
    {
      return to_address(ranges::begin(/*производный*/()));
    }
    constexpr auto data() const
      requires range<const D> && contiguous_iterator<iterator_t<const D>>
    {
      return to_address(ranges::begin(/*производный*/()));
    }
    constexpr auto size()
      requires forward_range<D> && sized_sentinel_for<sentinel_t<D>, iterator_t<D>>
    {
      return /*to-unsigned-like*/(ranges::end(/*производный*/()) -
                                  ranges::begin(/*производный*/()));
    }
    constexpr auto size() const
      requires forward_range<const D> &&
               sized_sentinel_for<sentinel_t<const D>, iterator_t<const D>>
    {
      return /*к-беззнаковому-типу*/(ranges::end(/*производный*/()) -
                                  ranges::begin(/*производный*/()));
    }
    constexpr decltype(auto) front()
      requires forward_range<D>;
    constexpr decltype(auto) front() const
      requires forward_range<const D>;
    constexpr decltype(auto) back()
      requires bidirectional_range<D> && common_range<D>;
    constexpr decltype(auto) back() const
      requires bidirectional_range<const D> && common_range<const D>;
    template<random_access_range R = D>
    constexpr decltype(auto) operator[](range_difference_t<R> n)
    {
      return ranges::begin(/*производный*/())[n];
    }
    template<random_access_range R = const D>
    constexpr decltype(auto) operator[](range_difference_t<R> n) const
    {
      return ranges::begin(/*производный*/())[n];
    }
  };
}

Шаблон класса std::ranges::subrange 

namespace std::ranges {
  template<class From, class To>
  concept /*использует-неквалифицированное-преобразование-указателя*/ = // exposition-only
    is_pointer_v<From> && is_pointer_v<To> &&
    !convertible_to<remove_pointer_t<From> (*)[], remove_pointer_t<To> (*)[]>;
  template<class From, class To>
  concept /*конвертируемый-без-срезки*/ = // exposition-only
    convertible_to<From, To> &&
    !/*использует-преобразование-указателя-без-квалификации*/<decay_t<From>, decay_t<To>>;
  template<class T, class U, class V>
  concept /*pair-like-convertible-from*/ = // exposition-only
    !range<T> && !is_reference_v<T> && /*pair-like*/<T> && constructible_from<T, U, V> &&
    /*конвертируемый-без-срезки*/<U, tuple_element_t<0, T>> &&
    convertible_to<V, tuple_element_t<1, T>>;
  template<input_or_output_iterator I,
           sentinel_for<I> S = I,
           subrange_kind K =
             sized_sentinel_for<S, I> ? subrange_kind::размерный : subrange_kind::unsized>
    requires(K == subrange_kind::размерный || !sized_sentinel_for<S, I>)
  class subrange : public view_interface<subrange<I, S, K>>
  {
  private:
    static constexpr bool /*StoreSize*/ = // exposition-only
      K == subrange_kind::размерный && !sized_sentinel_for<S, I>;
    I /*начало_*/ = I(); // exposition-only
    S /*конец_*/   = S(); // exposition-only
    /*make-unsigned-like-t*/<iter_difference_t<I>> /*размер_*/ =
      0; // экспозиция присутствует только
         // если StoreSize равно true
  public:
    subrange()
      requires default_initializable<I>
    = default;
    constexpr subrange(/*конвертируемый-без-срезки*/<I> auto i, S s)
      requires(!/*StoreSize*/);
    constexpr subrange(/*конвертируемый-без-срезки*/<I> auto i,
                       S s,
                       /*make-unsigned-like-t*/<iter_difference_t<I>> n)
      requires(K == subrange_kind::размерный);
    template</*отличается-от*/<subrange> R>
      requires borrowed_range<R> && /*конвертируемый-без-срезки*/<iterator_t<R>, I> &&
               convertible_to<sentinel_t<R>, S>
               constexpr subrange(R&& r)
                 requires(!/*StoreSize*/ || sized_range<R>);
    template<borrowed_range R>
      requires /*конвертируемый-без-срезки*/<iterator_t<R>, I> &&
               convertible_to<sentinel_t<R>, S>
               constexpr subrange(R&& r, /*make-unsigned-like-t*/<iter_difference_t<I>> n)
                 requires(K == subrange_kind::размерный)
      : subrange{ ranges::begin(r), ranges::end(r), n }
    {
    }
    template</*отличается-от*/<subrange> PairLike>
      requires /*pair-like-convertible-from*/<PairLike, const I&, const S&>
    constexpr operator PairLike() const;
    constexpr I begin() const
      requires copyable<I>;
    constexpr I begin()
      requires(!copyable<I>);
    constexpr S end() const;
    constexpr bool empty() const;
    constexpr /*make-unsigned-like-t*/<iter_difference_t<I>> size() const
      requires(K == subrange_kind::размерный);
    constexpr subrange next(iter_difference_t<I> n = 1) const&
      requires forward_iterator<I>;
    constexpr subrange next(iter_difference_t<I> n = 1) &&;
    constexpr subrange prev(iter_difference_t<I> n = 1) const
      requires bidirectional_iterator<I>;
    constexpr subrange& advance(iter_difference_t<I> n);
  };
  template<input_or_output_iterator I, sentinel_for<I> S>
  subrange(I, S) -> subrange<I, S>;
  template<input_or_output_iterator I, sentinel_for<I> S>
  subrange(I, S, /*make-unsigned-like-t*/<iter_difference_t<I>>)
    -> subrange<I, S, subrange_kind::размерный>;
  template<borrowed_range R>
  subrange(R&&)
    -> subrange<iterator_t<R>,
                sentinel_t<R>,
                (sized_range<R> || sized_sentinel_for<sentinel_t<R>, iterator_t<R>>)
                  ? subrange_kind::размерный
                  : subrange_kind::unsized>;
  template<borrowed_range R>
  subrange(R&&, /*make-unsigned-like-t*/<range_difference_t<R>>)
    -> subrange<iterator_t<R>, sentinel_t<R>, subrange_kind::размерный>;
}

Класс std::ranges::dangling 

namespace std::ranges {
  struct dangling
  {
    constexpr dangling() noexcept = default;
    constexpr dangling(auto&&...) noexcept {}
  };
}

Класс std::ranges::elements_of 

namespace std::ranges {
  template<range R, class Allocator = allocator<byte>>
  struct elements_of
  {
    [[no_unique_address]] R range;
    [[no_unique_address]] Allocator allocator = Allocator();
  };
  template<class R, class Allocator = allocator<byte>>
  elements_of(R&&, Allocator = Allocator()) -> elements_of<R&&, Allocator>;
}

Шаблон класса std::ranges::empty_view 

namespace std::ranges {
  template<class T>
    requires is_object_v<T>
  class empty_view : public view_interface<empty_view<T>>
  {
  public:
    static constexpr T* begin() noexcept { return nullptr; }
    static constexpr T* end() noexcept { return nullptr; }
    static constexpr T* data() noexcept { return nullptr; }
    static constexpr size_t size() noexcept { return 0; }
    static constexpr bool empty() noexcept { return true; }
  };
}

Шаблон класса std::ranges::single_view 

namespace std::ranges {
  template<move_constructible T>
    requires is_object_v<T>
  class single_view : public view_interface<single_view<T>>
  {
  private:
    /*movable-box*/<T> /*value_*/; // только для демонстрации
  public:
    single_view()
      requires default_initializable<T>
    = default;
    constexpr explicit single_view(const T& t)
      requires copy_constructible<T>;
    constexpr explicit single_view(T&& t);
    template<class... Args>
      requires constructible_from<T, Args...>
    constexpr explicit single_view(in_place_t, Args&&... args);
    constexpr T* begin() noexcept;
    constexpr const T* begin() const noexcept;
    constexpr T* end() noexcept;
    constexpr const T* end() const noexcept;
    static constexpr bool empty() noexcept;
    static constexpr size_t size() noexcept;
    constexpr T* data() noexcept;
    constexpr const T* data() const noexcept;
  };
  template<class T>
  single_view(T) -> single_view<T>;
}

Шаблон класса std::ranges::iota_view 

namespace std::ranges {
  template<class I>
  concept /*decrementable*/ = /* see description */; // только для демонстрации
  template<class I>
  concept /*advanceable*/ = /* see description */; // только для демонстрации
  template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
    requires /*weakly-equality-comparable-with*/<W, Bound> && copyable<W>
  class iota_view : public view_interface<iota_view<W, Bound>>
  {
  private:
    // класс iota_view::iterator
    struct /*iterator*/; // только для демонстрации
    // класс iota_view::sentinel
    struct /*sentinel*/; // только для демонстрации
    W /*value_*/     = W();     // только для демонстрации
    Bound /*bound_*/ = Bound(); // только для демонстрации
  public:
    iota_view()
      requires default_initializable<W>
    = default;
    constexpr explicit iota_view(W value);
    constexpr explicit iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);
    constexpr explicit iota_view(/*iterator*/ first, /* see description */ last);
    constexpr /*iterator*/ begin() const;
    constexpr auto end() const;
    constexpr /*iterator*/ end() const
      requires same_as<W, Bound>;
    constexpr bool empty() const;
    constexpr auto size() const
      requires /* see description */;
  };
  template<class W, class Bound>
    requires(!/*is-integer-like*/<W> || !/*is-integer-like*/<Bound> ||
             (/*is-signed-integer-like*/<W> == /*is-signed-integer-like*/<Bound>))
  iota_view(W, Bound) -> iota_view<W, Bound>;
}

Шаблон класса std::ranges::iota_view::iterator 

namespace std::ranges {
  template<weakly_incrementable W, semiregular Bound>
    requires /*weakly-equality-comparable-with*/<W, Bound> && copyable<W>
  struct iota_view<W, Bound>::/*iterator*/
  {
  private:
    W /*value_*/ = W(); // только для демонстрации
  public:
    using iterator_concept = /* см. описание */;
    using iterator_category =
      input_iterator_tag; // присутствует только если W моделирует incrementable и
                          // IOTA-DIFF-T(W) является целочисленным типом
    using value_type      = W;
    using difference_type = /*IOTA-DIFF-T*/(W);
    /*iterator*/()
      requires default_initializable<W>
    = default;
    constexpr explicit /*iterator*/(W value);
    constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v<W>);
    constexpr /*iterator*/& operator++();
    constexpr void operator++(int);
    constexpr /*iterator*/ operator++(int)
      requires incrementable<W>;
    constexpr /*iterator*/& operator--()
      requires /*decrementable*/<W>;
    constexpr /*iterator*/ operator--(int)
      requires /*decrementable*/<W>;
    constexpr /*iterator*/& operator+=(difference_type n)
      requires /*advanceable*/<W>;
    constexpr /*iterator*/& operator-=(difference_type n)
      requires /*advanceable*/<W>;
    constexpr W operator[](difference_type n) const
      requires /*advanceable*/<W>;
    friend constexpr bool operator==(const /*iterator*/& x, const /*iterator*/& y)
      requires equality_comparable<W>;
    friend constexpr bool operator<(const /*iterator*/& x, const /*iterator*/& y)
      requires totally_ordered<W>;
    friend constexpr bool operator>(const /*iterator*/& x, const /*iterator*/& y)
      requires totally_ordered<W>;
    friend constexpr bool operator<=(const /*iterator*/& x, const /*iterator*/& y)
      requires totally_ordered<W>;
    friend constexpr bool operator>=(const /*iterator*/& x, const /*iterator*/& y)
      requires totally_ordered<W>;
    friend constexpr auto operator<=>(const /*iterator*/& x, const /*iterator*/& y)
      requires totally_ordered<W> && three_way_comparable<W>;
    friend constexpr /*iterator*/ operator+(/*iterator*/ i, difference_type n)
      requires /*advanceable*/<W>;
    friend constexpr /*iterator*/ operator+(difference_type n, /*iterator*/ i)
      requires /*advanceable*/<W>;
    friend constexpr /*iterator*/ operator-(/*iterator*/ i, difference_type n)
      requires /*advanceable*/<W>;
    friend constexpr difference_type operator-(const /*iterator*/& x,
                                               const /*iterator*/& y)
      requires /*advanceable*/<W>;
  };
}

Шаблон класса std::ranges::iota_view::sentinel 

namespace std::ranges {
  template<weakly_incrementable W, semiregular Bound>
    requires /*weakly-equality-comparable-with*/<W, Bound> && copyable<W>
  struct iota_view<W, Bound>::/*sentinel*/
  {
  private:
    Bound /*bound_*/ = Bound(); // только для демонстрации
  public:
    /*sentinel*/() = default;
    constexpr explicit /*sentinel*/(Bound bound);
    friend constexpr bool operator==(const /*iterator*/& x, const /*sentinel*/& y);
    friend constexpr iter_difference_t<W> operator-(const /*iterator*/& x,
                                                    const /*sentinel*/& y)
      requires sized_sentinel_for<Bound, W>;
    friend constexpr iter_difference_t<W> operator-(const /*sentinel*/& x,
                                                    const /*iterator*/& y)
      requires sized_sentinel_for<Bound, W>;
  };
}

Шаблон класса std::ranges::repeat_view 

namespace std::ranges {
  template<class T>
  concept /*integer-like-with-usable-difference-type*/ = // только для демонстрации
    /*is-signed-integer-like*/<T> || (/*is-integer-like*/<T> && weakly_incrementable<T>);
  template<move_constructible T, semiregular Bound = unreachable_sentinel_t>
    requires(is_object_v<T> && same_as<T, remove_cv_t<T>> &&
             (/*integer-like-with-usable-difference-type*/<Bound> ||
              same_as<Bound, unreachable_sentinel_t>))
  class repeat_view : public view_interface<repeat_view<T, Bound>>
  {
  private:
    // класс repeat_view::iterator
    struct /*iterator*/; // только для демонстрации
    /*movable-box*/<T> /*value_*/; // только для демонстрации
    Bound /*bound_*/ = Bound();    // только для демонстрации
  public:
    repeat_view()
      requires default_initializable<T>
    = default;
    constexpr explicit repeat_view(const T& value, Bound bound = Bound())
      requires copy_constructible<T>;
    constexpr explicit repeat_view(T&& value, Bound bound = Bound());
    template<class... TArgs, class... BoundArgs>
      requires constructible_from<T, TArgs...> && constructible_from<Bound, BoundArgs...>
    constexpr explicit repeat_view(piecewise_construct_t,
                                   tuple<TArgs...> value_args,
                                   tuple<BoundArgs...> bound_args = tuple<>{});
    constexpr /*iterator*/ begin() const;
    constexpr /*iterator*/ end() const
      requires(!same_as<Bound, unreachable_sentinel_t>);
    constexpr unreachable_sentinel_t end() const noexcept;
    constexpr auto size() const
      requires(!same_as<Bound, unreachable_sentinel_t>);
  };
  template<class T, class Bound = unreachable_sentinel_t>
  repeat_view(T, Bound = Bound()) -> repeat_view<T, Bound>;
}

Шаблон класса std::ranges::repeat_view::iterator 

namespace std::ranges {
  template<move_constructible T, semiregular Bound>
    requires(is_object_v<T> && same_as<T, remove_cv_t<T>> &&
             (/*integer-like-with-usable-difference-type*/<Bound> ||
              same_as<Bound, unreachable_sentinel_t>))
  class repeat_view<T, Bound>::/*iterator*/
  {
  private:
    using /*index-type*/ = // только для пояснения
      conditional_t<same_as<Bound, unreachable_sentinel_t>, ptrdiff_t, Bound>;
    const T* /*value_*/         = nullptr;          // только для пояснения
    /*index-type*/ /*current_*/ = /*index-type*/(); // только для пояснения
    constexpr explicit /*iterator*/(
      const T* value,
      /*index-type*/ b = /*index-type*/()); // только для пояснения
  public:
    using iterator_concept  = random_access_iterator_tag;
    using iterator_category = random_access_iterator_tag;
    using value_type        = T;
    using difference_type   = /* см. описание */;
    /*iterator*/()          = default;
    constexpr const T& operator*() const noexcept;
    constexpr /*iterator*/& operator++();
    constexpr /*iterator*/ operator++(int);
    constexpr /*iterator*/& operator--();
    constexpr /*iterator*/ operator--(int);
    constexpr /*iterator*/& operator+=(difference_type n);
    constexpr /*iterator*/& operator-=(difference_type n);
    constexpr const T& operator[](difference_type n) const noexcept;
    friend constexpr bool operator==(const /*iterator*/& x, const /*iterator*/& y);
    friend constexpr auto operator<=>(const /*iterator*/& x, const /*iterator*/& y);
    friend constexpr /*iterator*/ operator+(/*iterator*/ i, difference_type n);
    friend constexpr /*iterator*/ operator+(difference_type n, /*iterator*/ i);
    friend constexpr /*iterator*/ operator-(/*iterator*/ i, difference_type n);
    friend constexpr difference_type operator-(const /*iterator*/& x,
                                               const /*iterator*/& y);
  };
}

Шаблон класса std::ranges::basic_istream_view 

namespace std::ranges {
  template<class Val, class CharT, class Traits>
  concept /*stream-extractable*/ = // только для экспозиции
    requires(basic_istream<CharT, Traits>& is, Val& t) { is >> t; };
  template<movable Val, class CharT, class Traits = char_traits<CharT>>
    requires default_initializable<Val> && /*stream-extractable*/<Val, CharT, Traits>
  class basic_istream_view : public view_interface<basic_istream_view<Val, CharT, Traits>>
  {
  public:
    constexpr explicit basic_istream_view(basic_istream<CharT, Traits>& stream);
    constexpr auto begin()
    {
      */*stream_*/ >> /*value_*/;
      return /*iterator*/{ *this };
    }
    constexpr default_sentinel_t end() const noexcept;
  private:
    // класс basic_istream_view::iterator
    struct /*iterator*/;                       // только для экспозиции
    basic_istream<CharT, Traits>* /*stream_*/; // только для экспозиции
    Val /*value_*/ = Val();                    // только для экспозиции
  };
}

Шаблон класса std::ranges::basic_istream_view::iterator 

namespace std::ranges {
  template<movable Val, class CharT, class Traits>
    requires default_initializable<Val> && /*stream-extractable*/<Val, CharT, Traits>
  class basic_istream_view<Val, CharT, Traits>::/*iterator*/
  {
  public:
    using iterator_concept = input_iterator_tag;
    using difference_type  = ptrdiff_t;
    using value_type       = Val;
    constexpr explicit /*iterator*/(basic_istream_view& parent) noexcept;
    /*iterator*/(const /*iterator*/&)            = delete;
    /*iterator*/(/*iterator*/&&)                 = default;
    /*iterator*/& operator=(const /*iterator*/&) = delete;
    /*iterator*/& operator=(/*iterator*/&&)      = default;
    /*iterator*/& operator++();
    void operator++(int);
    Val& operator*() const;
    friend bool operator==(const /*iterator*/& x, default_sentinel_t);
  private:
    basic_istream_view* /*parent_*/; // только для экспозиции
  };
}

Шаблон класса std::ranges::ref_view 

namespace std::ranges {
  template<range R>
    requires is_object_v<R>
  class ref_view : public view_interface<ref_view<R>>
  {
  private:
    R* /*r_*/; // только для демонстрации
  public:
    template</*different-from*/<ref_view> T>
      requires /* см. описание */
      constexpr
    ref_view(T&& t);
    constexpr R& base() const { return */*r_*/; }
    constexpr iterator_t<R> begin() const { return ranges::begin(*/*r_*/); }
    constexpr sentinel_t<R> end() const { return ranges::end(*/*r_*/); }
    constexpr bool empty() const
      requires requires { ranges::empty(*/*r_*/); }
    {
      return ranges::empty(*/*r_*/);
    }
    constexpr auto size() const
      requires sized_range<R>
    {
      return ranges::size(*/*r_*/);
    }
    constexpr auto reserve_hint() const
      requires approximately_sized_range<R>
    {
      return ranges::reserve_hint(*/*r_*/);
    }
    constexpr auto data() const
      requires contiguous_range<R>
    {
      return ranges::data(*/*r_*/);
    }
  };
  template<class R>
  ref_view(R&) -> ref_view<R>;
}

Шаблон класса std::ranges::owning_view 

namespace std::ranges {
  template<range R>
    requires movable<R> && (!/*is-initializer-list*/<R>)
  class owning_view : public view_interface<owning_view<R>>
  {
  private:
    R /*r_*/ = R(); // только для демонстрации
  public:
    owning_view()
      requires default_initializable<R>
    = default;
    constexpr owning_view(R&& t);
    owning_view(owning_view&&)            = default;
    owning_view& operator=(owning_view&&) = default;
    constexpr R& base() & noexcept { return /*r_*/; }
    constexpr const R& base() const& noexcept { return /*r_*/; }
    constexpr R&& base() && noexcept { return std::move(/*r_*/); }
    constexpr const R&& base() const&& noexcept { return std::move(/*r_*/); }
    constexpr iterator_t<R> begin() { return ranges::begin(/*r_*/); }
    constexpr sentinel_t<R> end() { return ranges::end(/*r_*/); }
    constexpr auto begin() const
      requires range<const R>
    {
      return ranges::begin(/*r_*/);
    }
    constexpr auto end() const
      requires range<const R>
    {
      return ranges::end(/*r_*/);
    }
    constexpr bool empty()
      requires requires { ranges::empty(/*r_*/); }
    {
      return ranges::empty(/*r_*/);
    }
    constexpr bool empty() const
      requires requires { ranges::empty(/*r_*/); }
    {
      return ranges::empty(/*r_*/);
    }
    constexpr auto size()
      requires sized_range<R>
    {
      return ranges::size(/*r_*/);
    }
    constexpr auto size() const
      requires sized_range<const R>
    {
      return ranges::size(/*r_*/);
    }
    constexpr auto reserve_hint()
      requires approximately_sized_range<R>
    {
      return ranges::reserve_hint(/*r_*/);
    }
    constexpr auto reserve_hint() const
      requires approximately_sized_range<const R>
    {
      return ranges::reserve_hint(/*r_*/);
    }
    constexpr auto data()
      requires contiguous_range<R>
    {
      return ranges::data(/*r_*/);
    }
    constexpr auto data() const
      requires contiguous_range<const R>
    {
      return ranges::data(/*r_*/);
    }
  };
}

Шаблон класса std::ranges::as_rvalue_view 

namespace std::ranges {
  template<view V>
    requires input_range<V>
  class as_rvalue_view : public view_interface<as_rvalue_view<V>>
  {
    V /*base_*/ = V(); // только для демонстрации
  public:
    as_rvalue_view()
      requires default_initializable<V>
    = default;
    constexpr explicit as_rvalue_view(V base);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr auto begin()
      requires(!/*simple-view*/<V>)
    {
      return move_iterator(ranges::begin(/*base_*/));
    }
    constexpr auto begin() const
      requires range<const V>
    {
      return move_iterator(ranges::begin(/*base_*/));
    }
    constexpr auto end()
      requires(!/*simple-view*/<V>)
    {
      if constexpr (common_range<V>) {
        return move_iterator(ranges::end(/*base_*/));
      } else {
        return move_sentinel(ranges::end(/*base_*/));
      }
    }
    constexpr auto end() const
      requires range<const V>
    {
      if constexpr (common_range<const V>) {
        return move_iterator(ranges::end(/*base_*/));
      } else {
        return move_sentinel(ranges::end(/*base_*/));
      }
    }
    constexpr auto size()
      requires sized_range<V>
    {
      return ranges::size(/*base_*/);
    }
    constexpr auto size() const
      requires sized_range<const V>
    {
      return ranges::size(/*base_*/);
    }
    constexpr auto reserve_hint()
      requires approximately_sized_range<V>
    {
      return ranges::reserve_hint(/*base_*/);
    }
    constexpr auto reserve_hint() const
      requires approximately_sized_range<const V>
    {
      return ranges::reserve_hint(/*base_*/);
    }
  };
  template<class R>
  as_rvalue_view(R&&) -> as_rvalue_view<views::all_t<R>>;
}

Шаблон класса std::ranges::filter_view 

namespace std::ranges {
  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
    requires view<V> && is_object_v<Pred>
  class filter_view : public view_interface<filter_view<V, Pred>>
  {
  private:
    V /*base_*/ = V();               // только для пояснения
    /*movable-box*/<Pred> /*pred_*/; // только для пояснения
    // класс filter_view::iterator
    class /*iterator*/; // только для пояснения
    // класс filter_view::sentinel
    class /*sentinel*/; // только для пояснения
  public:
    filter_view()
      requires default_initializable<V> && default_initializable<Pred>
    = default;
    constexpr explicit filter_view(V base, Pred pred);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr const Pred& pred() const;
    constexpr /*iterator*/ begin();
    constexpr auto end()
    {
      if constexpr (common_range<V>)
        return /*iterator*/{ *this, ranges::end(/*base_*/) };
      else
        return /*sentinel*/{ *this };
    }
  };
  template<class R, class Pred>
  filter_view(R&&, Pred) -> filter_view<views::all_t<R>, Pred>;
}

Шаблон класса std::ranges::filter_view::iterator 

namespace std::ranges {
  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
    requires view<V> && is_object_v<Pred>
  class filter_view<V, Pred>::/*iterator*/
  {
  private:
    iterator_t<V> /*current_*/ = iterator_t<V>(); // только для демонстрации
    filter_view* /*parent_*/   = nullptr;         // только для демонстрации
  public:
    using iterator_concept  = /* см. описание */;
    using iterator_category = /* см. описание */; // не всегда присутствует
    using value_type        = range_value_t<V>;
    using difference_type   = range_difference_t<V>;
    /*iterator*/()
      requires default_initializable<iterator_t<V>>
    = default;
    constexpr /*iterator*/(filter_view& parent, iterator_t<V> current);
    constexpr const iterator_t<V>& base() const& noexcept;
    constexpr iterator_t<V> base() &&;
    constexpr range_reference_t<V> operator*() const;
    constexpr iterator_t<V> operator->() const
      requires /*has-arrow*/<iterator_t<V>> && copyable<iterator_t<V>>;
    constexpr /*iterator*/& operator++();
    constexpr void operator++(int);
    constexpr /*iterator*/ operator++(int)
      requires forward_range<V>;
    constexpr /*iterator*/& operator--()
      requires bidirectional_range<V>;
    constexpr /*iterator*/ operator--(int)
      requires bidirectional_range<V>;
    friend constexpr bool operator==(const /*iterator*/& x, const /*iterator*/& y)
      requires equality_comparable<iterator_t<V>>;
    friend constexpr range_rvalue_reference_t<V> iter_move(
      const /*iterator*/& i) noexcept(noexcept(ranges::iter_move(i./*current_*/)));
    friend constexpr void iter_swap(
      const /*iterator*/& x,
      const /*iterator*/& y) noexcept(noexcept(ranges::iter_swap(x./*current_*/,
                                                                 y./*current_*/)))
      requires indirectly_swappable<iterator_t<V>>;
  };
}

Шаблон класса std::ranges::filter_view::sentinel 

namespace std::ranges {
  template<input_range V, indirect_unary_predicate<iterator_t<V>> Pred>
    requires view<V> && is_object_v<Pred>
  class filter_view<V, Pred>::/*sentinel*/
  {
  private:
    sentinel_t<V> /*end_*/ = sentinel_t<V>(); // только для демонстрации
  public:
    /*sentinel*/() = default;
    constexpr explicit /*sentinel*/(filter_view& parent);
    constexpr sentinel_t<V> base() const;
    friend constexpr bool operator==(const /*iterator*/& x, const /*sentinel*/& y);
  };
}

Шаблон класса std::ranges::transform_view 

namespace std::ranges {
  template<input_range V, move_constructible F>
    requires view<V> && is_object_v<F> && regular_invocable<F&, range_reference_t<V>> &&
             /*can-reference*/<invoke_result_t<F&, range_reference_t<V>>>
  class transform_view : public view_interface<transform_view<V, F>>
  {
  private:
    // шаблон класса transform_view::iterator
    template<bool>
    struct /*iterator*/; // только для экспозиции
    // шаблон класса transform_view::sentinel
    template<bool>
    struct /*sentinel*/; // только для экспозиции
    V /*base_*/ = V();           // только для экспозиции
    /*movable-box*/<F> /*fun_*/; // только для экспозиции
  public:
    transform_view()
      requires default_initializable<V> && default_initializable<F>
    = default;
    constexpr explicit transform_view(V base, F fun);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr /*iterator*/<false> begin();
    constexpr /*iterator*/<true> begin() const
      requires range<const V> && regular_invocable<const F&, range_reference_t<const V>>;
    constexpr /*sentinel*/<false> end();
    constexpr /*iterator*/<false> end()
      requires common_range<V>;
    constexpr /*sentinel*/<true> end() const
      requires range<const V> && regular_invocable<const F&, range_reference_t<const V>>;
    constexpr /*iterator*/<true> end() const
      requires common_range<const V> &&
               regular_invocable<const F&, range_reference_t<const V>>;
    constexpr auto size()
      requires sized_range<V>
    {
      return ranges::size(/*base_*/);
    }
    constexpr auto size() const
      requires sized_range<const V>
    {
      return ranges::size(/*base_*/);
    }
    constexpr auto reserve_hint()
      requires approximately_sized_range<V>
    {
      return ranges::reserve_hint(/*base_*/);
    }
    constexpr auto reserve_hint() const
      requires approximately_sized_range<const V>
    {
      return ranges::reserve_hint(/*base_*/);
    }
  };
  template<class R, class F>
  transform_view(R&&, F) -> transform_view<views::all_t<R>, F>;
}

Шаблон класса std::ranges::transform_view::iterator 

namespace std::ranges {
  template<input_range V, move_constructible F>
    requires view<V> && is_object_v<F> && regular_invocable<F&, range_reference_t<V>> &&
             /*может ссылаться*/<invoke_result_t<F&, range_reference_t<V>>>
  template<bool Const>
  class transform_view<V, F>::/*итератор*/
  {
  private:
    using /*Родительский*/ = /*возможно-константа*/<Const, transform_view>;  // только для экспозиции
    using /*Базовый*/   = /*возможно-константа*/<Const, V>;               // только для экспозиции
    iterator_t</*Базовый*/> /*current_*/ = iterator_t</*Базовый*/>(); // экспозиционная часть
    /*Родительский*/* /*родительский_*/           = nullptr;                // только для экспозиции
  public:
    using iterator_concept  = /* см. описание */;
    using iterator_category = /* см. описание */; // не всегда присутствует
    using value_type        = remove_cvref_t<
      invoke_result_t</*возможно-константа*/<Const, F>&, range_reference_t</*Базовый*/>>>;
    using difference_type = range_difference_t</*Базовый*/>;
    /*итератор*/()
      requires default_initializable<iterator_t</*Базовый*/>>
    = default;
    constexpr /*итератор*/(/*Родительский*/& parent, iterator_t</*Базовый*/> current);
    constexpr /*итератор*/(/*итератор*/<!Const> i)
      requires Const && convertible_to<iterator_t<V>, iterator_t</*Базовый*/>>;
    constexpr const iterator_t</*Базовый*/>& base() const& noexcept;
    constexpr iterator_t</*Базовый*/> base() &&;
    constexpr decltype(auto) operator*() const
      noexcept(noexcept(invoke(*/*родительский_*/->/*функция_*/, */*current_*/)))
    {
      return invoke(*/*родительский_*/->/*функция_*/, */*current_*/);
    }
    constexpr /*итератор*/& operator++();
    constexpr void operator++(int);
    constexpr /*итератор*/ operator++(int)
      requires forward_range</*Базовый*/>;
    constexpr /*итератор*/& operator--()
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/ operator--(int)
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/& operator+=(difference_type n)
      requires random_access_range</*Базовый*/>;
    constexpr /*итератор*/& operator-=(difference_type n)
      requires random_access_range</*Базовый*/>;
    constexpr decltype(auto) operator[](difference_type n) const
      requires random_access_range</*Базовый*/>
    {
      return invoke(*/*родительский_*/->/*функция_*/, /*current_*/[n]);
    }
    friend constexpr bool operator==(const /*итератор*/& x, const /*итератор*/& y)
      requires equality_comparable<iterator_t</*Базовый*/>>;
    friend constexpr bool operator<(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator>(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator<=(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator>=(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr auto operator<=>(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/> && three_way_comparable<iterator_t</*Базовый*/>>
    ;
    friend constexpr /*итератор*/ operator+(/*итератор*/ i, difference_type n)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator+(difference_type n, /*итератор*/ i)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator-(/*итератор*/ i, difference_type n)
      requires random_access_range</*Базовый*/>;
    friend constexpr difference_type operator-(const /*итератор*/& x,
                                               const /*итератор*/& y)
      requires sized_sentinel_for<iterator_t</*Базовый*/>, iterator_t</*Базовый*/>>;
  };
}

Шаблон класса std::ranges::transform_view::sentinel 

namespace std::ranges {
  template<input_range V, move_constructible F>
    requires view<V> && is_object_v<F> && regular_invocable<F&, range_reference_t<V>> &&
             /*can-reference*/<invoke_result_t<F&, range_reference_t<V>>>
  template<bool Const>
  class transform_view<V, F>::/*sentinel*/
  {
  private:
    using /*Parent*/ = /*maybe-const*/<Const, transform_view>; // только для экспозиции
    using /*Base*/   = /*maybe-const*/<Const, V>;              // только для экспозиции
    sentinel_t</*Base*/> /*end_*/ = sentinel_t</*Base*/>();    // только для экспозиции
  public:
    /*sentinel*/() = default;
    constexpr explicit /*sentinel*/(sentinel_t</*Base*/> end);
    constexpr /*sentinel*/(/*sentinel*/<!Const> i)
      requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;
    constexpr sentinel_t</*Base*/> base() const;
    template<bool OtherConst>
      requires sentinel_for<sentinel_t</*Base*/>,
                            iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr bool operator==(const /*iterator*/<OtherConst>& x,
                                     const /*sentinel*/& y);
    template<bool OtherConst>
      requires sized_sentinel_for<sentinel_t</*Base*/>,
                                  iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr range_difference_t</*maybe-const*/<OtherConst, V>> operator-(
      const /*iterator*/<OtherConst>& x,
      const /*sentinel*/& y);
    template<bool OtherConst>
      requires sized_sentinel_for<sentinel_t</*Base*/>,
                                  iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr range_difference_t</*maybe-const*/<OtherConst, V> operator-(
      const /*sentinel*/& y,
      const /*iterator*/<OtherConst>& x);
  };
}

Шаблон класса std::ranges::take_view 

namespace std::ranges {
  template<view V>
  class take_view : public view_interface<take_view<V>>
  {
  private:
    V /*базовый_*/                      = V(); // exposition-only
    range_difference_t<V> /*count_*/ = 0;   // exposition-only
    // шаблон класса take_view::sentinel
    template<bool>
    class /*sentinel*/; // exposition-only
  public:
    take_view()
      requires default_initializable<V>
    = default;
    constexpr explicit take_view(V base, range_difference_t<V> count);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*базовый_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr auto begin()
      requires(!/*простой-вид*/<V>)
    {
      если constexpr (sized_range<V>) {
        если constexpr (random_access_range<V>) {
          return ranges::begin(/*base_*/);
        } else {
          auto sz = range_difference_t<V>(size());
          return counted_iterator(ranges::begin(/*базовый_*/), sz);
        }
      } else if constexpr (sized_sentinel_for<sentinel_t<V>, iterator_t<V>>) {
        auto it = ranges::begin(/*базовый_*/);
        auto sz = std::min(/*count_*/, ranges::end(/*base_*/) - it);
        return counted_iterator(std::move(it), sz);
      } else {
        return counted_iterator(ranges::begin(/*базовый_*/), /*count_*/);
      }
    }
    constexpr auto begin() const
      requires range<const V>
    {
      если constexpr (sized_range<const V>) {
        if constexpr (random_access_range<const V>) {
          return ranges::begin(/*базовый_*/);
        } else {
          auto sz = range_difference_t<const V>(size());
          return counted_iterator(ranges::begin(/*базовый_*/), sz);
        }
      } else if constexpr (sized_sentinel_for<sentinel_t<const V>, iterator_t<const V>>) {
        auto it = ranges::begin(/*base_*/);
        auto sz = std::min(/*count_*/, ranges::end(/*базовый_*/) - it);
        return counted_iterator(std::move(it), sz);
      } else {
        return counted_iterator(ranges::begin(/*base_*/), /*count_*/);
      }
    }
    constexpr auto end()
      requires(!/*простой-вид*/<V>)
    {
      if constexpr (sized_range<V>) {
        if constexpr (random_access_range<V>)
          return ranges::begin(/*базовый_*/) + range_difference_t<V>(size());
        else
          return default_sentinel;
      } else если constexpr (sized_sentinel_for<sentinel_t<V>, iterator_t<V>>) {
        return default_sentinel;
      } else {
        return /*sentinel*/<false>{ ranges::end(/*base_*/) };
      }
    }
    constexpr auto end() const
      requires range<const V>
    {
      если constexpr (sized_range<const V>) {
        если constexpr (random_access_range<const V>)
          return ranges::begin(/*базовый_*/) + range_difference_t<const V>(size());
        else
          return default_sentinel;
      } else если constexpr (sized_sentinel_for<sentinel_t<const V>, iterator_t<const V>>) {
        return default_sentinel;
      } else {
        return /*sentinel*/<true>{ ranges::end(/*базовый_*/) };
      }
    }
    constexpr auto size()
      requires sized_range<V>
    {
      auto n = ranges::size(/*базовый_*/);
      return ranges::min(n, static_cast<decltype(n)>(/*count_*/));
    }
    constexpr auto size() const
      requires sized_range<const V>
    {
      auto n = ranges::size(/*базовый_*/);
      return ranges::min(n, static_cast<decltype(n)>(/*count_*/));
    }
    constexpr auto reserve_hint()
    {
      if constexpr (approximately_sized_range<V>) {
        auto n = static_cast<range_difference_t<V>>(ranges::reserve_hint(/*базовый_*/));
        return /*к-беззнаковому-типу*/(ranges::min(n, /*count_*/));
      }
      return /*к-беззнаковому-типу*/(/*count_*/);
    }
    constexpr auto reserve_hint() const
    {
      if constexpr (approximately_sized_range<const V>) {
        auto n =
          static_cast<range_difference_t<const V>>(ranges::reserve_hint(/*базовый_*/));
        return /*к-беззнаковому-типу*/(ranges::min(n, /*count_*/));
      }
      return /*к-беззнаковому-типу*/(/*count_*/);
    }
  };
  template<class R>
  take_view(R&&, range_difference_t<R>) -> take_view<views::all_t<R>>;
}

Шаблон класса std::ranges::take_view::sentinel 

namespace std::ranges {
  template<view V>
  template<bool Const>
  class take_view<V>::/*sentinel*/
  {
  private:
    using /*Base*/ = /*maybe-const*/<Const, V>; // только для пояснения
    template<bool OtherConst>
    using /*CI*/ =
      counted_iterator<iterator_t</*maybe-const*/<OtherConst, V>>>; // только для пояснения
    sentinel_t</*Base*/> /*end_*/ = sentinel_t</*Base*/>();         // только для пояснения
  public:
    /*sentinel*/() = default;
    constexpr explicit /*sentinel*/(sentinel_t</*Base*/> end);
    constexpr /*sentinel*/(/*sentinel*/<!Const> s)
      requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;
    constexpr sentinel_t</*Base*/> base() const;
    friend constexpr bool operator==(const /*CI*/<Const>& y, const /*sentinel*/& x);
    template<bool OtherConst = !Const>
      requires sentinel_for<sentinel_t</*Base*/>,
                            iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr bool operator==(const /*CI*/<OtherConst>& y, const /*sentinel*/& x);
  };
}

Шаблон класса std::ranges::take_while_view 

namespace std::ranges {
  template<view V, class Pred>
    requires input_range<V> && is_object_v<Pred> &&
             indirect_unary_predicate<const Pred, iterator_t<V>>
  class take_while_view : public view_interface<take_while_view<V, Pred>>
  {
    // шаблон класса take_while_view::sentinel
    template<bool>
    class /*sentinel*/; // только для экспозиции
    V /*base_*/ = V();               // только для экспозиции
    /*movable-box*/<Pred> /*pred_*/; // только для экспозиции
  public:
    take_while_view()
      requires default_initializable<V> && default_initializable<Pred>
    = default;
    constexpr explicit take_while_view(V base, Pred pred);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr const Pred& pred() const;
    constexpr auto begin()
      requires(!/*simple-view*/<V>)
    {
      return ranges::begin(/*base_*/);
    }
    constexpr auto begin() const
      requires range<const V> && indirect_unary_predicate<const Pred, iterator_t<const V>>
    {
      return ranges::begin(/*base_*/);
    }
    constexpr auto end()
      requires(!/*simple-view*/<V>)
    {
      return /*sentinel*/<false>(ranges::end(/*base_*/), addressof(*/*pred_*/));
    }
    constexpr auto end() const
      requires range<const V> && indirect_unary_predicate<const Pred, iterator_t<const V>>
    {
      return /*sentinel*/<true>(ranges::end(/*base_*/), addressof(*/*pred_*/));
    }
  };
  template<class R, class Pred>
  take_while_view(R&&, Pred) -> take_while_view<views::all_t<R>, Pred>;
}

Шаблон класса std::ranges::take_while_view::sentinel 

namespace std::ranges {
  template<view V, class Pred>
    requires input_range<V> && is_object_v<Pred> &&
             indirect_unary_predicate<const Pred, iterator_t<V>>
  template<bool Const>
  class take_while_view<V, Pred>::/*sentinel*/
  {
    using /*Base*/                = /*maybe-const*/<Const, V>; // только для пояснения
    sentinel_t</*Base*/> /*end_*/ = sentinel_t</*Base*/>(); // только для пояснения
    const Pred* /*pred_*/         = nullptr;                // только для пояснения
  public:
    /*sentinel*/() = default;
    constexpr explicit /*sentinel*/(sentinel_t</*Base*/> end, const Pred* pred);
    constexpr /*sentinel*/(/*sentinel*/<!Const> s)
      requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;
    constexpr sentinel_t</*Base*/> base() const { return /*end_*/; }
    friend constexpr bool operator==(const iterator_t</*Base*/>& x,
                                     const /*sentinel*/& y);
    template<bool OtherConst = !Const>
      requires sentinel_for<sentinel_t</*Base*/>,
                            iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr bool operator==(const iterator_t</*maybe-const*/<OtherConst, V>>& x,
                                     const /*sentinel*/& y);
  };
}

Шаблон класса std::ranges::drop_view 

namespace std::ranges {
  template<view V>
  class drop_view : public view_interface<drop_view<V>>
  {
  public:
    drop_view()
      requires default_initializable<V>
    = default;
    constexpr explicit drop_view(V base, range_difference_t<V> count);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr auto begin()
      requires(!(/*simple-view*/<V> && random_access_range<const V> &&
                 sized_range<const V>));
    constexpr auto begin() const
      requires random_access_range<const V> && sized_range<const V>;
    constexpr auto end()
      requires(!/*simple-view*/<V>)
    {
      return ranges::end(/*base_*/);
    }
    constexpr auto end() const
      requires range<const V>
    {
      return ranges::end(/*base_*/);
    }
    constexpr auto size()
      requires sized_range<V>
    {
      const auto s = ranges::size(/*base_*/);
      const auto c = static_cast<decltype(s)>(/*count_*/);
      return s < c ? 0 : s - c;
    }
    constexpr auto size() const
      requires sized_range<const V>
    {
      const auto s = ranges::size(/*base_*/);
      const auto c = static_cast<decltype(s)>(/*count_*/);
      return s < c ? 0 : s - c;
    }
    constexpr auto reserve_hint()
      requires approximately_sized_range<V>
    {
      const auto s = static_cast<range_difference_t<V>>(ranges::reserve_hint(/*base_*/));
      return /*to-unsigned-like*/(s < /*count_*/ ? 0 : s - /*count_*/);
    }
    constexpr auto reserve_hint() const
      requires approximately_sized_range<const V>
    {
      const auto s =
        static_cast<range_difference_t<const V>>(ranges::reserve_hint(/*base_*/));
      return /*to-unsigned-like*/(s < /*count_*/ ? 0 : s - /*count_*/);
    }
  private:
    V /*base_*/                      = V(); // только для демонстрации
    range_difference_t<V> /*count_*/ = 0;   // только для демонстрации
  };
  template<class R>
  drop_view(R&&, range_difference_t<R>) -> drop_view<views::all_t<R>>;
}

Шаблон класса std::ranges::drop_while_view 

namespace std::ranges {
  template<view V, class Pred>
    requires input_range<V> && is_object_v<Pred> &&
             indirect_unary_predicate<const Pred, iterator_t<V>>
  class drop_while_view : public view_interface<drop_while_view<V, Pred>>
  {
  public:
    drop_while_view()
      requires default_initializable<V> && default_initializable<Pred>
    = default;
    constexpr explicit drop_while_view(V base, Pred pred);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr const Pred& pred() const;
    constexpr auto begin();
    constexpr auto end() { return ranges::end(/*base_*/); }
  private:
    V /*base_*/ = V();               // только для демонстрации
    /*movable-box*/<Pred> /*pred_*/; // только для демонстрации
  };
  template<class R, class Pred>
  drop_while_view(R&&, Pred) -> drop_while_view<views::all_t<R>, Pred>;
}

Шаблон класса std::ranges::join_view 

namespace std::ranges {
  template<input_range V>
    requires view<V> && input_range<range_reference_t<V>>
  class join_view : public view_interface<join_view<V>>
  {
  private:
    using /*InnerRng*/ = range_reference_t<V>; // exposition-only
    // шаблон класса join_view::iterator
    template<bool Const>
    struct /*итератор*/; // exposition-only
    // шаблон класса join_view::sentinel
    template<bool Const>
    struct /*sentinel*/; // exposition-only
    V /*base_*/ = V(); // exposition-only
    /*не распространяющийся кеш*/<iterator_t<V>> /*внешний_*/; // экспозиция присутствует только
                                                         // когда !forward_range<V>
    /*не распространяющийся кеш*/<remove_cv_t</*InnerRng*/>>
      /*inner_*/; // экспозиционная часть присутствует только
                  // если is_reference_v<InnerRng> равно false
  public:
    join_view()
      requires default_initializable<V>
    = default;
    constexpr explicit join_view(V base);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*базовый_*/;
    }
    constexpr V base() && { return std::move(/*базовый_*/); }
    constexpr auto begin()
    {
      if constexpr (forward_range<V>) {
        constexpr bool use_const = /*простой-вид*/<V> && is_reference_v</*InnerRng*/>;
        return /*итератор*/<use_const>{ *this, ranges::begin(/*базовый_*/) };
      } else {
        /*внешний_*/ = ranges::begin(/*base_*/);
        return /*итератор*/<false>{ *this };
      }
    }
    constexpr auto begin() const
      requires forward_range<const V> && is_reference_v<range_reference_t<const V>> &&
               input_range<range_reference_t<const V>>
    {
      return /*итератор*/<true>{ *this, ranges::begin(/*base_*/) };
    }
    constexpr auto end()
    {
      если constexpr (forward_range<V> && is_reference_v</*InnerRng*/> &&
                    forward_range</*InnerRng*/> && common_range<V> &&
                    common_range</*InnerRng*/>)
        return /*итератор*/</*простой-вид*/<V>>{ *this, ranges::end(/*base_*/) };
      else
        return /*sentinel*/</*простой-вид*/<V>>{ *this };
    }
    constexpr auto end() const
      requires forward_range<const V> && is_reference_v<range_reference_t<const V>> &&
               input_range<range_reference_t<const V>>
    {
      если constexpr (forward_range<range_reference_t<const V>> && common_range<const V> &&
                    common_range<range_reference_t<const V>>)
        return /*итератор*/<true>{ *this, ranges::end(/*base_*/) };
      else
        return /*sentinel*/<true>{ *this };
    }
  };
  template<class R>
  explicit join_view(R&&) -> join_view<views::all_t<R>>;
}

Шаблон класса std::ranges::join_view::iterator 

namespace std::ranges {
  template<input_range V>
    requires view<V> && input_range<range_reference_t<V>>
  template<bool Const>
  struct join_view<V>::/*итератор*/
  {
  private:
    using /*Родительский*/    = /*возможно-константа*/<Const, join_view>;       // exposition-only
    using /*Базовый*/      = /*возможно-константа*/<Const, V>;               // только для экспозиции
    using /*OuterIter*/ = iterator_t</*Базовый*/>;                    // только для экспозиции
    using /*InnerIter*/ = iterator_t<range_reference_t</*Базовый*/>>; // только для экспозиции
    static constexpr bool /*ссылка-это-glvalue*/ = // только для экспозиции
      is_reference_v<range_reference_t</*Базовый*/>>;
    /*OuterIter*/ /*внешний_*/ = /*OuterIter*/(); // экспозиция присутствует только
                                                // если Base моделирует forward_range
    optional</*InnerIter*/> /*внутренний_*/;         // только для демонстрации
    /*Родительский*/* /*родительский_*/ = nullptr;          // exposition-only
    constexpr void /*удовлетворить*/(); // exposition-only
    constexpr /*OuterIter*/& /*внешний*/();             // только для экспозиции
    constexpr const /*OuterIter*/& /*внешний*/() const; // exposition-only
    constexpr /*итератор*/(/*Родительский*/& parent, /*OuterIter*/ outer)
      requires forward_range</*Базовый*/>; // только для экспозиции
    constexpr explicit /*итератор*/(/*Родительский*/& parent)
      requires(!forward_range</*Базовый*/>); // только для экспозиции
  public:
    using iterator_concept  = /* см. описание */;
    using iterator_category = /* см. описание */; // не всегда присутствует
    using value_type        = range_value_t<range_reference_t</*Базовый*/>>;
    using difference_type   = /* см. описание */;
    /*итератор*/()          = default;
    constexpr /*итератор*/(/*итератор*/<!Const> i)
      requires Const && convertible_to<iterator_t<V>, /*OuterIter*/> &&
               convertible_to<iterator_t</*InnerRng*/>, /*InnerIter*/>;
    constexpr decltype(auto) operator*() const { return **/*внутренний_*/; }
    constexpr /*InnerIter*/ operator->() const
      requires /*has-arrow*/</*InnerIter*/> && copyable</*InnerIter*/>;
    constexpr /*итератор*/& operator++();
    constexpr void operator++(int);
    constexpr /*итератор*/ operator++(int)
      requires /*ссылка-это-glvalue*/
               && forward_range</*Базовый*/> && forward_range<range_reference_t</*Базовый*/>>;
    constexpr /*итератор*/& operator--()
      requires /*ссылка-это-glvalue*/ && bidirectional_range</*Базовый*/> &&
               bidirectional_range<range_reference_t</*Базовый*/>> &&
               common_range<range_reference_t</*Базовый*/>>;
    constexpr /*итератор*/ operator--(int)
      requires /*ссылка-это-глвалуе*/ && bidirectional_range</*Базовый*/> &&
               bidirectional_range<range_reference_t</*Базовый*/>> &&
               common_range<range_reference_t</*Базовый*/>>;
    friend constexpr bool operator==(const /*итератор*/& x, const /*итератор*/& y)
      requires /*ссылка-это-глвалуе*/ && forward_range</*Базовый*/> &&
               equality_comparable<iterator_t<range_reference_t</*Базовый*/>>>;
    friend constexpr decltype(auto) iter_move(const /*итератор*/& i) noexcept(
      noexcept(ranges::iter_move(*i./*внутренний_*/)))
    {
      return ranges::iter_move(*i./*внутренний_*/);
    }
    friend constexpr void iter_swap(
      const /*итератор*/& x,
      const /*итератор*/& y) noexcept(noexcept(ranges::iter_swap(*x./*внутренний_*/,
                                                                 *y./*внутренний_*/)))
      requires indirectly_swappable</*InnerIter*/>;
  };
}

Шаблон класса std::ranges::join_view::sentinel 

namespace std::ranges {
  template<input_range V>
    requires view<V> && input_range<range_reference_t<V>>
  template<bool Const>
  struct join_view<V>::/*sentinel*/
  {
  private:
    using /*Parent*/              = /*maybe-const*/<Const, join_view>; // только для экспозиции
    using /*Base*/                = /*maybe-const*/<Const, V>;         // только для экспозиции
    sentinel_t</*Base*/> /*end_*/ = sentinel_t</*Base*/>();            // только для экспозиции
  public:
    /*sentinel*/() = default;
    constexpr explicit /*sentinel*/(/*Parent*/& parent);
    constexpr /*sentinel*/(/*sentinel*/<!Const> s)
      requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;
    template<bool OtherConst>
      requires sentinel_for<sentinel_t</*Base*/>,
                            iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr bool operator==(const /*iterator*/<OtherConst>& x,
                                     const /*sentinel*/& y);
  };
}

Шаблон класса std::ranges::join_with_view 

namespace std::ranges {
  template<class R>
  concept /*двунаправленный-общий*/ =
    bidirectional_range<R> && common_range<R>; // exposition-only
  template<input_range V, forward_range Pattern>
    requires view<V> && input_range<range_reference_t<V>> && view<Pattern> &&
             /*concatable*/<range_reference_t<V>, Pattern>
  class join_with_view : public view_interface<join_with_view<V, Pattern>>
  {
    using /*InnerRng*/ = range_reference_t<V>; // exposition-only
    V /*базовый_*/        = V();                               // exposition-only
    /*не распространяющийся кеш*/<iterator_t<V>> /*внешний-итератор_*/; // только для экспозиции присутствует
                                                            // только когда !forward_range<V>
    /*не распространяющийся кеш*/<remove_cv_t</*InnerRng*/>>
      /*внутренний_*/;                     // экспозиция присутствует только
                                      // если is_reference_v<InnerRng> равно false
    Pattern /*pattern_*/ = Pattern(); // exposition-only
    // шаблон класса join_with_view::iterator
    template<bool Const>
    struct /*итератор*/; // exposition-only
    // шаблон класса join_with_view::sentinel
    template<bool Const>
    struct /*sentinel*/; // exposition-only
  public:
    join_with_view()
      requires default_initializable<V> && default_initializable<Pattern>
    = default;
    constexpr explicit join_with_view(V base, Pattern pattern);
    template<input_range R>
      requires constructible_from<V, views::all_t<R>> &&
               constructible_from<Pattern, single_view<range_value_t</*InnerRng*/>>>
    constexpr explicit join_with_view(R&& r, range_value_t</*InnerRng*/> e);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*базовый_*/;
    }
    constexpr V base() && { return std::move(/*базовый_*/); }
    constexpr auto begin()
    {
      if constexpr (forward_range<V>) {
        constexpr bool use_const =
          /*простой-вид*/<V> && is_reference_v</*InnerRng*/> && /*простой-вид*/<Pattern>;
        return /*итератор*/<use_const>{ *this, ranges::begin(/*базовый_*/) };
      } else {
        /*внешний-итератор_*/ = ranges::begin(/*базовый_*/);
        return /*итератор*/<false>{ *this };
      }
    }
    constexpr auto begin() const
      requires forward_range<const V> && forward_range<const Pattern> &&
               is_reference_v<range_reference_t<const V>> &&
               input_range<range_reference_t<const V>> &&
               /*concatable*/<range_reference_t<const V>, const Pattern>
    {
      return /*итератор*/<true>{ *this, ranges::begin(/*base_*/) };
    }
    constexpr auto end()
    {
      if constexpr (forward_range<V> && is_reference_v</*InnerRng*/> &&
                    forward_range</*InnerRng*/> && common_range<V> &&
                    common_range</*InnerRng*/>)
        return /*итератор*/ < /*простой-вид*/<V> &&
               /*простой-вид*/ < Pattern >> { *this, ranges::end(/*base_*/) };
      else
        return /*sentinel*/ < /*простой-вид*/<V> &&
               /*простой-вид*/ < Pattern >> { *this };
    }
    constexpr auto end() const
      requires forward_range<const V> && forward_range<const Pattern> &&
               is_reference_v<range_reference_t<const V>> &&
               input_range<range_reference_t<const V>> &&
               /*concatable*/<range_reference_t<const V>, const Pattern>
    {
      using InnerConstRng = range_reference_t<const V>;
      if constexpr (forward_range<InnerConstRng> && common_range<const V> &&
                    common_range<InnerConstRng>)
        return /*итератор*/<true>{ *this, ranges::end(/*базовый_*/) };
      else
        return /*sentinel*/<true>{ *this };
    }
  };
  template<class R, class P>
  join_with_view(R&&, P&&) -> join_with_view<views::all_t<R>, views::all_t<P>>;
  template<input_range R>
  join_with_view(R&&, range_value_t<range_reference_t<R>>)
    -> join_with_view<views::all_t<R>, single_view<range_value_t<range_reference_t<R>>>>;
}

Шаблон класса std::ranges::join_with_view::iterator 

namespace std::ranges {
  template<input_range V, forward_range Pattern>
    requires view<V> && input_range<range_reference_t<V>> && view<Pattern> &&
             /*concatable*/<range_reference_t<V>, Pattern>
  template<bool Const>
  class join_with_view<V, Pattern>::/*итератор*/
  {
    using /*Родительский*/      = /*возможно-константа*/<Const, join_with_view>; // exposition-only
    using /*Базовый*/        = /*возможно-константа*/<Const, V>;              // только для демонстрации
    using /*InnerBase*/   = range_reference_t</*Базовый*/>;            // exposition-only
    using /*PatternBase*/ = /*возможно-константа*/<Const, Pattern>;        // exposition-only
    using /*OuterIter*/   = iterator_t</*Базовый*/>;        // exposition-only
    using /*InnerIter*/   = iterator_t</*InnerBase*/>;   // exposition-only
    using /*PatternIter*/ = iterator_t</*PatternBase*/>; // exposition-only
    static constexpr bool /*ref-is-glvalue*/ =
      is_reference_v</*InnerBase*/>; // экспозиционная часть
    /*Родительский*/* /*родительский_*/     = nullptr;                 // exposition-only
    /*OuterIter*/ /*внешний-итератор_*/ = /*OuterIter*/();         // экспозиция присутствует только
                                                           // если Base моделирует forward_range
    variant</*PatternIter*/, /*InnerIter*/> /*inner-it_*/; // exposition-only
    constexpr /*итератор*/(/*Родительский*/& parent, /*OuterIter*/ outer)
      requires forward_range</*Базовый*/>; // exposition-only
    constexpr explicit /*итератор*/(/*Родительский*/& parent)
      requires(!forward_range</*Базовый*/>);             // только для экспозиции
    constexpr /*OuterIter*/& /*внешний*/();             // exposition-only
    constexpr const /*OuterIter*/& /*внешний*/() const; // exposition-only
    constexpr auto& /*обновление-внутреннее*/();               // только для экспозиции
    constexpr auto& /*get-inner*/();                  // exposition-only
    constexpr void /*удовлетворить*/();                     // exposition-only
  public:
    using iterator_concept  = /* см. описание */;
    using iterator_category = /* см. описание */; // не всегда присутствует
    using value_type        = /* см. описание */;
    using difference_type   = /* см. описание */;
    /*итератор*/()          = default;
    constexpr /*итератор*/(/*итератор*/<!Const> i)
      requires Const && convertible_to<iterator_t<V>, /*OuterIter*/> &&
               convertible_to<iterator_t</*InnerRng*/>, /*InnerIter*/> &&
               convertible_to<iterator_t<Pattern>, /*PatternIter*/>;
    constexpr decltype(auto) operator*() const;
    constexpr /*итератор*/& operator++();
    constexpr void operator++(int);
    constexpr /*итератор*/ operator++(int)
      requires /*ссылка-это-глвалуе*/
               && forward_iterator</*OuterIter*/> && forward_iterator</*InnerIter*/>;
    constexpr /*итератор*/& operator--()
      requires /*ссылка-это-глвалуе*/ && bidirectional_range</*Базовый*/> &&
               /*двунаправленный-общий*/</*InnerBase*/> &&
               /*двунаправленный-общий*/</*PatternBase*/>;
    constexpr /*итератор*/ operator--(int)
      requires /*ссылка-это-глвалуе*/ && bidirectional_range</*Базовый*/> &&
               /*двунаправленный-общий*/</*InnerBase*/> &&
               /*двунаправленный-общий*/</*PatternBase*/>;
    friend constexpr bool operator==(const /*итератор*/& x, const /*итератор*/& y)
      requires /*ссылка-это-глвалуе*/
               && forward_range</*Базовый*/> && equality_comparable</*InnerIter*/>;
    friend constexpr decltype(auto) iter_move(const /*итератор*/& x)
    {
      using rvalue_reference =
        common_reference_t<iter_rvalue_reference_t</*InnerIter*/>,
                           iter_rvalue_reference_t</*PatternIter*/>>;
      return visit<rvalue_reference>(ranges::iter_move, x./*inner-it_*/);
    }
    friend constexpr void iter_swap(const /*итератор*/& x, const /*итератор*/& y)
      requires indirectly_swappable</*InnerIter*/, /*PatternIter*/>
    {
      visit(ranges::iter_swap, x./*inner-it_*/, y./*inner-it_*/);
    }
  };
}

Шаблон класса std::ranges::join_with_view::sentinel 

namespace std::ranges {
  template<input_range V, forward_range Pattern>
    requires view<V> && input_range<range_reference_t<V>> && view<Pattern> &&
             /*concatable*/<range_reference_t<V>, Pattern>
  template<bool Const>
  class join_with_view<V, Pattern>::/*sentinel*/
  {
    using /*Parent*/ = /*maybe-const*/<Const, join_with_view>; // только для пояснения
    using /*Base*/   = /*maybe-const*/<Const, V>;              // только для пояснения
    sentinel_t</*Base*/> /*end_*/ = sentinel_t</*Base*/>();    // только для пояснения
    constexpr explicit /*sentinel*/(/*Parent*/& parent); // только для пояснения
  public:
    /*sentinel*/() = default;
    constexpr /*sentinel*/(/*sentinel*/<!Const> s)
      requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;
    template<bool OtherConst>
      requires sentinel_for<sentinel_t</*Base*/>,
                            iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr bool operator==(const /*iterator*/<OtherConst>& x,
                                     const /*sentinel*/& y);
  };
}

Шаблон класса std::ranges::lazy_split_view 

namespace std::ranges {
  template<auto>
  struct /*require-constant*/; // exposition-only
  template<class R>
  concept /*tiny-range*/ = // только для демонстрации
    sized_range<R> && requires {
      typename /*require-constant*/<remove_reference_t<R>::size()>;
    } && (remove_reference_t<R>::size() <= 1);
  template<input_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
             indirectly_comparable<iterator_t<V>,
                                   iterator_t<Pattern>,
                                   ranges::equal_to> &&
             (forward_range<V> || /*tiny-range*/<Pattern>)
  class lazy_split_view : public view_interface<lazy_split_view<V, Pattern>>
  {
  private:
    V /*base_*/          = V();       // exposition-only
    Pattern /*pattern_*/ = Pattern(); // exposition-only
    /*не распространяющийся кеш*/<iterator_t<V>> /*current_*/; // экспозиционная часть присутствует только
                                                           // если forward_range<V> ложно
    // шаблон класса lazy_split_view::outer-iterator
    template<bool>
    struct /*внешний-итератор*/; // exposition-only
    // шаблон класса lazy_split_view::inner-iterator
    template<bool>
    struct /*внутренний итератор*/; // exposition-only
  public:
    lazy_split_view()
      requires default_initializable<V> && default_initializable<Pattern>
    = default;
    constexpr explicit lazy_split_view(V base, Pattern pattern);
    template<input_range R>
      requires constructible_from<V, views::all_t<R>> &&
               constructible_from<Pattern, single_view<range_value_t<R>>>
    constexpr explicit lazy_split_view(R&& r, range_value_t<R> e);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr auto begin()
    {
      if constexpr (forward_range<V>) {
        return /*внешний-итератор*/ < /*простой-вид*/<V> &&
               /*простой-вид*/ < Pattern >> { *this, ranges::begin(/*base_*/) };
      } else {
        /*current_*/ = ranges::begin(/*base_*/);
        return /*внешний-итератор*/<false>{ *this };
      }
    }
    constexpr auto begin() const
      requires forward_range<V> && forward_range<const V>
    {
      return /*внешний-итератор*/<true>{ *this, ranges::begin(/*base_*/) };
    }
    constexpr auto end()
      requires forward_range<V> && common_range<V>
    {
      return /*внешний-итератор*/ < /*простой-вид*/<V> &&
             /*простой-вид*/ < Pattern >> { *this, ranges::end(/*base_*/) };
    }
    constexpr auto end() const
    {
      if constexpr (forward_range<V> && forward_range<const V> && common_range<const V>)
        return /*внешний-итератор*/<true>{ *this, ranges::end(/*base_*/) };
      else
        return default_sentinel;
    }
  };
  template<class R, class P>
  lazy_split_view(R&&, P&&) -> lazy_split_view<views::all_t<R>, views::all_t<P>>;
  template<input_range R>
  lazy_split_view(R&&, range_value_t<R>)
    -> lazy_split_view<views::all_t<R>, single_view<range_value_t<R>>>;
}

Шаблон класса std::ranges::lazy_split_view::outer_iterator 

namespace std::ranges {
  template<input_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
             indirectly_comparable<iterator_t<V>,
                                   iterator_t<Pattern>,
                                   ranges::equal_to> &&
             (forward_range<V> || /*tiny-range*/<Pattern>)
  template<bool Const>
  struct lazy_split_view<V, Pattern>::/*outer-iterator*/
  {
  private:
    using /*Parent*/        = /*maybe-const*/<Const, lazy_split_view>; // только для экспозиции
    using /*Base*/          = /*maybe-const*/<Const, V>;               // только для экспозиции
    /*Parent*/* /*parent_*/ = nullptr;                                 // только для экспозиции
    iterator_t</*Base*/> /*current_*/ =
      iterator_t</*Base*/>(); // только для экспозиции, присутствует только
                              // если V моделирует forward_range
    bool /*trailing-empty_*/ = false; // только для экспозиции
  public:
    using iterator_concept =
      conditional_t<forward_range</*Base*/>, forward_iterator_tag, input_iterator_tag>;
    using iterator_category = input_iterator_tag; // присутствует только если Base
                                                  // моделирует forward_range
    // класс lazy_split_view::outer-iterator::value_type
    struct value_type;
    using difference_type = range_difference_t</*Base*/>;
    /*outer-iterator*/()  = default;
    constexpr explicit /*outer-iterator*/(/*Parent*/& parent)
      requires(!forward_range</*Base*/>);
    constexpr /*outer-iterator*/(/*Parent*/& parent, iterator_t</*Base*/> current)
      requires forward_range</*Base*/>;
    constexpr /*outer-iterator*/(/*outer-iterator*/<!Const> i)
      requires Const && convertible_to<iterator_t<V>, iterator_t</*Base*/>>;
    constexpr value_type operator*() const;
    constexpr /*outer-iterator*/& operator++();
    constexpr decltype(auto) operator++(int)
    {
      if constexpr (forward_range</*Base*/>) {
        auto tmp = *this;
        ++*this;
        return tmp;
      } else
        ++*this;
    }
    friend constexpr bool operator==(const /*outer-iterator*/& x,
                                     const /*outer-iterator*/& y)
      requires forward_range</*Base*/>;
    friend constexpr bool operator==(const /*outer-iterator*/& x, default_sentinel_t);
  };
}

Шаблон класса std::ranges::lazy_split_view::outer_iterator::value_type 

namespace std::ranges {
  template<input_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
             indirectly_comparable<iterator_t<V>,
                                   iterator_t<Pattern>,
                                   ranges::equal_to> &&
             (forward_range<V> || /*tiny-range*/<Pattern>)
  template<bool Const>
  struct lazy_split_view<V, Pattern>::/*outer-iterator*/<Const>::value_type
    : view_interface<value_type>
  {
  private:
    /*outer-iterator*/ /*i_*/ = /*outer-iterator*/(); // только для демонстрации
    constexpr explicit value_type(/*outer-iterator*/ i); // только для демонстрации
  public:
    constexpr /*inner-iterator*/<Const> begin() const;
    constexpr default_sentinel_t end() const noexcept;
  };
}

Шаблон класса std::ranges::lazy_split_view::inner_iterator 

namespace std::ranges {
  template<input_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
             indirectly_comparable<iterator_t<V>,
                                   iterator_t<Pattern>,
                                   ranges::equal_to> &&
             (forward_range<V> || /*tiny-range*/<Pattern>)
  template<bool Const>
  struct lazy_split_view<V, Pattern>::/*inner-iterator*/
  {
  private:
    using /*Base*/                   = /*maybe-const*/<Const, V>;   // только для пояснения
    /*outer-iterator*/<Const> /*i_*/ = /*outer-iterator*/<Const>(); // только для пояснения
    bool /*incremented_*/            = false;                       // только для пояснения
  public:
    using iterator_concept  = typename /*outer-iterator*/<Const>::iterator_concept;
    using iterator_category = /* см. описание */; // присутствует только если Base
                                                     // моделирует forward_range
    using value_type      = range_value_t</*Base*/>;
    using difference_type = range_difference_t</*Base*/>;
    /*inner-iterator*/()  = default;
    constexpr explicit /*inner-iterator*/(/*outer-iterator*/<Const> i);
    constexpr const iterator_t</*Base*/>& base() const& noexcept;
    constexpr iterator_t</*Base*/> base() &&
        requires forward_range<V>;
    constexpr decltype(auto) operator*() const { return */*i_*/./*current*/; }
    constexpr /*inner-iterator*/& operator++();
    constexpr decltype(auto) operator++(int)
    {
      if constexpr (forward_range</*Base*/>) {
        auto tmp = *this;
        ++*this;
        return tmp;
      } else
        ++*this;
    }
    friend constexpr bool operator==(const /*inner-iterator*/& x,
                                     const /*inner-iterator*/& y)
      requires forward_range</*Base*/>;
    friend constexpr bool operator==(const /*inner-iterator*/& x, default_sentinel_t);
    friend constexpr decltype(auto) iter_move(const /*inner-iterator*/& i) noexcept(
      noexcept(ranges::iter_move(i./*i_*/./*current*/)))
    {
      return ranges::iter_move(i./*i_*/./*current*/);
    }
    friend constexpr void
    iter_swap(const /*inner-iterator*/& x, const /*inner-iterator*/& y) noexcept(
      noexcept(ranges::iter_swap(x./*i_*/./*current*/, y./*i_*/./*current*/)))
      requires indirectly_swappable<iterator_t</*Base*/>>;
  };
}

Шаблон класса std::ranges::split_view 

namespace std::ranges {
  template<forward_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>
  class split_view : public view_interface<split_view<V, Pattern>>
  {
  private:
    V /*base_*/          = V();       // только для демонстрации
    Pattern /*pattern_*/ = Pattern(); // только для демонстрации
    // класс split_view::iterator
    struct /*iterator*/; // только для демонстрации
    // класс split_view::sentinel
    struct /*sentinel*/; // только для демонстрации
  public:
    split_view()
      requires default_initializable<V> && default_initializable<Pattern>
    = default;
    constexpr explicit split_view(V base, Pattern pattern);
    template<forward_range R>
      requires constructible_from<V, views::all_t<R>> &&
               constructible_from<Pattern, single_view<range_value_t<R>>>
    constexpr explicit split_view(R&& r, range_value_t<R> e);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr /*iterator*/ begin();
    constexpr auto end()
    {
      if constexpr (common_range<V>) {
        return /*iterator*/{ *this, ranges::end(/*base_*/), {} };
      } else {
        return /*sentinel*/{ *this };
      }
    }
    constexpr subrange<iterator_t<V>> /*find-next*/(iterator_t<V>); // только для демонстрации
  };
  template<class R, class P>
  split_view(R&&, P&&) -> split_view<views::all_t<R>, views::all_t<P>>;
  template<forward_range R>
  split_view(R&&, range_value_t<R>)
    -> split_view<views::all_t<R>, single_view<range_value_t<R>>>;
}

Шаблон класса std::ranges::split_view::iterator 

namespace std::ranges {
  template<forward_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>
  class split_view<V, Pattern>::/*iterator*/
  {
  private:
    split_view* /*parent_*/           = nullptr;                   // только для демонстрации
    iterator_t<V> /*cur_*/            = iterator_t<V>();           // только для демонстрации
    subrange<iterator_t<V>> /*next_*/ = subrange<iterator_t<V>>(); // только для демонстрации
    bool /*trailing-empty_*/          = false;                     // только для демонстрации
  public:
    using iterator_concept  = forward_iterator_tag;
    using iterator_category = input_iterator_tag;
    using value_type        = subrange<iterator_t<V>>;
    using difference_type   = range_difference_t<V>;
    /*iterator*/()          = default;
    constexpr /*iterator*/(split_view& parent,
                           iterator_t<V> current,
                           subrange<iterator_t<V>> next);
    constexpr iterator_t<V> base() const;
    constexpr value_type operator*() const;
    constexpr /*iterator*/& operator++();
    constexpr /*iterator*/ operator++(int);
    friend constexpr bool operator==(const /*iterator*/& x, const /*iterator*/& y);
  };
}

Шаблон класса std::ranges::split_view::sentinel 

namespace std::ranges {
  template<forward_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>
  struct split_view<V, Pattern>::/*sentinel*/
  {
  private:
    sentinel_t<V> /*end_*/ = sentinel_t<V>(); // только для демонстрации
  public:
    /*sentinel*/() = default;
    constexpr explicit /*sentinel*/(split_view& parent);
    friend constexpr bool operator==(const /*iterator*/& x, const /*sentinel*/& y);
  };
}

Шаблон класса std::ranges::concat 

namespace std::ranges {
  template<class... Rs>
  using /*concat-reference-t*/ =
    common_reference_t<range_reference_t<Rs>...>; // только для экспозиции
  template<class... Rs>
  using /*concat-value-t*/ = common_type_t<range_value_t<Rs>...>; // только для экспозиции
  template<class... Rs>
  using /*concat-rvalue-reference-t*/ = // только для экспозиции
    common_reference_t<range_rvalue_reference_t<Rs>...>;
  template<class... Rs>
  concept /*concat-indirectly-readable*/ = /* см. описание */; // только для экспозиции
  template<class... Rs>
  concept /*concatable*/ = /* см. описание */; // только для экспозиции
  template<bool Const, class... Rs>
  concept /*concat-is-random-access*/ = /* см. описание */; // только для экспозиции
  template<bool Const, class... Rs>
  concept /*concat-is-bidirectional*/ = /* см. описание */; // только для экспозиции
  template<input_range... Views>
    requires(view<Views> && ...) && (sizeof...(Views) > 0) && /*concatable*/<Views...>
  class concat_view : public view_interface<concat_view<Views...>>
  {
    tuple<Views...> /*views_*/; // только для экспозиции
    // шаблон класса concat_view::iterator
    template<bool>
    class /*iterator*/; // только для экспозиции
  public:
    constexpr concat_view() = default;
    constexpr explicit concat_view(Views... views);
    constexpr /*iterator*/<false> begin()
      requires(!(/*simple-view*/<Views> && ...));
    constexpr /*iterator*/<true> begin() const
      requires(range<const Views> && ...) && /*concatable*/<const Views...>;
    constexpr auto end()
      requires(!(/*simple-view*/<Views> && ...));
    constexpr auto end() const
      requires(range<const Views> && ...) && /*concatable*/<const Views...>;
    constexpr auto size()
      requires(sized_range<Views> && ...);
    constexpr auto size() const
      requires(sized_range<const Views> && ...);
  };
  template<class... R>
  concat_view(R&&...) -> concat_view<views::all_t<R>...>;
}

Шаблон класса std::ranges::concat::iterator 

namespace std::ranges {
  template<input_range... Просмотры>
    requires(view<Views> && ...) && (sizeof...(Views) > 0) && /*concatable*/<Views...>
  template<bool Const>
  class concat_view<Views...>::/*итератор*/
  {
  public:
    using iterator_category = /* см. описание */; // не всегда присутствует
    using iterator_concept  = /* см. описание */;
    using value_type        = /*concat-value-t*/</*возможно-константа*/<Const, Views>...>;
    using difference_type =
      common_type_t<range_difference_t</*возможно-константа*/<Const, Views>>...>;
  private:
    using /*базовый итератор*/ = // exposition-only
      variant<iterator_t</*возможно-константа*/<Const, Views>>...>;
    /*возможно-константа*/<Const, concat_view>* /*родительский_*/ = nullptr; // exposition-only
    /*базовый итератор*/ /*it_*/;                                      // exposition-only
    template<size_t N>
    constexpr void /*удовлетворить*/(); // exposition-only
    template<size_t N>
    constexpr void /*предыдущий*/(); // exposition-only
    template<size_t N>
    constexpr void /*advance-fwd*/(difference_type offset, // exposition-only
                                   difference_type steps);
    template<size_t N>
    constexpr void /*advance-bwd*/(difference_type offset, // exposition-only
                                   difference_type steps);
    template<class... Args>
    constexpr explicit /*итератор*/(
      /*возможно-константа*/<Const, concat_view>* parent, // exposition-only
      Args&&... args)
      requires constructible_from</*базовый итератор*/, Args&&...>;
  public:
    /*итератор*/() = default;
    constexpr /*итератор*/(/*итератор*/<!Const> i)
      requires Const &&
               (convertible_to<iterator_t<Views>, iterator_t<const Views>> && ...);
    constexpr decltype(auto) operator*() const;
    constexpr /*итератор*/& operator++();
    constexpr void operator++(int);
    constexpr /*итератор*/ operator++(int)
      requires /*все-вперед*/<Const, Views...>;
    constexpr /*итератор*/& operator--()
      requires /*concat-is-bidirectional*/<Const, Views...>;
    constexpr /*итератор*/ operator--(int)
      requires /*concat-is-bidirectional*/<Const, Views...>;
    constexpr /*итератор*/& operator+=(difference_type n)
      requires /*concat-is-random-access*/<Const, Views...>;
    constexpr /*итератор*/& operator-=(difference_type n)
      requires /*concat-is-random-access*/<Const, Views...>;
    constexpr decltype(auto) operator[](difference_type n) const
      requires /*concat-is-random-access*/<Const, Views...>;
    friend constexpr bool operator==(const /*итератор*/& x, const /*итератор*/& y)
      requires(equality_comparable<iterator_t</*возможно-константа*/<Const, Views>>> && ...);
    friend constexpr bool operator==(const /*итератор*/& it, default_sentinel_t);
    friend constexpr bool operator<(const /*итератор*/& x, const /*итератор*/& y)
      requires /*все-случайные-доступы*/<Const, Views...>;
    friend constexpr bool operator>(const /*итератор*/& x, const /*итератор*/& y)
      requires /*все-случайные-доступы*/<Const, Views...>;
    friend constexpr bool operator<=(const /*итератор*/& x, const /*итератор*/& y)
      requires /*все-случайные-доступы*/<Const, Views...>;
    friend constexpr bool operator>=(const /*итератор*/& x, const /*итератор*/& y)
      requires /*все-случайные-доступы*/<Const, Views...>;
    friend constexpr auto operator<=>(const /*итератор*/& x, const /*итератор*/& y)
      requires(/*все-случайные-доступы*/<Const, Views...> &&
               (three_way_comparable<iterator_t</*возможно-константа*/<Const, Views>>> && ...));
    friend constexpr /*итератор*/ operator+(const /*итератор*/& it, difference_type n)
      requires /*concat-is-random-access*/<Const, Views...>;
    friend constexpr /*итератор*/ operator+(difference_type n, const /*итератор*/& it)
      requires /*concat-is-random-access*/<Const, Views...>;
    friend constexpr /*итератор*/ operator-(const /*итератор*/& it, difference_type n)
      requires /*concat-is-random-access*/<Const, Views...>;
    friend constexpr difference_type operator-(const /*итератор*/& x,
                                               const /*итератор*/& y)
      requires /*concat-is-random-access*/<Const, Views...>;
    friend constexpr difference_type operator-(const /*итератор*/& x, default_sentinel_t)
      requires /* см. описание */;
    friend constexpr difference_type operator-(default_sentinel_t, const /*итератор*/& x)
      requires /* см. описание */;
    friend constexpr decltype(auto) iter_move(const /*итератор*/& it) noexcept(
      /* см. описание */);
    friend constexpr void iter_swap(const /*итератор*/& x,
                                    const /*итератор*/& y) noexcept(/* см. описание */)
      requires /* см. описание */;
  };
}

Шаблон класса std::ranges::common_view 

namespace std::ranges {
  template<view V>
    requires(!common_range<V> && copyable<iterator_t<V>>)
  class common_view : public view_interface<common_view<V>>
  {
  private:
    V /*base_*/ = V(); // exposition-only
  public:
    common_view()
      requires default_initializable<V>
    = default;
    constexpr explicit common_view(V r);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr auto begin()
      requires(!/*простой-вид*/<V>)
    {
      if constexpr (random_access_range<V> && sized_range<V>)
        return ranges::begin(/*base_*/);
      else
        return common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::begin(/*базовый_*/));
    }
    constexpr auto begin() const
      requires range<const V>
    {
      if constexpr (random_access_range<const V> && sized_range<const V>)
        return ranges::begin(/*базовый_*/);
      else
        return common_iterator<iterator_t<const V>, sentinel_t<const V>>(
          ranges::begin(/*base_*/));
    }
    constexpr auto end()
      requires(!/*простой-вид*/<V>)
    {
      if constexpr (random_access_range<V> && sized_range<V>)
        return ranges::begin(/*base_*/) + ranges::distance(/*base_*/);
      else
        return common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::end(/*базовый_*/));
    }
    constexpr auto end() const
      requires range<const V>
    {
      if constexpr (random_access_range<const V> && sized_range<const V>)
        return ranges::begin(/*base_*/) + ranges::distance(/*базовый_*/);
      else
        return common_iterator<iterator_t<const V>, sentinel_t<const V>>(
          ranges::end(/*base_*/));
    }
    constexpr auto size()
      requires sized_range<V>
    {
      return ranges::size(/*base_*/);
    }
    constexpr auto size() const
      requires sized_range<const V>
    {
      return ranges::size(/*base_*/);
    }
    constexpr auto reserve_hint()
      requires approximately_sized_range<V>
    {
      return ranges::reserve_hint(/*base_*/);
    }
    constexpr auto reserve_hint() const
      requires approximately_sized_range<const V>
    {
      return ranges::reserve_hint(/*base_*/);
    }
  };
  template<class R>
  common_view(R&&) -> common_view<views::all_t<R>>;
}

Шаблон класса std::ranges::reverse_view 

namespace std::ranges {
  template<view V>
    requires bidirectional_range<V>
  class reverse_view : public view_interface<reverse_view<V>>
  {
  private:
    V /*base_*/ = V(); // только для демонстрации
  public:
    reverse_view()
      requires default_initializable<V>
    = default;
    constexpr explicit reverse_view(V r);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr reverse_iterator<iterator_t<V>> begin();
    constexpr reverse_iterator<iterator_t<V>> begin()
      requires common_range<V>;
    constexpr auto begin() const
      requires common_range<const V>;
    constexpr reverse_iterator<iterator_t<V>> end();
    constexpr auto end() const
      requires common_range<const V>;
    constexpr auto size()
      requires sized_range<V>
    {
      return ranges::size(/*base_*/);
    }
    constexpr auto size() const
      requires sized_range<const V>
    {
      return ranges::size(/*base_*/);
    }
    constexpr auto reserve_hint()
      requires approximately_sized_range<V>
    {
      return ranges::reserve_hint(/*base_*/);
    }
    constexpr auto reserve_hint() const
      requires approximately_sized_range<const V>
    {
      return ranges::reserve_hint(/*base_*/);
    }
  };
  template<class R>
  reverse_view(R&&) -> reverse_view<views::all_t<R>>;
}

Шаблон класса std::ranges::as_const_view 

namespace std::ranges {
  template<view V>
    requires input_range<V>
  class as_const_view : public view_interface<as_const_view<V>>
  {
    V /*base_*/ = V(); // только для демонстрации
  public:
    as_const_view()
      requires default_initializable<V>
    = default;
    constexpr explicit as_const_view(V base);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr auto begin()
      requires(!/*simple-view*/<V>)
    {
      return ranges::cbegin(/*base_*/);
    }
    constexpr auto begin() const
      requires range<const V>
    {
      return ranges::cbegin(/*base_*/);
    }
    constexpr auto end()
      requires(!/*simple-view*/<V>)
    {
      return ranges::cend(/*base_*/);
    }
    constexpr auto end() const
      requires range<const V>
    {
      return ranges::cend(/*base_*/);
    }
    constexpr auto size()
      requires sized_range<V>
    {
      return ranges::size(/*base_*/);
    }
    constexpr auto size() const
      requires sized_range<const V>
    {
      return ranges::size(/*base_*/);
    }
    constexpr auto reserve_hint()
      requires approximately_sized_range<V>
    {
      return ranges::reserve_hint(/*base_*/);
    }
    constexpr auto reserve_hint() const
      requires approximately_sized_range<const V>
    {
      return ranges::reserve_hint(/*base_*/);
    }
  };
  template<class R>
  as_const_view(R&&) -> as_const_view<views::all_t<R>>;
}

Шаблон класса std::ranges::elements_view 

namespace std::ranges {
  template<class T, size_t N>
  concept /*has-tuple-element*/ = // только для демонстрации
    /*кортежеподобный*/<T> && N < tuple_size_v<T>;
  template<class T, size_t N>
  concept /*возвращаемый элемент*/ = // exposition-only
    is_reference_v<T> || move_constructible<tuple_element_t<N, T>>;
  template<input_range V, size_t N>
    requires view<V> && /*has-tuple-element*/<range_value_t<V>, N> &&
             /*has-tuple-element*/<remove_reference_t<range_reference_t<V>>, N> &&
             /*возвращаемый элемент*/<range_reference_t<V>, N>
  class elements_view : public view_interface<elements_view<V, N>>
  {
  public:
    elements_view()
      requires default_initializable<V>
    = default;
    constexpr explicit elements_view(V base);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr auto begin()
      requires(!/*простой-вид*/<V>)
    {
      return /*итератор*/<false>(ranges::begin(/*base_*/));
    }
    constexpr auto begin() const
      requires range<const V>
    {
      return /*итератор*/<true>(ranges::begin(/*base_*/));
    }
    constexpr auto end()
      requires(!/*простой-вид*/<V> && !common_range<V>)
    {
      return /*sentinel*/<false>{ ranges::end(/*base_*/) };
    }
    constexpr auto end()
      requires(!/*простой-вид*/<V> && common_range<V>)
    {
      return /*итератор*/<false>{ ranges::end(/*base_*/) };
    }
    constexpr auto end() const
      requires range<const V>
    {
      return /*sentinel*/<true>{ ranges::end(/*base_*/) };
    }
    constexpr auto end() const
      requires common_range<const V>
    {
      return /*итератор*/<true>{ ranges::end(/*base_*/) };
    }
    constexpr auto size()
      requires sized_range<V>
    {
      return ranges::size(/*base_*/);
    }
    constexpr auto size() const
      requires sized_range<const V>
    {
      return ranges::size(/*base_*/);
    }
    constexpr auto reserve_hint()
      requires approximately_sized_range<V>
    {
      return ranges::reserve_hint(/*базовый_*/);
    }
    constexpr auto reserve_hint() const
      requires approximately_sized_range<const V>
    {
      return ranges::reserve_hint(/*базовый_*/);
    }
  private:
    // шаблон класса elements_view::iterator
    template<bool>
    class /*итератор*/; // exposition-only
    // шаблон класса elements_view::sentinel
    template<bool>
    class /*sentinel*/; // exposition-only
    V /*base_*/ = V(); // exposition-only
  };
}

Шаблон класса std::ranges::elements_view::iterator 

namespace std::ranges {
  template<input_range V, size_t N>
    requires view<V> && /*has-tuple-element*/<range_value_t<V>, N> &&
             /*имеет-элемент-кортежа*/<remove_reference_t<range_reference_t<V>>, N> &&
             /*возвращаемый элемент*/<range_reference_t<V>, N>
  template<bool Const>
  class elements_view<V, N>::/*итератор*/
  {
    using /*Базовый*/                    = /*возможно-константа*/<Const, V>; // exposition-only
    iterator_t</*Базовый*/> /*current_*/ = iterator_t</*Базовый*/>(); // exposition-only
    static constexpr decltype(auto) /*получить-элемент*/(
      const iterator_t</*Базовый*/>& i); // exposition-only
  public:
    using iterator_concept  = /* см. описание */;
    using iterator_category = /* см. описание */; // не всегда присутствует
    using value_type        = remove_cvref_t<tuple_element_t<N, range_value_t</*Базовый*/>>>;
    using difference_type   = range_difference_t</*Базовый*/>;
    /*итератор*/()
      requires default_initializable<iterator_t</*Базовый*/>>
    = default;
    constexpr explicit /*итератор*/(iterator_t</*Базовый*/> current);
    constexpr /*итератор*/(/*итератор*/<!Const> i)
      requires Const && convertible_to<iterator_t<V>, iterator_t</*Базовый*/>>;
    constexpr const iterator_t</*Базовый*/>& base() const& noexcept;
    constexpr iterator_t</*Базовый*/> base() &&;
    constexpr decltype(auto) operator*() const { return /*получить-элемент*/(/*current_*/); }
    constexpr /*итератор*/& operator++();
    constexpr void operator++(int);
    constexpr /*итератор*/ operator++(int)
      requires forward_range</*Базовый*/>;
    constexpr /*итератор*/& operator--()
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/ operator--(int)
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/& operator+=(difference_type x)
      requires random_access_range</*Базовый*/>;
    constexpr /*итератор*/& operator-=(difference_type x)
      requires random_access_range</*Базовый*/>;
    constexpr decltype(auto) operator[](difference_type n) const
      requires random_access_range</*Базовый*/>
    {
      return /*получить-элемент*/(/*current_*/ + n);
    }
    friend constexpr bool operator==(const /*итератор*/& x, const /*итератор*/& y)
      requires equality_comparable<iterator_t</*Базовый*/>>;
    friend constexpr bool operator<(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator>(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator<=(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator>=(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr auto operator<=>(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/> && three_way_comparable<iterator_t</*Базовый*/>>
    ;
    friend constexpr /*итератор*/ operator+(const /*итератор*/& x, difference_type y)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator+(difference_type x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator-(const /*итератор*/& x, difference_type y)
      requires random_access_range</*Базовый*/>;
    friend constexpr difference_type operator-(const /*итератор*/& x,
                                               const /*итератор*/& y)
      requires sized_sentinel_for<iterator_t</*Базовый*/>, iterator_t</*Базовый*/>>;
  };
}

Шаблон класса std::ranges::elements_view::sentinel 

namespace std::ranges {
  template<input_range V, size_t N>
    requires view<V> && /*has-tuple-element*/<range_value_t<V>, N> &&
             /*has-tuple-element*/<remove_reference_t<range_reference_t<V>>, N> &&
             /*returnable-element*/<range_reference_t<V>, N>
  template<bool Const>
  class elements_view<V, N>::/*sentinel*/
  {
  private:
    using /*Base*/                = /*maybe-const*/<Const, V>; // только для экспозиции
    sentinel_t</*Base*/> /*end_*/ = sentinel_t</*Base*/>();    // только для экспозиции
  public:
    /*sentinel*/() = default;
    constexpr explicit /*sentinel*/(sentinel_t</*Base*/> end);
    constexpr /*sentinel*/(/*sentinel*/<!Const> other)
      requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;
    constexpr sentinel_t</*Base*/> base() const;
    template<bool OtherConst>
      requires sentinel_for<sentinel_t</*Base*/>,
                            iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr bool operator==(const /*iterator*/<OtherConst>& x,
                                     const /*sentinel*/& y);
    template<bool OtherConst>
      requires sized_sentinel_for<sentinel_t</*Base*/>,
                                  iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr range_difference_t</*maybe-const*/<OtherConst, V>> operator-(
      const /*iterator*/<OtherConst>& x,
      const /*sentinel*/& y);
    template<bool OtherConst>
      requires sized_sentinel_for<sentinel_t</*Base*/>,
                                  iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr range_difference_t</*maybe-const*/<OtherConst, V>> operator-(
      const /*sentinel*/& x,
      const /*iterator*/<OtherConst>& y);
  };
}

Шаблон класса std::ranges::enumerate_view 

namespace std::ranges {
  template<view V>
    requires /*диапазон-с-перемещаемыми-ссылками*/<V>
  class enumerate_view : public view_interface<enumerate_view<V>>
  {
    V /*base_*/ = V(); // exposition-only
    // шаблон класса enumerate_view::iterator
    template<bool Const>
    class /*итератор*/; // exposition-only
    // шаблон класса enumerate_view::sentinel
    template<bool Const>
    class /*sentinel*/; // exposition-only
  public:
    constexpr enumerate_view()
      requires default_initializable<V>
    = default;
    constexpr explicit enumerate_view(V base);
    constexpr auto begin()
      requires(!/*простой-вид*/<V>)
    {
      return /*итератор*/<false>(ranges::begin(/*base_*/), 0);
    }
    constexpr auto begin() const
      requires /*диапазон-с-перемещаемыми-ссылками*/<const V>
    {
      return /*итератор*/<true>(ranges::begin(/*base_*/), 0);
    }
    constexpr auto end()
      requires(!/*простой-вид*/<V>)
    {
      if constexpr (forward_range<V> && common_range<V> && sized_range<V>)
        return /*итератор*/<false>(ranges::end(/*base_*/), ranges::distance(/*base_*/));
      else
        return /*sentinel*/<false>(ranges::end(/*base_*/));
    }
    constexpr auto end() const
      requires /*диапазон-с-перемещаемыми-ссылками*/<const V>
    {
      if constexpr (forward_range<const V> && common_range<const V> &&
                    sized_range<const V>)
        return /*итератор*/<true>(ranges::end(/*base_*/), ranges::distance(/*base_*/));
      else
        return /*sentinel*/<true>(ranges::end(/*base_*/));
    }
    constexpr auto size()
      requires sized_range<V>
    {
      return ranges::size(/*base_*/);
    }
    constexpr auto size() const
      requires sized_range<const V>
    {
      return ranges::size(/*base_*/);
    }
    constexpr auto reserve_hint()
      requires approximately_sized_range<V>
    {
      return ranges::reserve_hint(/*base_*/);
    }
    constexpr auto reserve_hint() const
      requires approximately_sized_range<const V>
    {
      return ranges::reserve_hint(/*base_*/);
    }
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
  };
  template<class R>
  enumerate_view(R&&) -> enumerate_view<views::all_t<R>>;
}

Шаблон класса std::ranges::enumerate_view::iterator 

namespace std::ranges {
  template<view V>
    requires /*диапазон-с-перемещаемыми-ссылками*/<V>
  template<bool Const>
  class enumerate_view<V>::/*итератор*/
  {
    using /*Базовый*/ = /*возможно-константа*/<Const, V>; // exposition-only
  public:
    using iterator_category = input_iterator_tag;
    using iterator_concept  = /* см. описание */;
    using difference_type   = range_difference_t</*Базовый*/>;
    using value_type        = tuple<difference_type, range_value_t</*Базовый*/>>;
  private:
    using /*reference-type*/ = // exposition-only
      tuple<difference_type, range_reference_t</*Базовый*/>>;
    iterator_t</*Базовый*/> /*current_*/ = iterator_t</*Базовый*/>(); // exposition-only
    difference_type /*позиция_*/          = 0;                      // exposition-only
    constexpr explicit /*итератор*/(iterator_t</*Базовый*/> current,
                                    difference_type pos); // exposition-only
  public:
    /*итератор*/()
      requires default_initializable<iterator_t</*Базовый*/>>
    = default;
    constexpr /*итератор*/(/*итератор*/<!Const> i)
      requires Const && convertible_to<iterator_t<V>, iterator_t</*Базовый*/>>;
    constexpr const iterator_t</*Базовый*/>& base() const& noexcept;
    constexpr iterator_t</*Базовый*/> base() &&;
    constexpr difference_type index() const noexcept;
    constexpr auto operator*() const
    {
      return /*reference-type*/(/*позиция_*/, */*current_*/);
    }
    constexpr /*итератор*/& operator++();
    constexpr void operator++(int);
    constexpr /*итератор*/ operator++(int)
      requires forward_range</*Базовый*/>;
    constexpr /*итератор*/& operator--()
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/ operator--(int)
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/& operator+=(difference_type x)
      requires random_access_range</*Базовый*/>;
    constexpr /*итератор*/& operator-=(difference_type x)
      requires random_access_range</*Базовый*/>;
    constexpr auto operator[](difference_type n) const
      requires random_access_range</*Базовый*/>
    {
      return /*reference-type*/(/*позиция_*/ + n, /*current_*/[n]);
    }
    friend constexpr bool operator==(const /*итератор*/& x,
                                     const /*итератор*/& y) noexcept;
    friend constexpr strong_ordering operator<=>(const /*итератор*/& x,
                                                 const /*итератор*/& y) noexcept;
    friend constexpr /*итератор*/ operator+(const /*итератор*/& x, difference_type y)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator+(difference_type x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator-(const /*итератор*/& x, difference_type y)
      requires random_access_range</*Базовый*/>;
    friend constexpr difference_type operator-(const /*итератор*/& x,
                                               const /*итератор*/& y) noexcept;
    friend constexpr auto iter_move(const /*итератор*/& i) noexcept(
      noexcept(ranges::iter_move(i./*current_*/)) &&
      is_nothrow_move_constructible_v<range_rvalue_reference_t</*Базовый*/>>)
    {
      return tuple<difference_type, range_rvalue_reference_t</*Базовый*/>>(
        i./*позиция_*/, ranges::iter_move
(Примечание: В данном случае переводить нечего, так как текст состоит только из HTML-разметки и C++ термина `ranges::iter_move`, который согласно инструкции не подлежит переводу. Весь представленный контент сохраняется в исходном виде.)(i./*current_*/));
    }
  };
}

Шаблон класса std::ranges::enumerate_view::sentinel 

namespace std::ranges {
  template<view V>
    requires /*range-with-movable-references*/<V>
  template<bool Const>
  class enumerate_view<V>::/*sentinel*/
  {
    using /*Base*/                = /*maybe-const*/<Const, V>; // только для экспозиции
    sentinel_t</*Base*/> /*end_*/ = sentinel_t</*Base*/>();    // только для экспозиции
    constexpr explicit /*sentinel*/(sentinel_t</*Base*/> end); // только для экспозиции
  public:
    /*sentinel*/() = default;
    constexpr /*sentinel*/(/*sentinel*/<!Const> other)
      requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;
    constexpr sentinel_t</*Base*/> base() const;
    template<bool OtherConst>
      requires sentinel_for<sentinel_t</*Base*/>,
                            iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr bool operator==(const /*iterator*/<OtherConst>& x,
                                     const /*sentinel*/& y);
    template<bool OtherConst>
      requires sized_sentinel_for<sentinel_t</*Base*/>,
                                  iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr range_difference_t</*maybe-const*/<OtherConst, V>> operator-(
      const /*iterator*/<OtherConst>& x,
      const /*sentinel*/& y);
    template<bool OtherConst>
      requires sized_sentinel_for<sentinel_t</*Base*/>,
                                  iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr range_difference_t</*maybe-const*/<OtherConst, V>> operator-(
      const /*sentinel*/& x,
      const /*iterator*/<OtherConst>& y);
  };
}

Шаблон класса std::ranges::zip_view 

namespace std::ranges {
  template<class... Rs>
  concept /*zip-является-распространенным*/ = // только для демонстрации
    (sizeof...(Rs) == 1 && (common_range<Rs> && ...)) ||
    (!(bidirectional_range<Rs> && ...) && (common_range<Rs> && ...)) ||
    ((random_access_range<Rs> && ...) && (sized_range<Rs> && ...));
  template<input_range... Просмотры>
    requires(view<Views> && ...) && (sizeof...(Views) > 0)
  class zip_view : public view_interface<zip_view<Views...>>
  {
    tuple<Views...> /*представления_*/; // exposition-only
    // шаблон класса zip_view::iterator
    template<bool>
    class /*итератор*/; // exposition-only
    // шаблон класса zip_view::sentinel
    template<bool>
    class /*sentinel*/; // exposition-only
  public:
    zip_view() = default;
    constexpr explicit zip_view(Views... представления);
    constexpr auto begin()
      requires(!(/*простой-вид*/<Views> && ...))
    {
      return /*итератор*/<false>(/*tuple-transform*/(ranges::begin, /*представления_*/));
    }
    constexpr auto begin() const
      requires(range<const Views> && ...)
    {
      return /*итератор*/<true>(/*преобразование-кортежа*/(ranges::begin, /*представления_*/));
    }
    constexpr auto end()
      requires(!(/*простой-вид*/<Views> && ...))
    {
      if constexpr (!/*zip-является-распространенным*/<Views...>) {
        return /*sentinel*/<false>(/*tuple-transform*/(ranges::end, /*представления_*/));
      } else if constexpr ((random_access_range<Views> && ...)) {
        return begin() + iter_difference_t</*итератор*/<false>>(size());
      } else {
        return /*итератор*/<false>(/*преобразование-кортежа*/(ranges::end, /*представления_*/));
      }
    }
    constexpr auto end() const
      requires(range<const Views> && ...)
    {
      if constexpr (!/*zip-является-распространенным*/<const Views...>) {
        return /*sentinel*/<true>(/*преобразование-кортежа*/(ranges::end, /*представления_*/));
      } else if constexpr ((random_access_range<const Views> && ...)) {
        return begin() + iter_difference_t</*итератор*/<true>>(size());
      } else {
        return /*итератор*/<true>(/*трансформация-кортежа*/(ranges::end, /*представления_*/));
      }
    }
    constexpr auto size()
      requires(sized_range<Views> && ...);
    constexpr auto size() const
      requires(sized_range<const Views> && ...);
  };
  template<class... Rs>
  zip_view(Rs&&...) -> zip_view<views::all_t<Rs>...>;
}

Шаблон класса std::ranges::zip_view::iterator 

namespace std::ranges {
  template<input_range... Просмотры>
    requires(view<Views> && ...) && (sizeof...(Views) > 0)
  template<bool Const>
  class zip_view<Views...>::/*итератор*/
  {
    tuple<iterator_t</*возможно-константа*/<Const, Views>>...> /*current_*/; // exposition-only
    constexpr explicit /*итератор*/(tuple<iterator_t</*возможно-константа*/<Const, Views>>...>);
    // exposition-only
  public:
    using iterator_category = input_iterator_tag; // не всегда присутствует
    using iterator_concept  = /* см. описание */;
    using value_type        = tuple<range_value_t</*возможно-константа*/<Const, Views>>...>;
    using difference_type =
      common_type_t<range_difference_t</*возможно-константа*/<Const, Views>>...>;
    /*итератор*/() = default;
    constexpr /*итератор*/(/*итератор*/<!Const> i)
      requires Const &&
               (convertible_to<iterator_t<Views>, iterator_t<const Views>> && ...);
    constexpr auto operator*() const;
    constexpr /*итератор*/& operator++();
    constexpr void operator++(int);
    constexpr /*итератор*/ operator++(int)
      requires /*все-вперед*/<Const, Views...>;
    constexpr /*итератор*/& operator--()
      requires /*все-двунаправленные*/<Const, Views...>;
    constexpr /*итератор*/ operator--(int)
      requires /*все-двунаправленные*/<Const, Views...>;
    constexpr /*итератор*/& operator+=(difference_type x)
      requires /*все-произвольного-доступа*/<Const, Views...>;
    constexpr /*итератор*/& operator-=(difference_type x)
      requires /*все-произвольного-доступа*/<Const, Views...>;
    constexpr auto operator[](difference_type n) const
      requires /*все-случайные-доступы*/<Const, Views...>;
    friend constexpr bool operator==(const /*итератор*/& x, const /*итератор*/& y)
      requires(equality_comparable<iterator_t</*возможно-константа*/<Const, Views>>> && ...);
    friend constexpr auto operator<=>(const /*итератор*/& x, const /*итератор*/& y)
      requires /*все-случайные-доступы*/<Const, Views...>;
    friend constexpr /*итератор*/ operator+(const /*итератор*/& i, difference_type n)
      requires /*все-случайные-доступы*/<Const, Views...>;
    friend constexpr /*итератор*/ operator+(difference_type n, const /*итератор*/& i)
      requires /*все-случайные-доступы*/<Const, Views...>;
    friend constexpr /*итератор*/ operator-(const /*итератор*/& i, difference_type n)
      requires /*все-произвольного-доступа*/<Const, Views...>;
    friend constexpr difference_type operator-(const /*итератор*/& x,
                                               const /*итератор*/& y)
      requires(sized_sentinel_for<iterator_t</*возможно-константа*/<Const, Views>>,
                                  iterator_t</*возможно-константа*/<Const, Views>>> &&
               ...);
    friend constexpr auto iter_move(const /*итератор*/& i) noexcept(
      /* см. описание */);
    friend constexpr void iter_swap(const /*итератор*/& l,
                                    const /*итератор*/& r) noexcept(/* см. описание */)
      requires(indirectly_swappable<iterator_t</*возможно-константа*/<Const, Views>>> && ...);
  };
}

Шаблон класса std::ranges::zip_view::sentinel 

namespace std::ranges {
  template<input_range... Views>
    requires(view<Views> && ...) && (sizeof...(Views) > 0)
  template<bool Const>
  class zip_view<Views...>::/*sentinel*/
  {
    tuple<sentinel_t</*maybe-const*/<Const, Views>>...> /*end_*/; // только для демонстрации
    constexpr explicit /*sentinel*/(
      tuple<sentinel_t</*maybe-const*/<Const, Views>>...> end);
    // только для демонстрации
  public:
    /*sentinel*/() = default;
    constexpr /*sentinel*/(/*sentinel*/<!Const> i)
      requires Const &&
               (convertible_to<sentinel_t<Views>, sentinel_t<const Views>> && ...);
    template<bool OtherConst>
      requires(sentinel_for<sentinel_t</*maybe-const*/<Const, Views>>,
                            iterator_t</*maybe-const*/<OtherConst, Views>>> &&
               ...)
    friend constexpr bool operator==(const /*iterator*/<OtherConst>& x,
                                     const /*sentinel*/& y);
    template<bool OtherConst>
      requires(sized_sentinel_for<sentinel_t</*maybe-const*/<Const, Views>>,
                                  iterator_t</*maybe-const*/<OtherConst, Views>>> &&
               ...)
    friend constexpr common_type_t<
      range_difference_t</*maybe-const*/<OtherConst, Views>>...>
    operator-(const /*iterator*/<OtherConst>& x, const /*sentinel*/& y);
    template<bool OtherConst>
      requires(sized_sentinel_for<sentinel_t</*maybe-const*/<Const, Views>>,
                                  iterator_t</*maybe-const*/<OtherConst, Views>>> &&
               ...)
    friend constexpr common_type_t<
      range_difference_t</*maybe-const*/<OtherConst, Views>>...>
    operator-(const /*sentinel*/& y, const /*iterator*/<OtherConst>& x);
  };
}

Шаблон класса std::ranges::zip_transform_view 

namespace std::ranges {
  template<move_constructible F, input_range... Просмотры>
    requires(view<Views> && ...) && (sizeof...(Views) > 0) && is_object_v<F> &&
            regular_invocable<F&, range_reference_t<Views>...> &&
            /*может ссылаться*/<invoke_result_t<F&, range_reference_t<Views>...>>
  class zip_transform_view : public view_interface<zip_transform_view<F, Views...>>
  {
    /*перемещаемый блок*/<F> /*функция_*/; // exposition-only
    zip_view<Views...> /*zip_*/; // exposition-only
    using /*InnerView*/ = zip_view<Views...>; // exposition-only
    template<bool Const>
    using /*зиператор*/ =
      iterator_t</*возможно-константа*/<Const, /*InnerView*/>>; // exposition-only
    template<bool Const>
    using /*zentinel*/ =
      sentinel_t</*возможно-константа*/<Const, /*InnerView*/>>; // exposition-only
    // шаблон класса zip_transform_view::iterator
    template<bool>
    class /*итератор*/; // exposition-only
    // шаблон класса zip_transform_view::sentinel
    template<bool>
    class /*sentinel*/; // exposition-only
  public:
    zip_transform_view() = default;
    constexpr explicit zip_transform_view(F fun, Views... представления);
    constexpr auto begin() { return /*итератор*/<false>(*this, /*zip_*/.begin()); }
    constexpr auto begin() const
      requires range<const /*InnerView*/> &&
               regular_invocable<const F&, range_reference_t<const Views>...>
    {
      return /*итератор*/<true>(*this, /*zip_*/.begin());
    }
    constexpr auto end()
    {
      if constexpr (common_range</*InnerView*/>) {
        return /*итератор*/<false>(*this, /*zip_*/.end());
      } else {
        return /*sentinel*/<false>(/*zip_*/.end());
      }
    }
    constexpr auto end() const
      requires range<const /*InnerView*/> &&
               regular_invocable<const F&, range_reference_t<const Views>...>
    {
      if constexpr (common_range<const /*InnerView*/>) {
        return /*итератор*/<true>(*this, /*zip_*/.end());
      } else {
        return /*sentinel*/<true>(/*zip_*/.end());
      }
    }
    constexpr auto size()
      requires sized_range</*InnerView*/>
    {
      return /*zip_*/.size();
    }
    constexpr auto size() const
      requires sized_range<const /*InnerView*/>
    {
      return /*zip_*/.size();
    }
  };
  template<class F, class... Rs>
  zip_transform_view(F, Rs&&...) -> zip_transform_view<F, views::all_t<Rs>...>;
}

Шаблон класса std::ranges::zip_transform_view::iterator 

namespace std::ranges {
  template<move_constructible F, input_range... Просмотры>
    requires(view<Views> && ...) && (sizeof...(Views) > 0) && is_object_v<F> &&
            regular_invocable<F&, range_reference_t<Views>...> &&
            /*может ссылаться*/<invoke_result_t<F&, range_reference_t<Views>...>>
  template<bool Const>
  class zip_transform_view<F, Views...>::/*итератор*/
  {
    using /*Родительский*/ = /*возможно-константа*/<Const, zip_transform_view>; // exposition-only
    using /*Базовый*/   = /*возможно-константа*/<Const, /*InnerView*/>;      // exposition-only
    /*Родительский*/* /*родительский_*/ = nullptr;                             // exposition-only
    /*ziperator*/<Const> /*inner_*/;                               // exposition-only
    constexpr /*итератор*/(/*Родительский*/& parent,
                           /*ziperator*/<Const> inner); // exposition-only
  public:
    using iterator_category = /* см. описание */; // не всегда присутствует
    using iterator_concept  = typename /*ziperator*/<Const>::iterator_concept;
    using value_type        = remove_cvref_t<
      invoke_result_t</*возможно-константа*/<Const, F>&,
                      range_reference_t</*возможно-константа*/<Const, Views>>...>>;
    using difference_type = range_difference_t</*Базовый*/>;
    /*итератор*/()        = default;
    constexpr /*итератор*/(/*итератор*/<!Const> i)
      requires Const && convertible_to</*ziperator*/<false>, /*ziperator*/<Const>>;
    constexpr decltype(auto) operator*() const noexcept(/* см. описание */);
    constexpr /*итератор*/& operator++();
    constexpr void operator++(int);
    constexpr /*итератор*/ operator++(int)
      requires forward_range</*Базовый*/>;
    constexpr /*итератор*/& operator--()
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/ operator--(int)
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/& operator+=(difference_type x)
      requires random_access_range</*Базовый*/>;
    constexpr /*итератор*/& operator-=(difference_type x)
      requires random_access_range</*Базовый*/>;
    constexpr decltype(auto) operator[](difference_type n) const
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator==(const /*итератор*/& x, const /*итератор*/& y)
      requires equality_comparable</*ziperator*/<Const>>;
    friend constexpr auto operator<=>(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator+(const /*итератор*/& i, difference_type n)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator+(difference_type n, const /*итератор*/& i)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator-(const /*итератор*/& i, difference_type n)
      requires random_access_range</*Базовый*/>;
    friend constexpr difference_type operator-(const /*итератор*/& x,
                                               const /*итератор*/& y)
      requires sized_sentinel_for</*ziperator*/<Const>, /*ziperator*/<Const>>;
  };
}

Шаблон класса std::ranges::zip_transform_view::sentinel 

namespace std::ranges {
  template<move_constructible F, input_range... Views>
    requires(view<Views> && ...) && (sizeof...(Views) > 0) && is_object_v<F> &&
            regular_invocable<F&, range_reference_t<Views>...> &&
            /*can-reference*/<invoke_result_t<F&, range_reference_t<Views>...>>
  template<bool Const>
  class zip_transform_view<F, Views...>::/*sentinel*/
  {
    /*zentinel*/<Const> /*inner_*/;                             // только для пояснения
    constexpr explicit /*sentinel*/(/*zentinel*/<Const> inner); // только для пояснения
  public:
    /*sentinel*/() = default;
    constexpr /*sentinel*/(/*sentinel*/<!Const> i)
      requires Const && convertible_to</*zentinel*/<false>, /*zentinel*/<Const>>;
    template<bool OtherConst>
      requires sentinel_for</*zentinel*/<Const>, /*ziperator*/<OtherConst>>
    friend constexpr bool operator==(const /*iterator*/<OtherConst>& x,
                                     const /*sentinel*/& y);
    template<bool OtherConst>
      requires sized_sentinel_for</*zentinel*/<Const>, /*ziperator*/<OtherConst>>
    friend constexpr range_difference_t</*maybe-const*/<OtherConst, /*InnerView*/>>
    operator-(const /*iterator*/<OtherConst>& x, const /*sentinel*/& y);
    template<bool OtherConst>
      requires sized_sentinel_for</*zentinel*/<Const>, /*ziperator*/<OtherConst>>
    friend constexpr range_difference_t</*maybe-const*/<OtherConst, /*InnerView*/>>
    operator-(const /*sentinel*/& x, const /*iterator*/<OtherConst>& y);
  };
}

Шаблон класса std::ranges::adjacent_view 

namespace std::ranges {
  template<forward_range V, size_t N>
    requires view<V> && (N > 0)
  class adjacent_view : public view_interface<adjacent_view<V, N>>
  {
    V /*base_*/ = V(); // только для демонстрации
    // шаблон класса adjacent_view::iterator
    template<bool>
    class /*iterator*/; // только для демонстрации
    // шаблон класса adjacent_view::sentinel
    template<bool>
    class /*sentinel*/; // только для демонстрации
    struct /*as-sentinel*/
    {}; // только для демонстрации
  public:
    adjacent_view()
      requires default_initializable<V>
    = default;
    constexpr explicit adjacent_view(V base);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr auto begin()
      requires(!/*simple-view*/<V>)
    {
      return /*iterator*/<false>(ranges::begin(/*base_*/), ranges::end(/*base_*/));
    }
    constexpr auto begin() const
      requires range<const V>
    {
      return /*iterator*/<true>(ranges::begin(/*base_*/), ranges::end(/*base_*/));
    }
    constexpr auto end()
      requires(!/*simple-view*/<V>)
    {
      if constexpr (common_range<V>) {
        return /*iterator*/<false>(
          /*as-sentinel*/{}, ranges::begin(/*base_*/), ranges::end(/*base_*/));
      } else {
        return /*sentinel*/<false>(ranges::end(/*base_*/));
      }
    }
    constexpr auto end() const
      requires range<const V>
    {
      if constexpr (common_range<const V>) {
        return /*iterator*/<true>(
          /*as-sentinel*/{}, ranges::begin(/*base_*/), ranges::end(/*base_*/));
      } else {
        return /*sentinel*/<true>(ranges::end(/*base_*/));
      }
    }
    constexpr auto size()
      requires sized_range<V>;
    constexpr auto size() const
      requires sized_range<const V>;
    constexpr auto reserve_hint()
      requires approximately_sized_range<V>;
    constexpr auto reserve_hint() const
      requires approximately_sized_range<const V>;
  };
}

Шаблон класса std::ranges::adjacent_view::iterator 

namespace std::ranges {
  template<forward_range V, size_t N>
    requires view<V> && (N > 0)
  template<bool Const>
  class adjacent_view<V, N>::/*итератор*/
  {
    using /*Базовый*/ = /*возможно-константа*/<Const, V>; // exposition-only
    array<iterator_t</*Базовый*/>, N> /*current_*/ =
      array<iterator_t</*Базовый*/>, N>(); // exposition-only
    constexpr /*итератор*/(iterator_t</*Базовый*/> first,
                           sentinel_t</*Базовый*/> last); // exposition-only
    constexpr /*итератор*/(/*as-sentinel*/,
                           iterator_t</*Базовый*/> first,
                           iterator_t</*Базовый*/> last);
    // exposition-only
  public:
    using iterator_category = input_iterator_tag;
    using iterator_concept  = /* см. описание */;
    using value_type        = tuple</*ПОВТОРИТЬ*/(range_value_t</*Базовый*/>, N)...>;
    using difference_type   = range_difference_t</*Базовый*/>;
    /*итератор*/()          = default;
    constexpr /*итератор*/(/*итератор*/<!Const> i)
      requires Const && convertible_to<iterator_t<V>, iterator_t</*Базовый*/>>;
    constexpr auto operator*() const;
    constexpr /*итератор*/& operator++();
    constexpr /*итератор*/ operator++(int);
    constexpr /*итератор*/& operator--()
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/ operator--(int)
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/& operator+=(difference_type x)
      requires random_access_range</*Базовый*/>;
    constexpr /*итератор*/& operator-=(difference_type x)
      requires random_access_range</*Базовый*/>;
    constexpr auto operator[](difference_type n) const
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator==(const /*итератор*/& x, const /*итератор*/& y);
    friend constexpr bool operator<(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator>(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator<=(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator>=(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr auto operator<=>(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/> && three_way_comparable<iterator_t</*Базовый*/>>
    ;
    friend constexpr /*итератор*/ operator+(const /*итератор*/& i, difference_type n)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator+(difference_type n, const /*итератор*/& i)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator-(const /*итератор*/& i, difference_type n)
      requires random_access_range</*Базовый*/>;
    friend constexpr difference_type operator-(const /*итератор*/& x,
                                               const /*итератор*/& y)
      requires sized_sentinel_for<iterator_t</*Базовый*/>, iterator_t</*Базовый*/>>;
    friend constexpr auto iter_move(const /*итератор*/& i) noexcept(
      /* см. описание */);
    friend constexpr void iter_swap(const /*итератор*/& l,
                                    const /*итератор*/& r) noexcept(/* см. описание */)
      requires indirectly_swappable<iterator_t</*Базовый*/>>;
  };
}

Шаблон класса std::ranges::adjacent_view::sentinel 

namespace std::ranges {
  template<forward_range V, size_t N>
    requires view<V> && (N > 0)
  template<bool Const>
  class adjacent_view<V, N>::/*sentinel*/
  {
    using /*Base*/                = /*maybe-const*/<Const, V>; // только для пояснения
    sentinel_t</*Base*/> /*end_*/ = sentinel_t</*Base*/>();    // только для пояснения
    constexpr explicit /*sentinel*/(sentinel_t</*Base*/> end); // только для пояснения
  public:
    /*sentinel*/() = default;
    constexpr /*sentinel*/(/*sentinel*/<!Const> i)
      requires Const && convertible_to<sentinel_t<V>, sentinel_t</*Base*/>>;
    template<bool OtherConst>
      requires sentinel_for<sentinel_t</*Base*/>,
                            iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr bool operator==(const /*iterator*/<OtherConst>& x,
                                     const /*sentinel*/& y);
    template<bool OtherConst>
      requires sized_sentinel_for<sentinel_t</*Base*/>,
                                  iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr range_difference_t</*maybe-const*/<OtherConst, V>> operator-(
      const /*iterator*/<OtherConst>& x,
      const /*sentinel*/& y);
    template<bool OtherConst>
      requires sized_sentinel_for<sentinel_t</*Base*/>,
                                  iterator_t</*maybe-const*/<OtherConst, V>>>
    friend constexpr range_difference_t</*maybe-const*/<OtherConst, V>> operator-(
      const /*sentinel*/& y,
      const /*iterator*/<OtherConst>& x);
  };
}

Шаблон класса std::ranges::adjacent_transform_view 

namespace std::ranges {
  template<forward_range V, move_constructible F, size_t N>
    requires view<V> && (N > 0) && is_object_v<F> &&
             regular_invocable<F&, /*ПОВТОРИТЬ*/(range_reference_t<V>, N)...> &&
             /*может ссылаться*/<
               invoke_result_t<F&, /*ПОВТОРИТЬ*/(range_reference_t<V>, N)...>>
  class adjacent_transform_view : public view_interface<adjacent_transform_view<V, F, N>>
  {
    /*перемещаемый блок*/<F> /*функция_*/;    // exposition-only
    adjacent_view<V, N> /*внутренний_*/; // exposition-only
    using /*InnerView*/ = adjacent_view<V, N>; // exposition-only
    template<bool Const>
    using /*внутренний итератор*/ =
      iterator_t</*возможно-константа*/<Const, /*InnerView*/>>; // exposition-only
    template<bool Const>
    using /*внутренний-дозорный*/ =
      sentinel_t</*возможно-константа*/<Const, /*InnerView*/>>; // exposition-only
    // шаблон класса adjacent_transform_view::iterator
    template<bool>
    class /*итератор*/; // exposition-only
    // шаблон класса adjacent_transform_view::sentinel
    template<bool>
    class /*sentinel*/; // exposition-only
  public:
    adjacent_transform_view() = default;
    constexpr explicit adjacent_transform_view(V base, F fun);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*внутренний_*/.база();
    }
    constexpr V base() && { return std::move(/*внутренний_*/).база(); }
    constexpr auto begin() { return /*итератор*/<false>(*this, /*внутренний_*/.begin()); }
    constexpr auto begin() const
      requires range<const /*InnerView*/> &&
               regular_invocable<const F&, /*ПОВТОРИТЬ*/(range_reference_t<const V>, N)...>
    {
      return /*итератор*/<true>(*this, /*внутренний_*/.begin());
    }
    constexpr auto end()
    {
      if constexpr (common_range</*InnerView*/>) {
        return /*итератор*/<false>(*this, /*внутренний_*/.end());
      } else {
        return /*sentinel*/<false>(/*внутренний_*/.end());
      }
    }
    constexpr auto end() const
      requires range<const /*InnerView*/> &&
               regular_invocable<const F&, /*ПОВТОРИТЬ*/(range_reference_t<const V>, N)...>
    {
      if constexpr (common_range<const /*InnerView*/>) {
        return /*итератор*/<true>(*this, /*внутренний_*/.end());
      } else {
        return /*sentinel*/<true>(/*внутренний_*/.end());
      }
    }
    constexpr auto size()
      requires sized_range</*InnerView*/>
    {
      return /*внутренний_*/.size();
    }
    constexpr auto size() const
      requires sized_range<const /*InnerView*/>
    {
      return /*inner_*/.size();
    }
    constexpr auto reserve_hint()
      requires approximately_sized_range</*InnerView*/>
    {
      return /*внутренний_*/.reserve_hint();
    }
    constexpr auto reserve_hint() const
      requires approximately_sized_range<const /*InnerView*/>
    {
      return /*внутренний_*/.reserve_hint();
    }
  };
}

Шаблон класса std::ranges::adjacent_transform_view::iterator 

namespace std::ranges {
  template<forward_range V, move_constructible F, size_t N>
    requires view<V> && (N > 0) && is_object_v<F> &&
             regular_invocable<F&, /*ПОВТОРИТЬ*/(range_reference_t<V>, N)...> &&
             /*может ссылаться*/<
               invoke_result_t<F&, /*ПОВТОРИТЬ*/(range_reference_t<V>, N)...>>
  template<bool Const>
  class adjacent_transform_view<V, F, N>::/*итератор*/
  {
    using /*Родительский*/ = /*возможно-константа*/<Const, adjacent_transform_view>; // exposition-only
    using /*Базовый*/   = /*возможно-константа*/<Const, V>;                       // exposition-only
    /*Родительский*/* /*родительский_*/ = nullptr;                                  // exposition-only
    /*внутренний итератор*/<Const> /*внутренний_*/;                               // exposition-only
    constexpr /*итератор*/(/*Родительский*/& parent,
                           /*внутренний итератор*/<Const> inner); // exposition-only
  public:
    using iterator_category = /* см. описание */;
    using iterator_concept  = typename /*внутренний итератор*/<Const>::iterator_concept;
    using value_type =
      remove_cvref_t<invoke_result_t</*возможно-константа*/<Const, F>&,
                                     /*ПОВТОРИТЬ*/(range_reference_t</*Базовый*/>, N)...>>;
    using difference_type = range_difference_t</*Базовый*/>;
    /*итератор*/()        = default;
    constexpr /*итератор*/(/*итератор*/<!Const> i)
      requires Const
               && convertible_to</*внутренний итератор*/<false>, /*внутренний итератор*/<Const>>;
    constexpr decltype(auto) operator*() const noexcept(/* см. описание */);
    constexpr /*итератор*/& operator++();
    constexpr /*итератор*/ operator++(int);
    constexpr /*итератор*/& operator--()
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/ operator--(int)
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/& operator+=(difference_type x)
      requires random_access_range</*Базовый*/>;
    constexpr /*итератор*/& operator-=(difference_type x)
      requires random_access_range</*Базовый*/>;
    constexpr decltype(auto) operator[](difference_type n) const
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator==(const /*итератор*/& x, const /*итератор*/& y);
    friend constexpr bool operator<(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator>(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator<=(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator>=(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr auto operator<=>(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/> &&
               three_way_comparable</*внутренний итератор*/<Const>>;
    friend constexpr /*итератор*/ operator+(const /*итератор*/& i, difference_type n)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator+(difference_type n, const /*итератор*/& i)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator-(const /*итератор*/& i, difference_type n)
      requires random_access_range</*Базовый*/>;
    friend constexpr difference_type operator-(const /*итератор*/& x,
                                               const /*итератор*/& y)
      requires sized_sentinel_for</*внутренний итератор*/<Const>, /*внутренний-итератор*/<Const>>;
  };
}

Шаблон класса std::ranges::adjacent_transform_view::sentinel 

namespace std::ranges {
  template<forward_range V, move_constructible F, size_t N>
    requires view<V> && (N > 0) && is_object_v<F> &&
             regular_invocable<F&, /*REPEAT*/(range_reference_t<V>, N)...> &&
             /*can-reference*/<
               invoke_result_t<F&, /*REPEAT*/(range_reference_t<V>, N)...>>
  template<bool Const>
  class adjacent_transform_view<V, F, N>::/*sentinel*/
  {
    /*inner-sentinel*/<Const> /*inner_*/;                             // только для пояснения
    constexpr explicit /*sentinel*/(/*inner-sentinel*/<Const> inner); // только для пояснения
  public:
    /*sentinel*/() = default;
    constexpr /*sentinel*/(/*sentinel*/<!Const> i)
      requires Const
               && convertible_to</*inner-sentinel*/<false>, /*inner-sentinel*/<Const>>;
    template<bool OtherConst>
      requires sentinel_for</*inner-sentinel*/<Const>, /*inner-iterator*/<OtherConst>>
    friend constexpr bool operator==(const /*iterator*/<OtherConst>& x,
                                     const /*sentinel*/& y);
    template<bool OtherConst>
      requires sized_sentinel_for</*inner-sentinel*/<Const>,
                                  /*inner-iterator*/<OtherConst>>
    friend constexpr range_difference_t</*maybe-const*/<OtherConst, /*InnerView*/>>
    operator-(const /*iterator*/<OtherConst>& x, const /*sentinel*/& y);
    template<bool OtherConst>
      requires sized_sentinel_for</*inner-sentinel*/<Const>,
                                  /*inner-iterator*/<OtherConst>>
    friend constexpr range_difference_t</*maybe-const*/<OtherConst, /*InnerView*/>>
    operator-(const /*sentinel*/& x, const /*iterator*/<OtherConst>& y);
  };
}

Шаблон класса std::ranges::chunk_view для input_range s 

namespace std::ranges {
  template<class I>
  constexpr I /*div-ceil*/(I num, I denom)
  { // только для демонстрации
    I r = num / denom;
    if (num % denom)
      ++r;
    return r;
  }
  template<view V>
    requires input_range<V>
  class chunk_view : public view_interface<chunk_view<V>>
  {
    V /*base_*/;                              // только для демонстрации
    range_difference_t<V> /*n_*/;             // только для демонстрации
    range_difference_t<V> /*remainder_*/ = 0; // только для демонстрации
    /*non-propagating-cache*/<iterator_t<V>> /*current_*/; // только для демонстрации
    // класс chunk_view::outer-iterator
    class /*outer-iterator*/; // только для демонстрации
    // класс chunk_view::inner-iterator
    class /*inner-iterator*/; // только для демонстрации
  public:
    constexpr explicit chunk_view(V base, range_difference_t<V> n);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr /*outer-iterator*/ begin();
    constexpr default_sentinel_t end() const noexcept;
    constexpr auto size()
      requires sized_range<V>;
    constexpr auto size() const
      requires sized_range<const V>;
    constexpr auto reserve_hint()
      requires approximately_sized_range<V>;
    constexpr auto reserve_hint() const
      requires approximately_sized_range<const V>;
  };
  template<class R>
  chunk_view(R&&, range_difference_t<R>) -> chunk_view<views::all_t<R>>;
}

Шаблон класса std::ranges::chunk_view::outer_iterator для input_range s 

namespace std::ranges {
  template<view V>
    requires input_range<V>
  class chunk_view<V>::/*внешний-итератор*/
  {
    chunk_view* /*родитель_*/; // только для демонстрации
    constexpr explicit /*внешний-итератор*/(chunk_view& parent); // только для демонстрации
  public:
    using iterator_concept = input_iterator_tag;
    using difference_type  = range_difference_t<V>;
    // класс chunk_view::внешний-итератор::value_type
    struct value_type;
    /*внешний-итератор*/(/*внешний-итератор*/&&)            = default;
    /*внешний-итератор*/& operator=(/*внешний-итератор*/&&) = default;
    constexpr value_type operator*() const;
    constexpr /*внешний-итератор*/& operator++();
    constexpr void operator++(int);
    friend constexpr bool operator==(const /*внешний-итератор*/& x, default_sentinel_t);
    friend constexpr difference_type operator-(default_sentinel_t y,
                                               const /*внешний-итератор*/& x)
      requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
    friend constexpr difference_type operator-(const /*внешний-итератор*/& x,
                                               default_sentinel_t y)
      requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
  };
}

Шаблон класса std::ranges::chunk_view::outer_iterator::value_type для input_range s 

namespace std::ranges {
  template<view V>
    requires input_range<V>
  struct chunk_view<V>::/*outer-iterator*/::value_type : view_interface<value_type>
  {
  private:
    chunk_view* /*parent_*/; // только для демонстрации
    constexpr explicit value_type(chunk_view& parent); // только для демонстрации
  public:
    constexpr /*inner-iterator*/ begin() const noexcept;
    constexpr default_sentinel_t end() const noexcept;
    constexpr auto size() const
      requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
  };
}

Шаблон класса std::ranges::chunk_view::inner_iterator для input_range s 

namespace std::ranges {
  template<view V>
    requires input_range<V>
  class chunk_view<V>::/*inner-iterator*/
  {
    chunk_view* /*parent_*/; // только для демонстрации
    constexpr explicit /*inner-iterator*/(chunk_view& parent) noexcept; // только для демонстрации
  public:
    using iterator_concept                              = input_iterator_tag;
    using difference_type                               = range_difference_t<V>;
    using value_type                                    = range_value_t<V>;
    /*inner-iterator*/(/*inner-iterator*/&&)            = default;
    /*inner-iterator*/& operator=(/*inner-iterator*/&&) = default;
    constexpr const iterator_t<V>& base() const&;
    constexpr range_reference_t<V> operator*() const;
    constexpr /*inner-iterator*/& operator++();
    constexpr void operator++(int);
    friend constexpr bool operator==(const /*inner-iterator*/& x, default_sentinel_t);
    friend constexpr difference_type operator-(default_sentinel_t y,
                                               const /*inner-iterator*/& x)
      requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
    friend constexpr difference_type operator-(const /*inner-iterator*/& x,
                                               default_sentinel_t y)
      requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
    friend constexpr range_rvalue_reference_t<V>
    iter_move(const /*inner-iterator*/& i) noexcept(
      noexcept(ranges::iter_move(*i./*parent_*/->/*current_*/)));
    friend constexpr void
    iter_swap(const /*inner-iterator*/& x, const /*inner-iterator*/& y) noexcept(noexcept(
      ranges::iter_swap(*x./*parent_*/->/*current_*/, *y./*parent_*/->/*current_*/)))
      requires indirectly_swappable<iterator_t<V>>;
  };
}

Шаблон класса std::ranges::chunk_view для forward_range s 

namespace std::ranges {
  template<view V>
    requires forward_range<V>
  class chunk_view<V> : public view_interface<chunk_view<V>>
  {
    V /*base_*/;                  // только для демонстрации
    range_difference_t<V> /*n_*/; // только для демонстрации
    // шаблон класса chunk_view::iterator
    template<bool>
    class /*iterator*/; // только для демонстрации
  public:
    constexpr explicit chunk_view(V base, range_difference_t<V> n);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr auto begin()
      requires(!/*simple-view*/<V>)
    {
      return /*iterator*/<false>(this, ranges::begin(/*base_*/));
    }
    constexpr auto begin() const
      requires forward_range<const V>
    {
      return /*iterator*/<true>(this, ranges::begin(/*base_*/));
    }
    constexpr auto end()
      requires(!/*simple-view*/<V>)
    {
      if constexpr (common_range<V> && sized_range<V>) {
        auto missing = (/*n_*/ - ranges::distance(/*base_*/) % /*n_*/) % /*n_*/;
        return /*iterator*/<false>(this, ranges::end(/*base_*/), missing);
      } else if constexpr (common_range<V> && !bidirectional_range<V>) {
        return /*iterator*/<false>(this, ranges::end(/*base_*/));
      } else {
        return default_sentinel;
      }
    }
    constexpr auto end() const
      requires forward_range<const V>
    {
      if constexpr (common_range<const V> && sized_range<const V>) {
        auto missing = (/*n_*/ - ranges::distance(/*base_*/) % /*n_*/) % /*n_*/;
        return /*iterator*/<true>(this, ranges::end(/*base_*/), missing);
      } else if constexpr (common_range<const V> && !bidirectional_range<const V>) {
        return /*iterator*/<true>(this, ranges::end(/*base_*/));
      } else {
        return default_sentinel;
      }
    }
    constexpr auto size()
      requires sized_range<V>;
    constexpr auto size() const
      requires sized_range<const V>;
    constexpr auto reserve_hint()
      requires approximately_sized_range<V>;
    constexpr auto reserve_hint() const
      requires approximately_sized_range<const V>;
  };
}

Шаблон класса std::ranges::chunk_view::iterator для forward_range s 

namespace std::ranges {
  template<view V>
    requires forward_range<V>
  template<bool Const>
  class chunk_view<V>::/*итератор*/
  {
    using /*Родительский*/ = /*возможно-константа*/<Const, chunk_view>; // exposition-only
    using /*Базовый*/   = /*возможно-константа*/<Const, V>;          // exposition-only
    iterator_t</*Базовый*/> /*current_*/         = iterator_t</*Базовый*/>(); // exposition-only
    sentinel_t</*Базовый*/> /*end_*/             = sentinel_t</*Базовый*/>(); // exposition-only
    range_difference_t</*Базовый*/> /*n_*/       = 0;                      // exposition-only
    range_difference_t</*Базовый*/> /*отсутствует_*/ = 0;                      // exposition-only
    constexpr /*итератор*/(/*Родительский*/* parent,
                           iterator_t</*Базовый*/> current, // exposition-only
                           range_difference_t</*Базовый*/> missing = 0);
  public:
    using iterator_category = input_iterator_tag;
    using iterator_concept  = /* см. описание */;
    using value_type = decltype(views::take(subrange(/*current_*/, /*конец_*/), /*n_*/));
    using difference_type = range_difference_t</*Базовый*/>;
    /*итератор*/()        = default;
    constexpr /*итератор*/(/*итератор*/<!Const> i)
      requires Const && convertible_to<iterator_t<V>, iterator_t</*Базовый*/>> &&
               convertible_to<sentinel_t<V>, sentinel_t</*Базовый*/>>;
    constexpr iterator_t</*Базовый*/> base() const;
    constexpr value_type operator*() const;
    constexpr /*итератор*/& operator++();
    constexpr /*итератор*/ operator++(int);
    constexpr /*итератор*/& operator--()
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/ operator--(int)
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/& operator+=(difference_type x)
      requires random_access_range</*Базовый*/>;
    constexpr /*итератор*/& operator-=(difference_type x)
      requires random_access_range</*Базовый*/>;
    constexpr value_type operator[](difference_type n) const
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator==(const /*итератор*/& x, const /*итератор*/& y);
    friend constexpr bool operator==(const /*итератор*/& x, default_sentinel_t);
    friend constexpr bool operator<(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator>(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator<=(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator>=(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr auto operator<=>(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/> && three_way_comparable<iterator_t</*Базовый*/>>
    ;
    friend constexpr /*итератор*/ operator+(const /*итератор*/& i, difference_type n)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator+(difference_type n, const /*итератор*/& i)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator-(const /*итератор*/& i, difference_type n)
      requires random_access_range</*Базовый*/>;
    friend constexpr difference_type operator-(const /*итератор*/& x,
                                               const /*итератор*/& y)
      requires sized_sentinel_for<iterator_t</*Базовый*/>, iterator_t</*Базовый*/>>;
    friend constexpr difference_type operator-(default_sentinel_t y,
                                               const /*итератор*/& x)
      requires sized_sentinel_for<sentinel_t</*Базовый*/>, iterator_t</*Базовый*/>>;
    friend constexpr difference_type operator-(const /*итератор*/& x,
                                               default_sentinel_t y)
      requires sized_sentinel_for<sentinel_t</*Базовый*/>, iterator_t</*Базовый*/>>;
  };
}

Шаблон класса std::ranges::slide_view 

namespace std::ranges {
  template<class V>
  concept /*slide-caches-nothing*/ =
    random_access_range<V> && sized_range<V>; // только для экспозиции
  template<class V>
  concept /*slide-caches-last*/ = // только для экспозиции
    !/*slide-caches-nothing*/<V> && bidirectional_range<V> && common_range<V>;
  template<class V>
  concept /*slide-caches-first*/ = // только для экспозиции
    !/*slide-caches-nothing*/<V> && !/*slide-caches-last*/<V>;
  template<forward_range V>
    requires view<V>
  class slide_view : public view_interface<slide_view<V>>
  {
    V /*base_*/;                  // только для экспозиции
    range_difference_t<V> /*n_*/; // только для экспозиции
    // шаблон класса slide_view::iterator
    template<bool>
    class /*iterator*/; // только для экспозиции
    // класс slide_view::sentinel
    class /*sentinel*/; // только для экспозиции
  public:
    constexpr explicit slide_view(V base, range_difference_t<V> n);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr auto begin()
      requires(!(/*simple-view*/<V> && /*slide-caches-nothing*/<const V>));
    constexpr auto begin() const
      requires /*slide-caches-nothing*/<const V>;
    constexpr auto end()
      requires(!(/*simple-view*/<V> && /*slide-caches-nothing*/<const V>));
    constexpr auto end() const
      requires /*slide-caches-nothing*/<const V>;
    constexpr auto size()
      requires sized_range<V>;
    constexpr auto size() const
      requires sized_range<const V>;
    constexpr auto reserve_hintsize()
      requires approximately_sized_range<V>;
    constexpr auto reserve_hintsize() const
      requires approximately_sized_range<const V>;
  };
  template<class R>
  slide_view(R&&, range_difference_t<R>) -> slide_view<views::all_t<R>>;
}

Шаблон класса std::ranges::slide_view::iterator 

namespace std::ranges {
  template<forward_range V>
    requires view<V>
  template<bool Const>
  class slide_view<V>::/*итератор*/
  {
    using /*Базовый*/                    = /*возможно-константа*/<Const, V>; // exposition-only
    iterator_t</*Базовый*/> /*current_*/ = iterator_t</*Базовый*/>();    // exposition-only
    iterator_t</*Базовый*/> /*последний элемент*/ =
      iterator_t</*Базовый*/>(); // exposition-only
                              // присутствует только если базовые модели используют кэширование слайдов первыми
    range_difference_t</*Базовый*/> /*n_*/ = 0; // exposition-only
    constexpr /*итератор*/(iterator_t</*Базовый*/> current,
                           range_difference_t</*Базовый*/> n) // только для демонстрации
      requires(!/*кэши-первый-слайд*/</*Базовый*/>);
    constexpr /*итератор*/(iterator_t</*Базовый*/> current,
                           iterator_t</*Базовый*/> last_ele, // exposition-only
                           range_difference_t</*Базовый*/> n)
      requires /*кэши-первый-слайд*/</*Базовый*/>;
  public:
    using iterator_category = input_iterator_tag;
    using iterator_concept  = /* см. описание */;
    using value_type        = decltype(views::counted(/*current_*/, /*n_*/));
    using difference_type   = range_difference_t</*Базовый*/>;
    /*итератор*/()          = default;
    constexpr /*итератор*/(/*итератор*/<!Const> i)
      requires Const && convertible_to<iterator_t<V>, iterator_t</*Базовый*/>>;
    constexpr auto operator*() const;
    constexpr /*итератор*/& operator++();
    constexpr /*итератор*/ operator++(int);
    constexpr /*итератор*/& operator--()
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/ operator--(int)
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/& operator+=(difference_type x)
      requires random_access_range</*Базовый*/>;
    constexpr /*итератор*/& operator-=(difference_type x)
      requires random_access_range</*Базовый*/>;
    constexpr auto operator[](difference_type n) const
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator==(const /*итератор*/& x, const /*итератор*/& y);
    friend constexpr bool operator<(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator>(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator<=(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator>=(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr auto operator<=>(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/> && three_way_comparable<iterator_t</*Базовый*/>>
    ;
    friend constexpr /*итератор*/ operator+(const /*итератор*/& i, difference_type n)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator+(difference_type n, const /*итератор*/& i)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator-(const /*итератор*/& i, difference_type n)
      requires random_access_range</*Базовый*/>;
    friend constexpr difference_type operator-(const /*итератор*/& x,
                                               const /*итератор*/& y)
      requires sized_sentinel_for<iterator_t</*Базовый*/>, iterator_t</*Базовый*/>>;
  };
}

Шаблон класса std::ranges::slide_view::sentinel 

namespace std::ranges {
  template<forward_range V>
    requires view<V>
  class slide_view<V>::/*sentinel*/
  {
    sentinel_t<V> /*end_*/ = sentinel_t<V>();           // только для экспозиции
    constexpr explicit /*sentinel*/(sentinel_t<V> end); // только для экспозиции
  public:
    /*sentinel*/() = default;
    friend constexpr bool operator==(const /*iterator*/<false>& x, const /*sentinel*/& y);
    friend constexpr range_difference_t<V> operator-(const /*iterator*/<false>& x,
                                                     const /*sentinel*/& y)
      requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
    friend constexpr range_difference_t<V> operator-(const /*sentinel*/& y,
                                                     const /*iterator*/<false>& x)
      requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
  };
}

Шаблон класса std::ranges::chunk_by_view 

namespace std::ranges {
  template<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred>
    requires view<V> && is_object_v<Pred>
  class chunk_by_view : public view_interface<chunk_by_view<V, Pred>>
  {
    V /*base_*/ = V();               // только для демонстрации
    /*movable-box*/<Pred> /*pred_*/; // только для демонстрации
    // класс chunk_by_view::iterator
    class /*iterator*/; // только для демонстрации
  public:
    chunk_by_view()
      requires default_initializable<V> && default_initializable<Pred>
    = default;
    constexpr explicit chunk_by_view(V base, Pred pred);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr const Pred& pred() const;
    constexpr /*iterator*/ begin();
    constexpr auto end();
    constexpr iterator_t<V> /*find-next*/(iterator_t<V>); // только для демонстрации
    constexpr iterator_t<V> /*find-prev*/(iterator_t<V>)  // только для демонстрации
      requires bidirectional_range<V>;
  };
  template<class R, class Pred>
  chunk_by_view(R&&, Pred) -> chunk_by_view<views::all_t<R>, Pred>;
}

Шаблон класса std::ranges::chunk_by_view::iterator 

namespace std::ranges {
  template<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred>
    requires view<V> && is_object_v<Pred>
  class chunk_by_view<V, Pred>::/*iterator*/
  {
    chunk_by_view* /*parent_*/ = nullptr;         // только для демонстрации
    iterator_t<V> /*current_*/ = iterator_t<V>(); // только для демонстрации
    iterator_t<V> /*next_*/    = iterator_t<V>(); // только для демонстрации
    constexpr /*iterator*/(chunk_by_view& parent,
                           iterator_t<V> current, // только для демонстрации
                           iterator_t<V> next);
  public:
    using value_type        = subrange<iterator_t<V>>;
    using difference_type   = range_difference_t<V>;
    using iterator_category = input_iterator_tag;
    using iterator_concept  = /* см. описание */;
    /*iterator*/()          = default;
    constexpr value_type operator*() const;
    constexpr /*iterator*/& operator++();
    constexpr /*iterator*/ operator++(int);
    constexpr /*iterator*/& operator--()
      requires bidirectional_range<V>;
    constexpr /*iterator*/ operator--(int)
      requires bidirectional_range<V>;
    friend constexpr bool operator==(const /*iterator*/& x, const /*iterator*/& y);
    friend constexpr bool operator==(const /*iterator*/& x, default_sentinel_t);
  };
}

Шаблон класса std::ranges::stride_view 

namespace std::ranges {
  template<input_range V>
    requires view<V>
  class stride_view : public view_interface<stride_view<V>>
  {
    V /*базовый_*/;                       // только для экспозиции
    range_difference_t<V> /*stride_*/; // exposition-only
    // шаблон класса stride_view::iterator
    template<bool>
    class /*итератор*/; // exposition-only
  public:
    constexpr explicit stride_view(V base, range_difference_t<V> stride);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*базовый_*/;
    }
    constexpr V base() && { return std::move(/*базовый_*/); }
    constexpr range_difference_t<V> stride() const noexcept;
    constexpr auto begin()
      requires(!/*простой-вид*/<V>)
    {
      return /*итератор*/<false>(this, ranges::begin(/*базовый_*/));
    }
    constexpr auto begin() const
      requires range<const V>
    {
      return /*итератор*/<true>(this, ranges::begin(/*базовый_*/));
    }
    constexpr auto end()
      requires(!/*простой-вид*/<V>)
    {
      if constexpr (common_range<V> && sized_range<V> && forward_range<V>) {
        auto missing =
          (/*stride_*/ - ranges::distance(/*базовый_*/) % /*stride_*/) % /*stride_*/;
        return /*итератор*/<false>(this, ranges::end(/*базовый_*/), missing);
      } else if constexpr (common_range<V> && !bidirectional_range<V>) {
        return /*итератор*/<false>(this, ranges::end(/*базовый_*/));
      } else {
        return default_sentinel;
      }
    }
    constexpr auto end() const
      requires range<const V>
    {
      if constexpr (common_range<const V> && sized_range<const V> &&
                    forward_range<const V>) {
        auto missing =
          (/*stride_*/ - ranges::distance(/*базовый_*/) % /*stride_*/) % /*stride_*/;
        return /*итератор*/<true>(this, ranges::end(/*базовый_*/), missing);
      } else if constexpr (common_range<const V> && !bidirectional_range<const V>) {
        return /*итератор*/<true>(this, ranges::end(/*базовый_*/));
      } else {
        return default_sentinel;
      }
    }
    constexpr auto size()
      requires sized_range<V>;
    constexpr auto size() const
      requires sized_range<const V>;
    constexpr auto reserve_hint()
      requires approximately_sized_range<V>;
    constexpr auto reserve_hint() const
      requires approximately_sized_range<const V>;
  };
  template<class R>
  stride_view(R&&, range_difference_t<R>) -> stride_view<views::all_t<R>>;
}

Шаблон класса std::ranges::stride_view::iterator 

namespace std::ranges {
  template<input_range V>
    requires view<V>
  template<bool Const>
  class stride_view<V>::/*итератор*/
  {
    using /*Родительский*/ = /*возможно-константа*/<Const, stride_view>; // только для экспозиции
    using /*Базовый*/   = /*возможно-константа*/<Const, V>;           // exposition-only
    iterator_t</*Базовый*/> /*current_*/         = iterator_t</*Базовый*/>(); // exposition-only
    sentinel_t</*Базовый*/> /*конец_*/             = sentinel_t</*Базовый*/>(); // exposition-only
    range_difference_t</*Базовый*/> /*stride_*/  = 0;                      // exposition-only
    range_difference_t</*Базовый*/> /*отсутствует_*/ = 0;                      // exposition-only
    constexpr /*итератор*/(/*Родительский*/* parent,
                           iterator_t</*Базовый*/> current, // exposition-only
                           range_difference_t</*Базовый*/> missing = 0);
  public:
    using difference_type   = range_difference_t</*Базовый*/>;
    using value_type        = range_value_t</*Базовый*/>;
    using iterator_concept  = /* см. описание */;
    using iterator_category = /* см. описание */; // не всегда присутствует
    /*итератор*/()
      requires default_initializable<iterator_t</*Базовый*/>>
    = default;
    constexpr /*итератор*/(/*итератор*/<!Const> other)
      requires Const && convertible_to<iterator_t<V>, iterator_t</*Базовый*/>> &&
               convertible_to<sentinel_t<V>, sentinel_t</*Базовый*/>>;
    constexpr iterator_t</*Базовый*/> base() &&;
    constexpr const iterator_t</*Базовый*/>& base() const& noexcept;
    constexpr decltype(auto) operator*() const { return */*current_*/; }
    constexpr /*итератор*/& operator++();
    constexpr void operator++(int);
    constexpr /*итератор*/ operator++(int)
      requires forward_range</*Базовый*/>;
    constexpr /*итератор*/& operator--()
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/ operator--(int)
      requires bidirectional_range</*Базовый*/>;
    constexpr /*итератор*/& operator+=(difference_type n)
      requires random_access_range</*Базовый*/>;
    constexpr /*итератор*/& operator-=(difference_type n)
      requires random_access_range</*Базовый*/>;
    constexpr decltype(auto) operator[](difference_type n) const
      requires random_access_range</*Базовый*/>
    {
      return *(*this + n);
    }
    friend constexpr bool operator==(const /*итератор*/& x, default_sentinel_t);
    friend constexpr bool operator==(const /*итератор*/& x, const /*итератор*/& y)
      requires equality_comparable<iterator_t</*Базовый*/>>;
    friend constexpr bool operator<(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator>(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator<=(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr bool operator>=(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/>;
    friend constexpr auto operator<=>(const /*итератор*/& x, const /*итератор*/& y)
      requires random_access_range</*Базовый*/> && three_way_comparable<iterator_t</*Базовый*/>>
    ;
    friend constexpr /*итератор*/ operator+(const /*итератор*/& x, difference_type n)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator+(difference_type n, const /*итератор*/& x)
      requires random_access_range</*Базовый*/>;
    friend constexpr /*итератор*/ operator-(const /*итератор*/& x, difference_type n)
      requires random_access_range</*Базовый*/>;
    friend constexpr difference_type operator-(const /*итератор*/& x,
                                               const /*итератор*/& y)
      requires sized_sentinel_for<iterator_t</*Базовый*/>, iterator_t</*Базовый*/>>;
    friend constexpr difference_type operator-(default_sentinel_t y,
                                               const /*итератор*/& x)
      requires sized_sentinel_for<sentinel_t</*Базовый*/>, iterator_t</*Базовый*/>>;
    friend constexpr difference_type operator-(const /*итератор*/& x,
                                               default_sentinel_t y)
      requires sized_sentinel_for<sentinel_t</*Базовый*/>, iterator_t</*Базовый*/>>;
    friend constexpr range_rvalue_reference_t</*Базовый*/> iter_move(
      const /*итератор*/& i) noexcept(noexcept(ranges::iter_move(i./*current_*/)));
    friend constexpr void iter_swap(
      const /*итератор*/& x,
      const /*итератор*/& y) noexcept(noexcept(ranges::iter_swap(x./*current_*/,
                                                                 y./*current_*/)))
      requires indirectly_swappable<iterator_t</*Базовый*/>>;
  };
}

Шаблон класса std::ranges::cartesian_product_view 

namespace std::ranges {
  template<bool Const, class First, class... Vs>
  concept /*cartesian-product-is-random-access*/ = // только для экспозиции
    (random_access_range</*возможно-константа*/<Const, First>> && ... &&
     (random_access_range</*возможно-константа*/<Const, Vs>> &&
      sized_range</*возможно-константа*/<Const, Vs>>));
  template<class R>
  concept /*декартово-произведение-общий-аргумент*/ = // только для демонстрации
    common_range<R> || (sized_range<R> && random_access_range<R>);
  template<bool Const, class First, class... Vs>
  concept /*cartesian-product-is-bidirectional*/ = // exposition-only
    (bidirectional_range</*возможно-константа*/<Const, First>> && ... &&
     (bidirectional_range</*возможно-константа*/<Const, Vs>> &&
      /*cartesian-product-common-arg*/</*возможно-константа*/<Const, Vs>>));
  template<class First, class...>
  concept /*cartesian-product-is-common*/ = // экспозиционная часть
    /*декартово-произведение-общий-аргумент*/<First>;
  template<class... Vs>
  concept /*cartesian-product-is-sized*/ = // только для экспозиции
    (sized_range<Vs> && ...);
  template<bool Const, template<class> class FirstSent, class First, class... Vs>
  concept /*cartesian-is-sized-sentinel*/ = // только для экспозиции
    (sized_sentinel_for<FirstSent</*возможно-константа*/<Const, First>>,
                        iterator_t</*возможно-константа*/<Const, First>>> &&
     ... &&
     (sized_range</*возможно-константа*/<Const, Vs>> &&
      sized_sentinel_for<iterator_t</*возможно-константа*/<Const, Vs>>,
                         iterator_t</*возможно-константа*/<Const, Vs>>>));
  template</*декартово-произведение-общий-аргумент*/ R>
  constexpr auto /*cartesian-common-arg-end*/(R& r)
  { // exposition-only
    если constexpr (common_range<R>) {
      return ranges::end(r);
    } else {
      return ranges::begin(r) + ranges::distance(r);
    }
  }
  template<input_range First, forward_range... Vs>
    requires(view<First> && ... && view<Vs>)
  class cartesian_product_view
    : public view_interface<cartesian_product_view<First, Vs...>>
  {
  private:
    tuple<First, Vs...> /*bases_*/; // только для демонстрации
    // шаблон класса cartesian_product_view::iterator
    template<bool Const>
    class /*итератор*/; // exposition-only
  public:
    constexpr cartesian_product_view() = default;
    constexpr explicit cartesian_product_view(First first_base, Vs... базы);
    constexpr /*итератор*/<false> begin()
      requires(!/*простой-вид*/<First> || ... || !/*простой-вид*/<Vs>);
    constexpr /*итератор*/<true> begin() const
      requires(range<const First> && ... && range<const Vs>);
    constexpr /*итератор*/<false> end()
      requires((!/*простой-вид*/<First> || ... || !/*простой-вид*/<Vs>) &&
               /*декартово-произведение-является-общим*/<First, Vs...>);
    constexpr /*итератор*/<true> end() const
      requires /*cartesian-product-is-common*/<const First, const Vs...>;
    constexpr default_sentinel_t end() const noexcept;
    constexpr /* см. описание */ size()
      requires /*декартово-произведение-имеет-размер*/<First, Vs...>;
    constexpr /* см. описание */ size() const
      requires /*декартово-произведение-имеет-размер*/<const First, const Vs...>;
  };
  template<class... Vs>
  cartesian_product_view(Vs&&...) -> cartesian_product_view<views::all_t<Vs>...>;
}

Шаблон класса std::ranges::cartesian_product_view::iterator 

namespace std::ranges {
  template<input_range First, forward_range... Vs>
    requires(view<First> && ... && view<Vs>)
  template<bool Const>
  class cartesian_product_view<First, Vs...>::/*итератор*/
  {
  public:
    using iterator_category = input_iterator_tag;
    using iterator_concept  = /* см. описание */;
    using value_type        = tuple<range_value_t</*возможно-константа*/<Const, First>>,
                             range_value_t</*возможно-константа*/<Const, Vs>>...>;
    using reference         = tuple<range_reference_t</*возможно-константа*/<Const, First>>,
                            range_reference_t</*возможно-константа*/<Const, Vs>>...>;
    using difference_type   = /* см. описание */;
    /*итератор*/()          = default;
    constexpr /*итератор*/(/*итератор*/<!Const> i)
      requires Const && (convertible_to<iterator_t<First>, iterator_t<const First>> &&
                         ... && convertible_to<iterator_t<Vs>, iterator_t<const Vs>>);
    constexpr auto operator*() const;
    constexpr /*итератор*/& operator++();
    constexpr void operator++(int);
    constexpr /*итератор*/ operator++(int)
      requires forward_range</*возможно-константа*/<Const, First>>;
    constexpr /*итератор*/& operator--()
      requires /*cartesian-product-is-bidirectional*/<Const, First, Vs...>;
    constexpr /*итератор*/ operator--(int)
      requires /*cartesian-product-is-bidirectional*/<Const, First, Vs...>;
    constexpr /*итератор*/& operator+=(difference_type x)
      requires /*cartesian-product-is-random-access*/<Const, First, Vs...>;
    constexpr /*итератор*/& operator-=(difference_type x)
      requires /*cartesian-product-is-random-access*/<Const, First, Vs...>;
    constexpr reference operator[](difference_type n) const
      requires /*cartesian-product-is-random-access*/<Const, First, Vs...>;
    friend constexpr bool operator==(const /*итератор*/& x, const /*итератор*/& y)
      requires equality_comparable<iterator_t</*возможно-константа*/<Const, First>>>;
    friend constexpr bool operator==(const /*итератор*/& x, default_sentinel_t);
    friend constexpr auto operator<=>(const /*итератор*/& x, const /*итератор*/& y)
      requires /*все-произвольного-доступа*/<Const, First, Vs...>;
    friend constexpr /*итератор*/ operator+(const /*итератор*/& x, difference_type y)
      requires /*cartesian-product-is-random-access*/<Const, First, Vs...>;
    friend constexpr /*итератор*/ operator+(difference_type x, const /*итератор*/& y)
      requires /*cartesian-product-is-random-access*/<Const, First, Vs...>;
    friend constexpr /*итератор*/ operator-(const /*итератор*/& x, difference_type y)
      requires /*cartesian-product-is-random-access*/<Const, First, Vs...>;
    friend constexpr difference_type operator-(const /*итератор*/& x,
                                               const /*итератор*/& y)
      requires /*cartesian-is-sized-sentinel*/<Const, iterator_t, First, Vs...>;
    friend constexpr difference_type operator-(const /*итератор*/& i, default_sentinel_t)
      requires /*cartesian-is-sized-sentinel*/<Const, sentinel_t, First, Vs...>;
    friend constexpr difference_type operator-(default_sentinel_t, const /*итератор*/& i)
      requires /*cartesian-is-sized-sentinel*/<Const, sentinel_t, First, Vs...>;
    friend constexpr auto iter_move(const /*итератор*/& i) noexcept(
      /* см. описание */);
    friend constexpr void iter_swap(const /*итератор*/& l,
                                    const /*итератор*/& r) noexcept(/* см. описание */)
      requires(indirectly_swappable<iterator_t</*возможно-константа*/<Const, First>>> && ... &&
               indirectly_swappable<iterator_t</*возможно-константа*/<Const, Vs>>>);
  private:
    using /*Родительский*/ = /*возможно-константа*/<Const, cartesian_product_view>; // только для экспозиции
    /*Родительский*/* /*родительский_*/ = nullptr;                                 // экспозиционная часть
    tuple<iterator_t</*возможно-константа*/<Const, First>>,
          iterator_t</*возможно-константа*/<Const, Vs>>...>
      /*current_*/; // только для экспозиции
    template<size_t N = sizeof...(Vs)>
    constexpr void /*следующий*/(); // экспозиционная часть
    template<size_t N = sizeof...(Vs)>
    constexpr void /*предыдущий*/(); // только для экспозиции
    template<class Tuple>
    constexpr difference_type /*расстояние-от*/(const Tuple& t) const; // только для экспозиции
    constexpr /*итератор*/(
      /*Родительский*/& parent,
      tuple<iterator_t</*возможно-константа*/<Const, First>>,
            iterator_t</*возможно-константа*/<Const, Vs>>...> current); // только для экспозиции
  };
}

Шаблон класса std::ranges::cache_latest_view 

namespace std::ranges {
  template<input_range V>
    requires view<V>
  class cache_latest_view : public view_interface<cache_latest_view<V>>
  {
    V /*base_*/ = V(); // только для пояснения
    using /*cache-t*/ =
      conditional_t<is_reference_v<range_reference_t<V>>, // только для пояснения
                    add_pointer_t<range_reference_t<V>>,
                    range_reference_t<V>>;
    /*non-propagating-cache*/</*cache-t*/> /*cache_*/; // только для пояснения
    // класс cache_latest_view::iterator
    class /*iterator*/; // только для пояснения
    // класс cache_latest_view::sentinel
    class /*sentinel*/; // только для пояснения
  public:
    cache_latest_view()
      requires default_initializable<V>
    = default;
    constexpr explicit cache_latest_view(V base);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr auto begin();
    constexpr auto end();
    constexpr auto size()
      requires sized_range<V>;
    constexpr auto size() const
      requires sized_range<const V>;
  };
  template<class R>
  cache_latest_view(R&&) -> cache_latest_view<views::all_t<R>>;
}

Шаблон класса std::ranges::cache_latest_view::iterator 

namespace std::ranges {
  template<input_range V>
    requires view<V>
  class cache_latest_view<V>::/*iterator*/
  {
    cache_latest_view* /*parent_*/; // только для демонстрации
    iterator_t<V> /*current_*/;     // только для демонстрации
    constexpr explicit /*iterator*/(cache_latest_view& parent); // только для демонстрации
  public:
    using difference_type                   = range_difference_t<V>;
    using value_type                        = range_value_t<V>;
    using iterator_concept                  = input_iterator_tag;
    /*iterator*/(/*iterator*/&&)            = default;
    /*iterator*/& operator=(/*iterator*/&&) = default;
    constexpr iterator_t<V> base() &&;
    constexpr const iterator_t<V>& base() const& noexcept;
    constexpr range_reference_t<V>& operator*() const;
    constexpr /*iterator*/& operator++();
    constexpr void operator++(int);
    friend constexpr range_rvalue_reference_t<V> iter_move(
      const /*iterator*/& i) noexcept(noexcept(ranges::iter_move(i./*current_*/)));
    friend constexpr void iter_swap(
      const /*iterator*/& x,
      const /*iterator*/& y) noexcept(noexcept(ranges::iter_swap(x./*current_*/,
                                                                 y./*current_*/)))
      requires indirectly_swappable<iterator_t<V>>;
  };
}

Шаблон класса std::ranges::cache_latest_view::sentinel 

namespace std::ranges {
  template<input_range V>
    requires view<V>
  class cache_latest_view<V>::/*sentinel*/
  {
    sentinel_t<V> /*end_*/ = sentinel_t<V>(); // только для демонстрации
    constexpr explicit /*sentinel*/(cache_latest_view& parent); // только для демонстрации
  public:
    /*sentinel*/() = default;
    constexpr sentinel_t<V> base() const;
    friend constexpr bool operator==(const /*iterator*/& x, const /*sentinel*/& y);
    friend constexpr range_difference_t<V> operator-(const /*iterator*/& x,
                                                     const /*sentinel*/& y)
      requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
    friend constexpr range_difference_t<V> operator-(const /*sentinel*/& x,
                                                     const /*iterator*/& y)
      requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
  };
}

Шаблон класса std::ranges::to_input_view 

namespace std::ranges {
  template<input_range V>
    requires view<V>
  class to_input_view : public view_interface<to_input_view<V>>
  {
    V /*base_*/ = V(); // только для демонстрации
    // шаблон класса to_input_view::iterator
    template<bool Const>
    class /*iterator*/; // только для демонстрации
  public:
    to_input_view()
      requires default_initializable<V>
    = default;
    constexpr explicit to_input_view(V base);
    constexpr V base() const&
      requires copy_constructible<V>
    {
      return /*base_*/;
    }
    constexpr V base() && { return std::move(/*base_*/); }
    constexpr auto begin()
      requires(!/*simple-view*/<V>);
    constexpr auto begin() const
      requires range<const V>;
    constexpr auto end()
      requires(!/*simple-view*/<V>);
    constexpr auto end() const
      requires range<const V>;
    constexpr auto size()
      requires sized_range<V>;
    constexpr auto size() const
      requires sized_range<const V>;
  };
  template<class R>
  to_input_view(R&&) -> to_input_view<views::all_t<R>>;
}

Шаблон класса std::ranges::to_input_view::iterator 

namespace std::ranges {
  template<input_range V>
    requires view<V>
  template<bool Const>
  class to_input_view<V>::/*iterator*/
  {
    using /*Base*/                    = /*maybe-const*/<Const, V>; // только для экспозиции
    iterator_t</*Base*/> /*current_*/ = iterator_t</*Base*/>(); // только для экспозиции
    constexpr explicit /*iterator*/(iterator_t</*Base*/> current); // только для экспозиции
  public:
    using difference_type  = range_difference_t</*Base*/>;
    using value_type       = range_value_t</*Base*/>;
    using iterator_concept = input_iterator_tag;
    /*iterator*/()
      requires default_initializable<iterator_t</*Base*/>>
    = default;
    /*iterator*/(/*iterator*/&&)            = default;
    /*iterator*/& operator=(/*iterator*/&&) = default;
    constexpr /*iterator*/(/*iterator*/<!Const> i)
      requires Const && convertible_to<iterator_t<V>, iterator_t</*Base*/>>;
    constexpr iterator_t</*Base*/> base() &&;
    constexpr const iterator_t</*Base*/>& base() const& noexcept;
    constexpr decltype(auto) operator*() const { return */*current_*/; }
    constexpr /*iterator*/& operator++();
    constexpr void operator++(int);
    friend constexpr bool operator==(const /*iterator*/& x,
                                     const sentinel_t</*Base*/>& y);
    friend constexpr difference_type operator-(const sentinel_t</*Base*/>& y,
                                               const /*iterator*/& x)
      requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*Base*/>>;
    friend constexpr difference_type operator-(const /*iterator*/& x,
                                               const sentinel_t</*Base*/>& y)
      requires sized_sentinel_for<sentinel_t</*Base*/>, iterator_t</*Base*/>>;
    friend constexpr range_rvalue_reference_t</*Base*/> iter_move(
      const /*iterator*/& i) noexcept(noexcept(ranges::iter_move(i./*current_*/)));
    friend constexpr void iter_swap(
      const /*iterator*/& x,
      const /*iterator*/& y) noexcept(noexcept(ranges::iter_swap(x./*current_*/,
                                                                 y./*current_*/)))
      requires indirectly_swappable<iterator_t</*Base*/>>;
  };
}

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены задним числом к ранее опубликованным стандартам C++.

DR Applied to Behavior as published Correct behavior
LWG 3914 C++23 ограничение для std::ranges::enumerate_view
было некорректно указано в синопсисе 		исправлено