depish/cppdraft_translate
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
043225d523e821bfa89efb15f5074f0465fb7edf
cppdraft_translate/cppdraft/range/concat.md
Leonov Artur (Depish) 043225d523 Init
2025-10-25 03:02:53 +03:00

42 KiB
Raw Blame History

[range.concat]

25 Ranges library [ranges]

25.7 Range adaptors [range.adaptors]

25.7.18 Concat view [range.concat]

25.7.18.1 Overview [range.concat.overview]

1

#

concat_view presents a view that concatenates all the underlying ranges.

2

#

The name views​::​concat denotes a customization point object ([customization.point.object]).

Given a pack of subexpressions Es..., the expression views​::​concat(Es...) is expression-equivalent to

views​::​all(Es...) if Es is a pack with only one element whose type models input_range,

otherwise, concat_view(Es...).

[Example 1: vector v1{1, 2, 3}, v2{4, 5}, v3{}; array a{6, 7, 8};auto s = views::single(9);for (auto&& i : views::concat(v1, v2, v3, a, s)) { print("{} ", i); // prints 1 2 3 4 5 6 7 8 9} — end example]

25.7.18.2 Class template concat_view [range.concat.view]

🔗

namespace std::ranges {template<class... Rs>using concat-reference-t = common_reference_t<range_reference_t...>; // exposition onlytemplate<class... Rs>using concat-value-t = common_type_t<range_value_t...>; // exposition onlytemplate<class... Rs>using concat-rvalue-reference-t = // exposition only common_reference_t<range_rvalue_reference_t...>; template<class... Rs>concept concat-indirectly-readable = see below; // exposition onlytemplate<class... Rs>concept concatable = see below; // exposition onlytemplate<bool Const, class... Rs>concept concat-is-random-access = see below; // exposition onlytemplate<bool Const, class... Rs>concept concat-is-bidirectional = see below; // exposition onlytemplate<input_range... Views>requires (view && ...) && (sizeof...(Views) > 0) &&concatable<Views...>class concat_view : public view_interface<concat_view<Views...>> { tuple<Views...> views_; // exposition only// [range.concat.iterator], class template concat_view​::​iteratortemplate class iterator; // exposition onlypublic:constexpr concat_view() = default; constexpr explicit concat_view(Views... views); constexpr iterator begin() requires (!(simple-view && ...)); constexpr iterator begin() constrequires (range && ...) && concatable; constexpr auto end() requires (!(simple-view && ...)); constexpr auto end() constrequires (range && ...) && concatable; constexpr auto size() requires (sized_range && ...); constexpr auto size() const requires (sized_range && ...); }; template<class... R> concat_view(R&&...) -> concat_view<views::all_t...>;}

🔗

template<class... Rs> concept [concat-indirectly-readable](#concept:concat-indirectly-readable "25.7.18.2 Class template concat_­view [range.concat.view]") = see below; // exposition only

1

#

The exposition-only concat-indirectly-readable concept is equivalent to:template<class Ref, class RRef, class It>concept concat-indirectly-readable-impl = // exposition onlyrequires (const It it) {{ *it } -> convertible_to; { ranges::iter_move(it) } -> convertible_to; };

template<class... Rs>concept concat-indirectly-readable = // exposition onlycommon_reference_with<concat-reference-t<Rs...>&&, concat-value-t<Rs...>&> &&common_reference_with<concat-reference-t<Rs...>&&, concat-rvalue-reference-t<Rs...>&&> &&common_reference_with<concat-rvalue-reference-t<Rs...>&&, concat-value-t<Rs...> const&> &&(concat-indirectly-readable-impl<concat-reference-t<Rs...>, concat-rvalue-reference-t<Rs...>, iterator_t> && ...);

🔗

template<class... Rs> concept [concatable](#concept:concatable "25.7.18.2 Class template concat_­view [range.concat.view]") = see below; // exposition only

2

#

The exposition-only concatable concept is equivalent to:template<class... Rs>concept concatable = requires { // exposition onlytypename concat-reference-t<Rs...>; typename concat-value-t<Rs...>; typename concat-rvalue-reference-t<Rs...>; } && concat-indirectly-readable<Rs...>;

🔗

template<bool Const, class... Rs> concept [concat-is-random-access](#concept:concat-is-random-access "25.7.18.2 Class template concat_­view [range.concat.view]") = see below; // exposition only

3

#

Let Fs be the pack that consists of all elements of Rs except the last element, then concat-is-random-access is equivalent to:template<bool Const, class... Rs>concept concat-is-random-access = // exposition onlyall-random-access<Const, Rs...> &&(common_range<maybe-const<Const, Fs>> && ...);

🔗

template<bool Const, class... Rs> concept [concat-is-bidirectional](#concept:concat-is-bidirectional "25.7.18.2 Class template concat_­view [range.concat.view]") = see below; // exposition only

4

#

Let Fs be the pack that consists of all elements of Rs except the last element, then concat-is-bidirectional is equivalent to:template<bool Const, class... Rs>concept concat-is-bidirectional = // exposition onlyall-bidirectional<Const, Rs...> &&(common_range<maybe-const<Const, Fs>> && ...);

🔗

constexpr explicit concat_view(Views... views);

5

#

Effects: Initializes views_ with std​::​move(views)....

🔗

constexpr iterator<false> begin() requires (!([simple-view](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<Views> && ...)); constexpr iterator<true> begin() const requires ([range](range.range#concept:range "25.4.2 Ranges [range.range]")<const Views> && ...) && [concatable](#concept:concatable "25.7.18.2 Class template concat_­view [range.concat.view]")<const Views...>;

6

#

Effects: Let is-const betrue for the const-qualified overload, andfalse otherwise.

Equivalent to:iterator<is-const> it(this, in_place_index<0>, ranges::begin(std::get<0>(views_))); it.template satisfy<0>();return it;

🔗

constexpr auto end() requires (!([simple-view](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<Views> && ...)); constexpr auto end() const requires ([range](range.range#concept:range "25.4.2 Ranges [range.range]")<const Views> && ...) && [concatable](#concept:concatable "25.7.18.2 Class template concat_­view [range.concat.view]")<const Views...>;

7

#

Effects: Let is-const betrue for the const-qualified overload, andfalse otherwise.

Equivalent to:constexpr auto N = sizeof...(Views);if constexpr (common_range<maybe-const<is-const, Views...[N - 1]>>) {return iterator<is-const>(this, in_place_index<N - 1>, ranges::end(std::get<N - 1>(views_)));} else {return default_sentinel;}

🔗

constexpr auto size() requires ([sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<Views> && ...); constexpr auto size() const requires ([sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const Views> && ...);

8

#

Effects: Equivalent to:return apply([](auto... sizes) {using CT = make-unsigned-like-t<common_type_t<decltype(sizes)...>>; return (CT(sizes) + ...); }, tuple-transform(ranges::size, views_));

25.7.18.3 Class concat_view​::​iterator [range.concat.iterator]

🔗

namespace std::ranges {template<input_range... Views>requires (view && ...) && (sizeof...(Views) > 0) &&concatable<Views...>templateclass concat_view<Views...>::iterator {public:using iterator_category = see below; // not always presentusing iterator_concept = see below; using value_type = concat-value-t<maybe-const<Const, Views>...>; using difference_type = common_type_t<range_difference_t<maybe-const<Const, Views>>...>; private:using base-iter = // exposition only variant<iterator_t<maybe-const<Const, Views>>...>; maybe-const<Const, concat_view>* parent_ = nullptr; // exposition only**base-iter it_; // exposition onlytemplate<size_t N>constexpr void satisfy(); // exposition onlytemplate<size_t N>constexpr void prev(); // exposition onlytemplate<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 iterator(maybe-const<Const, concat_view>* parent, // exposition only Args&&... args)requires constructible_from<base-iter, Args&&...>; public:iterator() = default; constexpr iterator(iterator i)requires Const && (convertible_to<iterator_t, iterator_t> && ...); constexpr decltype(auto) operator*() const; constexpr iterator& operator++(); constexpr void operator++(int); constexpr iterator operator++(int)requires all-forward<Const, Views...>; constexpr iterator& operator--()requires concat-is-bidirectional<Const, Views...>; constexpr iterator operator--(int)requires concat-is-bidirectional<Const, Views...>; constexpr iterator& operator+=(difference_type n)requires concat-is-random-access<Const, Views...>; constexpr iterator& operator-=(difference_type n)requires concat-is-random-access<Const, Views...>; constexpr decltype(auto) operator[](difference_type n) constrequires concat-is-random-access<Const, Views...>; friend constexpr bool operator==(const iterator& x, const iterator& y)requires (equality_comparable<iterator_t<maybe-const<Const, Views>>> && ...); friend constexpr bool operator==(const iterator& it, default_sentinel_t); friend constexpr bool operator<(const iterator& x, const iterator& y)requires all-random-access<Const, Views...>; friend constexpr bool operator>(const iterator& x, const iterator& y)requires all-random-access<Const, Views...>; friend constexpr bool operator<=(const iterator& x, const iterator& y)requires all-random-access<Const, Views...>; friend constexpr bool operator>=(const iterator& x, const iterator& y)requires all-random-access<Const, Views...>; friend constexpr auto operator<=>(const iterator& x, const iterator& y)requires (all-random-access<Const, Views...> &&(three_way_comparable<iterator_t<maybe-const<Const, Views>>> && ...)); friend constexpr iterator operator+(const iterator& it, difference_type n)requires concat-is-random-access<Const, Views...>; friend constexpr iterator operator+(difference_type n, const iterator& it)requires concat-is-random-access<Const, Views...>; friend constexpr iterator operator-(const iterator& it, difference_type n)requires concat-is-random-access<Const, Views...>; friend constexpr difference_type operator-(const iterator& x, const iterator& y)requires concat-is-random-access<Const, Views...>; friend constexpr difference_type operator-(const iterator& x, default_sentinel_t)requires see below; friend constexpr difference_type operator-(default_sentinel_t, const iterator& x)requires see below; friend constexpr decltype(auto) iter_move(const iterator& it) noexcept(see below); friend constexpr void iter_swap(const iterator& x, const iterator& y) noexcept(see below)requires see below; };}

1

#

iterator​::​iterator_concept is defined as follows:

  • (1.1)

    Ifconcat-is-random-access<Const, Views...> is modeled, then iterator_concept denotes random_access_iterator_tag.

  • (1.2)

    Otherwise, ifconcat-is-bidirectional<Const, Views...> is modeled, then iterator_concept denotes bidirectional_iterator_tag.

  • (1.3)

    Otherwise, ifall-forward<Const, Views...> is modeled, then iterator_concept denotes forward_iterator_tag.

  • (1.4)

    Otherwise, iterator_concept denotes input_iterator_tag.

2

#

The member typedef-name iterator_category is defined if and only ifall-forward<Const, Views...> is modeled.

In that case,iterator​::​iterator_category is defined as follows:

  • (2.1)

    Ifis_reference_v<concat-reference-t<maybe-const<Const, Views>...>> is false, then iterator_category denotes input_iterator_tag.

  • (2.2)

    Otherwise, let Cs denote the pack of typesiterator_traits<iterator_t<maybe-const<Const, Views>>>​::​iterator_category....

    • (2.2.1)

      If(derived_from<Cs, random_access_iterator_tag> && ...) && concat-is-random-access<Const, Views...> is true,iterator_category denotes random_access_iterator_tag.

    • (2.2.2)

      Otherwise, if(derived_from<Cs, bidirectional_iterator_tag> && ...) && concat-is-bidirectional<Const, Views...> is true,iterator_category denotes bidirectional_iterator_tag.

    • (2.2.3)

      Otherwise, if(derived_from<Cs, forward_iterator_tag> && ...) is true,iterator_category denotes forward_iterator_tag.

    • (2.2.4)

      Otherwise, iterator_category denotes input_iterator_tag.

🔗

template<size_t N> constexpr void satisfy();

3

#

Effects: Equivalent to:if constexpr (N < (sizeof...(Views) - 1)) {if (std::get(it_) == ranges::end(std::get(parent_->views_))) {it_.template emplace<N + 1>(ranges::begin(std::get<N + 1>(parent_->views_))); satisfy<N + 1>(); }}

🔗

template<size_t N> constexpr void prev();

4

#

Effects: Equivalent to:if constexpr (N == 0) {--std::get<0>(it_);} else {if (std::get(it_) == ranges::begin(std::get(parent_->views_))) {it_.template emplace<N - 1>(ranges::end(std::get<N - 1>(parent_->views_))); prev<N - 1>(); } else {--std::get(it_); }}

🔗

template<size_t N> constexpr void advance-fwd(difference_type offset, difference_type steps);

5

#

Effects: Equivalent to:using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base-iter>>;if constexpr (N == sizeof...(Views) - 1) { std::get(it_) += static_cast<underlying_diff_type>(steps);} else {auto n_size = ranges::distance(std::get(parent_->views_)); if (offset + steps < n_size) { std::get(it_) += static_cast<underlying_diff_type>(steps); } else {it_.template emplace<N + 1>(ranges::begin(std::get<N + 1>(parent_->views_))); advance-fwd<N + 1>(0, offset + steps - n_size); }}

🔗

template<size_t N> constexpr void advance-bwd(difference_type offset, difference_type steps);

6

#

Effects: Equivalent to:using underlying_diff_type = iter_difference_t<variant_alternative_t<N, base-iter>>;if constexpr (N == 0) { std::get(it_) -= static_cast<underlying_diff_type>(steps);} else {if (offset >= steps) { std::get(it_) -= static_cast<underlying_diff_type>(steps); } else {auto prev_size = ranges::distance(std::get<N - 1>(parent_->views_)); it_.template emplace<N - 1>(ranges::end(std::get<N - 1>(parent_->views_))); advance-bwd<N - 1>(prev_size, steps - offset); }}

🔗

template<class... Args> constexpr explicit iterator(maybe-const<Const, concat_view>* parent, Args&&... args) requires [constructible_from](concept.constructible#concept:constructible_from "18.4.11 Concept constructible_­from [concept.constructible]")<base-iter, Args&&...>;

7

#

Effects: Initializes parent_ with parent, and initializes it_ with std​::​forward(args)....

🔗

constexpr iterator(iterator<!Const> it) requires Const && ([convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<iterator_t<Views>, iterator_t<const Views>> && ...);

8

#

Preconditions: it.it_.valueless_by_exception() is false.

9

#

Effects: Initializes parent_ with it.parent_, and let i be it.it_.index(), initializes it_ withbase-iter(in_place_index, std​::​get(std​::​move(it.it_))).

🔗

constexpr decltype(auto) operator*() const;

10

#

Preconditions: it_.valueless_by_exception() is false.

11

#

Effects: Equivalent to:using reference = concat-reference-t<maybe-const<Const, Views>...>;return std::visit([](auto&& it) -> reference { return *it; }, it_);

🔗

constexpr iterator& operator++();

12

#

Preconditions: it_.valueless_by_exception() is false.

13

#

Effects: Let i be it_.index().

Equivalent to:++std::get(it_);satisfy();return *this;

🔗

constexpr void operator++(int);

14

#

Effects: Equivalent to:++*this;

🔗

constexpr iterator operator++(int) requires [all-forward](range.adaptor.helpers#concept:all-forward "25.7.5 Range adaptor helpers [range.adaptor.helpers]")<Const, Views...>;

15

#

Effects: Equivalent to:auto tmp = *this;++*this;return tmp;

🔗

constexpr iterator& operator--() requires [concat-is-bidirectional](#concept:concat-is-bidirectional "25.7.18.2 Class template concat_­view [range.concat.view]")<Const, Views...>;

16

#

Preconditions: it_.valueless_by_exception() is false.

17

#

Effects: Let i be it_.index().

Equivalent to:prev();return *this;

🔗

constexpr iterator operator--(int) requires [concat-is-bidirectional](#concept:concat-is-bidirectional "25.7.18.2 Class template concat_­view [range.concat.view]")<Const, Views...>;

18

#

Effects: Equivalent to:auto tmp = *this;--*this;return tmp;

🔗

constexpr iterator& operator+=(difference_type n) requires [concat-is-random-access](#concept:concat-is-random-access "25.7.18.2 Class template concat_­view [range.concat.view]")<Const, Views...>;

19

#

Preconditions: it_.valueless_by_exception() is false.

20

#

Effects: Let i be it_.index().

Equivalent to:if (n > 0) {advance-fwd(std::get(it_) - ranges::begin(std::get(parent_->views_)), n);} else if (n < 0) {advance-bwd(std::get(it_) - ranges::begin(std::get(parent_->views_)), -n);}return *this;

🔗

constexpr iterator& operator-=(difference_type n) requires [concat-is-random-access](#concept:concat-is-random-access "25.7.18.2 Class template concat_­view [range.concat.view]")<Const, Views...>;

21

#

Effects: Equivalent to:*this += -n;return *this;

🔗

constexpr decltype(auto) operator[](difference_type n) const requires [concat-is-random-access](#concept:concat-is-random-access "25.7.18.2 Class template concat_­view [range.concat.view]")<Const, Views...>;

22

#

Effects: Equivalent to:return *((*this) + n);

🔗

friend constexpr bool operator==(const iterator& x, const iterator& y) requires ([equality_comparable](concept.equalitycomparable#concept:equality_comparable "18.5.4 Concept equality_­comparable [concept.equalitycomparable]")<iterator_t<maybe-const<Const, Views>>> && ...);

23

#

Preconditions: x.it_.valueless_by_exception() andy.it_.valueless_by_exception() are each false.

24

#

Effects: Equivalent to:return x.it_ == y.it_;

🔗

friend constexpr bool operator==(const iterator& it, default_sentinel_t);

25

#

Preconditions: it.it_.valueless_by_exception() is false.

26

#

Effects: Equivalent to:constexpr auto last_idx = sizeof...(Views) - 1;return it.it_.index() == last_idx && std::get<last_idx>(it.it_) == ranges::end(std::get<last_idx>(it.parent_->views_));

🔗

friend constexpr bool operator<(const iterator& x, const iterator& y) requires [all-random-access](range.adaptor.helpers#concept:all-random-access "25.7.5 Range adaptor helpers [range.adaptor.helpers]")<Const, Views...>; friend constexpr bool operator>(const iterator& x, const iterator& y) requires [all-random-access](range.adaptor.helpers#concept:all-random-access "25.7.5 Range adaptor helpers [range.adaptor.helpers]")<Const, Views...>; friend constexpr bool operator<=(const iterator& x, const iterator& y) requires [all-random-access](range.adaptor.helpers#concept:all-random-access "25.7.5 Range adaptor helpers [range.adaptor.helpers]")<Const, Views...>; friend constexpr bool operator>=(const iterator& x, const iterator& y) requires [all-random-access](range.adaptor.helpers#concept:all-random-access "25.7.5 Range adaptor helpers [range.adaptor.helpers]")<Const, Views...>; friend constexpr auto operator<=>(const iterator& x, const iterator& y) requires ([all-random-access](range.adaptor.helpers#concept:all-random-access "25.7.5 Range adaptor helpers [range.adaptor.helpers]")<Const, Views...> && ([three_way_comparable](cmp.concept#concept:three_way_comparable "17.12.4 Concept three_­way_­comparable [cmp.concept]")<iterator_t<maybe-const<Const, Views>>> && ...));

27

#

Preconditions: x.it_.valueless_by_exception() andy.it_.valueless_by_exception() are each false.

28

#

Let op be the operator.

29

#

Effects: Equivalent to:return x.it_ op y.it_;

🔗

friend constexpr iterator operator+(const iterator& it, difference_type n) requires [concat-is-random-access](#concept:concat-is-random-access "25.7.18.2 Class template concat_­view [range.concat.view]")<Const, Views...>;

30

#

Effects: Equivalent to:auto temp = it; temp += n;return temp;

🔗

friend constexpr iterator operator+(difference_type n, const iterator& it) requires [concat-is-random-access](#concept:concat-is-random-access "25.7.18.2 Class template concat_­view [range.concat.view]")<Const, Views...>;

31

#

Effects: Equivalent to:return it + n;

🔗

friend constexpr iterator operator-(const iterator& it, difference_type n) requires [concat-is-random-access](#concept:concat-is-random-access "25.7.18.2 Class template concat_­view [range.concat.view]")<Const, Views...>;

32

#

Effects: Equivalent to:auto temp = it; temp -= n;return temp;

🔗

friend constexpr difference_type operator-(const iterator& x, const iterator& y) requires [concat-is-random-access](#concept:concat-is-random-access "25.7.18.2 Class template concat_­view [range.concat.view]")<Const, Views...>;

33

#

Preconditions: x.it_.valueless_by_exception() andy.it_.valueless_by_exception() are each false.

34

#

Effects: Letix denote x.it_.index() andiy denote y.it_.index().

If ix > iy, letdy beranges​::​distance(std​::​get(y.it_), ranges​::​end(std​::​get(y.parent_->views_))),dx beranges​::​distance(ranges​::​begin(std​::​get(x.parent_->views_)), std​::​get(x.it_)). Let s denote the sum of the sizes of all the rangesstd​::​get(x.parent_->views_) for every integer i in the range [iy + 1, ix) if there is any, and0 otherwise, of type difference_type, equivalent to:return dy + s + dx;

otherwise, if ix < iy is true, equivalent to:return -(y - x);

otherwise, equivalent to:return std::get(x.it_) - std::get(y.it_);

🔗

friend constexpr difference_type operator-(const iterator& x, default_sentinel_t) requires see below;

35

#

Preconditions: x.it_.valueless_by_exception() is false.

36

#

Effects: Letix denote x.it_.index(),dx beranges​::​distance(std​::​get(x.it_), ranges​::​end(std​::​get(x.parent_->views_))).

Let s denote the sum of the sizes of all the rangesstd​::​get(x.parent_->views_) for every integer i in the range [ix + 1, sizeof...(Views)) if there is any, and0 otherwise, of type difference_type, equivalent to:return -(dx + s);

37

#

Remarks: Let Fs be the pack that consists of all elements of Views except the first element, the expression in the requires-clause is equivalent to:(sized_sentinel_for<sentinel_t<maybe-const<Const, Views>>, iterator_t<maybe-const<Const, Views>>> && ...) &&(sized_range<maybe-const<Const, Fs>> && ...)

🔗

friend constexpr difference_type operator-(default_sentinel_t, const iterator& x) requires see below;

38

#

Effects: Equivalent to:return -(x - default_sentinel);

39

#

Remarks: Let Fs be the pack that consists of all elements of Views except the first element, the expression in the requires-clause is equivalent to:(sized_sentinel_for<sentinel_t<maybe-const<Const, Views>>, iterator_t<maybe-const<Const, Views>>> && ...) &&(sized_range<maybe-const<Const, Fs>> && ...)

🔗

friend constexpr decltype(auto) iter_move(const iterator& it) noexcept(see below);

40

#

Preconditions: it.it_.valueless_by_exception() is false.

41

#

Effects: Equivalent to:return std::visit([](const auto& i)-> concat-rvalue-reference-t<maybe-const<Const, Views>...> {return ranges::iter_move(i); }, it.it_);

42

#

Remarks: The exception specification is equivalent to:((is_nothrow_invocable_v<decltype(ranges::iter_move), const iterator_t<maybe-const<Const, Views>>&> && is_nothrow_convertible_v<range_rvalue_reference_t<maybe-const<Const, Views>>, concat-rvalue-reference-t<maybe-const<Const, Views>...>>) &&...)

🔗

friend constexpr void iter_swap(const iterator& x, const iterator& y) noexcept(see below) requires see below;

43

#

Preconditions: x.it_.valueless_by_exception() andy.it_.valueless_by_exception() are each false.

44

#

Effects: Equivalent to:std::visit([&](const auto& it1, const auto& it2) {if constexpr (is_same_v<decltype(it1), decltype(it2)>) { ranges::iter_swap(it1, it2); } else { ranges::swap(*x, *y); }}, x.it_, y.it_);

45

#

Remarks: The exception specification is equivalent to(noexcept(ranges::swap(*x, *y)) && ... && noexcept(ranges::iter_swap(its, its))) where its is a pack of lvalues of typeconst iterator_t<maybe-const<Const, Views>> respectively.

The expression in the requires-clause is equivalent toswappable_with<iter_reference_t<iterator>, iter_reference_t<iterator>> &&(... && indirectly_swappable<iterator_t<maybe-const<Const, Views>>>)