[range.lazy.split]

# 25 Ranges library [[ranges]](./#ranges)

## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.lazy.split)

### 25.7.16 Lazy split view [range.lazy.split]

#### [25.7.16.1](#overview) Overview [[range.lazy.split.overview]](range.lazy.split.overview)

[1](#overview-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L7820)

lazy_split_view takes a view and a delimiter, and splits
the view into subranges on the delimiter[.](#overview-1.sentence-1)

The delimiter can be
a single element or a view of elements[.](#overview-1.sentence-2)

[2](#overview-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L7825)

The name views​::​lazy_split denotes a
range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#overview-2.sentence-1)

Given subexpressions E and F,
the expression views​::​lazy_split(E, F) is expression-equivalent tolazy_split_view(E, F)[.](#overview-2.sentence-2)

[3](#overview-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L7833)

[*Example [1](#overview-example-1)*: string str{"the quick brown fox"};for (auto word : str | views::lazy_split(' ')) {for (char ch : word) cout << ch;
 cout << '*';}// The above prints the*quick*brown*fox* â *end example*]

#### [25.7.16.2](#view) Class template lazy_split_view [[range.lazy.split.view]](range.lazy.split.view)

[ð](#lib:lazy_split_view)

namespace std::ranges {template<auto> struct *require-constant*; // *exposition only*template<class R>concept [*tiny-range*](#concept:tiny-range "25.7.16.2 Class template lazy_­split_­view [range.lazy.split.view]") = // *exposition only*[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R> &&requires { typename *require-constant*<remove_reference_t<R>::size()>; } &&(remove_reference_t<R>::size() <= 1); template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V, [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") Pattern>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && [view](range.view#concept:view "25.4.5 Views [range.view]")<Pattern> &&[indirectly_comparable](alg.req.ind.cmp#concept:indirectly_comparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&([forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V> || [*tiny-range*](#concept:tiny-range "25.7.16.2 Class template lazy_­split_­view [range.lazy.split.view]")<Pattern>)class lazy_split_view : public view_interface<lazy_split_view<V, Pattern>> {private: V *base_* = V(); // *exposition only* Pattern *pattern_* = Pattern(); // *exposition only**non-propagating-cache*<iterator_t<V>> *current_*; // *exposition only*, present only// if [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V> is false// [[range.lazy.split.outer]](#outer "25.7.16.3 Class template lazy_­split_­view​::​outer-iterator"), class template lazy_split_view​::​*outer-iterator*template<bool> struct *outer-iterator*; // *exposition only*// [[range.lazy.split.inner]](#inner "25.7.16.5 Class template lazy_­split_­view​::​inner-iterator"), class template lazy_split_view​::​*inner-iterator*template<bool> struct *inner-iterator*; // *exposition only*public: lazy_split_view()requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> && [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<Pattern> = default; constexpr explicit lazy_split_view(V base, Pattern pattern); template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") R>requires [constructible_from](concept.constructible#concept:constructible_from "18.4.11 Concept constructible_­from [concept.constructible]")<V, views::all_t<R>> &&[constructible_from](concept.constructible#concept:constructible_from "18.4.11 Concept constructible_­from [concept.constructible]")<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](concept.copyconstructible#concept:copy_constructible "18.4.14 Concept copy_­constructible [concept.copyconstructible]")<V> { return *base_*; }constexpr V base() && { return std::move(*base_*); }constexpr auto begin() {if constexpr ([forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V>) {return *outer-iterator*<[*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V> && [*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<Pattern>>{*this, ranges::begin(*base_*)}; } else {*current_* = ranges::begin(*base_*); return *outer-iterator*<false>{*this}; }}constexpr auto begin() const requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V> && [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<const V> {return *outer-iterator*<true>{*this, ranges::begin(*base_*)}; }constexpr auto end() requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V> && [common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<V> {return *outer-iterator*<[*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V> && [*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<Pattern>>{*this, ranges::end(*base_*)}; }constexpr auto end() const {if constexpr ([forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V> && [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<const V> && [common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<const V>)return *outer-iterator*<true>{*this, ranges::end(*base_*)}; elsereturn 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](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") R> lazy_split_view(R&&, range_value_t<R>)-> lazy_split_view<views::all_t<R>, single_view<range_value_t<R>>>;}

[ð](#lib:lazy_split_view,constructor)

`constexpr explicit lazy_split_view(V base, Pattern pattern);
`

[1](#view-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L7935)

*Effects*: Initializes *base_* with std​::​move(base), and*pattern_* with std​::​move(pattern)[.](#view-1.sentence-1)

[ð](#lib:lazy_split_view,constructor_)

`template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") R>
  requires [constructible_from](concept.constructible#concept:constructible_from "18.4.11 Concept constructible_­from [concept.constructible]")<V, views::all_t<R>> &&
           [constructible_from](concept.constructible#concept:constructible_from "18.4.11 Concept constructible_­from [concept.constructible]")<Pattern, single_view<range_value_t<R>>>
constexpr explicit lazy_split_view(R&& r, range_value_t<R> e);
`

[2](#view-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L7950)

*Effects*: Initializes *base_* with views​::​all(std​::​forward<R>(r)), and*pattern_* with views​::​single(std​::​move(e))[.](#view-2.sentence-1)

#### [25.7.16.3](#outer) Class template lazy_split_view​::​*outer-iterator* [[range.lazy.split.outer]](range.lazy.split.outer)

[ð](#lib:lazy_split_view::outer-iterator)

namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V, [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") Pattern>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && [view](range.view#concept:view "25.4.5 Views [range.view]")<Pattern> &&[indirectly_comparable](alg.req.ind.cmp#concept:indirectly_comparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&([forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V> || [*tiny-range*](#concept:tiny-range "25.7.16.2 Class template lazy_­split_­view [range.lazy.split.view]")<Pattern>)template<bool Const>struct lazy_split_view<V, Pattern>::*outer-iterator* {private:using *Parent* = *maybe-const*<Const, lazy_split_view>; // *exposition only*using *Base* = *maybe-const*<Const, V>; // *exposition only**Parent** *parent_* = nullptr; // *exposition only* iterator_t<*Base*> *current_* = iterator_t<*Base*>(); // *exposition only*, present only// if V models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")bool *trailing_empty_* = false; // *exposition only*public:using iterator_concept = conditional_t<[forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<*Base*>, forward_iterator_tag, input_iterator_tag>; using iterator_category = input_iterator_tag; // present only if *Base*// models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")// [[range.lazy.split.outer.value]](#outer.value "25.7.16.4 Class lazy_­split_­view​::​outer-iterator​::​value_­type"), class lazy_split_view​::​*outer-iterator*​::​value_typestruct value_type; using difference_type = range_difference_t<*Base*>; *outer-iterator*() = default; constexpr explicit *outer-iterator*(*Parent*& parent)requires (![forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<*Base*>); constexpr *outer-iterator*(*Parent*& parent, iterator_t<*Base*> current)requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr *outer-iterator*(*outer-iterator*<!Const> i)requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<iterator_t<V>, iterator_t<*Base*>>; constexpr value_type operator*() const; constexpr *outer-iterator*& operator++(); constexpr decltype(auto) operator++(int) {if constexpr ([forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<*Base*>) {auto tmp = *this; ++*this; return tmp; } else++*this; }friend constexpr bool operator==(const *outer-iterator*& x, const *outer-iterator*& y)requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr bool operator==(const *outer-iterator*& x, default_sentinel_t); };}

[1](#outer-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8016)

Many of the specifications in [range.lazy.split] refer to the notional member*current* of *outer-iterator*[.](#outer-1.sentence-1)

*current* is equivalent to *current_* if V models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]"), and **parent_*->*current_* otherwise[.](#outer-1.sentence-2)

[ð](#lib:lazy_split_view::outer-iterator,constructor)

`constexpr explicit outer-iterator(Parent& parent)
  requires (![forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<Base>);
`

[2](#outer-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8029)

*Effects*: Initializes *parent_* with addressof(parent)[.](#outer-2.sentence-1)

[ð](#lib:lazy_split_view::outer-iterator,constructor_)

`constexpr outer-iterator(Parent& parent, iterator_t<Base> current)
  requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<Base>;
`

[3](#outer-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8041)

*Effects*: Initializes *parent_* with addressof(parent) and *current_* with std​::​move(current)[.](#outer-3.sentence-1)

[ð](#lib:lazy_split_view::outer-iterator,constructor__)

`constexpr outer-iterator(outer-iterator<!Const> i)
  requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<iterator_t<V>, iterator_t<Base>>;
`

[4](#outer-4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8054)

*Effects*: Initializes *parent_* with i.*parent_*,*current_* with std​::​move(i.*current_*), and*trailing_empty_* with i.*trailing_empty_*[.](#outer-4.sentence-1)

[ð](#lib:operator*,lazy_split_view::outer-iterator)

`constexpr value_type operator*() const;
`

[5](#outer-5)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8067)

*Effects*: Equivalent to: return value_type{*this};

[ð](#lib:operator++,lazy_split_view::outer-iterator)

`constexpr outer-iterator& operator++();
`

[6](#outer-6)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8078)

*Effects*: Equivalent to:const auto end = ranges::end(*parent_*->*base_*);if (*current* == end) {*trailing_empty_* = false; return *this;}const auto [pbegin, pend] = subrange{*parent_*->*pattern_*};if (pbegin == pend) ++*current*;else if constexpr ([*tiny-range*](#concept:tiny-range "25.7.16.2 Class template lazy_­split_­view [range.lazy.split.view]")<Pattern>) {*current* = ranges::find(std::move(*current*), end, *pbegin); if (*current* != end) {++*current*; if (*current* == end)*trailing_empty_* = true; }}else {do {auto [b, p] = ranges::mismatch(*current*, end, pbegin, pend); if (p == pend) {*current* = b; if (*current* == end)*trailing_empty_* = true; break; // The pattern matched; skip it}} while (++*current* != end);}return *this;

[ð](#lib:operator==,lazy_split_view::outer-iterator)

`friend constexpr bool operator==(const outer-iterator& x, const outer-iterator& y)
  requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<Base>;
`

[7](#outer-7)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8119)

*Effects*: Equivalent to:return x.*current_* == y.*current_* && x.*trailing_empty_* == y.*trailing_empty_*;

[ð](#lib:operator==,lazy_split_view::outer-iterator_)

`friend constexpr bool operator==(const outer-iterator& x, default_sentinel_t);
`

[8](#outer-8)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8133)

*Effects*: Equivalent to:return x.*current* == ranges::end(x.*parent_*->*base_*) && !x.*trailing_empty_*;

#### [25.7.16.4](#outer.value) Class lazy_split_view​::​*outer-iterator*​::​value_type [[range.lazy.split.outer.value]](range.lazy.split.outer.value)

[ð](#lib:lazy_split_view::outer-iterator::value_type)

namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V, [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") Pattern>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && [view](range.view#concept:view "25.4.5 Views [range.view]")<Pattern> &&[indirectly_comparable](alg.req.ind.cmp#concept:indirectly_comparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&([forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V> || [*tiny-range*](#concept:tiny-range "25.7.16.2 Class template lazy_­split_­view [range.lazy.split.view]")<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*(); // *exposition only*constexpr explicit value_type(*outer-iterator* i); // *exposition only*public:constexpr *inner-iterator*<Const> begin() const; constexpr default_sentinel_t end() const noexcept; };}

[ð](#lib:lazy_split_view::outer-iterator::value_type,constructor)

`constexpr explicit value_type(outer-iterator i);
`

[1](#outer.value-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8171)

*Effects*: Initializes *i_* with std​::​move(i)[.](#outer.value-1.sentence-1)

[ð](#lib:begin,lazy_split_view::outer-iterator::value_type)

`constexpr inner-iterator<Const> begin() const;
`

[2](#outer.value-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8182)

*Effects*: Equivalent to: return *inner-iterator*<Const>{*i_*};

[ð](#lib:end,lazy_split_view::outer-iterator::value_type)

`constexpr default_sentinel_t end() const noexcept;
`

[3](#outer.value-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8193)

*Effects*: Equivalent to: return default_sentinel;

#### [25.7.16.5](#inner) Class template lazy_split_view​::​*inner-iterator* [[range.lazy.split.inner]](range.lazy.split.inner)

[ð](#lib:lazy_split_view::inner-iterator)

namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V, [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") Pattern>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && [view](range.view#concept:view "25.4.5 Views [range.view]")<Pattern> &&[indirectly_comparable](alg.req.ind.cmp#concept:indirectly_comparable "24.3.7.5 Concept indirectly_­comparable [alg.req.ind.cmp]")<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&([forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V> || [*tiny-range*](#concept:tiny-range "25.7.16.2 Class template lazy_­split_­view [range.lazy.split.view]")<Pattern>)template<bool Const>struct lazy_split_view<V, Pattern>::*inner-iterator* {private:using *Base* = *maybe-const*<Const, V>; // *exposition only**outer-iterator*<Const> *i_* = *outer-iterator*<Const>(); // *exposition only*bool *incremented_* = false; // *exposition only*public:using iterator_concept = typename *outer-iterator*<Const>::iterator_concept; using iterator_category = *see below*; // present only if *Base*// models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")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](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V>; constexpr decltype(auto) operator*() const { return **i_*.*current*; }constexpr *inner-iterator*& operator++(); constexpr decltype(auto) operator++(int) {if constexpr ([forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<*Base*>) {auto tmp = *this; ++*this; return tmp; } else++*this; }friend constexpr bool operator==(const *inner-iterator*& x, const *inner-iterator*& y)requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<*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](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<*Base*>>; };}

[1](#inner-1)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8257)

If *Base* does not model [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") there is no member iterator_category[.](#inner-1.sentence-1)

Otherwise, the [*typedef-name*](dcl.typedef#nt:typedef-name "9.2.4 The typedef specifier [dcl.typedef]") iterator_category denotes:

- [(1.1)](#inner-1.1)

forward_iterator_tag ifiterator_traits<iterator_t<*Base*>>​::​iterator_category models[derived_from](concept.derived#concept:derived_from "18.4.3 Concept derived_­from [concept.derived]")<forward_iterator_tag>;

- [(1.2)](#inner-1.2)

otherwise, iterator_traits<iterator_t<*Base*>>​::​iterator_category[.](#inner-1.sentence-2)

[ð](#lib:lazy_split_view::inner-iterator,constructor)

`constexpr explicit inner-iterator(outer-iterator<Const> i);
`

[2](#inner-2)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8275)

*Effects*: Initializes *i_* with std​::​move(i)[.](#inner-2.sentence-1)

[ð](#lib:base,lazy_split_view::inner-iterator)

`constexpr const iterator_t<Base>& base() const & noexcept;
`

[3](#inner-3)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8286)

*Effects*: Equivalent to: return *i_*.*current*;

[ð](#lib:base,lazy_split_view::inner-iterator_)

`constexpr iterator_t<Base> base() && requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V>;
`

[4](#inner-4)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8297)

*Effects*: Equivalent to: return std​::​move(*i_*.*current*);

[ð](#lib:operator++,lazy_split_view::inner-iterator)

`constexpr inner-iterator& operator++();
`

[5](#inner-5)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8308)

*Effects*: Equivalent to:*incremented_* = true;if constexpr (![forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<*Base*>) {if constexpr (Pattern::size() == 0) {return *this; }}++*i_*.*current*;return *this;

[ð](#lib:operator==,lazy_split_view::inner-iterator)

`friend constexpr bool operator==(const inner-iterator& x, const inner-iterator& y)
  requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<Base>;
`

[6](#inner-6)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8330)

*Effects*: Equivalent to: return x.*i_*.*current* == y.*i_*.*current*;

[ð](#lib:operator==,lazy_split_view::inner-iterator_)

`friend constexpr bool operator==(const inner-iterator& x, default_sentinel_t);
`

[7](#inner-7)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8341)

*Effects*: Equivalent to:auto [pcur, pend] = subrange{x.*i_*.*parent_*->*pattern_*};auto end = ranges::end(x.*i_*.*parent_*->*base_*);if constexpr ([*tiny-range*](#concept:tiny-range "25.7.16.2 Class template lazy_­split_­view [range.lazy.split.view]")<Pattern>) {const auto & cur = x.*i_*.*current*; if (cur == end) return true; if (pcur == pend) return x.*incremented_*; return *cur == *pcur;} else {auto cur = x.*i_*.*current*; if (cur == end) return true; if (pcur == pend) return x.*incremented_*; do {if (*cur != *pcur) return false; if (++pcur == pend) return true; } while (++cur != end); return false;}

[ð](#lib:iter_swap,lazy_split_view::inner-iterator)

`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](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<Base>>;
`

[8](#inner-8)

[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8373)

*Effects*: Equivalent toranges​::​iter_swap(x.*i_*.*current*, y.*i_*.*current*)[.](#inner-8.sentence-1)
