Init

cppdraft/range/access.md

@@ -0,0 +1,748 @@
+[range.access]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.3 Range access [range.access]
+
+### [25.3.1](#general) General [[range.access.general]](range.access.general)
+
+[1](#general-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L633)
+
+In addition to being available via inclusion of the [<ranges>](ranges.syn#header:%3cranges%3e "25.2 Header <ranges> synopsis [ranges.syn]") header, the customization point objects in [range.access] are
+available when the header [<iterator>](iterator.synopsis#header:%3citerator%3e "24.2 Header <iterator>&nbsp;synopsis [iterator.synopsis]") is included[.](#general-1.sentence-1)
+
+[2](#general-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L638)
+
+Within [range.access],
+the [*reified object*](#def:object,reified "25.3.1 General [range.access.general]") of a subexpression E denotes
+
+- [(2.1)](#general-2.1)
+
+the same object as E if E is a glvalue, or
+
+- [(2.2)](#general-2.2)
+
+the result of applying
+the temporary materialization conversion ([[conv.rval]](conv.rval "7.3.5 Temporary materialization conversion")) to E otherwise[.](#general-2.sentence-1)
+
+### [25.3.2](#begin) ranges​::​begin [[range.access.begin]](range.access.begin)
+
+[1](#begin-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L652)
+
+The name ranges​::​begin denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#begin-1.sentence-1)
+
+[2](#begin-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L656)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#begin-2.sentence-1)
+
+Then:
+
+- [(2.1)](#begin-2.1)
+
+  If E is an rvalue and enable_borrowed_range<remove_cv_t<T>> is false, ranges​::​begin(E) is ill-formed[.](#begin-2.1.sentence-1)
+
+- [(2.2)](#begin-2.2)
+
+  Otherwise, if T is an array type ([[dcl.array]](dcl.array#term.array.type "9.3.4.5 Arrays")) and remove_all_extents_t<T> is an incomplete type, ranges​::​begin(E) is ill-formed with no diagnostic required[.](#begin-2.2.sentence-1)
+
+- [(2.3)](#begin-2.3)
+
+  Otherwise, if T is an array type, ranges​::​begin(E) is expression-equivalent to t + 0[.](#begin-2.3.sentence-1)
+
+- [(2.4)](#begin-2.4)
+
+  Otherwise, if auto(t.begin()) is a valid expression whose type models [input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]"), ranges​::​begin(E) is expression-equivalent to auto(t.begin())[.](#begin-2.4.sentence-1)
+
+- [(2.5)](#begin-2.5)
+
+  Otherwise, if T is a class or enumeration type and auto(begin(t)) is a valid expression whose type models [input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]") where the meaning of begin is established as-if by performing
+ argument-dependent lookup only ([[basic.lookup.argdep]](basic.lookup.argdep "6.5.4 Argument-dependent name lookup")),
+ then ranges​::​begin(E) is expression-equivalent to
+ that expression[.](#begin-2.5.sentence-1)
+
+- [(2.6)](#begin-2.6)
+
+  Otherwise, ranges​::​begin(E) is ill-formed[.](#begin-2.6.sentence-1)
+
+[3](#begin-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L696)
+
+[*Note [1](#begin-note-1)*:
+
+Diagnosable ill-formed cases above
+result in substitution failure when ranges​::​begin(E) appears in the immediate context of a template instantiation[.](#begin-3.sentence-1)
+
+— *end note*]
+
+[4](#begin-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L703)
+
+[*Note [2](#begin-note-2)*:
+
+Whenever ranges​::​begin(E) is a valid expression, its type models[input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]")[.](#begin-4.sentence-1)
+
+— *end note*]
+
+### [25.3.3](#end) ranges​::​end [[range.access.end]](range.access.end)
+
+[1](#end-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L712)
+
+The name ranges​::​end denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#end-1.sentence-1)
+
+[2](#end-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L716)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#end-2.sentence-1)
+
+Then:
+
+- [(2.1)](#end-2.1)
+
+  If E is an rvalue and enable_borrowed_range<remove_cv_t<T>> is false, ranges​::​end(E) is ill-formed[.](#end-2.1.sentence-1)
+
+- [(2.2)](#end-2.2)
+
+  Otherwise, if T is an array type ([[dcl.array]](dcl.array#term.array.type "9.3.4.5 Arrays")) and remove_all_extents_t<T> is an incomplete type, ranges​::​end(E) is ill-formed with no diagnostic required[.](#end-2.2.sentence-1)
+
+- [(2.3)](#end-2.3)
+
+  Otherwise, if T is an array of unknown bound, ranges​::​end(E) is ill-formed[.](#end-2.3.sentence-1)
+
+- [(2.4)](#end-2.4)
+
+  Otherwise, if T is an array, ranges​::​end(E) is expression-equivalent to t + extent_v<T>[.](#end-2.4.sentence-1)
+
+- [(2.5)](#end-2.5)
+
+  Otherwise, if auto(t.end()) is a valid expression whose type models [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<iterator_t<T>> then ranges​::​end(E) is expression-equivalent to auto(t.end())[.](#end-2.5.sentence-1)
+
+- [(2.6)](#end-2.6)
+
+  Otherwise, if T is a class or enumeration type and auto(end(t)) is a valid expression whose type models [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<iterator_t<T>> where the meaning of end is established as-if by performing
+ argument-dependent lookup only ([[basic.lookup.argdep]](basic.lookup.argdep "6.5.4 Argument-dependent name lookup")),
+ then ranges​::​end(E) is expression-equivalent to
+ that expression[.](#end-2.6.sentence-1)
+
+- [(2.7)](#end-2.7)
+
+  Otherwise, ranges​::​end(E) is ill-formed[.](#end-2.7.sentence-1)
+
+[3](#end-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L761)
+
+[*Note [1](#end-note-1)*:
+
+Diagnosable ill-formed cases above
+result in substitution failure when ranges​::​end(E) appears in the immediate context of a template instantiation[.](#end-3.sentence-1)
+
+— *end note*]
+
+[4](#end-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L768)
+
+[*Note [2](#end-note-2)*:
+
+Whenever ranges​::​end(E) is a valid expression,
+the types S and I ofranges​::​end(E) and ranges​::​begin(E) model [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<S, I>[.](#end-4.sentence-1)
+
+— *end note*]
+
+### [25.3.4](#cbegin) ranges​::​cbegin [[range.access.cbegin]](range.access.cbegin)
+
+[1](#cbegin-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L779)
+
+The name ranges​::​cbegin denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#cbegin-1.sentence-1)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#cbegin-1.sentence-2)
+
+Then:
+
+- [(1.1)](#cbegin-1.1)
+
+  If E is an rvalue andenable_borrowed_range<remove_cv_t<T>> is false,ranges​::​cbegin(E) is ill-formed[.](#cbegin-1.1.sentence-1)
+
+- [(1.2)](#cbegin-1.2)
+
+  Otherwise,
+let U be ranges​::​begin(*possibly-const-range*(t))[.](#cbegin-1.2.sentence-1)
+  ranges​::​cbegin(E) is expression-equivalent toconst_iterator<decltype(U)>(U)[.](#cbegin-1.2.sentence-2)
+
+[2](#cbegin-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L797)
+
+[*Note [1](#cbegin-note-1)*:
+
+Whenever ranges​::​cbegin(E) is a valid expression, its type models[input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]") and [*constant-iterator*](const.iterators.alias#concept:constant-iterator "24.5.3.2 Alias templates [const.iterators.alias]")[.](#cbegin-2.sentence-1)
+
+— *end note*]
+
+### [25.3.5](#cend) ranges​::​cend [[range.access.cend]](range.access.cend)
+
+[1](#cend-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L806)
+
+The name ranges​::​cend denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#cend-1.sentence-1)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#cend-1.sentence-2)
+
+Then:
+
+- [(1.1)](#cend-1.1)
+
+  If E is an rvalue andenable_borrowed_range<remove_cv_t<T>> is false,ranges​::​cend(E) is ill-formed[.](#cend-1.1.sentence-1)
+
+- [(1.2)](#cend-1.2)
+
+  Otherwise,
+let U be ranges​::​end(*possibly-const-range*(t))[.](#cend-1.2.sentence-1)
+  ranges​::​cend(E) is expression-equivalent toconst_sentinel<decltype(U)>(U)[.](#cend-1.2.sentence-2)
+
+[2](#cend-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L824)
+
+[*Note [1](#cend-note-1)*:
+
+Whenever ranges​::​cend(E) is a valid expression,
+the types S and I of the expressionsranges​::​cend(E) and ranges​::​cbegin(E) model [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<S, I>[.](#cend-2.sentence-1)
+
+If S models [input_iterator](iterator.concept.input#concept:input_iterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]"),
+then S also models *constant-iterator*[.](#cend-2.sentence-2)
+
+— *end note*]
+
+### [25.3.6](#rbegin) ranges​::​rbegin [[range.access.rbegin]](range.access.rbegin)
+
+[1](#rbegin-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L837)
+
+The name ranges​::​rbegin denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#rbegin-1.sentence-1)
+
+[2](#rbegin-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L841)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#rbegin-2.sentence-1)
+
+Then:
+
+- [(2.1)](#rbegin-2.1)
+
+  If E is an rvalue and enable_borrowed_range<remove_cv_t<T>> is false, ranges​::​rbegin(E) is ill-formed[.](#rbegin-2.1.sentence-1)
+
+- [(2.2)](#rbegin-2.2)
+
+  Otherwise, if T is an array type ([[dcl.array]](dcl.array#term.array.type "9.3.4.5 Arrays")) and remove_all_extents_t<T> is an incomplete type, ranges​::​rbegin(E) is ill-formed with no diagnostic required[.](#rbegin-2.2.sentence-1)
+
+- [(2.3)](#rbegin-2.3)
+
+  Otherwise, if auto(t.rbegin()) is a valid expression whose type models [input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]"), ranges​::​rbegin(E) is expression-equivalent to auto(t.rbegin())[.](#rbegin-2.3.sentence-1)
+
+- [(2.4)](#rbegin-2.4)
+
+  Otherwise, if T is a class or enumeration type and auto(rbegin(t)) is a valid expression whose type models [input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]") where the meaning of rbegin is established as-if by performing
+ argument-dependent lookup only ([[basic.lookup.argdep]](basic.lookup.argdep "6.5.4 Argument-dependent name lookup")),
+ then ranges​::​rbegin(E) is expression-equivalent to
+ that expression[.](#rbegin-2.4.sentence-1)
+
+- [(2.5)](#rbegin-2.5)
+
+  Otherwise, if both ranges​::​begin(t) and ranges​::​end(t) are valid expressions of the same type which models [bidirectional_iterator](iterator.concept.bidir#concept:bidirectional_iterator "24.3.4.12 Concept bidirectional_­iterator [iterator.concept.bidir]") ([[iterator.concept.bidir]](iterator.concept.bidir "24.3.4.12 Concept bidirectional_­iterator")), ranges​::​rbegin(E) is expression-equivalent to make_reverse_iterator(ranges​::​end(t))[.](#rbegin-2.5.sentence-1)
+
+- [(2.6)](#rbegin-2.6)
+
+  Otherwise, ranges​::​rbegin(E) is ill-formed[.](#rbegin-2.6.sentence-1)
+
+[3](#rbegin-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L884)
+
+[*Note [1](#rbegin-note-1)*:
+
+Diagnosable ill-formed cases above result in substitution failure
+when ranges​::​rbegin(E) appears in the immediate context of a template instantiation[.](#rbegin-3.sentence-1)
+
+— *end note*]
+
+[4](#rbegin-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L891)
+
+[*Note [2](#rbegin-note-2)*:
+
+Whenever ranges​::​rbegin(E) is a valid expression, its type models[input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]")[.](#rbegin-4.sentence-1)
+
+— *end note*]
+
+### [25.3.7](#rend) ranges​::​rend [[range.access.rend]](range.access.rend)
+
+[1](#rend-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L900)
+
+The name ranges​::​rend denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#rend-1.sentence-1)
+
+[2](#rend-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L904)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#rend-2.sentence-1)
+
+Then:
+
+- [(2.1)](#rend-2.1)
+
+  If E is an rvalue and enable_borrowed_range<remove_cv_t<T>> is false, ranges​::​rend(E) is ill-formed[.](#rend-2.1.sentence-1)
+
+- [(2.2)](#rend-2.2)
+
+  Otherwise, if T is an array type ([[dcl.array]](dcl.array#term.array.type "9.3.4.5 Arrays")) and remove_all_extents_t<T> is an incomplete type, ranges​::​rend(E) is ill-formed with no diagnostic required[.](#rend-2.2.sentence-1)
+
+- [(2.3)](#rend-2.3)
+
+  Otherwise, if auto(t.rend()) is a valid expression whose type models [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<decltype(​ranges​::​rbegin(E))> then ranges​::​rend(E) is expression-equivalent to auto(t.rend())[.](#rend-2.3.sentence-1)
+
+- [(2.4)](#rend-2.4)
+
+  Otherwise, if T is a class or enumeration type and auto(rend(t)) is a valid expression whose type models [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<decltype(ranges​::​rbegin(E))> where the meaning of rend is established as-if by performing
+ argument-dependent lookup only ([[basic.lookup.argdep]](basic.lookup.argdep "6.5.4 Argument-dependent name lookup")),
+ then ranges​::​rend(E) is expression-equivalent to
+ that expression[.](#rend-2.4.sentence-1)
+
+- [(2.5)](#rend-2.5)
+
+  Otherwise, if both ranges​::​begin(t) and ranges​::​end(t) are valid expressions of the same type which models [bidirectional_iterator](iterator.concept.bidir#concept:bidirectional_iterator "24.3.4.12 Concept bidirectional_­iterator [iterator.concept.bidir]") ([[iterator.concept.bidir]](iterator.concept.bidir "24.3.4.12 Concept bidirectional_­iterator")),
+ then ranges​::​rend(E) is expression-equivalent to make_reverse_iterator(ranges​::​begin(t))[.](#rend-2.5.sentence-1)
+
+- [(2.6)](#rend-2.6)
+
+  Otherwise, ranges​::​rend(E) is ill-formed[.](#rend-2.6.sentence-1)
+
+[3](#rend-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L947)
+
+[*Note [1](#rend-note-1)*:
+
+Diagnosable ill-formed cases above
+result in substitution failure when ranges​::​rend(E) appears in the immediate context of a template instantiation[.](#rend-3.sentence-1)
+
+— *end note*]
+
+[4](#rend-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L954)
+
+[*Note [2](#rend-note-2)*:
+
+Whenever ranges​::​rend(E) is a valid expression,
+the types S and I of the expressionsranges​::​rend(E) and ranges​::​rbegin(E) model [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<S, I>[.](#rend-4.sentence-1)
+
+— *end note*]
+
+### [25.3.8](#crbegin) ranges​::​crbegin [[range.access.crbegin]](range.access.crbegin)
+
+[1](#crbegin-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L965)
+
+The name ranges​::​crbegin denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#crbegin-1.sentence-1)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#crbegin-1.sentence-2)
+
+Then:
+
+- [(1.1)](#crbegin-1.1)
+
+  If E is an rvalue andenable_borrowed_range<remove_cv_t<T>> is false,ranges​::​crbegin(E) is ill-formed[.](#crbegin-1.1.sentence-1)
+
+- [(1.2)](#crbegin-1.2)
+
+  Otherwise,
+let U be ranges​::​rbegin(*possibly-const-range*(t))[.](#crbegin-1.2.sentence-1)
+  ranges​::​crbegin(E) is expression-equivalent toconst_iterator<decltype(U)>(U)[.](#crbegin-1.2.sentence-2)
+
+[2](#crbegin-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L983)
+
+[*Note [1](#crbegin-note-1)*:
+
+Whenever ranges​::​crbegin(E) is a valid expression, its
+type models [input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]") and[*constant-iterator*](const.iterators.alias#concept:constant-iterator "24.5.3.2 Alias templates [const.iterators.alias]")[.](#crbegin-2.sentence-1)
+
+— *end note*]
+
+### [25.3.9](#crend) ranges​::​crend [[range.access.crend]](range.access.crend)
+
+[1](#crend-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L993)
+
+The name ranges​::​crend denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#crend-1.sentence-1)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#crend-1.sentence-2)
+
+Then:
+
+- [(1.1)](#crend-1.1)
+
+  If E is an rvalue andenable_borrowed_range<remove_cv_t<T>> is false,ranges​::​crend(E) is ill-formed[.](#crend-1.1.sentence-1)
+
+- [(1.2)](#crend-1.2)
+
+  Otherwise,
+let U be ranges​::​rend(*possibly-const-range*(t))[.](#crend-1.2.sentence-1)
+  ranges​::​crend(E) is expression-equivalent toconst_sentinel<decltype(U)>(U)[.](#crend-1.2.sentence-2)
+
+[2](#crend-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1011)
+
+[*Note [1](#crend-note-1)*:
+
+Whenever ranges​::​crend(E) is a valid expression,
+the types S and I of the expressionsranges​::​crend(E) and ranges​::​crbegin(E) model [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<S, I>[.](#crend-2.sentence-1)
+
+If S models [input_iterator](iterator.concept.input#concept:input_iterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]"),
+then S also models *constant-iterator*[.](#crend-2.sentence-2)
+
+— *end note*]
+
+### [25.3.10](#range.prim.size) ranges​::​size [[range.prim.size]](range.prim.size)
+
+[1](#range.prim.size-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1024)
+
+The name ranges​::​size denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#range.prim.size-1.sentence-1)
+
+[2](#range.prim.size-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1028)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#range.prim.size-2.sentence-1)
+
+Then:
+
+- [(2.1)](#range.prim.size-2.1)
+
+  If T is an array of unknown bound ([[dcl.array]](dcl.array#term.array.type "9.3.4.5 Arrays")), ranges​::​size(E) is ill-formed[.](#range.prim.size-2.1.sentence-1)
+
+- [(2.2)](#range.prim.size-2.2)
+
+  Otherwise, if T is an array type, ranges​::​size(E) is expression-equivalent to auto(extent_v<T>)[.](#range.prim.size-2.2.sentence-1)
+
+- [(2.3)](#range.prim.size-2.3)
+
+  Otherwise, if disable_sized_range<remove_cv_t<T>> ([[range.sized]](range.sized "25.4.4 Sized ranges"))
+ is false and auto(t.size()) is a valid expression of integer-like type ([[iterator.concept.winc]](iterator.concept.winc "24.3.4.4 Concept weakly_­incrementable")), ranges​::​size(E) is expression-equivalent to auto(​t.size())[.](#range.prim.size-2.3.sentence-1)
+
+- [(2.4)](#range.prim.size-2.4)
+
+  Otherwise, if T is a class or enumeration type, disable_sized_range<remove_cv_t<T>> is false and auto(size(t)) is a valid expression of integer-like type
+ where the meaning of size is established as-if by performing
+ argument-dependent lookup only ([[basic.lookup.argdep]](basic.lookup.argdep "6.5.4 Argument-dependent name lookup")),
+ then ranges​::​size(E) is expression-equivalent to
+ that expression[.](#range.prim.size-2.4.sentence-1)
+
+- [(2.5)](#range.prim.size-2.5)
+
+  Otherwise, if *to-unsigned-like*(ranges​::​end(t) - ranges​::​begin(t)) ([[ranges.syn]](ranges.syn "25.2 Header <ranges> synopsis"))
+ is a valid expression and
+ the types I and S of ranges​::​begin(t) and ranges​::​end(t) (respectively) model both [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<S, I> ([[iterator.concept.sizedsentinel]](iterator.concept.sizedsentinel "24.3.4.8 Concept sized_­sentinel_­for")) and [forward_iterator](iterator.concept.forward#concept:forward_iterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]")<I>,
+ then ranges​::​size(E) is expression-equivalent to *to-unsigned-like*(ranges​::​end(t) - ranges​::​begin(t))[.](#range.prim.size-2.5.sentence-1)
+
+- [(2.6)](#range.prim.size-2.6)
+
+  Otherwise, ranges​::​size(E) is ill-formed[.](#range.prim.size-2.6.sentence-1)
+
+[3](#range.prim.size-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1075)
+
+[*Note [1](#range.prim.size-note-1)*:
+
+Diagnosable ill-formed cases above
+result in substitution failure when ranges​::​size(E) appears in the immediate context of a template instantiation[.](#range.prim.size-3.sentence-1)
+
+— *end note*]
+
+[4](#range.prim.size-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1082)
+
+[*Note [2](#range.prim.size-note-2)*:
+
+Whenever ranges​::​size(E) is a valid expression, its
+type is integer-like[.](#range.prim.size-4.sentence-1)
+
+— *end note*]
+
+### [25.3.11](#range.prim.ssize) ranges​::​ssize [[range.prim.ssize]](range.prim.ssize)
+
+[1](#range.prim.ssize-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1091)
+
+The name ranges​::​ssize denotes
+a customization point object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#range.prim.ssize-1.sentence-1)
+
+[2](#range.prim.ssize-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1095)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#range.prim.ssize-2.sentence-1)
+
+If ranges​::​size(t) is ill-formed,ranges​::​ssize(E) is ill-formed[.](#range.prim.ssize-2.sentence-2)
+
+Otherwise let D be*make-signed-like-t*<decltype(ranges​::​​size(t))>, orptrdiff_t if it is wider than that type;ranges​::​ssize(E) is expression-equivalent tostatic_cast<D>(ranges​::​size(t))[.](#range.prim.ssize-2.sentence-3)
+
+### [25.3.12](#range.prim.size.hint) ranges​::​reserve_hint [[range.prim.size.hint]](range.prim.size.hint)
+
+[1](#range.prim.size.hint-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1109)
+
+The name ranges​::​reserve_hint denotes
+a customization point object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#range.prim.size.hint-1.sentence-1)
+
+[2](#range.prim.size.hint-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1113)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#range.prim.size.hint-2.sentence-1)
+
+Then:
+
+- [(2.1)](#range.prim.size.hint-2.1)
+
+  If ranges​::​size(E) is a valid expression,ranges​::​reserve_hint(E) is expression-equivalent toranges​::​size(E)[.](#range.prim.size.hint-2.1.sentence-1)
+
+- [(2.2)](#range.prim.size.hint-2.2)
+
+  Otherwise,
+if auto(t.reserve_hint()) is a valid expression of
+integer-like type ([[iterator.concept.winc]](iterator.concept.winc "24.3.4.4 Concept weakly_­incrementable")),ranges​::​reserve_hint(E) is expression-equivalent toauto(t.reserve_hint())[.](#range.prim.size.hint-2.2.sentence-1)
+
+- [(2.3)](#range.prim.size.hint-2.3)
+
+  Otherwise,
+if T is a class or enumeration type andauto(reserve_hint(t)) is a valid expression of
+integer-like type where
+the meaning of reserve_hint is established as-if by
+performing argument-dependent lookup only ([[basic.lookup.argdep]](basic.lookup.argdep "6.5.4 Argument-dependent name lookup")), thenranges​::​reserve_hint(E) is expression-equivalent to that expression[.](#range.prim.size.hint-2.3.sentence-1)
+
+- [(2.4)](#range.prim.size.hint-2.4)
+
+  Otherwise,ranges​::​reserve_hint(E) is ill-formed[.](#range.prim.size.hint-2.4.sentence-1)
+
+[*Note [1](#range.prim.size.hint-note-1)*:
+
+Diagnosable ill-formed cases above result in substitution failure whenranges​::​reserve_hint(E) appears in the immediate context of
+a template instantiation[.](#range.prim.size.hint-2.sentence-3)
+
+— *end note*]
+
+[*Note [2](#range.prim.size.hint-note-2)*:
+
+Whenever ranges​::​reserve_hint(E) is a valid expression,
+its type is integer-like[.](#range.prim.size.hint-2.sentence-4)
+
+— *end note*]
+
+### [25.3.13](#range.prim.empty) ranges​::​empty [[range.prim.empty]](range.prim.empty)
+
+[1](#range.prim.empty-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1153)
+
+The name ranges​::​empty denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#range.prim.empty-1.sentence-1)
+
+[2](#range.prim.empty-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1157)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#range.prim.empty-2.sentence-1)
+
+Then:
+
+- [(2.1)](#range.prim.empty-2.1)
+
+  If T is an array of unknown bound ([[dcl.array]](dcl.array#term.array.type "9.3.4.5 Arrays")), ranges​::​empty(E) is ill-formed[.](#range.prim.empty-2.1.sentence-1)
+
+- [(2.2)](#range.prim.empty-2.2)
+
+  Otherwise, if bool(t.empty()) is a valid expression, ranges​::​empty(E) is expression-equivalent to bool(t.empty())[.](#range.prim.empty-2.2.sentence-1)
+
+- [(2.3)](#range.prim.empty-2.3)
+
+  Otherwise, if (ranges​::​size(t) == 0) is a valid expression, ranges​::​empty(E) is expression-equivalent to (ranges​::​size(t) == 0)[.](#range.prim.empty-2.3.sentence-1)
+
+- [(2.4)](#range.prim.empty-2.4)
+
+  Otherwise, if bool(ranges​::​begin(t) == ranges​::​end(t)) is a valid expression and
+ the type of ranges​::​begin(t) models [forward_iterator](iterator.concept.forward#concept:forward_iterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]"), ranges​::​empty(E) is expression-equivalent to bool(​ranges​::​begin(t) == ranges​::​end(t))[.](#range.prim.empty-2.4.sentence-1)
+
+- [(2.5)](#range.prim.empty-2.5)
+
+  Otherwise, ranges​::​empty(E) is ill-formed[.](#range.prim.empty-2.5.sentence-1)
+
+[3](#range.prim.empty-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1187)
+
+[*Note [1](#range.prim.empty-note-1)*:
+
+Diagnosable ill-formed cases above
+result in substitution failure when ranges​::​empty(E) appears in the immediate context of a template instantiation[.](#range.prim.empty-3.sentence-1)
+
+— *end note*]
+
+[4](#range.prim.empty-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1194)
+
+[*Note [2](#range.prim.empty-note-2)*:
+
+Whenever ranges​::​empty(E) is a valid expression,
+it has type bool[.](#range.prim.empty-4.sentence-1)
+
+— *end note*]
+
+### [25.3.14](#range.prim.data) ranges​::​data [[range.prim.data]](range.prim.data)
+
+[1](#range.prim.data-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1203)
+
+The name ranges​::​data denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#range.prim.data-1.sentence-1)
+
+[2](#range.prim.data-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1207)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#range.prim.data-2.sentence-1)
+
+Then:
+
+- [(2.1)](#range.prim.data-2.1)
+
+  If E is an rvalue and enable_borrowed_range<remove_cv_t<T>> is false, ranges​::​data(E) is ill-formed[.](#range.prim.data-2.1.sentence-1)
+
+- [(2.2)](#range.prim.data-2.2)
+
+  Otherwise, if T is an array type ([[dcl.array]](dcl.array#term.array.type "9.3.4.5 Arrays")) and remove_all_extents_t<T> is an incomplete type, ranges​::​data(E) is ill-formed with no diagnostic required[.](#range.prim.data-2.2.sentence-1)
+
+- [(2.3)](#range.prim.data-2.3)
+
+  Otherwise, if auto(t.data()) is a valid expression of pointer to object type, ranges​::​data(E) is expression-equivalent to auto(t.data())[.](#range.prim.data-2.3.sentence-1)
+
+- [(2.4)](#range.prim.data-2.4)
+
+  Otherwise, if ranges​::​begin(t) is a valid expression whose type models [contiguous_iterator](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]"), ranges​::​data(E) is expression-equivalent to to_address(ranges​::​begin(t))[.](#range.prim.data-2.4.sentence-1)
+
+- [(2.5)](#range.prim.data-2.5)
+
+  Otherwise, ranges​::​data(E) is ill-formed[.](#range.prim.data-2.5.sentence-1)
+
+[3](#range.prim.data-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1239)
+
+[*Note [1](#range.prim.data-note-1)*:
+
+Diagnosable ill-formed cases above
+result in substitution failure when ranges​::​data(E) appears in the immediate context of a template instantiation[.](#range.prim.data-3.sentence-1)
+
+— *end note*]
+
+[4](#range.prim.data-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1246)
+
+[*Note [2](#range.prim.data-note-2)*:
+
+Whenever ranges​::​data(E) is a valid expression, it
+has pointer to object type[.](#range.prim.data-4.sentence-1)
+
+— *end note*]
+
+### [25.3.15](#range.prim.cdata) ranges​::​cdata [[range.prim.cdata]](range.prim.cdata)
+
+template<class T>constexpr auto *as-const-pointer*(const T* p) noexcept { return p; } // *exposition only*
+
+[1](#range.prim.cdata-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1260)
+
+The name ranges​::​cdata denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#range.prim.cdata-1.sentence-1)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#range.prim.cdata-1.sentence-2)
+
+Then:
+
+- [(1.1)](#range.prim.cdata-1.1)
+
+  If E is an rvalue andenable_borrowed_range<remove_cv_t<T>> is false,ranges​::​cdata(E) is ill-formed[.](#range.prim.cdata-1.1.sentence-1)
+
+- [(1.2)](#range.prim.cdata-1.2)
+
+  Otherwise,ranges​::​cdata(E) is expression-equivalent to*as-const-pointer*(ranges​::​data(*possibly-const-range*(t)))[.](#range.prim.cdata-1.2.sentence-1)
+
+[2](#range.prim.cdata-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1277)
+
+[*Note [1](#range.prim.cdata-note-1)*:
+
+Whenever ranges​::​cdata(E) is a valid expression, it
+has pointer to constant object type[.](#range.prim.cdata-2.sentence-1)
+
+— *end note*]

cppdraft/range/access/begin.md

@@ -0,0 +1,71 @@
+[range.access.begin]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.3 Range access [[range.access]](range.access#begin)
+
+### 25.3.2 ranges​::​begin [range.access.begin]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L652)
+
+The name ranges​::​begin denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L656)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#2.sentence-1)
+
+Then:
+
+- [(2.1)](#2.1)
+
+  If E is an rvalue and enable_borrowed_range<remove_cv_t<T>> is false, ranges​::​begin(E) is ill-formed[.](#2.1.sentence-1)
+
+- [(2.2)](#2.2)
+
+  Otherwise, if T is an array type ([[dcl.array]](dcl.array#term.array.type "9.3.4.5 Arrays")) and remove_all_extents_t<T> is an incomplete type, ranges​::​begin(E) is ill-formed with no diagnostic required[.](#2.2.sentence-1)
+
+- [(2.3)](#2.3)
+
+  Otherwise, if T is an array type, ranges​::​begin(E) is expression-equivalent to t + 0[.](#2.3.sentence-1)
+
+- [(2.4)](#2.4)
+
+  Otherwise, if auto(t.begin()) is a valid expression whose type models [input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]"), ranges​::​begin(E) is expression-equivalent to auto(t.begin())[.](#2.4.sentence-1)
+
+- [(2.5)](#2.5)
+
+  Otherwise, if T is a class or enumeration type and auto(begin(t)) is a valid expression whose type models [input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]") where the meaning of begin is established as-if by performing
+ argument-dependent lookup only ([[basic.lookup.argdep]](basic.lookup.argdep "6.5.4 Argument-dependent name lookup")),
+ then ranges​::​begin(E) is expression-equivalent to
+ that expression[.](#2.5.sentence-1)
+
+- [(2.6)](#2.6)
+
+  Otherwise, ranges​::​begin(E) is ill-formed[.](#2.6.sentence-1)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L696)
+
+[*Note [1](#note-1)*:
+
+Diagnosable ill-formed cases above
+result in substitution failure when ranges​::​begin(E) appears in the immediate context of a template instantiation[.](#3.sentence-1)
+
+— *end note*]
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L703)
+
+[*Note [2](#note-2)*:
+
+Whenever ranges​::​begin(E) is a valid expression, its type models[input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]")[.](#4.sentence-1)
+
+— *end note*]

cppdraft/range/access/cbegin.md

@@ -0,0 +1,39 @@
+[range.access.cbegin]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.3 Range access [[range.access]](range.access#cbegin)
+
+### 25.3.4 ranges​::​cbegin [range.access.cbegin]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L779)
+
+The name ranges​::​cbegin denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#1.sentence-1)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#1.sentence-2)
+
+Then:
+
+- [(1.1)](#1.1)
+
+  If E is an rvalue andenable_borrowed_range<remove_cv_t<T>> is false,ranges​::​cbegin(E) is ill-formed[.](#1.1.sentence-1)
+
+- [(1.2)](#1.2)
+
+  Otherwise,
+let U be ranges​::​begin(*possibly-const-range*(t))[.](#1.2.sentence-1)
+  ranges​::​cbegin(E) is expression-equivalent toconst_iterator<decltype(U)>(U)[.](#1.2.sentence-2)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L797)
+
+[*Note [1](#note-1)*:
+
+Whenever ranges​::​cbegin(E) is a valid expression, its type models[input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]") and [*constant-iterator*](const.iterators.alias#concept:constant-iterator "24.5.3.2 Alias templates [const.iterators.alias]")[.](#2.sentence-1)
+
+— *end note*]

cppdraft/range/access/cend.md

@@ -0,0 +1,43 @@
+[range.access.cend]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.3 Range access [[range.access]](range.access#cend)
+
+### 25.3.5 ranges​::​cend [range.access.cend]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L806)
+
+The name ranges​::​cend denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#1.sentence-1)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#1.sentence-2)
+
+Then:
+
+- [(1.1)](#1.1)
+
+  If E is an rvalue andenable_borrowed_range<remove_cv_t<T>> is false,ranges​::​cend(E) is ill-formed[.](#1.1.sentence-1)
+
+- [(1.2)](#1.2)
+
+  Otherwise,
+let U be ranges​::​end(*possibly-const-range*(t))[.](#1.2.sentence-1)
+  ranges​::​cend(E) is expression-equivalent toconst_sentinel<decltype(U)>(U)[.](#1.2.sentence-2)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L824)
+
+[*Note [1](#note-1)*:
+
+Whenever ranges​::​cend(E) is a valid expression,
+the types S and I of the expressionsranges​::​cend(E) and ranges​::​cbegin(E) model [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<S, I>[.](#2.sentence-1)
+
+If S models [input_iterator](iterator.concept.input#concept:input_iterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]"),
+then S also models *constant-iterator*[.](#2.sentence-2)
+
+— *end note*]

cppdraft/range/access/crbegin.md

@@ -0,0 +1,40 @@
+[range.access.crbegin]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.3 Range access [[range.access]](range.access#crbegin)
+
+### 25.3.8 ranges​::​crbegin [range.access.crbegin]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L965)
+
+The name ranges​::​crbegin denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#1.sentence-1)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#1.sentence-2)
+
+Then:
+
+- [(1.1)](#1.1)
+
+  If E is an rvalue andenable_borrowed_range<remove_cv_t<T>> is false,ranges​::​crbegin(E) is ill-formed[.](#1.1.sentence-1)
+
+- [(1.2)](#1.2)
+
+  Otherwise,
+let U be ranges​::​rbegin(*possibly-const-range*(t))[.](#1.2.sentence-1)
+  ranges​::​crbegin(E) is expression-equivalent toconst_iterator<decltype(U)>(U)[.](#1.2.sentence-2)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L983)
+
+[*Note [1](#note-1)*:
+
+Whenever ranges​::​crbegin(E) is a valid expression, its
+type models [input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]") and[*constant-iterator*](const.iterators.alias#concept:constant-iterator "24.5.3.2 Alias templates [const.iterators.alias]")[.](#2.sentence-1)
+
+— *end note*]

cppdraft/range/access/crend.md

@@ -0,0 +1,43 @@
+[range.access.crend]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.3 Range access [[range.access]](range.access#crend)
+
+### 25.3.9 ranges​::​crend [range.access.crend]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L993)
+
+The name ranges​::​crend denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#1.sentence-1)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#1.sentence-2)
+
+Then:
+
+- [(1.1)](#1.1)
+
+  If E is an rvalue andenable_borrowed_range<remove_cv_t<T>> is false,ranges​::​crend(E) is ill-formed[.](#1.1.sentence-1)
+
+- [(1.2)](#1.2)
+
+  Otherwise,
+let U be ranges​::​rend(*possibly-const-range*(t))[.](#1.2.sentence-1)
+  ranges​::​crend(E) is expression-equivalent toconst_sentinel<decltype(U)>(U)[.](#1.2.sentence-2)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1011)
+
+[*Note [1](#note-1)*:
+
+Whenever ranges​::​crend(E) is a valid expression,
+the types S and I of the expressionsranges​::​crend(E) and ranges​::​crbegin(E) model [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<S, I>[.](#2.sentence-1)
+
+If S models [input_iterator](iterator.concept.input#concept:input_iterator "24.3.4.9 Concept input_­iterator [iterator.concept.input]"),
+then S also models *constant-iterator*[.](#2.sentence-2)
+
+— *end note*]

cppdraft/range/access/end.md

@@ -0,0 +1,76 @@
+[range.access.end]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.3 Range access [[range.access]](range.access#end)
+
+### 25.3.3 ranges​::​end [range.access.end]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L712)
+
+The name ranges​::​end denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L716)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#2.sentence-1)
+
+Then:
+
+- [(2.1)](#2.1)
+
+  If E is an rvalue and enable_borrowed_range<remove_cv_t<T>> is false, ranges​::​end(E) is ill-formed[.](#2.1.sentence-1)
+
+- [(2.2)](#2.2)
+
+  Otherwise, if T is an array type ([[dcl.array]](dcl.array#term.array.type "9.3.4.5 Arrays")) and remove_all_extents_t<T> is an incomplete type, ranges​::​end(E) is ill-formed with no diagnostic required[.](#2.2.sentence-1)
+
+- [(2.3)](#2.3)
+
+  Otherwise, if T is an array of unknown bound, ranges​::​end(E) is ill-formed[.](#2.3.sentence-1)
+
+- [(2.4)](#2.4)
+
+  Otherwise, if T is an array, ranges​::​end(E) is expression-equivalent to t + extent_v<T>[.](#2.4.sentence-1)
+
+- [(2.5)](#2.5)
+
+  Otherwise, if auto(t.end()) is a valid expression whose type models [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<iterator_t<T>> then ranges​::​end(E) is expression-equivalent to auto(t.end())[.](#2.5.sentence-1)
+
+- [(2.6)](#2.6)
+
+  Otherwise, if T is a class or enumeration type and auto(end(t)) is a valid expression whose type models [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<iterator_t<T>> where the meaning of end is established as-if by performing
+ argument-dependent lookup only ([[basic.lookup.argdep]](basic.lookup.argdep "6.5.4 Argument-dependent name lookup")),
+ then ranges​::​end(E) is expression-equivalent to
+ that expression[.](#2.6.sentence-1)
+
+- [(2.7)](#2.7)
+
+  Otherwise, ranges​::​end(E) is ill-formed[.](#2.7.sentence-1)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L761)
+
+[*Note [1](#note-1)*:
+
+Diagnosable ill-formed cases above
+result in substitution failure when ranges​::​end(E) appears in the immediate context of a template instantiation[.](#3.sentence-1)
+
+— *end note*]
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L768)
+
+[*Note [2](#note-2)*:
+
+Whenever ranges​::​end(E) is a valid expression,
+the types S and I ofranges​::​end(E) and ranges​::​begin(E) model [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<S, I>[.](#4.sentence-1)
+
+— *end note*]

cppdraft/range/access/general.md

@@ -0,0 +1,30 @@
+[range.access.general]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.3 Range access [[range.access]](range.access#general)
+
+### 25.3.1 General [range.access.general]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L633)
+
+In addition to being available via inclusion of the [<ranges>](ranges.syn#header:%3cranges%3e "25.2 Header <ranges> synopsis [ranges.syn]") header, the customization point objects in [[range.access]](range.access "25.3 Range access") are
+available when the header [<iterator>](iterator.synopsis#header:%3citerator%3e "24.2 Header <iterator>&nbsp;synopsis [iterator.synopsis]") is included[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L638)
+
+Within [[range.access]](range.access "25.3 Range access"),
+the [*reified object*](#def:object,reified "25.3.1 General [range.access.general]") of a subexpression E denotes
+
+- [(2.1)](#2.1)
+
+the same object as E if E is a glvalue, or
+
+- [(2.2)](#2.2)
+
+the result of applying
+the temporary materialization conversion ([[conv.rval]](conv.rval "7.3.5 Temporary materialization conversion")) to E otherwise[.](#2.sentence-1)

cppdraft/range/access/rbegin.md

@@ -0,0 +1,71 @@
+[range.access.rbegin]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.3 Range access [[range.access]](range.access#rbegin)
+
+### 25.3.6 ranges​::​rbegin [range.access.rbegin]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L837)
+
+The name ranges​::​rbegin denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L841)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#2.sentence-1)
+
+Then:
+
+- [(2.1)](#2.1)
+
+  If E is an rvalue and enable_borrowed_range<remove_cv_t<T>> is false, ranges​::​rbegin(E) is ill-formed[.](#2.1.sentence-1)
+
+- [(2.2)](#2.2)
+
+  Otherwise, if T is an array type ([[dcl.array]](dcl.array#term.array.type "9.3.4.5 Arrays")) and remove_all_extents_t<T> is an incomplete type, ranges​::​rbegin(E) is ill-formed with no diagnostic required[.](#2.2.sentence-1)
+
+- [(2.3)](#2.3)
+
+  Otherwise, if auto(t.rbegin()) is a valid expression whose type models [input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]"), ranges​::​rbegin(E) is expression-equivalent to auto(t.rbegin())[.](#2.3.sentence-1)
+
+- [(2.4)](#2.4)
+
+  Otherwise, if T is a class or enumeration type and auto(rbegin(t)) is a valid expression whose type models [input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]") where the meaning of rbegin is established as-if by performing
+ argument-dependent lookup only ([[basic.lookup.argdep]](basic.lookup.argdep "6.5.4 Argument-dependent name lookup")),
+ then ranges​::​rbegin(E) is expression-equivalent to
+ that expression[.](#2.4.sentence-1)
+
+- [(2.5)](#2.5)
+
+  Otherwise, if both ranges​::​begin(t) and ranges​::​end(t) are valid expressions of the same type which models [bidirectional_iterator](iterator.concept.bidir#concept:bidirectional_iterator "24.3.4.12 Concept bidirectional_­iterator [iterator.concept.bidir]") ([[iterator.concept.bidir]](iterator.concept.bidir "24.3.4.12 Concept bidirectional_­iterator")), ranges​::​rbegin(E) is expression-equivalent to make_reverse_iterator(ranges​::​end(t))[.](#2.5.sentence-1)
+
+- [(2.6)](#2.6)
+
+  Otherwise, ranges​::​rbegin(E) is ill-formed[.](#2.6.sentence-1)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L884)
+
+[*Note [1](#note-1)*:
+
+Diagnosable ill-formed cases above result in substitution failure
+when ranges​::​rbegin(E) appears in the immediate context of a template instantiation[.](#3.sentence-1)
+
+— *end note*]
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L891)
+
+[*Note [2](#note-2)*:
+
+Whenever ranges​::​rbegin(E) is a valid expression, its type models[input_or_output_iterator](iterator.concept.iterator#concept:input_or_output_iterator "24.3.4.6 Concept input_­or_­output_­iterator [iterator.concept.iterator]")[.](#4.sentence-1)
+
+— *end note*]

cppdraft/range/access/rend.md

@@ -0,0 +1,73 @@
+[range.access.rend]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.3 Range access [[range.access]](range.access#rend)
+
+### 25.3.7 ranges​::​rend [range.access.rend]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L900)
+
+The name ranges​::​rend denotes a customization point
+object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L904)
+
+Given a subexpression E with type T,
+let t be an lvalue that denotes the reified object for E[.](#2.sentence-1)
+
+Then:
+
+- [(2.1)](#2.1)
+
+  If E is an rvalue and enable_borrowed_range<remove_cv_t<T>> is false, ranges​::​rend(E) is ill-formed[.](#2.1.sentence-1)
+
+- [(2.2)](#2.2)
+
+  Otherwise, if T is an array type ([[dcl.array]](dcl.array#term.array.type "9.3.4.5 Arrays")) and remove_all_extents_t<T> is an incomplete type, ranges​::​rend(E) is ill-formed with no diagnostic required[.](#2.2.sentence-1)
+
+- [(2.3)](#2.3)
+
+  Otherwise, if auto(t.rend()) is a valid expression whose type models [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<decltype(​ranges​::​rbegin(E))> then ranges​::​rend(E) is expression-equivalent to auto(t.rend())[.](#2.3.sentence-1)
+
+- [(2.4)](#2.4)
+
+  Otherwise, if T is a class or enumeration type and auto(rend(t)) is a valid expression whose type models [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<decltype(ranges​::​rbegin(E))> where the meaning of rend is established as-if by performing
+ argument-dependent lookup only ([[basic.lookup.argdep]](basic.lookup.argdep "6.5.4 Argument-dependent name lookup")),
+ then ranges​::​rend(E) is expression-equivalent to
+ that expression[.](#2.4.sentence-1)
+
+- [(2.5)](#2.5)
+
+  Otherwise, if both ranges​::​begin(t) and ranges​::​end(t) are valid expressions of the same type which models [bidirectional_iterator](iterator.concept.bidir#concept:bidirectional_iterator "24.3.4.12 Concept bidirectional_­iterator [iterator.concept.bidir]") ([[iterator.concept.bidir]](iterator.concept.bidir "24.3.4.12 Concept bidirectional_­iterator")),
+ then ranges​::​rend(E) is expression-equivalent to make_reverse_iterator(ranges​::​begin(t))[.](#2.5.sentence-1)
+
+- [(2.6)](#2.6)
+
+  Otherwise, ranges​::​rend(E) is ill-formed[.](#2.6.sentence-1)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L947)
+
+[*Note [1](#note-1)*:
+
+Diagnosable ill-formed cases above
+result in substitution failure when ranges​::​rend(E) appears in the immediate context of a template instantiation[.](#3.sentence-1)
+
+— *end note*]
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L954)
+
+[*Note [2](#note-2)*:
+
+Whenever ranges​::​rend(E) is a valid expression,
+the types S and I of the expressionsranges​::​rend(E) and ranges​::​rbegin(E) model [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<S, I>[.](#4.sentence-1)
+
+— *end note*]

cppdraft/range/adaptor/helpers.md

@@ -0,0 +1,9 @@
+[range.adaptor.helpers]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.adaptor.helpers)
+
+### 25.7.5 Range adaptor helpers [range.adaptor.helpers]
+
+namespace std::ranges {template<class F, class Tuple>constexpr auto *tuple-transform*(F&& f, Tuple&& t) { // *exposition only*return apply([&]<class... Ts>(Ts&&... elements) {return tuple<invoke_result_t<F&, Ts>...>(invoke(f, std::forward<Ts>(elements))...); }, std::forward<Tuple>(t)); }template<class F, class Tuple>constexpr void *tuple-for-each*(F&& f, Tuple&& t) { // *exposition only* apply([&]<class... Ts>(Ts&&... elements) {(static_cast<void>(invoke(f, std::forward<Ts>(elements))), ...); }, std::forward<Tuple>(t)); }template<class T>constexpr T& *as-lvalue*(T&& t) { // *exposition only*return static_cast<T&>(t); }template<bool Const, class... Views>concept [*all-random-access*](#concept:all-random-access "25.7.5 Range adaptor helpers [range.adaptor.helpers]") = // *exposition only*([random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*maybe-const*<Const, Views>> && ...); template<bool Const, class... Views>concept [*all-bidirectional*](#concept:all-bidirectional "25.7.5 Range adaptor helpers [range.adaptor.helpers]") = // *exposition only*([bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<*maybe-const*<Const, Views>> && ...); template<bool Const, class... Views>concept [*all-forward*](#concept:all-forward "25.7.5 Range adaptor helpers [range.adaptor.helpers]") = // *exposition only*([forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<*maybe-const*<Const, Views>> && ...);}

cppdraft/range/adaptor/object.md

@@ -0,0 +1,141 @@
+[range.adaptor.object]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.adaptor.object)
+
+### 25.7.2 Range adaptor objects [range.adaptor.object]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4206)
+
+A [*range adaptor closure object*](#def:range_adaptor_closure_object) is a unary function object that accepts
+a range argument[.](#1.sentence-1)
+
+For
+a range adaptor closure object C and an expression R such thatdecltype((R)) models [range](range.range#concept:range "25.4.2 Ranges [range.range]"), the following
+expressions are equivalent:C(R) R | C
+
+Given an additional range adaptor closure object D,
+the expression C | D produces another range adaptor
+closure object E[.](#1.sentence-3)
+
+E is a perfect forwarding call wrapper ([[func.require]](func.require#term.perfect.forwarding.call.wrapper "22.10.4 Requirements"))
+with the following properties:
+
+- [(1.1)](#1.1)
+
+  Its target object is an object d of type decay_t<decltype((D))> direct-non-list-initialized with D[.](#1.1.sentence-1)
+
+- [(1.2)](#1.2)
+
+  It has one bound argument entity,
+an object c of type decay_t<decltype((C))> direct-non-list-initialized with C[.](#1.2.sentence-1)
+
+- [(1.3)](#1.3)
+
+  Its call pattern is d(c(arg)),
+where arg is the argument used in
+a function call expression of E[.](#1.3.sentence-1)
+
+The expression C | D is well-formed if and only if
+the initializations of the state entities of E are all well-formed[.](#1.sentence-5)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4237)
+
+Given an object t of type T, where
+
+- [(2.1)](#2.1)
+
+t is a unary function object that accepts a range argument,
+
+- [(2.2)](#2.2)
+
+T models [derived_from](concept.derived#concept:derived_from "18.4.3 Concept derived_­from [concept.derived]")<range_adaptor_closure<T>>,
+
+- [(2.3)](#2.3)
+
+T has no other base classes of type range_adaptor_closure<U> for any other type U, and
+
+- [(2.4)](#2.4)
+
+T does not model [range](range.range#concept:range "25.4.2 Ranges [range.range]")
+
+then the implementation ensures
+that t is a range adaptor closure object[.](#2.sentence-1)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4252)
+
+The template parameter D for range_adaptor_closure may be an incomplete type[.](#3.sentence-1)
+
+If an expression of type cv D is used as an operand to the | operator,D shall be complete and
+model [derived_from](concept.derived#concept:derived_from "18.4.3 Concept derived_­from [concept.derived]")<range_adaptor_closure<D>>[.](#3.sentence-2)
+
+The behavior of an expression involving an object of type cv D as an operand to the | operator is undefined
+if overload resolution selects a program-defined operator| function[.](#3.sentence-3)
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4263)
+
+If an expression of type cv U is used as an operand to the | operator,
+where U has a base class of type range_adaptor_closure<T> for some type T other than U, the behavior is undefined[.](#4.sentence-1)
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4269)
+
+The behavior of a program
+that adds a specialization for range_adaptor_closure is undefined[.](#5.sentence-1)
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4273)
+
+A [*range adaptor object*](#def:range_adaptor_object) is a
+customization point object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))
+that accepts a [viewable_range](range.refinements#concept:viewable_range "25.4.6 Other range refinements [range.refinements]") as its first argument and returns a view[.](#6.sentence-1)
+
+[7](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4278)
+
+If a range adaptor object accepts only one argument,
+then it is a range adaptor closure object[.](#7.sentence-1)
+
+[8](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4282)
+
+If a range adaptor object adaptor accepts more than one argument,
+then let range be an expression
+such that decltype((range)) models [viewable_range](range.refinements#concept:viewable_range "25.4.6 Other range refinements [range.refinements]"),
+let args... be arguments
+such that adaptor(range, args...) is a well-formed expression
+as specified in the rest of subclause [[range.adaptors]](range.adaptors "25.7 Range adaptors"), and
+let BoundArgs be a pack
+that denotes decay_t<decltype((args))>...[.](#8.sentence-1)
+
+The expression adaptor(args...) produces a range adaptor closure object f that is a perfect forwarding call wrapper ([[func.require]](func.require#term.perfect.forwarding.call.wrapper "22.10.4 Requirements")) with the following properties:
+
+- [(8.1)](#8.1)
+
+  Its target object is a copy of adaptor[.](#8.1.sentence-1)
+
+- [(8.2)](#8.2)
+
+  Its bound argument entities bound_args consist of objects of types BoundArgs... direct-non-list-initialized with std​::​forward<decltype((args))>(args)..., respectively[.](#8.2.sentence-1)
+
+- [(8.3)](#8.3)
+
+  Its call pattern is adaptor(r, bound_args...),
+where r is the argument used in a function call expression of f[.](#8.3.sentence-1)
+
+The expression adaptor(args...) is well-formed if and only if
+the initialization of the bound argument entities of the result,
+as specified above, are all well-formed[.](#8.sentence-3)

cppdraft/range/adaptors/general.md

@@ -0,0 +1,40 @@
+[range.adaptors.general]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#general)
+
+### 25.7.1 General [range.adaptors.general]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4177)
+
+Subclause [[range.adaptors]](range.adaptors "25.7 Range adaptors") defines [*range adaptors*](#def:range_adaptors), which are utilities that transform a
+range into a view with custom behaviors[.](#1.sentence-1)
+
+These
+adaptors can be chained to create pipelines of range transformations that
+evaluate lazily as the resulting view is iterated[.](#1.sentence-2)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4183)
+
+Range adaptors are declared in namespace std​::​ranges​::​views[.](#2.sentence-1)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4186)
+
+The bitwise or operator is overloaded for the purpose of creating adaptor chain
+pipelines[.](#3.sentence-1)
+
+The adaptors also support function call syntax with equivalent
+semantics[.](#3.sentence-2)
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4191)
+
+[*Example [1](#example-1)*: vector<int> ints{0,1,2,3,4,5};auto even = [](int i) { return 0 == i % 2; };auto square = [](int i) { return i * i; };for (int i : ints | views::filter(even) | views::transform(square)) { cout << i << ' '; // prints 0 4 16} assert(ranges::equal(ints | views::filter(even), views::filter(ints, even))); — *end example*]

cppdraft/range/adjacent.md

@@ -0,0 +1,532 @@
+[range.adjacent]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.adjacent)
+
+### 25.7.27 Adjacent view [range.adjacent]
+
+#### [25.7.27.1](#overview) Overview [[range.adjacent.overview]](range.adjacent.overview)
+
+[1](#overview-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12539)
+
+adjacent_view takes a view and
+produces a view whose Mth element is
+a tuple of references to
+the Mth through (M+N−1)th elements of
+the original view[.](#overview-1.sentence-1)
+
+If the original view has fewer than N elements, the resulting view is empty[.](#overview-1.sentence-2)
+
+[2](#overview-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12547)
+
+The name views​::​adjacent<N> denotes
+a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#overview-2.sentence-1)
+
+Given a subexpression E and a constant expression N,
+the expression views​::​adjacent<N>(E) is expression-equivalent to
+
+- [(2.1)](#overview-2.1)
+
+((void)E, auto(views​::​empty<tuple<>>)) if N is equal to 0 anddecltype((E)) models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]"),
+
+- [(2.2)](#overview-2.2)
+
+otherwise, adjacent_view<views​::​all_t<decltype((E))>, N>(E)[.](#overview-2.sentence-2)
+
+[*Example [1](#overview-example-1)*: vector v = {1, 2, 3, 4};
+
+for (auto i : v | views::adjacent<2>) { cout << "(" << std::get<0>(i) << ", " << std::get<1>(i) << ") "; // prints (1, 2) (2, 3) (3, 4)} — *end example*]
+
+[3](#overview-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12572)
+
+Define *REPEAT*(T, N) as a pack of N types,
+each of which denotes the same type as T[.](#overview-3.sentence-1)
+
+#### [25.7.27.2](#view) Class template adjacent_view [[range.adjacent.view]](range.adjacent.view)
+
+[🔗](#lib:adjacent_view)
+
+namespace std::ranges {template<[forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") V, size_t N>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && (N > 0)class adjacent_view : public view_interface<adjacent_view<V, N>> { V *base_* = V(); // *exposition only*// [[range.adjacent.iterator]](#iterator "25.7.27.3 Class template adjacent_­view​::​iterator"), class template adjacent_view​::​*iterator*template<bool> class *iterator*; // *exposition only*// [[range.adjacent.sentinel]](#sentinel "25.7.27.4 Class template adjacent_­view​::​sentinel"), class template adjacent_view​::​*sentinel*template<bool> class *sentinel*; // *exposition only*struct *as-sentinel*{}; // *exposition only*public: adjacent_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> = default; constexpr explicit adjacent_view(V base); 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() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) {return *iterator*<false>(ranges::begin(*base_*), ranges::end(*base_*)); }constexpr auto begin() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V> {return *iterator*<true>(ranges::begin(*base_*), ranges::end(*base_*)); }constexpr auto end() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) {if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<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](range.range#concept:range "25.4.2 Ranges [range.range]")<const V> {if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<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](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>; constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>; constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>; constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>; };}
+
+[🔗](#lib:adjacent_view,constructor)
+
+`constexpr explicit adjacent_view(V base);
+`
+
+[1](#view-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12642)
+
+*Effects*: Initializes *base_* with std​::​move(base)[.](#view-1.sentence-1)
+
+[🔗](#lib:size,adjacent_view)
+
+`constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>;
+constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>;
+`
+
+[2](#view-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12654)
+
+*Effects*: Equivalent to:using ST = decltype(ranges::size(*base_*));using CT = common_type_t<ST, size_t>;auto sz = static_cast<CT>(ranges::size(*base_*));
+sz -= std::min<CT>(sz, N - 1);return static_cast<ST>(sz);
+
+[🔗](#lib:reserve_hint,adjacent_view)
+
+`constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>;
+constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>;
+`
+
+[3](#view-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12673)
+
+*Effects*: Equivalent to:using DT = range_difference_t<decltype((*base_*))>;using CT = common_type_t<DT, size_t>;auto sz = static_cast<CT>(ranges::reserve_hint(*base_*));
+sz -= std::min<CT>(sz, N - 1);return *to-unsigned-like*(sz);
+
+#### [25.7.27.3](#iterator) Class template adjacent_view​::​*iterator* [[range.adjacent.iterator]](range.adjacent.iterator)
+
+[🔗](#lib:adjacent_view::iterator)
+
+namespace std::ranges {template<[forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") V, size_t N>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && (N > 0)template<bool Const>class adjacent_view<V, N>::*iterator* {using *Base* = *maybe-const*<Const, V>; // *exposition only* array<iterator_t<*Base*>, N> *current_* = array<iterator_t<*Base*>, N>(); // *exposition only*constexpr *iterator*(iterator_t<*Base*> first, sentinel_t<*Base*> last); // *exposition only*constexpr *iterator*(*as-sentinel*, iterator_t<*Base*> first, iterator_t<*Base*> last); // *exposition only*public:using iterator_category = input_iterator_tag; using iterator_concept = *see below*; using value_type = tuple<*REPEAT*(range_value_t<*Base*>, N)...>; using difference_type = range_difference_t<*Base*>; *iterator*() = default; constexpr *iterator*(*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 auto operator*() const; constexpr *iterator*& operator++(); constexpr *iterator* operator++(int); constexpr *iterator*& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr *iterator* operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr *iterator*& operator+=(difference_type x)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr *iterator*& operator-=(difference_type x)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr auto operator[](difference_type n) constrequires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr bool operator==(const *iterator*& x, const *iterator*& y); friend constexpr bool operator<(const *iterator*& x, const *iterator*& y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr bool operator>(const *iterator*& x, const *iterator*& y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr bool operator<=(const *iterator*& x, const *iterator*& y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr bool operator>=(const *iterator*& x, const *iterator*& y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr auto operator<=>(const *iterator*& x, const *iterator*& y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*> &&[three_way_comparable](cmp.concept#concept:three_way_comparable "17.12.4 Concept three_­way_­comparable [cmp.concept]")<iterator_t<*Base*>>; friend constexpr *iterator* operator+(const *iterator*& i, difference_type n)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr *iterator* operator+(difference_type n, const *iterator*& i)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr *iterator* operator-(const *iterator*& i, difference_type n)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr difference_type operator-(const *iterator*& x, const *iterator*& y)requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<iterator_t<*Base*>, iterator_t<*Base*>>; friend constexpr auto iter_move(const *iterator*& i) noexcept(*see below*); friend constexpr void iter_swap(const *iterator*& l, const *iterator*& r) noexcept(*see below*)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](#iterator-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12753)
+
+*iterator*​::​iterator_concept is defined as follows:
+
+- [(1.1)](#iterator-1.1)
+
+  If *Base* models [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]"),
+then iterator_concept denotes random_access_iterator_tag[.](#iterator-1.1.sentence-1)
+
+- [(1.2)](#iterator-1.2)
+
+  Otherwise, if *Base* models [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]"),
+then iterator_concept denotes bidirectional_iterator_tag[.](#iterator-1.2.sentence-1)
+
+- [(1.3)](#iterator-1.3)
+
+  Otherwise, iterator_concept denotes forward_iterator_tag[.](#iterator-1.3.sentence-1)
+
+[2](#iterator-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12766)
+
+If the invocation of any non-const member function of *iterator* exits via an exception, the *iterator* acquires a singular value[.](#iterator-2.sentence-1)
+
+[🔗](#lib:adjacent_view::iterator,constructor)
+
+`constexpr iterator(iterator_t<Base> first, sentinel_t<Base> last);
+`
+
+[3](#iterator-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12776)
+
+*Postconditions*: *current_*[0] == first is true, and
+for every integer 1≤i<N,*current_*[i] == ranges​::​next(*current_*[i-1], 1, last) is true[.](#iterator-3.sentence-1)
+
+[🔗](#lib:adjacent_view::iterator,constructor_)
+
+`constexpr iterator(as-sentinel, iterator_t<Base> first, iterator_t<Base> last);
+`
+
+[4](#iterator-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12790)
+
+*Postconditions*: If *Base* does not model [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]"),
+each element of *current_* is equal to *last*[.](#iterator-4.sentence-1)
+
+Otherwise, *current_*[N-1] == last is true, and
+for every integer 0≤i<(N−1),*current_*[i] == ranges​::​prev(*current_*[i+1], 1, first) is true[.](#iterator-4.sentence-2)
+
+[🔗](#lib:adjacent_view::iterator,constructor__)
+
+`constexpr iterator(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>>;
+`
+
+[5](#iterator-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12807)
+
+*Effects*: Initializes each element of *current_* with the corresponding element of i.*current_* as an xvalue[.](#iterator-5.sentence-1)
+
+[🔗](#lib:operator*,adjacent_view::iterator)
+
+`constexpr auto operator*() const;
+`
+
+[6](#iterator-6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12819)
+
+*Effects*: Equivalent to:return *tuple-transform*([](auto& i) -> decltype(auto) { return *i; }, *current_*);
+
+[🔗](#lib:operator++,adjacent_view::iterator)
+
+`constexpr iterator& operator++();
+`
+
+[7](#iterator-7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12833)
+
+*Preconditions*: *current_*.back() is incrementable[.](#iterator-7.sentence-1)
+
+[8](#iterator-8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12837)
+
+*Postconditions*: Each element of *current_* is equal to ranges​::​next(i),
+where i is the value of that element before the call[.](#iterator-8.sentence-1)
+
+[9](#iterator-9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12842)
+
+*Returns*: *this[.](#iterator-9.sentence-1)
+
+[🔗](#lib:operator++,adjacent_view::iterator_)
+
+`constexpr iterator operator++(int);
+`
+
+[10](#iterator-10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12853)
+
+*Effects*: Equivalent to:auto tmp = *this;++*this;return tmp;
+
+[🔗](#lib:operator--,adjacent_view::iterator)
+
+`constexpr iterator& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[11](#iterator-11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12869)
+
+*Preconditions*: *current_*.front() is decrementable[.](#iterator-11.sentence-1)
+
+[12](#iterator-12)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12873)
+
+*Postconditions*: Each element of *current_* is equal to ranges​::​prev(i),
+where i is the value of that element before the call[.](#iterator-12.sentence-1)
+
+[13](#iterator-13)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12878)
+
+*Returns*: *this[.](#iterator-13.sentence-1)
+
+[🔗](#lib:operator--,adjacent_view::iterator_)
+
+`constexpr iterator operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[14](#iterator-14)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12889)
+
+*Effects*: Equivalent to:auto tmp = *this;--*this;return tmp;
+
+[🔗](#lib:operator+=,adjacent_view::iterator)
+
+`constexpr iterator& operator+=(difference_type x)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[15](#iterator-15)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12906)
+
+*Preconditions*: *current_*.back() + x has well-defined behavior[.](#iterator-15.sentence-1)
+
+[16](#iterator-16)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12910)
+
+*Postconditions*: Each element of *current_* is equal to i + x,
+where i is the value of that element before the call[.](#iterator-16.sentence-1)
+
+[17](#iterator-17)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12915)
+
+*Returns*: *this[.](#iterator-17.sentence-1)
+
+[🔗](#lib:operator-=,adjacent_view::iterator)
+
+`constexpr iterator& operator-=(difference_type x)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[18](#iterator-18)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12927)
+
+*Preconditions*: *current_*.front() - x has well-defined behavior[.](#iterator-18.sentence-1)
+
+[19](#iterator-19)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12931)
+
+*Postconditions*: Each element of *current_* is equal to i - x,
+where i is the value of that element before the call[.](#iterator-19.sentence-1)
+
+[20](#iterator-20)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12936)
+
+*Returns*: *this[.](#iterator-20.sentence-1)
+
+[🔗](#lib:operator%5b%5d,adjacent_view::iterator)
+
+`constexpr auto operator[](difference_type n) const
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[21](#iterator-21)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12948)
+
+*Effects*: Equivalent to:return *tuple-transform*([&](auto& i) -> decltype(auto) { return i[n]; }, *current_*);
+
+[🔗](#lib:operator==,adjacent_view::iterator)
+
+`friend constexpr bool operator==(const iterator& x, const iterator& y);
+`
+
+[22](#iterator-22)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12962)
+
+*Returns*: x.*current_*.back() == y.*current_*.back()[.](#iterator-22.sentence-1)
+
+[🔗](#lib:operator%3c,adjacent_view::iterator)
+
+`friend constexpr bool operator<(const iterator& x, const iterator& y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[23](#iterator-23)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12974)
+
+*Returns*: x.*current_*.back() < y.*current_*.back()[.](#iterator-23.sentence-1)
+
+[🔗](#lib:operator%3e,adjacent_view::iterator)
+
+`friend constexpr bool operator>(const iterator& x, const iterator& y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[24](#iterator-24)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12986)
+
+*Effects*: Equivalent to: return y < x;
+
+[🔗](#lib:operator%3c=,adjacent_view::iterator)
+
+`friend constexpr bool operator<=(const iterator& x, const iterator& y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[25](#iterator-25)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12998)
+
+*Effects*: Equivalent to: return !(y < x);
+
+[🔗](#lib:operator%3e=,adjacent_view::iterator)
+
+`friend constexpr bool operator>=(const iterator& x, const iterator& y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[26](#iterator-26)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13010)
+
+*Effects*: Equivalent to: return !(x < y);
+
+[🔗](#lib:operator%3c=%3e,adjacent_view::iterator)
+
+`friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base> &&
+           [three_way_comparable](cmp.concept#concept:three_way_comparable "17.12.4 Concept three_­way_­comparable [cmp.concept]")<iterator_t<Base>>;
+`
+
+[27](#iterator-27)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13023)
+
+*Returns*: x.*current_*.back() <=> y.*current_*.back()[.](#iterator-27.sentence-1)
+
+[🔗](#lib:operator+,adjacent_view::iterator)
+
+`friend constexpr iterator operator+(const iterator& i, difference_type n)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+friend constexpr iterator operator+(difference_type n, const iterator& i)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[28](#iterator-28)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13037)
+
+*Effects*: Equivalent to:auto r = i;
+r += n;return r;
+
+[🔗](#lib:operator-,adjacent_view::iterator)
+
+`friend constexpr iterator operator-(const iterator& i, difference_type n)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[29](#iterator-29)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13054)
+
+*Effects*: Equivalent to:auto r = i;
+r -= n;return r;
+
+[🔗](#lib:operator-,adjacent_view::iterator_)
+
+`friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<iterator_t<Base>, iterator_t<Base>>;
+`
+
+[30](#iterator-30)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13071)
+
+*Effects*: Equivalent to:return x.*current_*.back() - y.*current_*.back();
+
+[🔗](#lib:iter_move,adjacent_view::iterator)
+
+`friend constexpr auto iter_move(const iterator& i) noexcept(see below);
+`
+
+[31](#iterator-31)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13083)
+
+*Effects*: Equivalent to:return *tuple-transform*(ranges​::​iter_move, i.*current_*);
+
+[32](#iterator-32)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13088)
+
+*Remarks*: The exception specification is equivalent to:noexcept(ranges::iter_move(declval<const iterator_t<*Base*>&>())) && is_nothrow_move_constructible_v<range_rvalue_reference_t<*Base*>>
+
+[🔗](#lib:iter_swap,adjacent_view::iterator)
+
+`friend constexpr void iter_swap(const iterator& l, const iterator& r) noexcept(see below)
+  requires [indirectly_swappable](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<Base>>;
+`
+
+[33](#iterator-33)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13104)
+
+*Preconditions*: None of the iterators in l.*current_* is equal to
+an iterator in r.*current_*[.](#iterator-33.sentence-1)
+
+[34](#iterator-34)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13109)
+
+*Effects*: For every integer 0≤i<N,
+performsranges​::​iter_swap(l.*current_*[i], r.*current_*[i])[.](#iterator-34.sentence-1)
+
+[35](#iterator-35)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13115)
+
+*Remarks*: The exception specification is equivalent to:noexcept(ranges::iter_swap(declval<iterator_t<*Base*>>(), declval<iterator_t<*Base*>>()))
+
+#### [25.7.27.4](#sentinel) Class template adjacent_view​::​*sentinel* [[range.adjacent.sentinel]](range.adjacent.sentinel)
+
+[🔗](#lib:adjacent_view::sentinel)
+
+namespace std::ranges {template<[forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") V, size_t N>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && (N > 0)template<bool Const>class adjacent_view<V, N>::*sentinel* {using *Base* = *maybe-const*<Const, V>; // *exposition only* sentinel_t<*Base*> *end_* = sentinel_t<*Base*>(); // *exposition only*constexpr explicit *sentinel*(sentinel_t<*Base*> end); // *exposition only*public:*sentinel*() = default; constexpr *sentinel*(*sentinel*<!Const> i)requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<sentinel_t<V>, sentinel_t<*Base*>>; template<bool OtherConst>requires [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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); };}
+
+[🔗](#lib:adjacent_view::sentinel,constructor)
+
+`constexpr explicit sentinel(sentinel_t<Base> end);
+`
+
+[1](#sentinel-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13164)
+
+*Effects*: Initializes *end_* with end[.](#sentinel-1.sentence-1)
+
+[🔗](#lib:adjacent_view::sentinel,constructor_)
+
+`constexpr sentinel(sentinel<!Const> i)
+  requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<sentinel_t<V>, sentinel_t<Base>>;
+`
+
+[2](#sentinel-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13176)
+
+*Effects*: Initializes *end_* with std​::​move(i.*end_*)[.](#sentinel-2.sentence-1)
+
+[🔗](#lib:operator==,adjacent_view::sentinel)
+
+`template<bool OtherConst>
+  requires [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
+`
+
+[3](#sentinel-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13189)
+
+*Effects*: Equivalent to: return x.*current_*.back() == y.*end_*;
+
+[🔗](#lib:operator-,adjacent_view::sentinel)
+
+`template<bool OtherConst>
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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);
+`
+
+[4](#sentinel-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13203)
+
+*Effects*: Equivalent to: return x.*current_*.back() - y.*end_*;
+
+[🔗](#lib:operator-,adjacent_view::sentinel_)
+
+`template<bool OtherConst>
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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);
+`
+
+[5](#sentinel-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13217)
+
+*Effects*: Equivalent to: return y.*end_* - x.*current_*.back();

cppdraft/range/adjacent/iterator.md

@@ -0,0 +1,376 @@
+[range.adjacent.iterator]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.adjacent.iterator)
+
+### 25.7.27 Adjacent view [[range.adjacent]](range.adjacent#iterator)
+
+#### 25.7.27.3 Class template adjacent_view​::​*iterator* [range.adjacent.iterator]
+
+[🔗](#lib:adjacent_view::iterator)
+
+namespace std::ranges {template<[forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") V, size_t N>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && (N > 0)template<bool Const>class adjacent_view<V, N>::*iterator* {using *Base* = *maybe-const*<Const, V>; // *exposition only* array<iterator_t<*Base*>, N> *current_* = array<iterator_t<*Base*>, N>(); // *exposition only*constexpr *iterator*(iterator_t<*Base*> first, sentinel_t<*Base*> last); // *exposition only*constexpr *iterator*(*as-sentinel*, iterator_t<*Base*> first, iterator_t<*Base*> last); // *exposition only*public:using iterator_category = input_iterator_tag; using iterator_concept = *see below*; using value_type = tuple<*REPEAT*(range_value_t<*Base*>, N)...>; using difference_type = range_difference_t<*Base*>; *iterator*() = default; constexpr *iterator*(*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 auto operator*() const; constexpr *iterator*& operator++(); constexpr *iterator* operator++(int); constexpr *iterator*& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr *iterator* operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr *iterator*& operator+=(difference_type x)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr *iterator*& operator-=(difference_type x)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr auto operator[](difference_type n) constrequires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr bool operator==(const *iterator*& x, const *iterator*& y); friend constexpr bool operator<(const *iterator*& x, const *iterator*& y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr bool operator>(const *iterator*& x, const *iterator*& y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr bool operator<=(const *iterator*& x, const *iterator*& y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr bool operator>=(const *iterator*& x, const *iterator*& y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr auto operator<=>(const *iterator*& x, const *iterator*& y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*> &&[three_way_comparable](cmp.concept#concept:three_way_comparable "17.12.4 Concept three_­way_­comparable [cmp.concept]")<iterator_t<*Base*>>; friend constexpr *iterator* operator+(const *iterator*& i, difference_type n)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr *iterator* operator+(difference_type n, const *iterator*& i)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr *iterator* operator-(const *iterator*& i, difference_type n)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr difference_type operator-(const *iterator*& x, const *iterator*& y)requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<iterator_t<*Base*>, iterator_t<*Base*>>; friend constexpr auto iter_move(const *iterator*& i) noexcept(*see below*); friend constexpr void iter_swap(const *iterator*& l, const *iterator*& r) noexcept(*see below*)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](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12753)
+
+*iterator*​::​iterator_concept is defined as follows:
+
+- [(1.1)](#1.1)
+
+  If *Base* models [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]"),
+then iterator_concept denotes random_access_iterator_tag[.](#1.1.sentence-1)
+
+- [(1.2)](#1.2)
+
+  Otherwise, if *Base* models [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]"),
+then iterator_concept denotes bidirectional_iterator_tag[.](#1.2.sentence-1)
+
+- [(1.3)](#1.3)
+
+  Otherwise, iterator_concept denotes forward_iterator_tag[.](#1.3.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12766)
+
+If the invocation of any non-const member function of *iterator* exits via an exception, the *iterator* acquires a singular value[.](#2.sentence-1)
+
+[🔗](#lib:adjacent_view::iterator,constructor)
+
+`constexpr iterator(iterator_t<Base> first, sentinel_t<Base> last);
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12776)
+
+*Postconditions*: *current_*[0] == first is true, and
+for every integer 1≤i<N,*current_*[i] == ranges​::​next(*current_*[i-1], 1, last) is true[.](#3.sentence-1)
+
+[🔗](#lib:adjacent_view::iterator,constructor_)
+
+`constexpr iterator(as-sentinel, iterator_t<Base> first, iterator_t<Base> last);
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12790)
+
+*Postconditions*: If *Base* does not model [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]"),
+each element of *current_* is equal to *last*[.](#4.sentence-1)
+
+Otherwise, *current_*[N-1] == last is true, and
+for every integer 0≤i<(N−1),*current_*[i] == ranges​::​prev(*current_*[i+1], 1, first) is true[.](#4.sentence-2)
+
+[🔗](#lib:adjacent_view::iterator,constructor__)
+
+`constexpr iterator(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>>;
+`
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12807)
+
+*Effects*: Initializes each element of *current_* with the corresponding element of i.*current_* as an xvalue[.](#5.sentence-1)
+
+[🔗](#lib:operator*,adjacent_view::iterator)
+
+`constexpr auto operator*() const;
+`
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12819)
+
+*Effects*: Equivalent to:return *tuple-transform*([](auto& i) -> decltype(auto) { return *i; }, *current_*);
+
+[🔗](#lib:operator++,adjacent_view::iterator)
+
+`constexpr iterator& operator++();
+`
+
+[7](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12833)
+
+*Preconditions*: *current_*.back() is incrementable[.](#7.sentence-1)
+
+[8](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12837)
+
+*Postconditions*: Each element of *current_* is equal to ranges​::​next(i),
+where i is the value of that element before the call[.](#8.sentence-1)
+
+[9](#9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12842)
+
+*Returns*: *this[.](#9.sentence-1)
+
+[🔗](#lib:operator++,adjacent_view::iterator_)
+
+`constexpr iterator operator++(int);
+`
+
+[10](#10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12853)
+
+*Effects*: Equivalent to:auto tmp = *this;++*this;return tmp;
+
+[🔗](#lib:operator--,adjacent_view::iterator)
+
+`constexpr iterator& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[11](#11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12869)
+
+*Preconditions*: *current_*.front() is decrementable[.](#11.sentence-1)
+
+[12](#12)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12873)
+
+*Postconditions*: Each element of *current_* is equal to ranges​::​prev(i),
+where i is the value of that element before the call[.](#12.sentence-1)
+
+[13](#13)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12878)
+
+*Returns*: *this[.](#13.sentence-1)
+
+[🔗](#lib:operator--,adjacent_view::iterator_)
+
+`constexpr iterator operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[14](#14)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12889)
+
+*Effects*: Equivalent to:auto tmp = *this;--*this;return tmp;
+
+[🔗](#lib:operator+=,adjacent_view::iterator)
+
+`constexpr iterator& operator+=(difference_type x)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[15](#15)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12906)
+
+*Preconditions*: *current_*.back() + x has well-defined behavior[.](#15.sentence-1)
+
+[16](#16)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12910)
+
+*Postconditions*: Each element of *current_* is equal to i + x,
+where i is the value of that element before the call[.](#16.sentence-1)
+
+[17](#17)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12915)
+
+*Returns*: *this[.](#17.sentence-1)
+
+[🔗](#lib:operator-=,adjacent_view::iterator)
+
+`constexpr iterator& operator-=(difference_type x)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[18](#18)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12927)
+
+*Preconditions*: *current_*.front() - x has well-defined behavior[.](#18.sentence-1)
+
+[19](#19)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12931)
+
+*Postconditions*: Each element of *current_* is equal to i - x,
+where i is the value of that element before the call[.](#19.sentence-1)
+
+[20](#20)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12936)
+
+*Returns*: *this[.](#20.sentence-1)
+
+[🔗](#lib:operator%5b%5d,adjacent_view::iterator)
+
+`constexpr auto operator[](difference_type n) const
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[21](#21)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12948)
+
+*Effects*: Equivalent to:return *tuple-transform*([&](auto& i) -> decltype(auto) { return i[n]; }, *current_*);
+
+[🔗](#lib:operator==,adjacent_view::iterator)
+
+`friend constexpr bool operator==(const iterator& x, const iterator& y);
+`
+
+[22](#22)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12962)
+
+*Returns*: x.*current_*.back() == y.*current_*.back()[.](#22.sentence-1)
+
+[🔗](#lib:operator%3c,adjacent_view::iterator)
+
+`friend constexpr bool operator<(const iterator& x, const iterator& y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[23](#23)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12974)
+
+*Returns*: x.*current_*.back() < y.*current_*.back()[.](#23.sentence-1)
+
+[🔗](#lib:operator%3e,adjacent_view::iterator)
+
+`friend constexpr bool operator>(const iterator& x, const iterator& y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[24](#24)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12986)
+
+*Effects*: Equivalent to: return y < x;
+
+[🔗](#lib:operator%3c=,adjacent_view::iterator)
+
+`friend constexpr bool operator<=(const iterator& x, const iterator& y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[25](#25)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12998)
+
+*Effects*: Equivalent to: return !(y < x);
+
+[🔗](#lib:operator%3e=,adjacent_view::iterator)
+
+`friend constexpr bool operator>=(const iterator& x, const iterator& y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[26](#26)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13010)
+
+*Effects*: Equivalent to: return !(x < y);
+
+[🔗](#lib:operator%3c=%3e,adjacent_view::iterator)
+
+`friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base> &&
+           [three_way_comparable](cmp.concept#concept:three_way_comparable "17.12.4 Concept three_­way_­comparable [cmp.concept]")<iterator_t<Base>>;
+`
+
+[27](#27)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13023)
+
+*Returns*: x.*current_*.back() <=> y.*current_*.back()[.](#27.sentence-1)
+
+[🔗](#lib:operator+,adjacent_view::iterator)
+
+`friend constexpr iterator operator+(const iterator& i, difference_type n)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+friend constexpr iterator operator+(difference_type n, const iterator& i)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[28](#28)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13037)
+
+*Effects*: Equivalent to:auto r = i;
+r += n;return r;
+
+[🔗](#lib:operator-,adjacent_view::iterator)
+
+`friend constexpr iterator operator-(const iterator& i, difference_type n)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[29](#29)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13054)
+
+*Effects*: Equivalent to:auto r = i;
+r -= n;return r;
+
+[🔗](#lib:operator-,adjacent_view::iterator_)
+
+`friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<iterator_t<Base>, iterator_t<Base>>;
+`
+
+[30](#30)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13071)
+
+*Effects*: Equivalent to:return x.*current_*.back() - y.*current_*.back();
+
+[🔗](#lib:iter_move,adjacent_view::iterator)
+
+`friend constexpr auto iter_move(const iterator& i) noexcept(see below);
+`
+
+[31](#31)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13083)
+
+*Effects*: Equivalent to:return *tuple-transform*(ranges​::​iter_move, i.*current_*);
+
+[32](#32)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13088)
+
+*Remarks*: The exception specification is equivalent to:noexcept(ranges::iter_move(declval<const iterator_t<*Base*>&>())) && is_nothrow_move_constructible_v<range_rvalue_reference_t<*Base*>>
+
+[🔗](#lib:iter_swap,adjacent_view::iterator)
+
+`friend constexpr void iter_swap(const iterator& l, const iterator& r) noexcept(see below)
+  requires [indirectly_swappable](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<Base>>;
+`
+
+[33](#33)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13104)
+
+*Preconditions*: None of the iterators in l.*current_* is equal to
+an iterator in r.*current_*[.](#33.sentence-1)
+
+[34](#34)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13109)
+
+*Effects*: For every integer 0≤i<N,
+performsranges​::​iter_swap(l.*current_*[i], r.*current_*[i])[.](#34.sentence-1)
+
+[35](#35)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13115)
+
+*Remarks*: The exception specification is equivalent to:noexcept(ranges::iter_swap(declval<iterator_t<*Base*>>(), declval<iterator_t<*Base*>>()))

cppdraft/range/adjacent/overview.md

@@ -0,0 +1,50 @@
+[range.adjacent.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.adjacent.overview)
+
+### 25.7.27 Adjacent view [[range.adjacent]](range.adjacent#overview)
+
+#### 25.7.27.1 Overview [range.adjacent.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12539)
+
+adjacent_view takes a view and
+produces a view whose Mth element is
+a tuple of references to
+the Mth through (M+N−1)th elements of
+the original view[.](#1.sentence-1)
+
+If the original view has fewer than N elements, the resulting view is empty[.](#1.sentence-2)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12547)
+
+The name views​::​adjacent<N> denotes
+a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#2.sentence-1)
+
+Given a subexpression E and a constant expression N,
+the expression views​::​adjacent<N>(E) is expression-equivalent to
+
+- [(2.1)](#2.1)
+
+((void)E, auto(views​::​empty<tuple<>>)) if N is equal to 0 anddecltype((E)) models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]"),
+
+- [(2.2)](#2.2)
+
+otherwise, adjacent_view<views​::​all_t<decltype((E))>, N>(E)[.](#2.sentence-2)
+
+[*Example [1](#example-1)*: vector v = {1, 2, 3, 4};
+
+for (auto i : v | views::adjacent<2>) { cout << "(" << std::get<0>(i) << ", " << std::get<1>(i) << ") "; // prints (1, 2) (2, 3) (3, 4)} — *end example*]
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12572)
+
+Define *REPEAT*(T, N) as a pack of N types,
+each of which denotes the same type as T[.](#3.sentence-1)

cppdraft/range/adjacent/sentinel.md

@@ -0,0 +1,77 @@
+[range.adjacent.sentinel]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.adjacent.sentinel)
+
+### 25.7.27 Adjacent view [[range.adjacent]](range.adjacent#sentinel)
+
+#### 25.7.27.4 Class template adjacent_view​::​*sentinel* [range.adjacent.sentinel]
+
+[🔗](#lib:adjacent_view::sentinel)
+
+namespace std::ranges {template<[forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") V, size_t N>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && (N > 0)template<bool Const>class adjacent_view<V, N>::*sentinel* {using *Base* = *maybe-const*<Const, V>; // *exposition only* sentinel_t<*Base*> *end_* = sentinel_t<*Base*>(); // *exposition only*constexpr explicit *sentinel*(sentinel_t<*Base*> end); // *exposition only*public:*sentinel*() = default; constexpr *sentinel*(*sentinel*<!Const> i)requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<sentinel_t<V>, sentinel_t<*Base*>>; template<bool OtherConst>requires [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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); };}
+
+[🔗](#lib:adjacent_view::sentinel,constructor)
+
+`constexpr explicit sentinel(sentinel_t<Base> end);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13164)
+
+*Effects*: Initializes *end_* with end[.](#1.sentence-1)
+
+[🔗](#lib:adjacent_view::sentinel,constructor_)
+
+`constexpr sentinel(sentinel<!Const> i)
+  requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<sentinel_t<V>, sentinel_t<Base>>;
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13176)
+
+*Effects*: Initializes *end_* with std​::​move(i.*end_*)[.](#2.sentence-1)
+
+[🔗](#lib:operator==,adjacent_view::sentinel)
+
+`template<bool OtherConst>
+  requires [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13189)
+
+*Effects*: Equivalent to: return x.*current_*.back() == y.*end_*;
+
+[🔗](#lib:operator-,adjacent_view::sentinel)
+
+`template<bool OtherConst>
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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);
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13203)
+
+*Effects*: Equivalent to: return x.*current_*.back() - y.*end_*;
+
+[🔗](#lib:operator-,adjacent_view::sentinel_)
+
+`template<bool OtherConst>
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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);
+`
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13217)
+
+*Effects*: Equivalent to: return y.*end_* - x.*current_*.back();

cppdraft/range/adjacent/transform/overview.md

@@ -0,0 +1,51 @@
+[range.adjacent.transform.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.adjacent.transform.overview)
+
+### 25.7.28 Adjacent transform view [[range.adjacent.transform]](range.adjacent.transform#overview)
+
+#### 25.7.28.1 Overview [range.adjacent.transform.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13226)
+
+adjacent_transform_view takes an invocable object and
+a view and produces a view
+whose Mth element is the result of applying the invocable object
+to the Mth through (M+N−1)th elements
+of the original view[.](#1.sentence-1)
+
+If the original view has fewer than N elements, the resulting view is empty[.](#1.sentence-2)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13234)
+
+The name views​::​adjacent_transform<N> denotes
+a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#2.sentence-1)
+
+Given subexpressions E and F and
+a constant expression N:
+
+- [(2.1)](#2.1)
+
+  If N is equal to 0 anddecltype((E)) models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]"),views​::​adjacent_transform<N>(E, F) is expression-equivalent to((void)E, views​::​zip_transform(F)),
+except that the evaluations of E and F are
+indeterminately sequenced[.](#2.1.sentence-1)
+
+- [(2.2)](#2.2)
+
+  Otherwise,
+the expression views​::​adjacent_transform<N>(E, F) is
+expression-equivalent toadjacent_transform_view<views​::​all_t<decltype((E))>, decay_t<decltype((F))>, N>(E, F)[.](#2.2.sentence-1)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13255)
+
+[*Example [1](#example-1)*: vector v = {1, 2, 3, 4};
+
+for (auto i : v | views::adjacent_transform<2>(std::multiplies())) { cout << i << ' '; // prints 2 6 12} — *end example*]

cppdraft/range/adjacent/transform/sentinel.md

@@ -0,0 +1,68 @@
+[range.adjacent.transform.sentinel]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.adjacent.transform.sentinel)
+
+### 25.7.28 Adjacent transform view [[range.adjacent.transform]](range.adjacent.transform#sentinel)
+
+#### 25.7.28.4 Class template adjacent_transform_view​::​*sentinel* [range.adjacent.transform.sentinel]
+
+[🔗](#lib:adjacent_transform_view::sentinel)
+
+namespace std::ranges {template<[forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") V, [move_constructible](concept.moveconstructible#concept:move_constructible "18.4.13 Concept move_­constructible [concept.moveconstructible]") F, size_t N>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && (N > 0) && is_object_v<F> &&[regular_invocable](concept.regularinvocable#concept:regular_invocable "18.7.3 Concept regular_­invocable [concept.regularinvocable]")<F&, *REPEAT*(range_reference_t<V>, N)...> &&[*can-reference*](iterator.synopsis#concept:can-reference "24.2 Header <iterator>&nbsp;synopsis [iterator.synopsis]")<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_*; // *exposition only*constexpr explicit *sentinel*(*inner-sentinel*<Const> inner); // *exposition only*public:*sentinel*() = default; constexpr *sentinel*(*sentinel*<!Const> i)requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<*inner-sentinel*<false>, *inner-sentinel*<Const>>; template<bool OtherConst>requires [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<*inner-sentinel*<Const>, *inner-iterator*<OtherConst>>friend constexpr bool operator==(const *iterator*<OtherConst>& x, const *sentinel*& y); template<bool OtherConst>requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<*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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<*inner-sentinel*<Const>, *inner-iterator*<OtherConst>>friend constexpr range_difference_t<*maybe-const*<OtherConst, *InnerView*>>operator-(const *sentinel*& x, const *iterator*<OtherConst>& y); };}
+
+[🔗](#lib:adjacent_transform_view::sentinel,constructor)
+
+`constexpr explicit sentinel(inner-sentinel<Const> inner);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13721)
+
+*Effects*: Initializes *inner_* with inner[.](#1.sentence-1)
+
+[🔗](#lib:adjacent_transform_view::sentinel,constructor_)
+
+`constexpr sentinel(sentinel<!Const> i)
+  requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<inner-sentinel<false>, inner-sentinel<Const>>;
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13733)
+
+*Effects*: Initializes *inner_* with std​::​move(i.*inner_*)[.](#2.sentence-1)
+
+[🔗](#lib:operator==,adjacent_transform_view::sentinel)
+
+`template<bool OtherConst>
+  requires [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<inner-sentinel<Const>, inner-iterator<OtherConst>>
+friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13746)
+
+*Effects*: Equivalent to: return x.*inner_* == y.*inner_*;
+
+[🔗](#lib:operator-,adjacent_transform_view::sentinel)
+
+`template<bool OtherConst>
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<inner-sentinel<Const>, inner-iterator<OtherConst>>
+friend constexpr range_difference_t<maybe-const<OtherConst, InnerView>>
+  operator-(const sentinel& x, const iterator<OtherConst>& y);
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13765)
+
+*Effects*: Equivalent to: return x.*inner_* - y.*inner_*;

cppdraft/range/adjacent/transform/view.md

@@ -0,0 +1,24 @@
+[range.adjacent.transform.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.adjacent.transform.view)
+
+### 25.7.28 Adjacent transform view [[range.adjacent.transform]](range.adjacent.transform#view)
+
+#### 25.7.28.2 Class template adjacent_transform_view [range.adjacent.transform.view]
+
+[🔗](#lib:adjacent_transform_view)
+
+namespace std::ranges {template<[forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") V, [move_constructible](concept.moveconstructible#concept:move_constructible "18.4.13 Concept move_­constructible [concept.moveconstructible]") F, size_t N>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && (N > 0) && is_object_v<F> &&[regular_invocable](concept.regularinvocable#concept:regular_invocable "18.7.3 Concept regular_­invocable [concept.regularinvocable]")<F&, *REPEAT*(range_reference_t<V>, N)...> &&[*can-reference*](iterator.synopsis#concept:can-reference "24.2 Header <iterator>&nbsp;synopsis [iterator.synopsis]")<invoke_result_t<F&, *REPEAT*(range_reference_t<V>, N)...>>class adjacent_transform_view : public view_interface<adjacent_transform_view<V, F, N>> {*movable-box*<F> *fun_*; // *exposition only* adjacent_view<V, N> *inner_*; // *exposition only*using *InnerView* = adjacent_view<V, N>; // *exposition only*template<bool Const>using *inner-iterator* = iterator_t<*maybe-const*<Const, *InnerView*>>; // *exposition only*template<bool Const>using *inner-sentinel* = sentinel_t<*maybe-const*<Const, *InnerView*>>; // *exposition only*// [[range.adjacent.transform.iterator]](range.adjacent.transform.iterator "25.7.28.3 Class template adjacent_­transform_­view​::​iterator"), class template adjacent_transform_view​::​*iterator*template<bool> class *iterator*; // *exposition only*// [[range.adjacent.transform.sentinel]](range.adjacent.transform.sentinel "25.7.28.4 Class template adjacent_­transform_­view​::​sentinel"), class template 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](concept.copyconstructible#concept:copy_constructible "18.4.14 Concept copy_­constructible [concept.copyconstructible]")<V> { return *inner_*.base(); }constexpr V base() && { return std::move(*inner_*).base(); }constexpr auto begin() {return *iterator*<false>(*this, *inner_*.begin()); }constexpr auto begin() constrequires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const *InnerView*> &&[regular_invocable](concept.regularinvocable#concept:regular_invocable "18.7.3 Concept regular_­invocable [concept.regularinvocable]")<const F&, *REPEAT*(range_reference_t<const V>, N)...> {return *iterator*<true>(*this, *inner_*.begin()); }constexpr auto end() {if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<*InnerView*>) {return *iterator*<false>(*this, *inner_*.end()); } else {return *sentinel*<false>(*inner_*.end()); }}constexpr auto end() constrequires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const *InnerView*> &&[regular_invocable](concept.regularinvocable#concept:regular_invocable "18.7.3 Concept regular_­invocable [concept.regularinvocable]")<const F&, *REPEAT*(range_reference_t<const V>, N)...> {if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<const *InnerView*>) {return *iterator*<true>(*this, *inner_*.end()); } else {return *sentinel*<true>(*inner_*.end()); }}constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<*InnerView*> {return *inner_*.size(); }constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const *InnerView*> {return *inner_*.size(); }constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<*InnerView*> {return *inner_*.reserve_hint(); }constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const *InnerView*> {return *inner_*.reserve_hint(); }};}
+
+[🔗](#lib:adjacent_transform_view,constructor)
+
+`constexpr explicit adjacent_transform_view(V base, F fun);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13356)
+
+*Effects*: Initializes *fun_* with std​::​move(fun) and*inner_* with std​::​move(base)[.](#1.sentence-1)

cppdraft/range/adjacent/view.md

@@ -0,0 +1,50 @@
+[range.adjacent.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.adjacent.view)
+
+### 25.7.27 Adjacent view [[range.adjacent]](range.adjacent#view)
+
+#### 25.7.27.2 Class template adjacent_view [range.adjacent.view]
+
+[🔗](#lib:adjacent_view)
+
+namespace std::ranges {template<[forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") V, size_t N>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && (N > 0)class adjacent_view : public view_interface<adjacent_view<V, N>> { V *base_* = V(); // *exposition only*// [[range.adjacent.iterator]](range.adjacent.iterator "25.7.27.3 Class template adjacent_­view​::​iterator"), class template adjacent_view​::​*iterator*template<bool> class *iterator*; // *exposition only*// [[range.adjacent.sentinel]](range.adjacent.sentinel "25.7.27.4 Class template adjacent_­view​::​sentinel"), class template adjacent_view​::​*sentinel*template<bool> class *sentinel*; // *exposition only*struct *as-sentinel*{}; // *exposition only*public: adjacent_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> = default; constexpr explicit adjacent_view(V base); 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() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) {return *iterator*<false>(ranges::begin(*base_*), ranges::end(*base_*)); }constexpr auto begin() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V> {return *iterator*<true>(ranges::begin(*base_*), ranges::end(*base_*)); }constexpr auto end() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) {if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<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](range.range#concept:range "25.4.2 Ranges [range.range]")<const V> {if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<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](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>; constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>; constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>; constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>; };}
+
+[🔗](#lib:adjacent_view,constructor)
+
+`constexpr explicit adjacent_view(V base);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12642)
+
+*Effects*: Initializes *base_* with std​::​move(base)[.](#1.sentence-1)
+
+[🔗](#lib:size,adjacent_view)
+
+`constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>;
+constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>;
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12654)
+
+*Effects*: Equivalent to:using ST = decltype(ranges::size(*base_*));using CT = common_type_t<ST, size_t>;auto sz = static_cast<CT>(ranges::size(*base_*));
+sz -= std::min<CT>(sz, N - 1);return static_cast<ST>(sz);
+
+[🔗](#lib:reserve_hint,adjacent_view)
+
+`constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>;
+constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>;
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L12673)
+
+*Effects*: Equivalent to:using DT = range_difference_t<decltype((*base_*))>;using CT = common_type_t<DT, size_t>;auto sz = static_cast<CT>(ranges::reserve_hint(*base_*));
+sz -= std::min<CT>(sz, N - 1);return *to-unsigned-like*(sz);

cppdraft/range/all.md

@@ -0,0 +1,97 @@
+[range.all]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.all)
+
+### 25.7.6 All view [range.all]
+
+#### [25.7.6.1](#general) General [[range.all.general]](range.all.general)
+
+[1](#general-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4494)
+
+views​::​all returns a view that includes all elements of
+its range argument[.](#general-1.sentence-1)
+
+[2](#general-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4499)
+
+The name views​::​all denotes a
+range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#general-2.sentence-1)
+
+Given a subexpression E, the expressionviews​::​all(E) is expression-equivalent to:
+
+- [(2.1)](#general-2.1)
+
+  *decay-copy*(E) if the decayed type of E models [view](range.view#concept:view "25.4.5 Views [range.view]")[.](#general-2.1.sentence-1)
+
+- [(2.2)](#general-2.2)
+
+  Otherwise, ref_view{E} if that expression is well-formed[.](#general-2.2.sentence-1)
+
+- [(2.3)](#general-2.3)
+
+  Otherwise, owning_view{E}[.](#general-2.3.sentence-1)
+
+#### [25.7.6.2](#range.ref.view) Class template ref_view [[range.ref.view]](range.ref.view)
+
+[1](#range.ref.view-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4515)
+
+ref_view is a view of the elements of some other range[.](#range.ref.view-1.sentence-1)
+
+[🔗](#lib:ref_view)
+
+namespace std::ranges {template<[range](range.range#concept:range "25.4.2 Ranges [range.range]") R>requires is_object_v<R>class ref_view : public view_interface<ref_view<R>> {private: R* *r_*; // *exposition only*public:template<[*different-from*](range.utility.helpers#concept:different-from "25.5.2 Helper concepts [range.utility.helpers]")<ref_view> T>requires *see below*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() constrequires requires { ranges::empty(**r_*); }{ return ranges::empty(**r_*); }constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R>{ return ranges::size(**r_*); }constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<R>{ return ranges::reserve_hint(**r_*); }constexpr auto data() const requires [contiguous_range](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]")<R>{ return ranges::data(**r_*); }}; template<class R> ref_view(R&) -> ref_view<R>;}
+
+[🔗](#lib:ref_view,constructor)
+
+`template<[different-from](range.utility.helpers#concept:different-from "25.5.2 Helper concepts [range.utility.helpers]")<ref_view> T>
+  requires see below
+constexpr ref_view(T&& t);
+`
+
+[2](#range.ref.view-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4563)
+
+*Effects*: Initializes *r_* withaddressof(static_cast<R&>(std​::​forward<T>(t)))[.](#range.ref.view-2.sentence-1)
+
+[3](#range.ref.view-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4568)
+
+*Remarks*: Let *FUN* denote the exposition-only functionsvoid *FUN*(R&);void *FUN*(R&&) = delete;
+
+The expression in the [*requires-clause*](temp.pre#nt:requires-clause "13.1 Preamble [temp.pre]") is equivalent to:[convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<T, R&> && requires { *FUN*(declval<T>()); }
+
+#### [25.7.6.3](#range.owning.view) Class template owning_view [[range.owning.view]](range.owning.view)
+
+[1](#range.owning.view-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4583)
+
+owning_view is a move-only view
+of the elements of some other range[.](#range.owning.view-1.sentence-1)
+
+[🔗](#lib:owning_view)
+
+namespace std::ranges {template<[range](range.range#concept:range "25.4.2 Ranges [range.range]") R>requires [movable](concepts.object#concept:movable "18.6 Object concepts [concepts.object]")<R> && (!*is-initializer-list*<R>) // see [[range.refinements]](range.refinements "25.4.6 Other range refinements")class owning_view : public view_interface<owning_view<R>> {private: R *r_* = R(); // *exposition only*public: owning_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<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](range.range#concept:range "25.4.2 Ranges [range.range]")<const R>{ return ranges::begin(*r_*); }constexpr auto end() const requires [range](range.range#concept:range "25.4.2 Ranges [range.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](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R>{ return ranges::size(*r_*); }constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const R>{ return ranges::size(*r_*); }constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<R>{ return ranges::reserve_hint(*r_*); }constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const R>{ return ranges::reserve_hint(*r_*); }constexpr auto data() requires [contiguous_range](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]")<R>{ return ranges::data(*r_*); }constexpr auto data() const requires [contiguous_range](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]")<const R>{ return ranges::data(*r_*); }};}
+
+[🔗](#lib:owning_view,constructor)
+
+`constexpr owning_view(R&& t);
+`
+
+[2](#range.owning.view-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4645)
+
+*Effects*: Initializes *r_* with std​::​move(t)[.](#range.owning.view-2.sentence-1)

cppdraft/range/all/general.md

@@ -0,0 +1,37 @@
+[range.all.general]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.all.general)
+
+### 25.7.6 All view [[range.all]](range.all#general)
+
+#### 25.7.6.1 General [range.all.general]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4494)
+
+views​::​all returns a view that includes all elements of
+its range argument[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4499)
+
+The name views​::​all denotes a
+range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#2.sentence-1)
+
+Given a subexpression E, the expressionviews​::​all(E) is expression-equivalent to:
+
+- [(2.1)](#2.1)
+
+  *decay-copy*(E) if the decayed type of E models [view](range.view#concept:view "25.4.5 Views [range.view]")[.](#2.1.sentence-1)
+
+- [(2.2)](#2.2)
+
+  Otherwise, ref_view{E} if that expression is well-formed[.](#2.2.sentence-1)
+
+- [(2.3)](#2.3)
+
+  Otherwise, owning_view{E}[.](#2.3.sentence-1)

cppdraft/range/approximately/sized.md

@@ -0,0 +1,48 @@
+[range.approximately.sized]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.4 Range requirements [[range.req]](range.req#range.approximately.sized)
+
+### 25.4.3 Approximately sized ranges [range.approximately.sized]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1427)
+
+The [approximately_sized_range](#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]") concept refines [range](range.range#concept:range "25.4.2 Ranges [range.range]") with the requirement that
+an approximation of the number of elements in the range
+can be determined in amortized constant time using ranges​::​reserve_hint[.](#1.sentence-1)
+
+[🔗](#concept:approximately_sized_range)
+
+`template<class T>
+  concept [approximately_sized_range](#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]") =
+    [range](range.range#concept:range "25.4.2 Ranges [range.range]")<T> && requires(T& t) { ranges::reserve_hint(t); };
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L1440)
+
+Given an lvalue t of type remove_reference_t<T>,T models [approximately_sized_range](#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]") only if
+
+- [(2.1)](#2.1)
+
+ranges​::​reserve_hint(t) is amortized O(1),
+does not modify t, and
+has a value that
+is not negative and is representable in range_difference_t<T>, and
+
+- [(2.2)](#2.2)
+
+if iterator_t<T> models [forward_iterator](iterator.concept.forward#concept:forward_iterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]"),ranges​::​reserve_hint(t) is well-defined
+regardless of the evaluation of ranges​::​begin(t)[.](#2.sentence-1)
+  [*Note [1](#note-1)*:
+  ranges​::​reserve_hint(t) is otherwise not required to be well-defined
+after evaluating ranges​::​begin(t)[.](#2.2.sentence-2)
+  For example,
+it is possible for ranges​::​reserve_hint(t) to be well-defined for
+an [approximately_sized_range](#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]") whose
+iterator type does not model [forward_iterator](iterator.concept.forward#concept:forward_iterator "24.3.4.11 Concept forward_­iterator [iterator.concept.forward]") only if evaluated before the first call to ranges​::​begin(t)[.](#2.2.sentence-3)
+ — *end note*]

cppdraft/range/as/const.md

@@ -0,0 +1,89 @@
+[range.as.const]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.as.const)
+
+### 25.7.22 As const view [range.as.const]
+
+#### [25.7.22.1](#overview) Overview [[range.as.const.overview]](range.as.const.overview)
+
+[1](#overview-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10028)
+
+as_const_view presents a view of an underlying sequence as constant[.](#overview-1.sentence-1)
+
+That is, the elements of an as_const_view cannot be modified[.](#overview-1.sentence-2)
+
+[2](#overview-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10032)
+
+The name views​::​as_const denotes
+a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#overview-2.sentence-1)
+
+Let E be an expression,
+let T be decltype((E)), and
+let U be remove_cvref_t<T>[.](#overview-2.sentence-2)
+
+The expression views​::​as_const(E) is expression-equivalent to:
+
+- [(2.1)](#overview-2.1)
+
+  If views​::​all_t<T> models [constant_range](range.refinements#concept:constant_range "25.4.6 Other range refinements [range.refinements]"),
+then views​::​all(E)[.](#overview-2.1.sentence-1)
+
+- [(2.2)](#overview-2.2)
+
+  Otherwise,
+if U denotes empty_view<X> for some type X, then auto(views​::​empty<const X>)[.](#overview-2.2.sentence-1)
+
+- [(2.3)](#overview-2.3)
+
+  Otherwise,
+if U denotes span<X, Extent> for some type X and some extent Extent,
+then span<const X, Extent>(E)[.](#overview-2.3.sentence-1)
+
+- [(2.4)](#overview-2.4)
+
+  Otherwise,
+if U denotes ref_view<X> for some type X andconst X models [constant_range](range.refinements#concept:constant_range "25.4.6 Other range refinements [range.refinements]"),
+then ref_view(static_cast<const X&>(E.base()))[.](#overview-2.4.sentence-1)
+
+- [(2.5)](#overview-2.5)
+
+  Otherwise,
+if E is an lvalue,const U models [constant_range](range.refinements#concept:constant_range "25.4.6 Other range refinements [range.refinements]"), andU does not model [view](range.view#concept:view "25.4.5 Views [range.view]"),
+then ref_view(static_cast<const U&>(E))[.](#overview-2.5.sentence-1)
+
+- [(2.6)](#overview-2.6)
+
+  Otherwise, as_const_view(E)[.](#overview-2.6.sentence-1)
+
+[3](#overview-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10067)
+
+[*Example [1](#overview-example-1)*: template<[constant_range](range.refinements#concept:constant_range "25.4.6 Other range refinements [range.refinements]") R>void cant_touch_this(R&&);
+
+vector<char> hammer = {'m', 'c'};
+span<char> beat = hammer;
+cant_touch_this(views::as_const(beat)); // will not modify the elements of hammer — *end example*]
+
+#### [25.7.22.2](#view) Class template as_const_view [[range.as.const.view]](range.as.const.view)
+
+[🔗](#lib:as_const_view::iterator)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires [input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]")<V>class as_const_view : public view_interface<as_const_view<V>> { V *base_* = V(); // *exposition only*public: as_const_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> = default; constexpr explicit as_const_view(V base); 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() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) { return ranges::cbegin(*base_*); }constexpr auto begin() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V> { return ranges::cbegin(*base_*); }constexpr auto end() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) { return ranges::cend(*base_*); }constexpr auto end() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V> { return ranges::cend(*base_*); }constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V> { return ranges::size(*base_*); }constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V> { return ranges::size(*base_*); }constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>{ return ranges::reserve_hint(*base_*); }constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>{ return ranges::reserve_hint(*base_*); }}; template<class R> as_const_view(R&&) -> as_const_view<views::all_t<R>>;}
+
+[🔗](#lib:as_const_view::iterator,constructor)
+
+`constexpr explicit as_const_view(V base);
+`
+
+[1](#view-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10122)
+
+*Effects*: Initializes *base_* with std​::​move(base)[.](#view-1.sentence-1)

cppdraft/range/as/const/overview.md

@@ -0,0 +1,72 @@
+[range.as.const.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.as.const.overview)
+
+### 25.7.22 As const view [[range.as.const]](range.as.const#overview)
+
+#### 25.7.22.1 Overview [range.as.const.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10028)
+
+as_const_view presents a view of an underlying sequence as constant[.](#1.sentence-1)
+
+That is, the elements of an as_const_view cannot be modified[.](#1.sentence-2)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10032)
+
+The name views​::​as_const denotes
+a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#2.sentence-1)
+
+Let E be an expression,
+let T be decltype((E)), and
+let U be remove_cvref_t<T>[.](#2.sentence-2)
+
+The expression views​::​as_const(E) is expression-equivalent to:
+
+- [(2.1)](#2.1)
+
+  If views​::​all_t<T> models [constant_range](range.refinements#concept:constant_range "25.4.6 Other range refinements [range.refinements]"),
+then views​::​all(E)[.](#2.1.sentence-1)
+
+- [(2.2)](#2.2)
+
+  Otherwise,
+if U denotes empty_view<X> for some type X, then auto(views​::​empty<const X>)[.](#2.2.sentence-1)
+
+- [(2.3)](#2.3)
+
+  Otherwise,
+if U denotes span<X, Extent> for some type X and some extent Extent,
+then span<const X, Extent>(E)[.](#2.3.sentence-1)
+
+- [(2.4)](#2.4)
+
+  Otherwise,
+if U denotes ref_view<X> for some type X andconst X models [constant_range](range.refinements#concept:constant_range "25.4.6 Other range refinements [range.refinements]"),
+then ref_view(static_cast<const X&>(E.base()))[.](#2.4.sentence-1)
+
+- [(2.5)](#2.5)
+
+  Otherwise,
+if E is an lvalue,const U models [constant_range](range.refinements#concept:constant_range "25.4.6 Other range refinements [range.refinements]"), andU does not model [view](range.view#concept:view "25.4.5 Views [range.view]"),
+then ref_view(static_cast<const U&>(E))[.](#2.5.sentence-1)
+
+- [(2.6)](#2.6)
+
+  Otherwise, as_const_view(E)[.](#2.6.sentence-1)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10067)
+
+[*Example [1](#example-1)*: template<[constant_range](range.refinements#concept:constant_range "25.4.6 Other range refinements [range.refinements]") R>void cant_touch_this(R&&);
+
+vector<char> hammer = {'m', 'c'};
+span<char> beat = hammer;
+cant_touch_this(views::as_const(beat)); // will not modify the elements of hammer — *end example*]

cppdraft/range/as/const/view.md

@@ -0,0 +1,24 @@
+[range.as.const.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.as.const.view)
+
+### 25.7.22 As const view [[range.as.const]](range.as.const#view)
+
+#### 25.7.22.2 Class template as_const_view [range.as.const.view]
+
+[🔗](#lib:as_const_view::iterator)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires [input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]")<V>class as_const_view : public view_interface<as_const_view<V>> { V *base_* = V(); // *exposition only*public: as_const_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> = default; constexpr explicit as_const_view(V base); 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() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) { return ranges::cbegin(*base_*); }constexpr auto begin() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V> { return ranges::cbegin(*base_*); }constexpr auto end() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) { return ranges::cend(*base_*); }constexpr auto end() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V> { return ranges::cend(*base_*); }constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V> { return ranges::size(*base_*); }constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V> { return ranges::size(*base_*); }constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>{ return ranges::reserve_hint(*base_*); }constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>{ return ranges::reserve_hint(*base_*); }}; template<class R> as_const_view(R&&) -> as_const_view<views::all_t<R>>;}
+
+[🔗](#lib:as_const_view::iterator,constructor)
+
+`constexpr explicit as_const_view(V base);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10122)
+
+*Effects*: Initializes *base_* with std​::​move(base)[.](#1.sentence-1)

cppdraft/range/as/rvalue.md

@@ -0,0 +1,61 @@
+[range.as.rvalue]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.as.rvalue)
+
+### 25.7.7 As rvalue view [range.as.rvalue]
+
+#### [25.7.7.1](#overview) Overview [[range.as.rvalue.overview]](range.as.rvalue.overview)
+
+[1](#overview-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4654)
+
+as_rvalue_view presents a view of an underlying sequence
+with the same behavior as the underlying sequence
+except that its elements are rvalues[.](#overview-1.sentence-1)
+
+Some generic algorithms can be called with an as_rvalue_view to replace copying with moving[.](#overview-1.sentence-2)
+
+[2](#overview-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4661)
+
+The name views​::​as_rvalue denotes
+a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#overview-2.sentence-1)
+
+Let E be an expression and let T be decltype((E))[.](#overview-2.sentence-2)
+
+The expression views​::​as_rvalue(E) is expression-equivalent to:
+
+- [(2.1)](#overview-2.1)
+
+  views​::​all(E) ifT models [input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") and[same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<range_rvalue_reference_t<T>, range_reference_t<T>> is true[.](#overview-2.1.sentence-1)
+
+- [(2.2)](#overview-2.2)
+
+  Otherwise, as_rvalue_view(E)[.](#overview-2.2.sentence-1)
+
+[3](#overview-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4676)
+
+[*Example [1](#overview-example-1)*: vector<string> words = {"the", "quick", "brown", "fox", "ate", "a", "pterodactyl"};
+vector<string> new_words;
+ranges::copy(words | views::as_rvalue, back_inserter(new_words)); // moves each string from words into new_words — *end example*]
+
+#### [25.7.7.2](#view) Class template as_rvalue_view [[range.as.rvalue.view]](range.as.rvalue.view)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires [input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]")<V>class [as_rvalue_view](#lib:as_rvalue_view "25.7.7.2 Class template as_­rvalue_­view [range.as.rvalue.view]") : public view_interface<as_rvalue_view<V>> { V *base_* = V(); // *exposition only*public: as_rvalue_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> = default; constexpr explicit as_rvalue_view(V base); 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() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>){ return move_iterator(ranges::begin(*base_*)); }constexpr auto begin() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V>{ return move_iterator(ranges::begin(*base_*)); }constexpr auto end() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) {if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<V>) {return move_iterator(ranges::end(*base_*)); } else {return move_sentinel(ranges::end(*base_*)); }}constexpr auto end() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V> {if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<const V>) {return move_iterator(ranges::end(*base_*)); } else {return move_sentinel(ranges::end(*base_*)); }}constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V> { return ranges::size(*base_*); }constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V> { return ranges::size(*base_*); }constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>{ return ranges::reserve_hint(*base_*); }constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>{ return ranges::reserve_hint(*base_*); }}; template<class R> as_rvalue_view(R&&) -> as_rvalue_view<views::all_t<R>>;}
+
+[🔗](#lib:as_rvalue_view,constructor)
+
+`constexpr explicit as_rvalue_view(V base);
+`
+
+[1](#view-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4742)
+
+*Effects*: Initializes *base_* with std​::​move(base)[.](#view-1.sentence-1)

cppdraft/range/as/rvalue/overview.md

@@ -0,0 +1,46 @@
+[range.as.rvalue.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.as.rvalue.overview)
+
+### 25.7.7 As rvalue view [[range.as.rvalue]](range.as.rvalue#overview)
+
+#### 25.7.7.1 Overview [range.as.rvalue.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4654)
+
+as_rvalue_view presents a view of an underlying sequence
+with the same behavior as the underlying sequence
+except that its elements are rvalues[.](#1.sentence-1)
+
+Some generic algorithms can be called with an as_rvalue_view to replace copying with moving[.](#1.sentence-2)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4661)
+
+The name views​::​as_rvalue denotes
+a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#2.sentence-1)
+
+Let E be an expression and let T be decltype((E))[.](#2.sentence-2)
+
+The expression views​::​as_rvalue(E) is expression-equivalent to:
+
+- [(2.1)](#2.1)
+
+  views​::​all(E) ifT models [input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") and[same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<range_rvalue_reference_t<T>, range_reference_t<T>> is true[.](#2.1.sentence-1)
+
+- [(2.2)](#2.2)
+
+  Otherwise, as_rvalue_view(E)[.](#2.2.sentence-1)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4676)
+
+[*Example [1](#example-1)*: vector<string> words = {"the", "quick", "brown", "fox", "ate", "a", "pterodactyl"};
+vector<string> new_words;
+ranges::copy(words | views::as_rvalue, back_inserter(new_words)); // moves each string from words into new_words — *end example*]

cppdraft/range/as/rvalue/view.md

@@ -0,0 +1,22 @@
+[range.as.rvalue.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.as.rvalue.view)
+
+### 25.7.7 As rvalue view [[range.as.rvalue]](range.as.rvalue#view)
+
+#### 25.7.7.2 Class template as_rvalue_view [range.as.rvalue.view]
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires [input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]")<V>class [as_rvalue_view](#lib:as_rvalue_view "25.7.7.2 Class template as_­rvalue_­view [range.as.rvalue.view]") : public view_interface<as_rvalue_view<V>> { V *base_* = V(); // *exposition only*public: as_rvalue_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> = default; constexpr explicit as_rvalue_view(V base); 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() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>){ return move_iterator(ranges::begin(*base_*)); }constexpr auto begin() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V>{ return move_iterator(ranges::begin(*base_*)); }constexpr auto end() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) {if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<V>) {return move_iterator(ranges::end(*base_*)); } else {return move_sentinel(ranges::end(*base_*)); }}constexpr auto end() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V> {if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<const V>) {return move_iterator(ranges::end(*base_*)); } else {return move_sentinel(ranges::end(*base_*)); }}constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V> { return ranges::size(*base_*); }constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V> { return ranges::size(*base_*); }constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>{ return ranges::reserve_hint(*base_*); }constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>{ return ranges::reserve_hint(*base_*); }}; template<class R> as_rvalue_view(R&&) -> as_rvalue_view<views::all_t<R>>;}
+
+[🔗](#lib:as_rvalue_view,constructor)
+
+`constexpr explicit as_rvalue_view(V base);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4742)
+
+*Effects*: Initializes *base_* with std​::​move(base)[.](#1.sentence-1)

cppdraft/range/cache/latest.md

@@ -0,0 +1,263 @@
+[range.cache.latest]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.cache.latest)
+
+### 25.7.34 Cache latest view [range.cache.latest]
+
+#### [25.7.34.1](#overview) Overview [[range.cache.latest.overview]](range.cache.latest.overview)
+
+[1](#overview-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17363)
+
+cache_latest_view caches the last-accessed element of
+its underlying sequence
+so that the element does not have to be recomputed on repeated access[.](#overview-1.sentence-1)
+
+[*Note [1](#overview-note-1)*:
+
+This is useful if computation of the element to produce is expensive[.](#overview-1.sentence-2)
+
+— *end note*]
+
+[2](#overview-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17371)
+
+The name views​::​cache_latest denotes
+a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#overview-2.sentence-1)
+
+Let E be an expression[.](#overview-2.sentence-2)
+
+The expression views​::​cache_latest(E) is expression-equivalent tocache_latest_view(E)[.](#overview-2.sentence-3)
+
+#### [25.7.34.2](#view) Class template cache_latest_view [[range.cache.latest.view]](range.cache.latest.view)
+
+namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V>class [cache_latest_view](#lib:cache_latest_view "25.7.34.2 Class template cache_­latest_­view [range.cache.latest.view]") : public view_interface<cache_latest_view<V>> { V *base_* = V(); // *exposition only*using *cache-t* = conditional_t<is_reference_v<range_reference_t<V>>, // *exposition only* add_pointer_t<range_reference_t<V>>,
+ range_reference_t<V>>; *non-propagating-cache*<*cache-t*> *cache_*; // *exposition only*// [[range.cache.latest.iterator]](#iterator "25.7.34.3 Class cache_­latest_­view​::​iterator"), class cache_latest_view​::​*iterator*class *iterator*; // *exposition only*// [[range.cache.latest.sentinel]](#sentinel "25.7.34.4 Class cache_­latest_­view​::​sentinel"), class cache_latest_view​::​*sentinel*class *sentinel*; // *exposition only*public: cache_latest_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> = default; constexpr explicit cache_latest_view(V base); 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(); constexpr auto end(); constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>; constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>; constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>; constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>; }; template<class R> cache_latest_view(R&&) -> cache_latest_view<views::all_t<R>>;}
+
+[🔗](#lib:cache_latest_view,constructor)
+
+`constexpr explicit cache_latest_view(V base);
+`
+
+[1](#view-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17425)
+
+*Effects*: Initializes *base_* with std​::​move(base)[.](#view-1.sentence-1)
+
+[🔗](#lib:begin,cache_latest_view)
+
+`constexpr auto begin();
+`
+
+[2](#view-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17436)
+
+*Effects*: Equivalent to: return *iterator*(*this);
+
+[🔗](#lib:end,cache_latest_view)
+
+`constexpr auto end();
+`
+
+[3](#view-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17447)
+
+*Effects*: Equivalent to: return *sentinel*(*this);
+
+[🔗](#lib:size,cache_latest_view)
+
+`constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>;
+constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>;
+`
+
+[4](#view-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17459)
+
+*Effects*: Equivalent to: return ranges​::​size(*base_*);
+
+[🔗](#lib:reserve_hint,cache_latest_view)
+
+`constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>;
+constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>;
+`
+
+[5](#view-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17471)
+
+*Effects*: Equivalent to: return ranges​::​reserve_hint(*base_*);
+
+#### [25.7.34.3](#iterator) Class cache_latest_view​::​*iterator* [[range.cache.latest.iterator]](range.cache.latest.iterator)
+
+[🔗](#lib:cache_latest_view::iiterator)
+
+namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V>class cache_latest_view<V>::*iterator* { cache_latest_view* *parent_*; // *exposition only* iterator_t<V> *current_*; // *exposition only*constexpr explicit *iterator*(cache_latest_view& parent); // *exposition only*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](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<V>>; };}
+
+[🔗](#lib:cache_latest_view::iterator,constructor)
+
+`constexpr explicit iterator(cache_latest_view& parent);
+`
+
+[1](#iterator-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17521)
+
+*Effects*: Initializes *current_* withranges​::​begin(parent.*base_*) and *parent_* with addressof(parent)[.](#iterator-1.sentence-1)
+
+[🔗](#lib:base,cache_latest_view::iterator)
+
+`constexpr iterator_t<V> base() &&;
+`
+
+[2](#iterator-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17534)
+
+*Returns*: std​::​move(*current_*)[.](#iterator-2.sentence-1)
+
+[🔗](#lib:base,cache_latest_view::iterator_)
+
+`constexpr const iterator_t<V>& base() const & noexcept;
+`
+
+[3](#iterator-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17545)
+
+*Returns*: *current_*[.](#iterator-3.sentence-1)
+
+[🔗](#lib:operator++,cache_latest_view::iterator)
+
+`constexpr iterator& operator++();
+`
+
+[4](#iterator-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17556)
+
+*Effects*: Equivalent to:*parent_*->*cache_*.reset();++*current_*;return *this;
+
+[🔗](#lib:operator++,cache_latest_view::iterator_)
+
+`constexpr void operator++(int);
+`
+
+[5](#iterator-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17572)
+
+*Effects*: Equivalent to: ++*this[.](#iterator-5.sentence-1)
+
+[🔗](#lib:operator*,cache_latest_view::iterator)
+
+`constexpr range_reference_t<V>& operator*() const;
+`
+
+[6](#iterator-6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17583)
+
+*Effects*: Equivalent to:if constexpr (is_reference_v<range_reference_t<V>>) {if (!*parent_*->*cache_*) {*parent_*->*cache_* = addressof(*as-lvalue*(**current_*)); }return ***parent_*->*cache_*;} else {if (!*parent_*->c*ache_*) {*parent_*->*cache_*.*emplace-deref*(*current_*); }return **parent_*->*cache_*;}
+
+[*Note [1](#iterator-note-1)*:
+
+Evaluations of operator* on the same iterator object
+can conflict ([[intro.races]](intro.races "6.10.2.2 Data races"))[.](#iterator-6.sentence-1)
+
+— *end note*]
+
+[🔗](#lib:iter_move,cache_latest_view::iterator)
+
+`friend constexpr range_rvalue_reference_t<V> iter_move(const iterator& i)
+  noexcept(noexcept(ranges::iter_move(i.current_)));
+`
+
+[7](#iterator-7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17612)
+
+*Effects*: Equivalent to: return ranges​::​iter_move(i.*current_*);
+
+[🔗](#lib:iter_swap,cache_latest_view::iterator)
+
+`friend constexpr void iter_swap(const iterator& x, const iterator& y)
+  noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
+  requires [indirectly_swappable](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<V>>;
+`
+
+[8](#iterator-8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17625)
+
+*Effects*: Equivalent toranges​::​iter_swap(x.*current_*, y.*current_*)[.](#iterator-8.sentence-1)
+
+#### [25.7.34.4](#sentinel) Class cache_latest_view​::​*sentinel* [[range.cache.latest.sentinel]](range.cache.latest.sentinel)
+
+[🔗](#lib:cache_latest_view::sentinel)
+
+namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V>class cache_latest_view<V>::*sentinel* { sentinel_t<V> *end_* = sentinel_t<V>(); // *exposition only*constexpr explicit *sentinel*(cache_latest_view& parent); // *exposition only*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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>; friend constexpr range_difference_t<V> operator-(const *sentinel*& x, const *iterator*& y)requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>; };}
+
+[🔗](#lib:cache_latest_view::sentinel,constructor)
+
+`constexpr explicit sentinel(cache_latest_view& parent);
+`
+
+[1](#sentinel-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17664)
+
+*Effects*: Initializes *end_* with ranges​::​end(parent.*base_*)[.](#sentinel-1.sentence-1)
+
+[🔗](#lib:base,cache_latest_view::sentinel)
+
+`constexpr sentinel_t<V> base() const;
+`
+
+[2](#sentinel-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17675)
+
+*Returns*: *end_*[.](#sentinel-2.sentence-1)
+
+[🔗](#lib:operator==,cache_latest_view::iterator)
+
+`friend constexpr bool operator==(const iterator& x, const sentinel& y);
+`
+
+[3](#sentinel-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17687)
+
+*Returns*: x.*current_* == y.*end_*[.](#sentinel-3.sentence-1)
+
+[🔗](#lib:operator-,cache_latest_view::iterator)
+
+`friend constexpr range_difference_t<V> operator-(const iterator& x, const sentinel& y)
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>;
+`
+
+[4](#sentinel-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17700)
+
+*Returns*: x.*current_* - y.*end_*[.](#sentinel-4.sentence-1)
+
+[🔗](#lib:operator-,cache_latest_view::iterator_)
+
+`friend constexpr range_difference_t<V> operator-(const sentinel& x, const iterator& y)
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>;
+`
+
+[5](#sentinel-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17713)
+
+*Returns*: x.*end_* - y.*current_*[.](#sentinel-5.sentence-1)

cppdraft/range/cache/latest/iterator.md

@@ -0,0 +1,111 @@
+[range.cache.latest.iterator]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.cache.latest.iterator)
+
+### 25.7.34 Cache latest view [[range.cache.latest]](range.cache.latest#iterator)
+
+#### 25.7.34.3 Class cache_latest_view​::​*iterator* [range.cache.latest.iterator]
+
+[🔗](#lib:cache_latest_view::iiterator)
+
+namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V>class cache_latest_view<V>::*iterator* { cache_latest_view* *parent_*; // *exposition only* iterator_t<V> *current_*; // *exposition only*constexpr explicit *iterator*(cache_latest_view& parent); // *exposition only*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](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<V>>; };}
+
+[🔗](#lib:cache_latest_view::iterator,constructor)
+
+`constexpr explicit iterator(cache_latest_view& parent);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17521)
+
+*Effects*: Initializes *current_* withranges​::​begin(parent.*base_*) and *parent_* with addressof(parent)[.](#1.sentence-1)
+
+[🔗](#lib:base,cache_latest_view::iterator)
+
+`constexpr iterator_t<V> base() &&;
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17534)
+
+*Returns*: std​::​move(*current_*)[.](#2.sentence-1)
+
+[🔗](#lib:base,cache_latest_view::iterator_)
+
+`constexpr const iterator_t<V>& base() const & noexcept;
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17545)
+
+*Returns*: *current_*[.](#3.sentence-1)
+
+[🔗](#lib:operator++,cache_latest_view::iterator)
+
+`constexpr iterator& operator++();
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17556)
+
+*Effects*: Equivalent to:*parent_*->*cache_*.reset();++*current_*;return *this;
+
+[🔗](#lib:operator++,cache_latest_view::iterator_)
+
+`constexpr void operator++(int);
+`
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17572)
+
+*Effects*: Equivalent to: ++*this[.](#5.sentence-1)
+
+[🔗](#lib:operator*,cache_latest_view::iterator)
+
+`constexpr range_reference_t<V>& operator*() const;
+`
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17583)
+
+*Effects*: Equivalent to:if constexpr (is_reference_v<range_reference_t<V>>) {if (!*parent_*->*cache_*) {*parent_*->*cache_* = addressof(*as-lvalue*(**current_*)); }return ***parent_*->*cache_*;} else {if (!*parent_*->c*ache_*) {*parent_*->*cache_*.*emplace-deref*(*current_*); }return **parent_*->*cache_*;}
+
+[*Note [1](#note-1)*:
+
+Evaluations of operator* on the same iterator object
+can conflict ([[intro.races]](intro.races "6.10.2.2 Data races"))[.](#6.sentence-1)
+
+— *end note*]
+
+[🔗](#lib:iter_move,cache_latest_view::iterator)
+
+`friend constexpr range_rvalue_reference_t<V> iter_move(const iterator& i)
+  noexcept(noexcept(ranges::iter_move(i.current_)));
+`
+
+[7](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17612)
+
+*Effects*: Equivalent to: return ranges​::​iter_move(i.*current_*);
+
+[🔗](#lib:iter_swap,cache_latest_view::iterator)
+
+`friend constexpr void iter_swap(const iterator& x, const iterator& y)
+  noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
+  requires [indirectly_swappable](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<V>>;
+`
+
+[8](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17625)
+
+*Effects*: Equivalent toranges​::​iter_swap(x.*current_*, y.*current_*)[.](#8.sentence-1)

cppdraft/range/cache/latest/overview.md

@@ -0,0 +1,34 @@
+[range.cache.latest.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.cache.latest.overview)
+
+### 25.7.34 Cache latest view [[range.cache.latest]](range.cache.latest#overview)
+
+#### 25.7.34.1 Overview [range.cache.latest.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17363)
+
+cache_latest_view caches the last-accessed element of
+its underlying sequence
+so that the element does not have to be recomputed on repeated access[.](#1.sentence-1)
+
+[*Note [1](#note-1)*:
+
+This is useful if computation of the element to produce is expensive[.](#1.sentence-2)
+
+— *end note*]
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17371)
+
+The name views​::​cache_latest denotes
+a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#2.sentence-1)
+
+Let E be an expression[.](#2.sentence-2)
+
+The expression views​::​cache_latest(E) is expression-equivalent tocache_latest_view(E)[.](#2.sentence-3)

cppdraft/range/cache/latest/sentinel.md

@@ -0,0 +1,70 @@
+[range.cache.latest.sentinel]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.cache.latest.sentinel)
+
+### 25.7.34 Cache latest view [[range.cache.latest]](range.cache.latest#sentinel)
+
+#### 25.7.34.4 Class cache_latest_view​::​*sentinel* [range.cache.latest.sentinel]
+
+[🔗](#lib:cache_latest_view::sentinel)
+
+namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V>class cache_latest_view<V>::*sentinel* { sentinel_t<V> *end_* = sentinel_t<V>(); // *exposition only*constexpr explicit *sentinel*(cache_latest_view& parent); // *exposition only*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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>; friend constexpr range_difference_t<V> operator-(const *sentinel*& x, const *iterator*& y)requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>; };}
+
+[🔗](#lib:cache_latest_view::sentinel,constructor)
+
+`constexpr explicit sentinel(cache_latest_view& parent);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17664)
+
+*Effects*: Initializes *end_* with ranges​::​end(parent.*base_*)[.](#1.sentence-1)
+
+[🔗](#lib:base,cache_latest_view::sentinel)
+
+`constexpr sentinel_t<V> base() const;
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17675)
+
+*Returns*: *end_*[.](#2.sentence-1)
+
+[🔗](#lib:operator==,cache_latest_view::iterator)
+
+`friend constexpr bool operator==(const iterator& x, const sentinel& y);
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17687)
+
+*Returns*: x.*current_* == y.*end_*[.](#3.sentence-1)
+
+[🔗](#lib:operator-,cache_latest_view::iterator)
+
+`friend constexpr range_difference_t<V> operator-(const iterator& x, const sentinel& y)
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>;
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17700)
+
+*Returns*: x.*current_* - y.*end_*[.](#4.sentence-1)
+
+[🔗](#lib:operator-,cache_latest_view::iterator_)
+
+`friend constexpr range_difference_t<V> operator-(const sentinel& x, const iterator& y)
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>;
+`
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17713)
+
+*Returns*: x.*end_* - y.*current_*[.](#5.sentence-1)

cppdraft/range/cache/latest/view.md

@@ -0,0 +1,69 @@
+[range.cache.latest.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.cache.latest.view)
+
+### 25.7.34 Cache latest view [[range.cache.latest]](range.cache.latest#view)
+
+#### 25.7.34.2 Class template cache_latest_view [range.cache.latest.view]
+
+namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V>class [cache_latest_view](#lib:cache_latest_view "25.7.34.2 Class template cache_­latest_­view [range.cache.latest.view]") : public view_interface<cache_latest_view<V>> { V *base_* = V(); // *exposition only*using *cache-t* = conditional_t<is_reference_v<range_reference_t<V>>, // *exposition only* add_pointer_t<range_reference_t<V>>,
+ range_reference_t<V>>; *non-propagating-cache*<*cache-t*> *cache_*; // *exposition only*// [[range.cache.latest.iterator]](range.cache.latest.iterator "25.7.34.3 Class cache_­latest_­view​::​iterator"), class cache_latest_view​::​*iterator*class *iterator*; // *exposition only*// [[range.cache.latest.sentinel]](range.cache.latest.sentinel "25.7.34.4 Class cache_­latest_­view​::​sentinel"), class cache_latest_view​::​*sentinel*class *sentinel*; // *exposition only*public: cache_latest_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> = default; constexpr explicit cache_latest_view(V base); 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(); constexpr auto end(); constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>; constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>; constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>; constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>; }; template<class R> cache_latest_view(R&&) -> cache_latest_view<views::all_t<R>>;}
+
+[🔗](#lib:cache_latest_view,constructor)
+
+`constexpr explicit cache_latest_view(V base);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17425)
+
+*Effects*: Initializes *base_* with std​::​move(base)[.](#1.sentence-1)
+
+[🔗](#lib:begin,cache_latest_view)
+
+`constexpr auto begin();
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17436)
+
+*Effects*: Equivalent to: return *iterator*(*this);
+
+[🔗](#lib:end,cache_latest_view)
+
+`constexpr auto end();
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17447)
+
+*Effects*: Equivalent to: return *sentinel*(*this);
+
+[🔗](#lib:size,cache_latest_view)
+
+`constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>;
+constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>;
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17459)
+
+*Effects*: Equivalent to: return ranges​::​size(*base_*);
+
+[🔗](#lib:reserve_hint,cache_latest_view)
+
+`constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>;
+constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>;
+`
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17471)
+
+*Effects*: Equivalent to: return ranges​::​reserve_hint(*base_*);

cppdraft/range/cartesian.md

@@ -0,0 +1,627 @@
+[range.cartesian]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.cartesian)
+
+### 25.7.33 Cartesian product view [range.cartesian]
+
+#### [25.7.33.1](#overview) Overview [[range.cartesian.overview]](range.cartesian.overview)
+
+[1](#overview-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16562)
+
+cartesian_product_view takes any non-zero number of ranges n and
+produces a view of tuples calculated by
+the n-ary cartesian product of the provided ranges[.](#overview-1.sentence-1)
+
+[2](#overview-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16567)
+
+The name views​::​cartesian_product denotes a customization point object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#overview-2.sentence-1)
+
+Given a pack of subexpressions Es,
+the expression views​::​cartesian_product(Es...) is expression-equivalent to
+
+- [(2.1)](#overview-2.1)
+
+views​::​single(tuple()) if Es is an empty pack,
+
+- [(2.2)](#overview-2.2)
+
+otherwise,cartesian_product_view<views​::​all_t<decltype((Es))>...>(Es...)[.](#overview-2.sentence-2)
+
+[3](#overview-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16581)
+
+[*Example [1](#overview-example-1)*: vector<int> v { 0, 1, 2 };for (auto&& [a, b, c] : views::cartesian_product(v, v, v)) { cout << a << ' ' << b << ' ' << c << '\n';}// The above prints// 0 0 0// 0 0 1// 0 0 2// 0 1 0// 0 1 1// ... — *end example*]
+
+#### [25.7.33.2](#view) Class template cartesian_product_view [[range.cartesian.view]](range.cartesian.view)
+
+[🔗](#lib:cartesian_product_view_)
+
+namespace std::ranges {template<bool Const, class First, class... Vs>concept [*cartesian-product-is-random-access*](#concept:cartesian-product-is-random-access "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]") = // *exposition only*([random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*maybe-const*<Const, First>> && ... &&([random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*maybe-const*<Const, Vs>>&& [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<*maybe-const*<Const, Vs>>)); template<class R>concept [*cartesian-product-common-arg*](#concept:cartesian-product-common-arg "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]") = // *exposition only*[common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<R> || ([sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R> && [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<R>); template<bool Const, class First, class... Vs>concept [*cartesian-product-is-bidirectional*](#concept:cartesian-product-is-bidirectional "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]") = // *exposition only*([bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<*maybe-const*<Const, First>> && ... &&([bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<*maybe-const*<Const, Vs>>&& [*cartesian-product-common-arg*](#concept:cartesian-product-common-arg "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<*maybe-const*<Const, Vs>>)); template<class First, class...>concept [*cartesian-product-is-common*](#concept:cartesian-product-is-common "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]") = // *exposition only*[*cartesian-product-common-arg*](#concept:cartesian-product-common-arg "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<First>; template<class... Vs>concept [*cartesian-product-is-sized*](#concept:cartesian-product-is-sized "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]") = // *exposition only*([sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<Vs> && ...); template<bool Const, template<class> class FirstSent, class First, class... Vs>concept [*cartesian-is-sized-sentinel*](#concept:cartesian-is-sized-sentinel "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]") = // *exposition only*([sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<FirstSent<*maybe-const*<Const, First>>,
+ iterator_t<*maybe-const*<Const, First>>> && ...&& ([sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<*maybe-const*<Const, Vs>>&& [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<iterator_t<*maybe-const*<Const, Vs>>,
+ iterator_t<*maybe-const*<Const, Vs>>>)); template<[*cartesian-product-common-arg*](#concept:cartesian-product-common-arg "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]") R>constexpr auto *cartesian-common-arg-end*(R& r) { // *exposition only*if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<R>) {return ranges::end(r); } else {return ranges::begin(r) + ranges::distance(r); }}template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") First, [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")... Vs>requires ([view](range.view#concept:view "25.4.5 Views [range.view]")<First> && ... && [view](range.view#concept:view "25.4.5 Views [range.view]")<Vs>)class cartesian_product_view : public view_interface<cartesian_product_view<First, Vs...>> {private: tuple<First, Vs...> *bases_*; // *exposition only*// [[range.cartesian.iterator]](#iterator "25.7.33.3 Class template cartesian_­product_­view​::​iterator"), class template cartesian_product_view​::​*iterator*template<bool Const> class *iterator*; // *exposition only*public:constexpr cartesian_product_view() = default; constexpr explicit cartesian_product_view(First first_base, Vs... bases); constexpr *iterator*<false> begin()requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<First> || ... || ![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<Vs>); constexpr *iterator*<true> begin() constrequires ([range](range.range#concept:range "25.4.2 Ranges [range.range]")<const First> && ... && [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const Vs>); constexpr *iterator*<false> end()requires ((![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<First> || ... || ![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<Vs>) &&[*cartesian-product-is-common*](#concept:cartesian-product-is-common "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<First, Vs...>); constexpr *iterator*<true> end() constrequires [*cartesian-product-is-common*](#concept:cartesian-product-is-common "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<const First, const Vs...>; constexpr default_sentinel_t end() const noexcept; constexpr *see below* size()requires [*cartesian-product-is-sized*](#concept:cartesian-product-is-sized "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<First, Vs...>; constexpr *see below* size() constrequires [*cartesian-product-is-sized*](#concept:cartesian-product-is-sized "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<const First, const Vs...>; }; template<class... Vs> cartesian_product_view(Vs&&...) -> cartesian_product_view<views::all_t<Vs>...>;}
+
+[🔗](#lib:cartesian_product_view,constructor)
+
+`constexpr explicit cartesian_product_view(First first_base, Vs... bases);
+`
+
+[1](#view-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16685)
+
+*Effects*: Initializes *bases_* with std​::​move(first_base), std​::​move(bases)...[.](#view-1.sentence-1)
+
+[🔗](#lib:begin,cartesian_product_view)
+
+`constexpr iterator<false> begin()
+  requires (![simple-view](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<First> || ... || ![simple-view](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<Vs>);
+`
+
+[2](#view-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16698)
+
+*Effects*: Equivalent to:return *iterator*<false>(*this, *tuple-transform*(ranges::begin, *bases_*));
+
+[🔗](#lib:begin,cartesian_product_view_)
+
+`constexpr iterator<true> begin() const
+  requires ([range](range.range#concept:range "25.4.2 Ranges [range.range]")<const First> && ... && [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const Vs>);
+`
+
+[3](#view-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16713)
+
+*Effects*: Equivalent to:return *iterator*<true>(*this, *tuple-transform*(ranges::begin, *bases_*));
+
+[🔗](#lib:end,cartesian_product_view)
+
+`constexpr iterator<false> end()
+  requires ((![simple-view](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<First> || ... || ![simple-view](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<Vs>)
+    && [cartesian-product-is-common](#concept:cartesian-product-is-common "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<First, Vs...>);
+constexpr iterator<true> end() const
+  requires [cartesian-product-is-common](#concept:cartesian-product-is-common "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<const First, const Vs...>;
+`
+
+[4](#view-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16731)
+
+Let:
+
+- [(4.1)](#view-4.1)
+
+*is-const* be true for the const-qualified overload, andfalse otherwise;
+
+- [(4.2)](#view-4.2)
+
+*is-empty* be true if the expression ranges​::​empty(rng) is true for any rng among the underlying ranges except the first one andfalse otherwise; and
+
+- [(4.3)](#view-4.3)
+
+*begin-or-first-end*(rng) be expression-equivalent to*is-empty* ? ranges​::​begin(rng) : ​*cartesian-common-arg-end*(rng) if rng is the first underlying range andranges​::​begin(rng) otherwise[.](#view-4.sentence-1)
+
+[5](#view-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16749)
+
+*Effects*: Equivalent to:*iterator*<*is-const*> it(*this, *tuple-transform*([](auto& rng){ return *begin-or-first-end*(rng); }, *bases_*));return it;
+
+[🔗](#lib:end,cartesian_product_view_)
+
+`constexpr default_sentinel_t end() const noexcept;
+`
+
+[6](#view-6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16765)
+
+*Returns*: default_sentinel[.](#view-6.sentence-1)
+
+[🔗](#lib:size,cartesian_product_view)
+
+`constexpr see below size()
+  requires [cartesian-product-is-sized](#concept:cartesian-product-is-sized "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<First, Vs...>;
+constexpr see below size() const
+  requires [cartesian-product-is-sized](#concept:cartesian-product-is-sized "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<const First, const Vs...>;
+`
+
+[7](#view-7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16779)
+
+The return type is an implementation-defined unsigned-integer-like type[.](#view-7.sentence-1)
+
+[8](#view-8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16782)
+
+*Recommended practice*: The return type should be the smallest unsigned-integer-like type
+that is sufficiently wide to store the product of the maximum sizes of
+all the underlying ranges, if such a type exists[.](#view-8.sentence-1)
+
+[9](#view-9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16788)
+
+Let p be the product of the sizes of all the ranges in *bases_*[.](#view-9.sentence-1)
+
+[10](#view-10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16791)
+
+*Preconditions*: p can be represented by the return type[.](#view-10.sentence-1)
+
+[11](#view-11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16795)
+
+*Returns*: p[.](#view-11.sentence-1)
+
+#### [25.7.33.3](#iterator) Class template cartesian_product_view​::​*iterator* [[range.cartesian.iterator]](range.cartesian.iterator)
+
+[🔗](#lib:cartesian_product_view::iterator)
+
+namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") First, [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")... Vs>requires ([view](range.view#concept:view "25.4.5 Views [range.view]")<First> && ... && [view](range.view#concept:view "25.4.5 Views [range.view]")<Vs>)template<bool Const>class cartesian_product_view<First, Vs...>::*iterator* {public:using iterator_category = input_iterator_tag; using iterator_concept = *see below*; using value_type = tuple<range_value_t<*maybe-const*<Const, First>>,
+ range_value_t<*maybe-const*<Const, Vs>>...>; using reference = tuple<range_reference_t<*maybe-const*<Const, First>>,
+ range_reference_t<*maybe-const*<Const, Vs>>...>; using difference_type = *see below*; *iterator*() = default; constexpr *iterator*(*iterator*<!Const> i) requires Const &&([convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<iterator_t<First>, iterator_t<const First>> &&... && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<iterator_t<Vs>, iterator_t<const Vs>>); constexpr auto operator*() const; constexpr *iterator*& operator++(); constexpr void operator++(int); constexpr *iterator* operator++(int) requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<*maybe-const*<Const, First>>; constexpr *iterator*& operator--()requires [*cartesian-product-is-bidirectional*](#concept:cartesian-product-is-bidirectional "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>; constexpr *iterator* operator--(int)requires [*cartesian-product-is-bidirectional*](#concept:cartesian-product-is-bidirectional "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>; constexpr *iterator*& operator+=(difference_type x)requires [*cartesian-product-is-random-access*](#concept:cartesian-product-is-random-access "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>; constexpr *iterator*& operator-=(difference_type x)requires [*cartesian-product-is-random-access*](#concept:cartesian-product-is-random-access "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>; constexpr reference operator[](difference_type n) constrequires [*cartesian-product-is-random-access*](#concept:cartesian-product-is-random-access "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>; 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, First>>>; friend constexpr bool operator==(const *iterator*& x, default_sentinel_t); 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, First, Vs...>; friend constexpr *iterator* operator+(const *iterator*& x, difference_type y)requires [*cartesian-product-is-random-access*](#concept:cartesian-product-is-random-access "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>; friend constexpr *iterator* operator+(difference_type x, const *iterator*& y)requires [*cartesian-product-is-random-access*](#concept:cartesian-product-is-random-access "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>; friend constexpr *iterator* operator-(const *iterator*& x, difference_type y)requires [*cartesian-product-is-random-access*](#concept:cartesian-product-is-random-access "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>; friend constexpr difference_type operator-(const *iterator*& x, const *iterator*& y)requires [*cartesian-is-sized-sentinel*](#concept:cartesian-is-sized-sentinel "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, iterator_t, First, Vs...>; friend constexpr difference_type operator-(const *iterator*& i, default_sentinel_t)requires [*cartesian-is-sized-sentinel*](#concept:cartesian-is-sized-sentinel "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, sentinel_t, First, Vs...>; friend constexpr difference_type operator-(default_sentinel_t, const *iterator*& i)requires [*cartesian-is-sized-sentinel*](#concept:cartesian-is-sized-sentinel "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, sentinel_t, First, Vs...>; friend constexpr auto iter_move(const *iterator*& i) noexcept(*see below*); friend constexpr void iter_swap(const *iterator*& l, const *iterator*& r) noexcept(*see below*)requires ([indirectly_swappable](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<*maybe-const*<Const, First>>> && ... &&[indirectly_swappable](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<*maybe-const*<Const, Vs>>>); private:using *Parent* = *maybe-const*<Const, cartesian_product_view>; // *exposition only**Parent** *parent_* = nullptr; // *exposition only* tuple<iterator_t<*maybe-const*<Const, First>>,
+ iterator_t<*maybe-const*<Const, Vs>>...> *current_*; // *exposition only*template<size_t N = sizeof...(Vs)>constexpr void *next*(); // *exposition only*template<size_t N = sizeof...(Vs)>constexpr void *prev*(); // *exposition only*template<class Tuple>constexpr difference_type *distance-from*(const Tuple& t) const; // *exposition only*constexpr *iterator*(*Parent*& parent, tuple<iterator_t<*maybe-const*<Const, First>>,
+ iterator_t<*maybe-const*<Const, Vs>>...> current); // *exposition only*};}
+
+[1](#iterator-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16891)
+
+*iterator*​::​iterator_concept is defined as follows:
+
+- [(1.1)](#iterator-1.1)
+
+  If [*cartesian-product-is-random-access*](#concept:cartesian-product-is-random-access "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...> is modeled,
+then iterator_concept denotes random_access_iterator_tag[.](#iterator-1.1.sentence-1)
+
+- [(1.2)](#iterator-1.2)
+
+  Otherwise,
+if [*cartesian-product-is-bidirectional*](#concept:cartesian-product-is-bidirectional "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...> is modeled,
+then iterator_concept denotes bidirectional_iterator_tag[.](#iterator-1.2.sentence-1)
+
+- [(1.3)](#iterator-1.3)
+
+  Otherwise,
+if *maybe-const*<Const, First> models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]"),
+then iterator_concept denotes forward_iterator_tag[.](#iterator-1.3.sentence-1)
+
+- [(1.4)](#iterator-1.4)
+
+  Otherwise, iterator_concept denotes input_iterator_tag[.](#iterator-1.4.sentence-1)
+
+[2](#iterator-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16911)
+
+*iterator*​::​difference_type is
+an implementation-defined
+signed-integer-like type[.](#iterator-2.sentence-1)
+
+[3](#iterator-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16916)
+
+*Recommended practice*: *iterator*​::​difference_type should be
+the smallest signed-integer-like type
+that is sufficiently wide to store
+the product of the maximum sizes of all underlying ranges
+if such a type exists[.](#iterator-3.sentence-1)
+
+[🔗](#lib:next,cartesian_product_view)
+
+`template<size_t N = sizeof...(Vs)>
+  constexpr void next();
+`
+
+[4](#iterator-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16931)
+
+*Effects*: Equivalent to:auto& it = std::get<N>(*current_*);++it;if constexpr (N > 0) {if (it == ranges::end(std::get<N>(*parent_*->*bases_*))) { it = ranges::begin(std::get<N>(*parent_*->*bases_*)); *next*<N - 1>(); }}
+
+[🔗](#lib:prev,cartesian_product_view)
+
+`template<size_t N = sizeof...(Vs)>
+  constexpr void prev();
+`
+
+[5](#iterator-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16953)
+
+*Effects*: Equivalent to:auto& it = std::get<N>(*current_*);if constexpr (N > 0) {if (it == ranges::begin(std::get<N>(*parent_*->*bases_*))) { it = *cartesian-common-arg-end*(std::get<N>(*parent_*->*bases_*)); *prev*<N - 1>(); }}--it;
+
+[🔗](#lib:distance-from,cartesian_product_view)
+
+`template<class Tuple>
+  constexpr difference_type distance-from(const Tuple& t) const;
+`
+
+[6](#iterator-6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16975)
+
+Let:
+
+- [(6.1)](#iterator-6.1)
+
+*scaled-size*(N) be the product ofstatic_cast<difference_type>(ranges​::​size(std​::​get<​N>(*parent_*->*bases_*))) andscaled-size(N+1) if N ≤ sizeof...(Vs), otherwise static_cast<difference_type>(1);
+
+- [(6.2)](#iterator-6.2)
+
+*scaled-distance*(N) be the product ofstatic_cast<difference_type>(std​::​get<N>(*current_*) - std​::​get<N>(t)) and scaled-size(N+1); and
+
+- [(6.3)](#iterator-6.3)
+
+*scaled-sum* be the sum of *scaled-distance*(N) for every integer 0 ≤ N ≤ sizeof...(Vs)[.](#iterator-6.sentence-1)
+
+[7](#iterator-7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16991)
+
+*Preconditions*: *scaled-sum* can be represented by difference_type[.](#iterator-7.sentence-1)
+
+[8](#iterator-8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16995)
+
+*Returns*: *scaled-sum*[.](#iterator-8.sentence-1)
+
+[🔗](#lib:cartesian_product_view::iterator,constructor)
+
+`constexpr iterator(Parent& parent, tuple<iterator_t<maybe-const<Const, First>>,
+  iterator_t<maybe-const<Const, Vs>>...> current);
+`
+
+[9](#iterator-9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17007)
+
+*Effects*: Initializes*parent_* with addressof(parent) and*current_* with std​::​move(current)[.](#iterator-9.sentence-1)
+
+[🔗](#lib:cartesian_product_view::iterator,constructor_)
+
+`constexpr iterator(iterator<!Const> i) requires Const &&
+  ([convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<iterator_t<First>, iterator_t<const First>> &&
+    ... && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<iterator_t<Vs>, iterator_t<const Vs>>);
+`
+
+[10](#iterator-10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17022)
+
+*Effects*: Initializes*parent_* with i.*parent_* and*current_* with std​::​move(i.*current_*)[.](#iterator-10.sentence-1)
+
+[🔗](#lib:operator*,cartesian_product_view::iterator)
+
+`constexpr auto operator*() const;
+`
+
+[11](#iterator-11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17035)
+
+*Effects*: Equivalent to:return *tuple-transform*([](auto& i) -> decltype(auto) { return *i; }, *current_*);
+
+[🔗](#lib:operator++,cartesian_product_view::iterator)
+
+`constexpr iterator& operator++();
+`
+
+[12](#iterator-12)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17049)
+
+*Effects*: Equivalent to:*next*();return *this;
+
+[🔗](#lib:operator++,cartesian_product_view::iterator_)
+
+`constexpr void operator++(int);
+`
+
+[13](#iterator-13)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17064)
+
+*Effects*: Equivalent to ++*this[.](#iterator-13.sentence-1)
+
+[🔗](#lib:operator++,cartesian_product_view::iterator__)
+
+`constexpr iterator operator++(int) requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<maybe-const<Const, First>>;
+`
+
+[14](#iterator-14)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17075)
+
+*Effects*: Equivalent to:auto tmp = *this;++*this;return tmp;
+
+[🔗](#lib:operator--,cartesian_product_view::iterator)
+
+`constexpr iterator& operator--()
+  requires [cartesian-product-is-bidirectional](#concept:cartesian-product-is-bidirectional "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>;
+`
+
+[15](#iterator-15)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17092)
+
+*Effects*: Equivalent to:*prev*();return *this;
+
+[🔗](#lib:operator--,cartesian_product_view::iterator_)
+
+`constexpr iterator operator--(int)
+  requires [cartesian-product-is-bidirectional](#concept:cartesian-product-is-bidirectional "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>;
+`
+
+[16](#iterator-16)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17108)
+
+*Effects*: Equivalent to:auto tmp = *this;--*this;return tmp;
+
+[🔗](#lib:operator+=,cartesian_product_view::iterator)
+
+`constexpr iterator& operator+=(difference_type x)
+  requires [cartesian-product-is-random-access](#concept:cartesian-product-is-random-access "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>;
+`
+
+[17](#iterator-17)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17125)
+
+Let orig be the value of *this before the call[.](#iterator-17.sentence-1)
+
+Let ret be:
+
+- [(17.1)](#iterator-17.1)
+
+  If x > 0,
+the value of *this had *next* been called x times[.](#iterator-17.1.sentence-1)
+
+- [(17.2)](#iterator-17.2)
+
+  Otherwise, if x < 0,
+the value of *this had *prev* been called -x times[.](#iterator-17.2.sentence-1)
+
+- [(17.3)](#iterator-17.3)
+
+  Otherwise, orig[.](#iterator-17.3.sentence-1)
+
+[18](#iterator-18)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17140)
+
+*Preconditions*: x is in the range[ranges​::​distance(*this, ranges​::​begin(**parent_*)),  
+ranges​::​distance(*this, ranges​::​end(**parent_*))][.](#iterator-18.sentence-1)
+
+[19](#iterator-19)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17146)
+
+*Effects*: Sets the value of *this to ret[.](#iterator-19.sentence-1)
+
+[20](#iterator-20)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17150)
+
+*Returns*: *this[.](#iterator-20.sentence-1)
+
+[21](#iterator-21)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17154)
+
+*Complexity*: Constant[.](#iterator-21.sentence-1)
+
+[🔗](#lib:operator-=,cartesian_product_view::iterator)
+
+`constexpr iterator& operator-=(difference_type x)
+  requires [cartesian-product-is-random-access](#concept:cartesian-product-is-random-access "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>;
+`
+
+[22](#iterator-22)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17166)
+
+*Effects*: Equivalent to:*this += -x;return *this;
+
+[🔗](#lib:operator%5b%5d,cartesian_product_view::iterator)
+
+`constexpr reference operator[](difference_type n) const
+  requires [cartesian-product-is-random-access](#concept:cartesian-product-is-random-access "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>;
+`
+
+[23](#iterator-23)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17182)
+
+*Effects*: Equivalent to: return *((*this) + n);
+
+[🔗](#lib:operator==,cartesian_product_view::iterator)
+
+`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, First>>>;
+`
+
+[24](#iterator-24)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17194)
+
+*Effects*: Equivalent to: return x.*current_* == y.*current_*;
+
+[🔗](#lib:operator==,cartesian_product_view::iterator_)
+
+`friend constexpr bool operator==(const iterator& x, default_sentinel_t);
+`
+
+[25](#iterator-25)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17205)
+
+*Returns*: true if std​::​get<i>(x.*current_*) == ranges​::​end(std​::​get<i>(x.*parent_*->*bases_*)) is true for any integer 0 ≤ i ≤ sizeof...(Vs);
+otherwise, false[.](#iterator-25.sentence-1)
+
+[🔗](#lib:operator%3c=%3e,cartesian_product_view::iterator)
+
+`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, First, Vs...>;
+`
+
+[26](#iterator-26)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17220)
+
+*Effects*: Equivalent to: return x.*current_* <=> y.*current_*;
+
+[🔗](#lib:operator+,cartesian_product_view::iterator)
+
+`friend constexpr iterator operator+(const iterator& x, difference_type y)
+  requires [cartesian-product-is-random-access](#concept:cartesian-product-is-random-access "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>;
+`
+
+[27](#iterator-27)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17232)
+
+*Effects*: Equivalent to: return *iterator*(x) += y;
+
+[🔗](#lib:operator+,cartesian_product_view::iterator_)
+
+`friend constexpr iterator operator+(difference_type x, const iterator& y)
+  requires [cartesian-product-is-random-access](#concept:cartesian-product-is-random-access "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>;
+`
+
+[28](#iterator-28)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17244)
+
+*Effects*: Equivalent to: return y + x;
+
+[🔗](#lib:operator-,cartesian_product_view::iterator)
+
+`friend constexpr iterator operator-(const iterator& x, difference_type y)
+  requires [cartesian-product-is-random-access](#concept:cartesian-product-is-random-access "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, First, Vs...>;
+`
+
+[29](#iterator-29)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17256)
+
+*Effects*: Equivalent to: return *iterator*(x) -= y;
+
+[🔗](#lib:operator-,cartesian_product_view::iterator_)
+
+`friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+  requires [cartesian-is-sized-sentinel](#concept:cartesian-is-sized-sentinel "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, iterator_t, First, Vs...>;
+`
+
+[30](#iterator-30)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17268)
+
+*Effects*: Equivalent to: return x.*distance-from*(y.*current_*);
+
+[🔗](#lib:operator-,cartesian_product_view::iterator__)
+
+`friend constexpr difference_type operator-(const iterator& i, default_sentinel_t)
+  requires [cartesian-is-sized-sentinel](#concept:cartesian-is-sized-sentinel "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, sentinel_t, First, Vs...>;
+`
+
+[31](#iterator-31)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17280)
+
+Let *end-tuple* be an object of a type
+that is a specialization of tuple, such that:
+
+- [(31.1)](#iterator-31.1)
+
+std​::​get<0>(*end-tuple*) has the same value asranges​::​end(std​::​get<0>(i.*parent_*->*bases_*));
+
+- [(31.2)](#iterator-31.2)
+
+std​::​get<N>(*end-tuple*) has the same value asranges​::​begin(std​::​get<N>(i.*parent_*->*bases_*)) for every integer 1 ≤ N ≤ sizeof...(Vs)[.](#iterator-31.sentence-1)
+
+[32](#iterator-32)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17293)
+
+*Effects*: Equivalent to: return i.*distance-from*(*end-tuple*);
+
+[🔗](#lib:operator-,cartesian_product_view::iterator___)
+
+`friend constexpr difference_type operator-(default_sentinel_t s, const iterator& i)
+  requires [cartesian-is-sized-sentinel](#concept:cartesian-is-sized-sentinel "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<Const, sentinel_t, First, Vs...>;
+`
+
+[33](#iterator-33)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17305)
+
+*Effects*: Equivalent to: return -(i - s);
+
+[🔗](#lib:iter_move,cartesian_product_view::iterator)
+
+`friend constexpr auto iter_move(const iterator& i) noexcept(see below);
+`
+
+[34](#iterator-34)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17316)
+
+*Effects*: Equivalent to: return *tuple-transform*(ranges​::​iter_move, i.*current_*);
+
+[35](#iterator-35)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17320)
+
+*Remarks*: The exception specification is equivalent to
+the logical and of the following expressions:
+
+- [(35.1)](#iterator-35.1)
+
+noexcept(ranges​::​iter_move(std​::​get<N>(i.*current_*))) for every integer  
+0 ≤ N ≤ sizeof...(Vs),
+
+- [(35.2)](#iterator-35.2)
+
+is_nothrow_move_constructible_v<range_rvalue_reference_t<*maybe-const*<Const, T>>>  
+for every type T in First, Vs...[.](#iterator-35.sentence-1)
+
+[🔗](#lib:iter_swap,cartesian_product_view::iterator)
+
+`friend constexpr void iter_swap(const iterator& l, const iterator& r) noexcept(see below)
+  requires ([indirectly_swappable](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<maybe-const<Const, First>>> && ... &&
+        [indirectly_swappable](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<maybe-const<Const, Vs>>>);
+`
+
+[36](#iterator-36)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17342)
+
+*Effects*: For every integer 0 ≤ i ≤ sizeof...(Vs), performs:ranges::iter_swap(std::get<i>(l.*current_*), std::get<i>(r.*current_*))
+
+[37](#iterator-37)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L17349)
+
+*Remarks*: The exception specification is equivalent to the logical and of the following expressions:
+
+- [(37.1)](#iterator-37.1)
+
+noexcept(ranges​::​iter_swap(std​::​get<i>(l.*current_*), std​::​get<i>(r.*current_*))) for  
+every integer 0 ≤ i ≤ sizeof...(Vs)[.](#iterator-37.sentence-1)

cppdraft/range/cartesian/overview.md

@@ -0,0 +1,40 @@
+[range.cartesian.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.cartesian.overview)
+
+### 25.7.33 Cartesian product view [[range.cartesian]](range.cartesian#overview)
+
+#### 25.7.33.1 Overview [range.cartesian.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16562)
+
+cartesian_product_view takes any non-zero number of ranges n and
+produces a view of tuples calculated by
+the n-ary cartesian product of the provided ranges[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16567)
+
+The name views​::​cartesian_product denotes a customization point object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#2.sentence-1)
+
+Given a pack of subexpressions Es,
+the expression views​::​cartesian_product(Es...) is expression-equivalent to
+
+- [(2.1)](#2.1)
+
+views​::​single(tuple()) if Es is an empty pack,
+
+- [(2.2)](#2.2)
+
+otherwise,cartesian_product_view<views​::​all_t<decltype((Es))>...>(Es...)[.](#2.sentence-2)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16581)
+
+[*Example [1](#example-1)*: vector<int> v { 0, 1, 2 };for (auto&& [a, b, c] : views::cartesian_product(v, v, v)) { cout << a << ' ' << b << ' ' << c << '\n';}// The above prints// 0 0 0// 0 0 1// 0 0 2// 0 1 0// 0 1 1// ... — *end example*]

cppdraft/range/cartesian/view.md

@@ -0,0 +1,134 @@
+[range.cartesian.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.cartesian.view)
+
+### 25.7.33 Cartesian product view [[range.cartesian]](range.cartesian#view)
+
+#### 25.7.33.2 Class template cartesian_product_view [range.cartesian.view]
+
+[🔗](#lib:cartesian_product_view)
+
+namespace std::ranges {template<bool Const, class First, class... Vs>concept [*cartesian-product-is-random-access*](#concept:cartesian-product-is-random-access "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]") = // *exposition only*([random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*maybe-const*<Const, First>> && ... &&([random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*maybe-const*<Const, Vs>>&& [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<*maybe-const*<Const, Vs>>)); template<class R>concept [*cartesian-product-common-arg*](#concept:cartesian-product-common-arg "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]") = // *exposition only*[common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<R> || ([sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R> && [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<R>); template<bool Const, class First, class... Vs>concept [*cartesian-product-is-bidirectional*](#concept:cartesian-product-is-bidirectional "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]") = // *exposition only*([bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<*maybe-const*<Const, First>> && ... &&([bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<*maybe-const*<Const, Vs>>&& [*cartesian-product-common-arg*](#concept:cartesian-product-common-arg "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<*maybe-const*<Const, Vs>>)); template<class First, class...>concept [*cartesian-product-is-common*](#concept:cartesian-product-is-common "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]") = // *exposition only*[*cartesian-product-common-arg*](#concept:cartesian-product-common-arg "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<First>; template<class... Vs>concept [*cartesian-product-is-sized*](#concept:cartesian-product-is-sized "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]") = // *exposition only*([sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<Vs> && ...); template<bool Const, template<class> class FirstSent, class First, class... Vs>concept [*cartesian-is-sized-sentinel*](#concept:cartesian-is-sized-sentinel "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]") = // *exposition only*([sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<FirstSent<*maybe-const*<Const, First>>,
+ iterator_t<*maybe-const*<Const, First>>> && ...&& ([sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<*maybe-const*<Const, Vs>>&& [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<iterator_t<*maybe-const*<Const, Vs>>,
+ iterator_t<*maybe-const*<Const, Vs>>>)); template<[*cartesian-product-common-arg*](#concept:cartesian-product-common-arg "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]") R>constexpr auto *cartesian-common-arg-end*(R& r) { // *exposition only*if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<R>) {return ranges::end(r); } else {return ranges::begin(r) + ranges::distance(r); }}template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") First, [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")... Vs>requires ([view](range.view#concept:view "25.4.5 Views [range.view]")<First> && ... && [view](range.view#concept:view "25.4.5 Views [range.view]")<Vs>)class cartesian_product_view : public view_interface<cartesian_product_view<First, Vs...>> {private: tuple<First, Vs...> *bases_*; // *exposition only*// [[range.cartesian.iterator]](range.cartesian.iterator "25.7.33.3 Class template cartesian_­product_­view​::​iterator"), class template cartesian_product_view​::​*iterator*template<bool Const> class *iterator*; // *exposition only*public:constexpr cartesian_product_view() = default; constexpr explicit cartesian_product_view(First first_base, Vs... bases); constexpr *iterator*<false> begin()requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<First> || ... || ![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<Vs>); constexpr *iterator*<true> begin() constrequires ([range](range.range#concept:range "25.4.2 Ranges [range.range]")<const First> && ... && [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const Vs>); constexpr *iterator*<false> end()requires ((![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<First> || ... || ![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<Vs>) &&[*cartesian-product-is-common*](#concept:cartesian-product-is-common "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<First, Vs...>); constexpr *iterator*<true> end() constrequires [*cartesian-product-is-common*](#concept:cartesian-product-is-common "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<const First, const Vs...>; constexpr default_sentinel_t end() const noexcept; constexpr *see below* size()requires [*cartesian-product-is-sized*](#concept:cartesian-product-is-sized "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<First, Vs...>; constexpr *see below* size() constrequires [*cartesian-product-is-sized*](#concept:cartesian-product-is-sized "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<const First, const Vs...>; }; template<class... Vs> cartesian_product_view(Vs&&...) -> cartesian_product_view<views::all_t<Vs>...>;}
+
+[🔗](#lib:cartesian_product_view,constructor)
+
+`constexpr explicit cartesian_product_view(First first_base, Vs... bases);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16685)
+
+*Effects*: Initializes *bases_* with std​::​move(first_base), std​::​move(bases)...[.](#1.sentence-1)
+
+[🔗](#lib:begin,cartesian_product_view)
+
+`constexpr iterator<false> begin()
+  requires (![simple-view](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<First> || ... || ![simple-view](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<Vs>);
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16698)
+
+*Effects*: Equivalent to:return *iterator*<false>(*this, *tuple-transform*(ranges::begin, *bases_*));
+
+[🔗](#lib:begin,cartesian_product_view_)
+
+`constexpr iterator<true> begin() const
+  requires ([range](range.range#concept:range "25.4.2 Ranges [range.range]")<const First> && ... && [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const Vs>);
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16713)
+
+*Effects*: Equivalent to:return *iterator*<true>(*this, *tuple-transform*(ranges::begin, *bases_*));
+
+[🔗](#lib:end,cartesian_product_view)
+
+`constexpr iterator<false> end()
+  requires ((![simple-view](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<First> || ... || ![simple-view](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<Vs>)
+    && [cartesian-product-is-common](#concept:cartesian-product-is-common "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<First, Vs...>);
+constexpr iterator<true> end() const
+  requires [cartesian-product-is-common](#concept:cartesian-product-is-common "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<const First, const Vs...>;
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16731)
+
+Let:
+
+- [(4.1)](#4.1)
+
+*is-const* be true for the const-qualified overload, andfalse otherwise;
+
+- [(4.2)](#4.2)
+
+*is-empty* be true if the expression ranges​::​empty(rng) is true for any rng among the underlying ranges except the first one andfalse otherwise; and
+
+- [(4.3)](#4.3)
+
+*begin-or-first-end*(rng) be expression-equivalent to*is-empty* ? ranges​::​begin(rng) : ​*cartesian-common-arg-end*(rng) if rng is the first underlying range andranges​::​begin(rng) otherwise[.](#4.sentence-1)
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16749)
+
+*Effects*: Equivalent to:*iterator*<*is-const*> it(*this, *tuple-transform*([](auto& rng){ return *begin-or-first-end*(rng); }, *bases_*));return it;
+
+[🔗](#lib:end,cartesian_product_view_)
+
+`constexpr default_sentinel_t end() const noexcept;
+`
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16765)
+
+*Returns*: default_sentinel[.](#6.sentence-1)
+
+[🔗](#lib:size,cartesian_product_view)
+
+`constexpr see below size()
+  requires [cartesian-product-is-sized](#concept:cartesian-product-is-sized "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<First, Vs...>;
+constexpr see below size() const
+  requires [cartesian-product-is-sized](#concept:cartesian-product-is-sized "25.7.33.2 Class template cartesian_­product_­view [range.cartesian.view]")<const First, const Vs...>;
+`
+
+[7](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16779)
+
+The return type is an implementation-defined unsigned-integer-like type[.](#7.sentence-1)
+
+[8](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16782)
+
+*Recommended practice*: The return type should be the smallest unsigned-integer-like type
+that is sufficiently wide to store the product of the maximum sizes of
+all the underlying ranges, if such a type exists[.](#8.sentence-1)
+
+[9](#9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16788)
+
+Let p be the product of the sizes of all the ranges in *bases_*[.](#9.sentence-1)
+
+[10](#10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16791)
+
+*Preconditions*: p can be represented by the return type[.](#10.sentence-1)
+
+[11](#11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L16795)
+
+*Returns*: p[.](#11.sentence-1)

cppdraft/range/chunk/by.md

@@ -0,0 +1,269 @@
+[range.chunk.by]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.chunk.by)
+
+### 25.7.31 Chunk by view [range.chunk.by]
+
+#### [25.7.31.1](#overview) Overview [[range.chunk.by.overview]](range.chunk.by.overview)
+
+[1](#overview-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15582)
+
+chunk_by_view takes a view and a predicate, and
+splits the view into subranges
+between each pair of adjacent elements
+for which the predicate returns false[.](#overview-1.sentence-1)
+
+[2](#overview-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15588)
+
+The name views​::​chunk_by 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​::​chunk_by(E, F) is expression-equivalent tochunk_by_view(E, F)[.](#overview-2.sentence-2)
+
+[*Example [1](#overview-example-1)*: vector v = {1, 2, 2, 3, 0, 4, 5, 2};
+
+for (auto r : v | views::chunk_by(ranges::less_equal{})) { cout << '['; auto sep = ""; for (auto i : r) { cout << sep << i;
+ sep = ", "; } cout << "] ";}// The above prints [1, 2, 2, 3] [0, 4, 5] [2] — *end example*]
+
+#### [25.7.31.2](#view) Class template chunk_by_view [[range.chunk.by.view]](range.chunk.by.view)
+
+[🔗](#lib:chunk_by_view)
+
+namespace std::ranges {template<[forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") V, [indirect_binary_predicate](indirectcallable.indirectinvocable#concept:indirect_binary_predicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<iterator_t<V>, iterator_t<V>> Pred>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && is_object_v<Pred>class chunk_by_view : public view_interface<chunk_by_view<V, Pred>> { V *base_* = V(); // *exposition only**movable-box*<Pred> *pred_*; // *exposition only*// [[range.chunk.by.iter]](#iter "25.7.31.3 Class chunk_­by_­view​::​iterator"), class chunk_by_view​::​*iterator*class *iterator*; // *exposition only*public: chunk_by_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]")<Pred> = default; constexpr explicit chunk_by_view(V base, Pred pred); 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 const Pred& pred() const; constexpr *iterator* begin(); constexpr auto end(); constexpr iterator_t<V> *find-next*(iterator_t<V>); // *exposition only*constexpr iterator_t<V> *find-prev*(iterator_t<V>) // *exposition only*requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>; }; template<class R, class Pred> chunk_by_view(R&&, Pred) -> chunk_by_view<views::all_t<R>, Pred>;}
+
+[🔗](#lib:chunk_by_view,constructor)
+
+`constexpr explicit chunk_by_view(V base, Pred pred);
+`
+
+[1](#view-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15654)
+
+*Effects*: Initializes *base_* with std​::​move(base) and*pred_* with std​::​move(pred)[.](#view-1.sentence-1)
+
+[🔗](#lib:pred,chunk_by_view)
+
+`constexpr const Pred& pred() const;
+`
+
+[2](#view-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15666)
+
+*Effects*: Equivalent to: return **pred_*;
+
+[🔗](#lib:begin,chunk_by_view)
+
+`constexpr iterator begin();
+`
+
+[3](#view-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15677)
+
+*Preconditions*: *pred_*.has_value() is true[.](#view-3.sentence-1)
+
+[4](#view-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15681)
+
+*Returns*: *iterator*(*this, ranges​::​begin(*base_*), *find-next*(ranges​::​begin(*base_*)))[.](#view-4.sentence-1)
+
+[5](#view-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15685)
+
+*Remarks*: In order to provide
+the amortized constant-time complexity required by the [range](range.range#concept:range "25.4.2 Ranges [range.range]") concept,
+this function caches the result within the chunk_by_view for use on subsequent calls[.](#view-5.sentence-1)
+
+[🔗](#lib:end,chunk_by_view)
+
+`constexpr auto end();
+`
+
+[6](#view-6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15699)
+
+*Effects*: Equivalent to:if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<V>) {return *iterator*(*this, ranges::end(*base_*), ranges::end(*base_*));} else {return default_sentinel;}
+
+[🔗](#lib:find-next,chunk_by_view)
+
+`constexpr iterator_t<V> find-next(iterator_t<V> current);
+`
+
+[7](#view-7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15717)
+
+*Preconditions*: *pred_*.has_value() is true[.](#view-7.sentence-1)
+
+[8](#view-8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15721)
+
+*Returns*: ranges::next(ranges::adjacent_find(current, ranges::end(*base_*), not_fn(ref(**pred_*))), 1, ranges::end(*base_*))
+
+[🔗](#lib:find-prev,chunk_by_view)
+
+`constexpr iterator_t<V> find-prev(iterator_t<V> current) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>;
+`
+
+[9](#view-9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15735)
+
+*Preconditions*: 
+
+- [(9.1)](#view-9.1)
+
+  current is not equal to ranges​::​begin(*base_*)[.](#view-9.1.sentence-1)
+
+- [(9.2)](#view-9.2)
+
+  *pred_*.has_value() is true[.](#view-9.2.sentence-1)
+
+[10](#view-10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15744)
+
+*Returns*: An iterator i in the range [ranges​::​begin(*base_*), current) such that:
+
+- [(10.1)](#view-10.1)
+
+ranges​::​adjacent_find(i, current, not_fn(ref(**pred_*))) is equal to current; and
+
+- [(10.2)](#view-10.2)
+
+if i is not equal to ranges​::​begin(*base_*),
+then bool(invoke(**pred_*, *ranges​::​prev(i), *i)) is false[.](#view-10.sentence-1)
+
+#### [25.7.31.3](#iter) Class chunk_by_view​::​*iterator* [[range.chunk.by.iter]](range.chunk.by.iter)
+
+[🔗](#lib:chunk_by_view::iterator)
+
+namespace std::ranges {template<[forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") V, [indirect_binary_predicate](indirectcallable.indirectinvocable#concept:indirect_binary_predicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<iterator_t<V>, iterator_t<V>> Pred>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && is_object_v<Pred>class chunk_by_view<V, Pred>::*iterator* { chunk_by_view* *parent_* = nullptr; // *exposition only* iterator_t<V> *current_* = iterator_t<V>(); // *exposition only* iterator_t<V> *next_* = iterator_t<V>(); // *exposition only*constexpr *iterator*(chunk_by_view& parent, iterator_t<V> current, // *exposition only* 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 = *see below*; *iterator*() = default; constexpr value_type operator*() const; constexpr *iterator*& operator++(); constexpr *iterator* operator++(int); constexpr *iterator*& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>; constexpr *iterator* operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>; friend constexpr bool operator==(const *iterator*& x, const *iterator*& y); friend constexpr bool operator==(const *iterator*& x, default_sentinel_t); };}
+
+[1](#iter-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15794)
+
+*iterator*​::​iterator_concept is defined as follows:
+
+- [(1.1)](#iter-1.1)
+
+  If V models [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]"),
+then iterator_concept denotes bidirectional_iterator_tag[.](#iter-1.1.sentence-1)
+
+- [(1.2)](#iter-1.2)
+
+  Otherwise, iterator_concept denotes forward_iterator_tag[.](#iter-1.2.sentence-1)
+
+[🔗](#lib:chunk_by_view::iterator,constructor)
+
+`constexpr iterator(chunk_by_view& parent, iterator_t<V> current, iterator_t<V> next);
+`
+
+[2](#iter-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15810)
+
+*Effects*: Initializes *parent_* with addressof(parent),*current_* with current, and*next_* with next[.](#iter-2.sentence-1)
+
+[🔗](#lib:operator*,chunk_by_view::iterator)
+
+`constexpr value_type operator*() const;
+`
+
+[3](#iter-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15823)
+
+*Preconditions*: *current_* is not equal to *next_*[.](#iter-3.sentence-1)
+
+[4](#iter-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15827)
+
+*Returns*: subrange(*current_*, *next_*)[.](#iter-4.sentence-1)
+
+[🔗](#lib:operator++,chunk_by_view::iterator)
+
+`constexpr iterator& operator++();
+`
+
+[5](#iter-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15838)
+
+*Preconditions*: *current_* is not equal to *next_*[.](#iter-5.sentence-1)
+
+[6](#iter-6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15842)
+
+*Effects*: Equivalent to:*current_* = *next_*;*next_* = *parent_*->*find-next*(*current_*);return *this;
+
+[🔗](#lib:operator++,chunk_by_view::iterator_)
+
+`constexpr iterator operator++(int);
+`
+
+[7](#iter-7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15858)
+
+*Effects*: Equivalent to:auto tmp = *this;++*this;return tmp;
+
+[🔗](#lib:operator--,chunk_by_view::iterator)
+
+`constexpr iterator& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>;
+`
+
+[8](#iter-8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15874)
+
+*Effects*: Equivalent to:*next_* = *current_*;*current_* = *parent_*->*find-prev*(*next_*);return *this;
+
+[🔗](#lib:operator--,chunk_by_view::iterator_)
+
+`constexpr iterator operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>;
+`
+
+[9](#iter-9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15890)
+
+*Effects*: Equivalent to:auto tmp = *this;--*this;return tmp;
+
+[🔗](#lib:operator==,chunk_by_view::iterator)
+
+`friend constexpr bool operator==(const iterator& x, const iterator& y);
+`
+
+[10](#iter-10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15906)
+
+*Returns*: x.*current_* == y.*current_*[.](#iter-10.sentence-1)
+
+[🔗](#lib:operator==,chunk_by_view::iterator_)
+
+`friend constexpr bool operator==(const iterator& x, default_sentinel_t);
+`
+
+[11](#iter-11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15917)
+
+*Returns*: x.*current_* == x.*next_*[.](#iter-11.sentence-1)

cppdraft/range/chunk/by/iter.md

@@ -0,0 +1,128 @@
+[range.chunk.by.iter]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.chunk.by.iter)
+
+### 25.7.31 Chunk by view [[range.chunk.by]](range.chunk.by#iter)
+
+#### 25.7.31.3 Class chunk_by_view​::​*iterator* [range.chunk.by.iter]
+
+[🔗](#lib:chunk_by_view::iterator)
+
+namespace std::ranges {template<[forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") V, [indirect_binary_predicate](indirectcallable.indirectinvocable#concept:indirect_binary_predicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<iterator_t<V>, iterator_t<V>> Pred>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && is_object_v<Pred>class chunk_by_view<V, Pred>::*iterator* { chunk_by_view* *parent_* = nullptr; // *exposition only* iterator_t<V> *current_* = iterator_t<V>(); // *exposition only* iterator_t<V> *next_* = iterator_t<V>(); // *exposition only*constexpr *iterator*(chunk_by_view& parent, iterator_t<V> current, // *exposition only* 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 = *see below*; *iterator*() = default; constexpr value_type operator*() const; constexpr *iterator*& operator++(); constexpr *iterator* operator++(int); constexpr *iterator*& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>; constexpr *iterator* operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>; friend constexpr bool operator==(const *iterator*& x, const *iterator*& y); friend constexpr bool operator==(const *iterator*& x, default_sentinel_t); };}
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15794)
+
+*iterator*​::​iterator_concept is defined as follows:
+
+- [(1.1)](#1.1)
+
+  If V models [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]"),
+then iterator_concept denotes bidirectional_iterator_tag[.](#1.1.sentence-1)
+
+- [(1.2)](#1.2)
+
+  Otherwise, iterator_concept denotes forward_iterator_tag[.](#1.2.sentence-1)
+
+[🔗](#lib:chunk_by_view::iterator,constructor)
+
+`constexpr iterator(chunk_by_view& parent, iterator_t<V> current, iterator_t<V> next);
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15810)
+
+*Effects*: Initializes *parent_* with addressof(parent),*current_* with current, and*next_* with next[.](#2.sentence-1)
+
+[🔗](#lib:operator*,chunk_by_view::iterator)
+
+`constexpr value_type operator*() const;
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15823)
+
+*Preconditions*: *current_* is not equal to *next_*[.](#3.sentence-1)
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15827)
+
+*Returns*: subrange(*current_*, *next_*)[.](#4.sentence-1)
+
+[🔗](#lib:operator++,chunk_by_view::iterator)
+
+`constexpr iterator& operator++();
+`
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15838)
+
+*Preconditions*: *current_* is not equal to *next_*[.](#5.sentence-1)
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15842)
+
+*Effects*: Equivalent to:*current_* = *next_*;*next_* = *parent_*->*find-next*(*current_*);return *this;
+
+[🔗](#lib:operator++,chunk_by_view::iterator_)
+
+`constexpr iterator operator++(int);
+`
+
+[7](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15858)
+
+*Effects*: Equivalent to:auto tmp = *this;++*this;return tmp;
+
+[🔗](#lib:operator--,chunk_by_view::iterator)
+
+`constexpr iterator& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>;
+`
+
+[8](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15874)
+
+*Effects*: Equivalent to:*next_* = *current_*;*current_* = *parent_*->*find-prev*(*next_*);return *this;
+
+[🔗](#lib:operator--,chunk_by_view::iterator_)
+
+`constexpr iterator operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>;
+`
+
+[9](#9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15890)
+
+*Effects*: Equivalent to:auto tmp = *this;--*this;return tmp;
+
+[🔗](#lib:operator==,chunk_by_view::iterator)
+
+`friend constexpr bool operator==(const iterator& x, const iterator& y);
+`
+
+[10](#10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15906)
+
+*Returns*: x.*current_* == y.*current_*[.](#10.sentence-1)
+
+[🔗](#lib:operator==,chunk_by_view::iterator_)
+
+`friend constexpr bool operator==(const iterator& x, default_sentinel_t);
+`
+
+[11](#11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15917)
+
+*Returns*: x.*current_* == x.*next_*[.](#11.sentence-1)

cppdraft/range/chunk/by/overview.md

@@ -0,0 +1,33 @@
+[range.chunk.by.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.chunk.by.overview)
+
+### 25.7.31 Chunk by view [[range.chunk.by]](range.chunk.by#overview)
+
+#### 25.7.31.1 Overview [range.chunk.by.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15582)
+
+chunk_by_view takes a view and a predicate, and
+splits the view into subranges
+between each pair of adjacent elements
+for which the predicate returns false[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15588)
+
+The name views​::​chunk_by denotes
+a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#2.sentence-1)
+
+Given subexpressions E and F,
+the expression views​::​chunk_by(E, F) is expression-equivalent tochunk_by_view(E, F)[.](#2.sentence-2)
+
+[*Example [1](#example-1)*: vector v = {1, 2, 2, 3, 0, 4, 5, 2};
+
+for (auto r : v | views::chunk_by(ranges::less_equal{})) { cout << '['; auto sep = ""; for (auto i : r) { cout << sep << i;
+ sep = ", "; } cout << "] ";}// The above prints [1, 2, 2, 3] [0, 4, 5] [2] — *end example*]

cppdraft/range/chunk/by/view.md

@@ -0,0 +1,122 @@
+[range.chunk.by.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.chunk.by.view)
+
+### 25.7.31 Chunk by view [[range.chunk.by]](range.chunk.by#view)
+
+#### 25.7.31.2 Class template chunk_by_view [range.chunk.by.view]
+
+[🔗](#lib:chunk_by_view)
+
+namespace std::ranges {template<[forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") V, [indirect_binary_predicate](indirectcallable.indirectinvocable#concept:indirect_binary_predicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<iterator_t<V>, iterator_t<V>> Pred>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && is_object_v<Pred>class chunk_by_view : public view_interface<chunk_by_view<V, Pred>> { V *base_* = V(); // *exposition only**movable-box*<Pred> *pred_*; // *exposition only*// [[range.chunk.by.iter]](range.chunk.by.iter "25.7.31.3 Class chunk_­by_­view​::​iterator"), class chunk_by_view​::​*iterator*class *iterator*; // *exposition only*public: chunk_by_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]")<Pred> = default; constexpr explicit chunk_by_view(V base, Pred pred); 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 const Pred& pred() const; constexpr *iterator* begin(); constexpr auto end(); constexpr iterator_t<V> *find-next*(iterator_t<V>); // *exposition only*constexpr iterator_t<V> *find-prev*(iterator_t<V>) // *exposition only*requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>; }; template<class R, class Pred> chunk_by_view(R&&, Pred) -> chunk_by_view<views::all_t<R>, Pred>;}
+
+[🔗](#lib:chunk_by_view,constructor)
+
+`constexpr explicit chunk_by_view(V base, Pred pred);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15654)
+
+*Effects*: Initializes *base_* with std​::​move(base) and*pred_* with std​::​move(pred)[.](#1.sentence-1)
+
+[🔗](#lib:pred,chunk_by_view)
+
+`constexpr const Pred& pred() const;
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15666)
+
+*Effects*: Equivalent to: return **pred_*;
+
+[🔗](#lib:begin,chunk_by_view)
+
+`constexpr iterator begin();
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15677)
+
+*Preconditions*: *pred_*.has_value() is true[.](#3.sentence-1)
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15681)
+
+*Returns*: *iterator*(*this, ranges​::​begin(*base_*), *find-next*(ranges​::​begin(*base_*)))[.](#4.sentence-1)
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15685)
+
+*Remarks*: In order to provide
+the amortized constant-time complexity required by the [range](range.range#concept:range "25.4.2 Ranges [range.range]") concept,
+this function caches the result within the chunk_by_view for use on subsequent calls[.](#5.sentence-1)
+
+[🔗](#lib:end,chunk_by_view)
+
+`constexpr auto end();
+`
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15699)
+
+*Effects*: Equivalent to:if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<V>) {return *iterator*(*this, ranges::end(*base_*), ranges::end(*base_*));} else {return default_sentinel;}
+
+[🔗](#lib:find-next,chunk_by_view)
+
+`constexpr iterator_t<V> find-next(iterator_t<V> current);
+`
+
+[7](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15717)
+
+*Preconditions*: *pred_*.has_value() is true[.](#7.sentence-1)
+
+[8](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15721)
+
+*Returns*: ranges::next(ranges::adjacent_find(current, ranges::end(*base_*), not_fn(ref(**pred_*))), 1, ranges::end(*base_*))
+
+[🔗](#lib:find-prev,chunk_by_view)
+
+`constexpr iterator_t<V> find-prev(iterator_t<V> current) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>;
+`
+
+[9](#9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15735)
+
+*Preconditions*: 
+
+- [(9.1)](#9.1)
+
+  current is not equal to ranges​::​begin(*base_*)[.](#9.1.sentence-1)
+
+- [(9.2)](#9.2)
+
+  *pred_*.has_value() is true[.](#9.2.sentence-1)
+
+[10](#10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L15744)
+
+*Returns*: An iterator i in the range [ranges​::​begin(*base_*), current) such that:
+
+- [(10.1)](#10.1)
+
+ranges​::​adjacent_find(i, current, not_fn(ref(**pred_*))) is equal to current; and
+
+- [(10.2)](#10.2)
+
+if i is not equal to ranges​::​begin(*base_*),
+then bool(invoke(**pred_*, *ranges​::​prev(i), *i)) is false[.](#10.sentence-1)

cppdraft/range/chunk/inner/iter.md

@@ -0,0 +1,141 @@
+[range.chunk.inner.iter]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.chunk.inner.iter)
+
+### 25.7.29 Chunk view [[range.chunk]](range.chunk#inner.iter)
+
+#### 25.7.29.5 Class chunk_view​::​*inner-iterator* [range.chunk.inner.iter]
+
+[🔗](#lib:chunk_view::inner-iterator)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires [input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]")<V>class chunk_view<V>::*inner-iterator* { chunk_view* *parent_*; // *exposition only*constexpr explicit *inner-iterator*(chunk_view& parent) noexcept; // *exposition only*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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>; friend constexpr difference_type operator-(const *inner-iterator*& x, default_sentinel_t y)requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<V>>; };}
+
+[🔗](#lib:chunk_view::inner-iterator,constructor)
+
+`constexpr explicit inner-iterator(chunk_view& parent) noexcept;
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14204)
+
+*Effects*: Initializes *parent_* with addressof(parent)[.](#1.sentence-1)
+
+[🔗](#lib:base,chunk_view::inner-iterator)
+
+`constexpr const iterator_t<V>& base() const &;
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14215)
+
+*Effects*: Equivalent to: return **parent_*->*current_*;
+
+[🔗](#lib:operator*,chunk_view::inner-iterator)
+
+`constexpr range_reference_t<V> operator*() const;
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14226)
+
+*Preconditions*: *this == default_sentinel is false[.](#3.sentence-1)
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14230)
+
+*Effects*: Equivalent to: return ***parent_*->*current_*;
+
+[🔗](#lib:operator++,chunk_view::inner-iterator)
+
+`constexpr inner-iterator& operator++();
+`
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14241)
+
+*Preconditions*: *this == default_sentinel is false[.](#5.sentence-1)
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14245)
+
+*Effects*: Equivalent to:++**parent_*->*current_*;if (**parent_*->*current_* == ranges::end(*parent_*->*base_*))*parent_*->*remainder_* = 0;else--*parent_*->*remainder_*;return *this;
+
+[🔗](#lib:operator++,chunk_view::inner-iterator_)
+
+`constexpr void operator++(int);
+`
+
+[7](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14264)
+
+*Effects*: Equivalent to ++*this[.](#7.sentence-1)
+
+[🔗](#lib:operator==,chunk_view::inner-iterator)
+
+`friend constexpr bool operator==(const inner-iterator& x, default_sentinel_t);
+`
+
+[8](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14275)
+
+*Returns*: x.*parent_*->*remainder_* == 0[.](#8.sentence-1)
+
+[🔗](#lib:operator-,chunk_view::inner-iterator)
+
+`friend constexpr difference_type operator-(default_sentinel_t y, const inner-iterator& x)
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>;
+`
+
+[9](#9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14287)
+
+*Effects*: Equivalent to:return ranges::min(x.*parent_*->*remainder_*,
+ ranges::end(x.*parent_*->*base_*) - *x.*parent_*->*current_*);
+
+[🔗](#lib:operator-,chunk_view::inner-iterator_)
+
+`friend constexpr difference_type operator-(const inner-iterator& x, default_sentinel_t y)
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>;
+`
+
+[10](#10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14303)
+
+*Effects*: Equivalent to: return -(y - x);
+
+[🔗](#lib:iter_move,chunk_view::inner-iterator)
+
+`friend constexpr range_rvalue_reference_t<V> iter_move(const inner-iterator& i)
+  noexcept(noexcept(ranges::iter_move(*i.parent_->current_)));
+`
+
+[11](#11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14315)
+
+*Effects*: Equivalent to: return ranges​::​iter_move(*i.*parent_*->*current_*);
+
+[🔗](#lib:iter_swap,chunk_view::inner-iterator)
+
+`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](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<V>>;
+`
+
+[12](#12)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14328)
+
+*Effects*: Equivalent to: ranges​::​iter_swap(*x.*parent_*->*current_*, *y.*parent_*->*current_*);

cppdraft/range/chunk/outer/iter.md

@@ -0,0 +1,104 @@
+[range.chunk.outer.iter]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.chunk.outer.iter)
+
+### 25.7.29 Chunk view [[range.chunk]](range.chunk#outer.iter)
+
+#### 25.7.29.3 Class chunk_view​::​*outer-iterator* [range.chunk.outer.iter]
+
+[🔗](#lib:chunk_view::outer-iterator)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires [input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]")<V>class chunk_view<V>::*outer-iterator* { chunk_view* *parent_*; // *exposition only*constexpr explicit *outer-iterator*(chunk_view& parent); // *exposition only*public:using iterator_concept = input_iterator_tag; using difference_type = range_difference_t<V>; // [[range.chunk.outer.value]](range.chunk.outer.value "25.7.29.4 Class chunk_­view​::​outer-iterator​::​value_­type"), class chunk_view​::​*outer-iterator*​::​value_typestruct value_type; *outer-iterator*(*outer-iterator*&&) = default; *outer-iterator*& operator=(*outer-iterator*&&) = default; constexpr value_type operator*() const; constexpr *outer-iterator*& operator++(); constexpr void operator++(int); friend constexpr bool operator==(const *outer-iterator*& x, default_sentinel_t); friend constexpr difference_type operator-(default_sentinel_t y, const *outer-iterator*& x)requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>; friend constexpr difference_type operator-(const *outer-iterator*& x, default_sentinel_t y)requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>; };}
+
+[🔗](#lib:chunk_view::outer-iterator,constructor)
+
+`constexpr explicit outer-iterator(chunk_view& parent);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13971)
+
+*Effects*: Initializes *parent_* with addressof(parent)[.](#1.sentence-1)
+
+[🔗](#lib:operator*,chunk_view::outer-iterator)
+
+`constexpr value_type operator*() const;
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13982)
+
+*Preconditions*: *this == default_sentinel is false[.](#2.sentence-1)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13986)
+
+*Returns*: value_type(**parent_*)[.](#3.sentence-1)
+
+[🔗](#lib:operator++,chunk_view::outer-iterator)
+
+`constexpr outer-iterator& operator++();
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13997)
+
+*Preconditions*: *this == default_sentinel is false[.](#4.sentence-1)
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14001)
+
+*Effects*: Equivalent to:ranges::advance(**parent_*->*current_*, *parent_*->*remainder_*, ranges::end(*parent_*->*base_*));*parent_*->*remainder_* = *parent_*->*n_*;return *this;
+
+[🔗](#lib:operator++,chunk_view::outer-iterator_)
+
+`constexpr void operator++(int);
+`
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14017)
+
+*Effects*: Equivalent to ++*this[.](#6.sentence-1)
+
+[🔗](#lib:operator==,chunk_view::outer-iterator)
+
+`friend constexpr bool operator==(const outer-iterator& x, default_sentinel_t);
+`
+
+[7](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14028)
+
+*Effects*: Equivalent to:return *x.*parent_*->*current_* == ranges::end(x.*parent_*->*base_*) && x.*parent_*->*remainder_* != 0;
+
+[🔗](#lib:operator-,chunk_view::outer-iterator)
+
+`friend constexpr difference_type operator-(default_sentinel_t y, const outer-iterator& x)
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>;
+`
+
+[8](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14043)
+
+*Effects*: Equivalent to:const auto dist = ranges::end(x.*parent_*->*base_*) - *x.*parent_*->*current_*;if (dist < x.*parent_*->*remainder_*) {return dist == 0 ? 0 : 1;}return *div-ceil*(dist - x.*parent_*->*remainder_*, x.*parent_*->*n_*) + 1;
+
+[🔗](#lib:operator-,chunk_view::outer-iterator_)
+
+`friend constexpr difference_type operator-(const outer-iterator& x, default_sentinel_t y)
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>;
+`
+
+[9](#9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14062)
+
+*Effects*: Equivalent to: return -(y - x);

cppdraft/range/chunk/outer/value.md

@@ -0,0 +1,70 @@
+[range.chunk.outer.value]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.chunk.outer.value)
+
+### 25.7.29 Chunk view [[range.chunk]](range.chunk#outer.value)
+
+#### 25.7.29.4 Class chunk_view​::​*outer-iterator*​::​value_type [range.chunk.outer.value]
+
+[🔗](#lib:chunk_view::outer-iterator::value_type)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires [input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]")<V>struct chunk_view<V>::*outer-iterator*::value_type : view_interface<value_type> {private: chunk_view* *parent_*; // *exposition only*constexpr explicit value_type(chunk_view& parent); // *exposition only*public:constexpr *inner-iterator* begin() const noexcept; constexpr default_sentinel_t end() const noexcept; constexpr auto size() constrequires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>; constexpr auto reserve_hint() const noexcept; };}
+
+[🔗](#lib:chunk_view::outer-iterator::value_type,constructor)
+
+`constexpr explicit value_type(chunk_view& parent);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14098)
+
+*Effects*: Initializes *parent_* with addressof(parent)[.](#1.sentence-1)
+
+[🔗](#lib:begin,chunk_view::outer-iterator::value_type)
+
+`constexpr inner-iterator begin() const noexcept;
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14109)
+
+*Returns*: *inner-iterator*(**parent_*)[.](#2.sentence-1)
+
+[🔗](#lib:end,chunk_view::outer-iterator::value_type)
+
+`constexpr default_sentinel_t end() const noexcept;
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14120)
+
+*Returns*: default_sentinel[.](#3.sentence-1)
+
+[🔗](#lib:size,chunk_view::outer-iterator::value_type)
+
+`constexpr auto size() const
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<V>, iterator_t<V>>;
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14132)
+
+*Effects*: Equivalent to:return *to-unsigned-like*(ranges::min(*parent_*->*remainder_*,
+ ranges::end(*parent_*->*base_*) - **parent_*->*current_*));
+
+[🔗](#lib:reserve_hint,chunk_view::outer-iterator::value_type)
+
+`constexpr auto reserve_hint() const noexcept;
+`
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14147)
+
+*Effects*: Equivalent to:return *to-unsigned-like*(*parent_*->*remainder_*);

cppdraft/range/chunk/overview.md

@@ -0,0 +1,35 @@
+[range.chunk.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.chunk.overview)
+
+### 25.7.29 Chunk view [[range.chunk]](range.chunk#overview)
+
+#### 25.7.29.1 Overview [range.chunk.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13774)
+
+chunk_view takes a view and a number N and
+produces a range of views
+that are N-sized non-overlapping successive chunks of
+the elements of the original view, in order[.](#1.sentence-1)
+
+The last view in the range can have fewer than N elements[.](#1.sentence-2)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13781)
+
+The name views​::​chunk denotes
+a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#2.sentence-1)
+
+Given subexpressions E and N,
+the expression views​::​chunk(E, N) is expression-equivalent tochunk_view(E, N)[.](#2.sentence-2)
+
+[*Example [1](#example-1)*: vector v = {1, 2, 3, 4, 5};
+
+for (auto r : v | views::chunk(2)) { cout << '['; auto sep = ""; for (auto i : r) { cout << sep << i;
+ sep = ", "; } cout << "] ";}// The above prints [1, 2] [3, 4] [5] — *end example*]

cppdraft/range/chunk/view/fwd.md

@@ -0,0 +1,54 @@
+[range.chunk.view.fwd]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.chunk.view.fwd)
+
+### 25.7.29 Chunk view [[range.chunk]](range.chunk#view.fwd)
+
+#### 25.7.29.6 Class template chunk_view for forward ranges [range.chunk.view.fwd]
+
+[🔗](#lib:chunk_view)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V>class chunk_view<V> : public view_interface<chunk_view<V>> { V *base_*; // *exposition only* range_difference_t<V> *n_*; // *exposition only*// [[range.chunk.fwd.iter]](range.chunk.fwd.iter "25.7.29.7 Class template chunk_­view​::​iterator for forward ranges"), class template chunk_view​::​*iterator*template<bool> class *iterator*; // *exposition only*public:constexpr explicit chunk_view(V base, range_difference_t<V> n); 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() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) {return *iterator*<false>(this, ranges::begin(*base_*)); }constexpr auto begin() const requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<const V> {return *iterator*<true>(this, ranges::begin(*base_*)); }constexpr auto end() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) {if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>) {auto missing = (*n_* - ranges::distance(*base_*) % *n_*) % *n_*; return *iterator*<false>(this, ranges::end(*base_*), missing); } else if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<V> && ![bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>) {return *iterator*<false>(this, ranges::end(*base_*)); } else {return default_sentinel; }}constexpr auto end() const requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<const V> {if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<const V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>) {auto missing = (*n_* - ranges::distance(*base_*) % *n_*) % *n_*; return *iterator*<true>(this, ranges::end(*base_*), missing); } else if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<const V> && ![bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<const V>) {return *iterator*<true>(this, ranges::end(*base_*)); } else {return default_sentinel; }}constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>; constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>; constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>; constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>; };}
+
+[🔗](#lib:chunk_view,constructor)
+
+`constexpr explicit chunk_view(V base, range_difference_t<V> n);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14400)
+
+*Preconditions*: n > 0 is true[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14404)
+
+*Effects*: Initializes *base_* with std​::​move(base) and*n_* with n[.](#2.sentence-1)
+
+[🔗](#lib:size,chunk_view)
+
+`constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>;
+constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>;
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14417)
+
+*Effects*: Equivalent to:return *to-unsigned-like*(*div-ceil*(ranges::distance(*base_*), *n_*));
+
+[🔗](#lib:reserve_hint,chunk_view)
+
+`constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>;
+constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>;
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L14432)
+
+*Effects*: Equivalent to:auto s = static_cast<range_difference_t<decltype((*base_*))>>(ranges::reserve_hint(*base_*));return *to-unsigned-like*(*div-ceil*(s, *n_*));

cppdraft/range/chunk/view/input.md

@@ -0,0 +1,76 @@
+[range.chunk.view.input]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.chunk.view.input)
+
+### 25.7.29 Chunk view [[range.chunk]](range.chunk#view.input)
+
+#### 25.7.29.2 Class template chunk_view for input ranges [range.chunk.view.input]
+
+[🔗](#lib:chunk_view)
+
+namespace std::ranges {template<class I>constexpr I *div-ceil*(I num, I denom) { // *exposition only* I r = num / denom; if (num % denom)++r; return r; }template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires [input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]")<V>class chunk_view : public view_interface<chunk_view<V>> { V *base_*; // *exposition only* range_difference_t<V> *n_*; // *exposition only* range_difference_t<V> *remainder_* = 0; // *exposition only**non-propagating-cache*<iterator_t<V>> *current_*; // *exposition only*// [[range.chunk.outer.iter]](range.chunk.outer.iter "25.7.29.3 Class chunk_­view​::​outer-iterator"), class chunk_view​::​*outer-iterator*class *outer-iterator*; // *exposition only*// [[range.chunk.inner.iter]](range.chunk.inner.iter "25.7.29.5 Class chunk_­view​::​inner-iterator"), class chunk_view​::​*inner-iterator*class *inner-iterator*; // *exposition only*public:constexpr explicit chunk_view(V base, range_difference_t<V> n); 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 *outer-iterator* begin(); constexpr default_sentinel_t end() const noexcept; constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>; constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>; constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>; constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>; }; template<class R> chunk_view(R&&, range_difference_t<R>) -> chunk_view<views::all_t<R>>;}
+
+[🔗](#lib:chunk_view,constructor)
+
+`constexpr explicit chunk_view(V base, range_difference_t<V> n);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13861)
+
+*Preconditions*: n > 0 is true[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13865)
+
+*Effects*: Initializes *base_* with std​::​move(base) and*n_* with n[.](#2.sentence-1)
+
+[🔗](#lib:begin,chunk_view)
+
+`constexpr outer-iterator begin();
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13877)
+
+*Effects*: Equivalent to:*current_* = ranges::begin(*base_*);*remainder_* = *n_*;return *outer-iterator*(*this);
+
+[🔗](#lib:end,chunk_view)
+
+`constexpr default_sentinel_t end() const noexcept;
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13893)
+
+*Returns*: default_sentinel[.](#4.sentence-1)
+
+[🔗](#lib:size,chunk_view)
+
+`constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>;
+constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>;
+`
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13905)
+
+*Effects*: Equivalent to:return *to-unsigned-like*(*div-ceil*(ranges::distance(*base_*), *n_*));
+
+[🔗](#lib:reserve_hint,chunk_view)
+
+`constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>;
+constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>;
+`
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L13920)
+
+*Effects*: Equivalent to:auto s = static_cast<range_difference_t<decltype((*base_*))>>(ranges::reserve_hint(*base_*));return *to-unsigned-like*(*div-ceil*(s, *n_*));

cppdraft/range/cmp.md

@@ -0,0 +1,187 @@
+[range.cmp]
+
+# 22 General utilities library [[utilities]](./#utilities)
+
+## 22.10 Function objects [[function.objects]](function.objects#range.cmp)
+
+### 22.10.9 Concept-constrained comparisons [range.cmp]
+
+[🔗](#lib:equal_to)
+
+struct ranges::equal_to {template<class T, class U>constexpr bool operator()(T&& t, U&& u) const; using is_transparent = *unspecified*;};
+
+[🔗](#itemdecl:1)
+
+`template<class T, class U>
+  constexpr bool operator()(T&& t, U&& u) const;
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12601)
+
+*Constraints*: T and U satisfy [equality_comparable_with](concept.equalitycomparable#concept:equality_comparable_with "18.5.4 Concept equality_­comparable [concept.equalitycomparable]")[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12605)
+
+*Preconditions*: If the expression std​::​forward<T>(t) == std​::​forward<U>(u) results in a call to a built-in operator == comparing pointers of typeP, the conversion sequences from both T and U to P are equality-preserving ([[concepts.equality]](concepts.equality "18.2 Equality preservation"));
+otherwise, T and U model [equality_comparable_with](concept.equalitycomparable#concept:equality_comparable_with "18.5.4 Concept equality_­comparable [concept.equalitycomparable]")[.](#2.sentence-1)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12613)
+
+*Effects*: 
+
+- [(3.1)](#3.1)
+
+If the expression std​::​forward<T>(t) == std​::​forward<U>(u) results in
+ a call to a built-in operator == comparing pointers:
+ returns false if either (the converted value of) t precedes u or u precedes t in the implementation-defined strict
+ total order over pointers ([[defns.order.ptr]](defns.order.ptr "3.28 implementation-defined strict total order over pointers")) and otherwise true.
+
+- [(3.2)](#3.2)
+
+Otherwise, equivalent to: return std​::​forward<T>(t) == std​::​forward<U>(u);
+
+[🔗](#lib:not_equal_to)
+
+struct ranges::not_equal_to {template<class T, class U>constexpr bool operator()(T&& t, U&& u) const; using is_transparent = *unspecified*;};
+
+[🔗](#itemdecl:2)
+
+`template<class T, class U>
+  constexpr bool operator()(T&& t, U&& u) const;
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12645)
+
+*Constraints*: T and U satisfy [equality_comparable_with](concept.equalitycomparable#concept:equality_comparable_with "18.5.4 Concept equality_­comparable [concept.equalitycomparable]")[.](#4.sentence-1)
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12649)
+
+*Effects*: Equivalent to:return !ranges::equal_to{}(std::forward<T>(t), std::forward<U>(u));
+
+[🔗](#lib:greater)
+
+struct ranges::greater {template<class T, class U>constexpr bool operator()(T&& t, U&& u) const; using is_transparent = *unspecified*;};
+
+[🔗](#itemdecl:3)
+
+`template<class T, class U>
+  constexpr bool operator()(T&& t, U&& u) const;
+`
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12673)
+
+*Constraints*: T and U satisfy [totally_ordered_with](concept.totallyordered#concept:totally_ordered_with "18.5.5 Concept totally_­ordered [concept.totallyordered]")[.](#6.sentence-1)
+
+[7](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12677)
+
+*Effects*: Equivalent to:return ranges::less{}(std::forward<U>(u), std::forward<T>(t));
+
+[🔗](#lib:less)
+
+struct ranges::less {template<class T, class U>constexpr bool operator()(T&& t, U&& u) const; using is_transparent = *unspecified*;};
+
+[🔗](#itemdecl:4)
+
+`template<class T, class U>
+  constexpr bool operator()(T&& t, U&& u) const;
+`
+
+[8](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12701)
+
+*Constraints*: T and U satisfy [totally_ordered_with](concept.totallyordered#concept:totally_ordered_with "18.5.5 Concept totally_­ordered [concept.totallyordered]")[.](#8.sentence-1)
+
+[9](#9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12705)
+
+*Preconditions*: If the expression std​::​forward<T>(t) < std​::​forward<U>(u) results in a
+call to a built-in operator < comparing pointers of type P, the
+conversion sequences from both T and U to P are
+equality-preserving ([[concepts.equality]](concepts.equality "18.2 Equality preservation"));
+otherwise, T and U model [totally_ordered_with](concept.totallyordered#concept:totally_ordered_with "18.5.5 Concept totally_­ordered [concept.totallyordered]")[.](#9.sentence-1)
+
+For any expressionsET and EU such that decltype((ET)) is T anddecltype((EU)) is U, exactly one ofranges​::​less{}(ET, EU),ranges​::​less{}(EU, ET), orranges​::​equal_to{}(ET, EU) is true[.](#9.sentence-2)
+
+[10](#10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12720)
+
+*Effects*: 
+
+- [(10.1)](#10.1)
+
+If the expression std​::​forward<T>(t) < std​::​forward<U>(u) results in a
+call to a built-in operator < comparing pointers:
+returns true if (the converted value of) t precedes u in
+the implementation-defined strict total order over pointers ([[defns.order.ptr]](defns.order.ptr "3.28 implementation-defined strict total order over pointers"))
+and otherwise false.
+
+- [(10.2)](#10.2)
+
+Otherwise, equivalent to:return std​::​forward<T>(t) < std​::​forward<U>(u);
+
+[🔗](#lib:greater_equal)
+
+struct ranges::greater_equal {template<class T, class U>constexpr bool operator()(T&& t, U&& u) const; using is_transparent = *unspecified*;};
+
+[🔗](#itemdecl:5)
+
+`template<class T, class U>
+  constexpr bool operator()(T&& t, U&& u) const;
+`
+
+[11](#11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12752)
+
+*Constraints*: T and U satisfy [totally_ordered_with](concept.totallyordered#concept:totally_ordered_with "18.5.5 Concept totally_­ordered [concept.totallyordered]")[.](#11.sentence-1)
+
+[12](#12)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12756)
+
+*Effects*: Equivalent to:return !ranges::less{}(std::forward<T>(t), std::forward<U>(u));
+
+[🔗](#lib:less_equal)
+
+`struct ranges::less_equal {
+  template<class T, class U>
+    constexpr bool operator()(T&& t, U&& u) const;
+
+  using is_transparent = unspecified;
+};
+`
+
+[🔗](#itemdecl:7)
+
+`template<class T, class U>
+  constexpr bool operator()(T&& t, U&& u) const;
+`
+
+[13](#13)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12780)
+
+*Constraints*: T and U satisfy [totally_ordered_with](concept.totallyordered#concept:totally_ordered_with "18.5.5 Concept totally_­ordered [concept.totallyordered]")[.](#13.sentence-1)
+
+[14](#14)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/utilities.tex#L12784)
+
+*Effects*: Equivalent to:return !ranges::less{}(std::forward<U>(u), std::forward<T>(t));

cppdraft/range/common.md

@@ -0,0 +1,72 @@
+[range.common]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.common)
+
+### 25.7.20 Common view [range.common]
+
+#### [25.7.20.1](#overview) Overview [[range.common.overview]](range.common.overview)
+
+[1](#overview-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L9754)
+
+common_view takes a view which has different types for
+its iterator and sentinel and turns it into a view of the same
+elements with an iterator and sentinel of the same type[.](#overview-1.sentence-1)
+
+[2](#overview-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L9759)
+
+[*Note [1](#overview-note-1)*:
+
+common_view is useful for calling legacy algorithms that expect
+a range's iterator and sentinel types to be the same[.](#overview-2.sentence-1)
+
+— *end note*]
+
+[3](#overview-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L9765)
+
+The name views​::​common denotes a
+range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#overview-3.sentence-1)
+
+Given a subexpression E,
+the expression views​::​common(E) is expression-equivalent to:
+
+- [(3.1)](#overview-3.1)
+
+  views​::​all(E),
+ if decltype((E)) models [common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]") and views​::​all(E) is a well-formed expression[.](#overview-3.1.sentence-1)
+
+- [(3.2)](#overview-3.2)
+
+  Otherwise, common_view{E}[.](#overview-3.2.sentence-1)
+
+[4](#overview-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L9779)
+
+[*Example [1](#overview-example-1)*: // Legacy algorithm:template<class ForwardIterator> size_t count(ForwardIterator first, ForwardIterator last);
+
+template<[forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") R>void my_algo(R&& r) {auto&& common = views::common(r); auto cnt = count(common.begin(), common.end()); // ...} — *end example*]
+
+#### [25.7.20.2](#view) Class template common_view [[range.common.view]](range.common.view)
+
+[🔗](#lib:common_view)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires (![common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<V> && [copyable](concepts.object#concept:copyable "18.6 Object concepts [concepts.object]")<iterator_t<V>>)class common_view : public view_interface<common_view<V>> {private: V *base_* = V(); // *exposition only*public: common_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> = default; constexpr explicit common_view(V r); 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() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) {if constexpr ([random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>)return ranges::begin(*base_*); elsereturn common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::begin(*base_*)); }constexpr auto begin() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V> {if constexpr ([random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<const V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>)return ranges::begin(*base_*); elsereturn common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::begin(*base_*)); }constexpr auto end() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) {if constexpr ([random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>)return ranges::begin(*base_*) + ranges::distance(*base_*); elsereturn common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::end(*base_*)); }constexpr auto end() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V> {if constexpr ([random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<const V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>)return ranges::begin(*base_*) + ranges::distance(*base_*); elsereturn common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::end(*base_*)); }constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V> {return ranges::size(*base_*); }constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V> {return ranges::size(*base_*); }constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V> {return ranges::reserve_hint(*base_*); }constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V> {return ranges::reserve_hint(*base_*); }}; template<class R> common_view(R&&) -> common_view<views::all_t<R>>;}
+
+[🔗](#lib:common_view,constructor)
+
+`constexpr explicit common_view(V base);
+`
+
+[1](#view-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L9872)
+
+*Effects*: Initializes *base_* with std​::​move(base)[.](#view-1.sentence-1)

cppdraft/range/common/overview.md

@@ -0,0 +1,55 @@
+[range.common.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.common.overview)
+
+### 25.7.20 Common view [[range.common]](range.common#overview)
+
+#### 25.7.20.1 Overview [range.common.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L9754)
+
+common_view takes a view which has different types for
+its iterator and sentinel and turns it into a view of the same
+elements with an iterator and sentinel of the same type[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L9759)
+
+[*Note [1](#note-1)*:
+
+common_view is useful for calling legacy algorithms that expect
+a range's iterator and sentinel types to be the same[.](#2.sentence-1)
+
+— *end note*]
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L9765)
+
+The name views​::​common denotes a
+range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#3.sentence-1)
+
+Given a subexpression E,
+the expression views​::​common(E) is expression-equivalent to:
+
+- [(3.1)](#3.1)
+
+  views​::​all(E),
+ if decltype((E)) models [common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]") and views​::​all(E) is a well-formed expression[.](#3.1.sentence-1)
+
+- [(3.2)](#3.2)
+
+  Otherwise, common_view{E}[.](#3.2.sentence-1)
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L9779)
+
+[*Example [1](#example-1)*: // Legacy algorithm:template<class ForwardIterator> size_t count(ForwardIterator first, ForwardIterator last);
+
+template<[forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]") R>void my_algo(R&& r) {auto&& common = views::common(r); auto cnt = count(common.begin(), common.end()); // ...} — *end example*]

cppdraft/range/common/view.md

@@ -0,0 +1,24 @@
+[range.common.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.common.view)
+
+### 25.7.20 Common view [[range.common]](range.common#view)
+
+#### 25.7.20.2 Class template common_view [range.common.view]
+
+[🔗](#lib:common_view)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires (![common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<V> && [copyable](concepts.object#concept:copyable "18.6 Object concepts [concepts.object]")<iterator_t<V>>)class common_view : public view_interface<common_view<V>> {private: V *base_* = V(); // *exposition only*public: common_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> = default; constexpr explicit common_view(V r); 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() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) {if constexpr ([random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>)return ranges::begin(*base_*); elsereturn common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::begin(*base_*)); }constexpr auto begin() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V> {if constexpr ([random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<const V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>)return ranges::begin(*base_*); elsereturn common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::begin(*base_*)); }constexpr auto end() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) {if constexpr ([random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>)return ranges::begin(*base_*) + ranges::distance(*base_*); elsereturn common_iterator<iterator_t<V>, sentinel_t<V>>(ranges::end(*base_*)); }constexpr auto end() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V> {if constexpr ([random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<const V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>)return ranges::begin(*base_*) + ranges::distance(*base_*); elsereturn common_iterator<iterator_t<const V>, sentinel_t<const V>>(ranges::end(*base_*)); }constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V> {return ranges::size(*base_*); }constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V> {return ranges::size(*base_*); }constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V> {return ranges::reserve_hint(*base_*); }constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V> {return ranges::reserve_hint(*base_*); }}; template<class R> common_view(R&&) -> common_view<views::all_t<R>>;}
+
+[🔗](#lib:common_view,constructor)
+
+`constexpr explicit common_view(V base);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L9872)
+
+*Effects*: Initializes *base_* with std​::​move(base)[.](#1.sentence-1)

cppdraft/range/concat/overview.md

@@ -0,0 +1,37 @@
+[range.concat.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.concat.overview)
+
+### 25.7.18 Concat view [[range.concat]](range.concat#overview)
+
+#### 25.7.18.1 Overview [range.concat.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8697)
+
+concat_view presents a view that concatenates all the underlying ranges[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8700)
+
+The name views​::​concat denotes
+a customization point object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#2.sentence-1)
+
+Given a pack of subexpressions Es...,
+the expression views​::​concat(Es...) is expression-equivalent to
+
+- [(2.1)](#2.1)
+
+views​::​all(Es...) if Es is a pack with only one element
+whose type models [input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]"),
+
+- [(2.2)](#2.2)
+
+otherwise, concat_view(Es...)[.](#2.sentence-2)
+
+[*Example [1](#example-1)*: vector<int> 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*]

cppdraft/range/concat/view.md

@@ -0,0 +1,122 @@
+[range.concat.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.concat.view)
+
+### 25.7.18 Concat view [[range.concat]](range.concat#view)
+
+#### 25.7.18.2 Class template concat_view [range.concat.view]
+
+[🔗](#lib:concat_view)
+
+namespace std::ranges {template<class... Rs>using *concat-reference-t* = common_reference_t<range_reference_t<Rs>...>; // *exposition only*template<class... Rs>using *concat-value-t* = common_type_t<range_value_t<Rs>...>; // *exposition only*template<class... Rs>using *concat-rvalue-reference-t* = // *exposition only* common_reference_t<range_rvalue_reference_t<Rs>...>; 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*template<class... Rs>concept [*concatable*](#concept:concatable "25.7.18.2 Class template concat_­view [range.concat.view]") = *see below*; // *exposition only*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*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*template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]")... Views>requires ([view](range.view#concept:view "25.4.5 Views [range.view]")<Views> && ...) && (sizeof...(Views) > 0) &&[*concatable*](#concept:concatable "25.7.18.2 Class template concat_­view [range.concat.view]")<Views...>class concat_view : public view_interface<concat_view<Views...>> { tuple<Views...> *views_*; // *exposition only*// [[range.concat.iterator]](range.concat.iterator "25.7.18.3 Class concat_­view​::​iterator"), class template concat_view​::​*iterator*template<bool> class *iterator*; // *exposition only*public:constexpr concat_view() = default; constexpr explicit concat_view(Views... 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() constrequires ([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...>; constexpr auto end() requires (!([*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<Views> && ...)); constexpr auto end() constrequires ([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...>; 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> && ...); }; template<class... R> concat_view(R&&...) -> concat_view<views::all_t<R>...>;}
+
+[🔗](#concept:concat-indirectly-readable)
+
+`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](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8780)
+
+The exposition-only [*concat-indirectly-readable*](#concept:concat-indirectly-readable "25.7.18.2 Class template concat_­view [range.concat.view]") concept
+is equivalent to:template<class Ref, class RRef, class It>concept [*concat-indirectly-readable-impl*](#concept:concat-indirectly-readable-impl "25.7.18.2 Class template concat_­view [range.concat.view]") = // *exposition only*requires (const It it) {{ *it } -> [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<Ref>; { ranges::iter_move(it) } -> [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<RRef>; };
+
+template<class... Rs>concept [*concat-indirectly-readable*](#concept:concat-indirectly-readable "25.7.18.2 Class template concat_­view [range.concat.view]") = // *exposition only*[common_reference_with](concept.commonref#concept:common_reference_with "18.4.5 Concept common_­reference_­with [concept.commonref]")<*concat-reference-t*<Rs...>&&, *concat-value-t*<Rs...>&> &&[common_reference_with](concept.commonref#concept:common_reference_with "18.4.5 Concept common_­reference_­with [concept.commonref]")<*concat-reference-t*<Rs...>&&, *concat-rvalue-reference-t*<Rs...>&&> &&[common_reference_with](concept.commonref#concept:common_reference_with "18.4.5 Concept common_­reference_­with [concept.commonref]")<*concat-rvalue-reference-t*<Rs...>&&, *concat-value-t*<Rs...> const&> &&([*concat-indirectly-readable-impl*](#concept:concat-indirectly-readable-impl "25.7.18.2 Class template concat_­view [range.concat.view]")<*concat-reference-t*<Rs...>, *concat-rvalue-reference-t*<Rs...>,
+ iterator_t<Rs>> && ...);
+
+[🔗](#concept:concatable)
+
+`template<class... Rs>
+  concept [concatable](#concept:concatable "25.7.18.2 Class template concat_­view [range.concat.view]") = see below;                                           // exposition only
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8811)
+
+The exposition-only [*concatable*](#concept:concatable "25.7.18.2 Class template concat_­view [range.concat.view]") concept is equivalent to:template<class... Rs>concept [*concatable*](#concept:concatable "25.7.18.2 Class template concat_­view [range.concat.view]") = requires { // *exposition only*typename *concat-reference-t*<Rs...>; typename *concat-value-t*<Rs...>; typename *concat-rvalue-reference-t*<Rs...>; } && [*concat-indirectly-readable*](#concept:concat-indirectly-readable "25.7.18.2 Class template concat_­view [range.concat.view]")<Rs...>;
+
+[🔗](#concept:concat-is-random-access)
+
+`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](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8829)
+
+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*](#concept:concat-is-random-access "25.7.18.2 Class template concat_­view [range.concat.view]") = // *exposition only*[*all-random-access*](range.adaptor.helpers#concept:all-random-access "25.7.5 Range adaptor helpers [range.adaptor.helpers]")<Const, Rs...> &&([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<*maybe-const*<Const, Fs>> && ...);
+
+[🔗](#concept:concat-is-bidirectional)
+
+`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](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8848)
+
+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*](#concept:concat-is-bidirectional "25.7.18.2 Class template concat_­view [range.concat.view]") = // *exposition only*[*all-bidirectional*](range.adaptor.helpers#concept:all-bidirectional "25.7.5 Range adaptor helpers [range.adaptor.helpers]")<Const, Rs...> &&([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<*maybe-const*<Const, Fs>> && ...);
+
+[🔗](#lib:concat_view,constructor)
+
+`constexpr explicit concat_view(Views... views);
+`
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8867)
+
+*Effects*: Initializes *views_* with std​::​move(views)...[.](#5.sentence-1)
+
+[🔗](#lib:begin,concat_view)
+
+`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](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8880)
+
+*Effects*: Let *is-const* betrue for the const-qualified overload, andfalse otherwise[.](#6.sentence-1)
+
+Equivalent to:*iterator*<*is-const*> it(this, in_place_index<0>, ranges::begin(std::get<0>(*views_*)));
+it.template *satisfy*<0>();return it;
+
+[🔗](#lib:end,concat_view)
+
+`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](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8901)
+
+*Effects*: Let *is-const* betrue for the const-qualified overload, andfalse otherwise[.](#7.sentence-1)
+
+Equivalent to:constexpr auto N = sizeof...(Views);if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<*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;}
+
+[🔗](#lib:size,concat_view)
+
+`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](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L8925)
+
+*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_*));

cppdraft/range/counted.md

@@ -0,0 +1,51 @@
+[range.counted]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.counted)
+
+### 25.7.19 Counted view [range.counted]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L9712)
+
+A counted view presents a view of the elements
+of the counted range ([[iterator.requirements.general]](iterator.requirements.general "24.3.1 General")) i+[0, n) for an iterator i and non-negative integer n[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L9718)
+
+The name views​::​counted denotes
+a customization point object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#2.sentence-1)
+
+Let E and F be expressions,
+let T be decay_t<decltype((E))>, and
+let D be iter_difference_t<T>[.](#2.sentence-2)
+
+If decltype((F)) does not model[convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<D>,views​::​counted(E, F) is ill-formed[.](#2.sentence-3)
+
+[*Note [1](#note-1)*:
+
+This case can result in substitution failure
+when views​::​counted(E, F) appears in the immediate context of a template instantiation[.](#2.sentence-4)
+
+— *end note*]
+
+Otherwise, views​::​counted(E, F) is expression-equivalent to:
+
+- [(2.1)](#2.1)
+
+  If T models [contiguous_iterator](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]"),
+then span(to_address(E), static_cast<size_t>(static_cast<D>(F)))[.](#2.1.sentence-1)
+
+- [(2.2)](#2.2)
+
+  Otherwise, if T models [random_access_iterator](iterator.concept.random.access#concept:random_access_iterator "24.3.4.13 Concept random_­access_­iterator [iterator.concept.random.access]"),
+then subrange(E, E + static_cast<D>(F)),
+except that E is evaluated only once[.](#2.2.sentence-1)
+
+- [(2.3)](#2.3)
+
+  Otherwise,subrange(counted_iterator(E, F), default_sentinel)[.](#2.3.sentence-1)

cppdraft/range/dangling.md

@@ -0,0 +1,56 @@
+[range.dangling]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.5 Range utilities [[range.utility]](range.utility#range.dangling)
+
+### 25.5.5 Dangling iterator handling [range.dangling]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2252)
+
+The type dangling is used together with the template aliasesborrowed_iterator_t and borrowed_subrange_t[.](#1.sentence-1)
+
+When an algorithm
+that typically returns an iterator into, or a subrange of, a range argument
+is called with an rvalue range argument
+that does not model [borrowed_range](range.range#concept:borrowed_range "25.4.2 Ranges [range.range]") ([[range.range]](range.range "25.4.2 Ranges")),
+the return value possibly refers to a range whose lifetime has ended[.](#1.sentence-2)
+
+In such cases,
+the type dangling is returned instead of an iterator or subrange[.](#1.sentence-3)
+
+[🔗](#lib:dangling)
+
+namespace std::ranges {struct dangling {constexpr dangling() noexcept = default; constexpr dangling(auto&&...) noexcept {}};}
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2272)
+
+[*Example [1](#example-1)*: vector<int> f();auto result1 = ranges::find(f(), 42); // #1static_assert([same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<decltype(result1), ranges::dangling>);auto vec = f();auto result2 = ranges::find(vec, 42); // #2static_assert([same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<decltype(result2), vector<int>::iterator>);auto result3 = ranges::find(ranges::subrange{vec}, 42); // #3static_assert([same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<decltype(result3), vector<int>::iterator>);
+
+The call to ranges​::​find at #1 returns ranges​::​dangling since f() is an rvalue vector;
+it is possible for the vector to be destroyed
+before a returned iterator is dereferenced[.](#2.sentence-1)
+
+However, the calls at #2 and #3 both return iterators
+since the lvalue vec and specializations of subrange model [borrowed_range](range.range#concept:borrowed_range "25.4.2 Ranges [range.range]")[.](#2.sentence-2)
+
+— *end example*]
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2293)
+
+For a type R that models [range](range.range#concept:range "25.4.2 Ranges [range.range]"):
+
+- [(3.1)](#3.1)
+
+if R models [borrowed_range](range.range#concept:borrowed_range "25.4.2 Ranges [range.range]"), thenborrowed_iterator_t<R> denotes iterator_t<R>, andborrowed_subrange_t<R> denotes subrange<iterator_t<R>>;
+
+- [(3.2)](#3.2)
+
+otherwise,
+both borrowed_iterator_t<R> and borrowed_subrange_t<R> denote dangling[.](#3.sentence-1)

cppdraft/range/drop.md

@@ -0,0 +1,148 @@
+[range.drop]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.drop)
+
+### 25.7.12 Drop view [range.drop]
+
+#### [25.7.12.1](#overview) Overview [[range.drop.overview]](range.drop.overview)
+
+[1](#overview-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6345)
+
+drop_view produces a view
+excluding the first N elements from another view, or
+an empty range if the adapted view contains fewer than N elements[.](#overview-1.sentence-1)
+
+[2](#overview-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6350)
+
+The name views​::​drop denotes
+a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#overview-2.sentence-1)
+
+Let E and F be expressions,
+let T be remove_cvref_t<decltype((E))>, and
+let D be range_difference_t<decltype((E))>[.](#overview-2.sentence-2)
+
+If decltype((F)) does not model[convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<D>,views​::​drop(E, F) is ill-formed[.](#overview-2.sentence-3)
+
+Otherwise, the expression views​::​drop(E, F) is expression-equivalent to:
+
+- [(2.1)](#overview-2.1)
+
+  If T is a specialization ofempty_view ([[range.empty.view]](range.empty.view "25.6.2.2 Class template empty_­view")),
+then ((void)F, *decay-copy*(E)),
+except that the evaluations of E and F are indeterminately sequenced[.](#overview-2.1.sentence-1)
+
+- [(2.2)](#overview-2.2)
+
+  Otherwise, if T models[random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]") and [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]") and is
+  * [(2.2.1)](#overview-2.2.1)
+
+a specialization of span ([[views.span]](views.span "23.7.2.2 Class template span")),
+
+  * [(2.2.2)](#overview-2.2.2)
+
+a specialization of basic_string_view ([[string.view]](string.view "27.3 String view classes")),
+
+  * [(2.2.3)](#overview-2.2.3)
+
+a specialization of iota_view ([[range.iota.view]](range.iota.view "25.6.4.2 Class template iota_­view")), or
+
+  * [(2.2.4)](#overview-2.2.4)
+
+a specialization of subrange ([[range.subrange]](range.subrange "25.5.4 Sub-ranges"))
+where T​::​*StoreSize* is false,
+
+then U(ranges​::​begin(E) + std​::​min<D>(ranges​::​distance(E), F), ranges​::​end(E)),
+except that E is evaluated only once,
+where U is span<typename T​::​element_type> if T is a specialization of span and T otherwise[.](#overview-2.2.sentence-1)
+
+- [(2.3)](#overview-2.3)
+
+  Otherwise,
+if T is
+a specialization of subrange that models [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]") and [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]"),
+thenT(ranges​::​begin(E) + std​::​min<D>(ranges​::​distance(E), F), ranges​::​end(E),*to-unsigned-like*(ranges​::​distance(E) - std​::​min<D>(ranges​::​distance(E), F))),
+except that E and F are each evaluated only once[.](#overview-2.3.sentence-1)
+
+- [(2.4)](#overview-2.4)
+
+  Otherwise, if T is
+a specialization of repeat_view ([[range.repeat.view]](range.repeat.view "25.6.5.2 Class template repeat_­view")):
+  * [(2.4.1)](#overview-2.4.1)
+
+if T models [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]"),
+thenviews::repeat(*E.*value_*, ranges::distance(E) - std::min<D>(ranges::distance(E), F)) except that E is evaluated only once;
+
+  * [(2.4.2)](#overview-2.4.2)
+
+otherwise, ((void)F, *decay-copy*(E)),
+except that the evaluations of E and F are indeterminately sequenced[.](#overview-2.4.sentence-1)
+
+- [(2.5)](#overview-2.5)
+
+  Otherwise, drop_view(E, F)[.](#overview-2.5.sentence-1)
+
+[3](#overview-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6417)
+
+[*Example [1](#overview-example-1)*: auto ints = views::iota(0) | views::take(10);for (auto i : ints | views::drop(5)) { cout << i << ' '; // prints 5 6 7 8 9} — *end example*]
+
+#### [25.7.12.2](#view) Class template drop_view [[range.drop.view]](range.drop.view)
+
+[🔗](#lib:drop_view)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>class drop_view : public view_interface<drop_view<V>> {public: drop_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> = default; constexpr explicit drop_view(V base, range_difference_t<V> count); 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()requires (!([*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V> &&[random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<const V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>)); constexpr auto begin() constrequires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<const V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>; constexpr auto end() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>){ return ranges::end(*base_*); }constexpr auto end() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V>{ return ranges::end(*base_*); }constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<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](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<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](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<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](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<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(); // *exposition only* range_difference_t<V> *count_* = 0; // *exposition only*}; template<class R> drop_view(R&&, range_difference_t<R>) -> drop_view<views::all_t<R>>;}
+
+[🔗](#lib:drop_view,constructor)
+
+`constexpr explicit drop_view(V base, range_difference_t<V> count);
+`
+
+[1](#view-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6494)
+
+*Preconditions*: count >= 0 is true[.](#view-1.sentence-1)
+
+[2](#view-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6498)
+
+*Effects*: Initializes *base_* with std​::​move(base) and*count_* with count[.](#view-2.sentence-1)
+
+[🔗](#lib:begin,drop_view)
+
+`constexpr auto begin()
+  requires (!([simple-view](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V> &&
+              [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<const V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>));
+constexpr auto begin() const
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<const V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>;
+`
+
+[3](#view-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6514)
+
+*Returns*: ranges​::​next(ranges​::​begin(*base_*), *count_*, ranges​::​end(*base_*))[.](#view-3.sentence-1)
+
+[4](#view-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6518)
+
+*Remarks*: In order to provide the amortized constant-time complexity required
+by the [range](range.range#concept:range "25.4.2 Ranges [range.range]") concept
+when drop_view models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]"),
+the first overload caches the result within the drop_view for use on subsequent calls[.](#view-4.sentence-1)
+
+[*Note [1](#view-note-1)*:
+
+Without this,
+applying a reverse_view over a drop_view would have quadratic iteration complexity[.](#view-4.sentence-2)
+
+— *end note*]

cppdraft/range/drop/overview.md

@@ -0,0 +1,94 @@
+[range.drop.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.drop.overview)
+
+### 25.7.12 Drop view [[range.drop]](range.drop#overview)
+
+#### 25.7.12.1 Overview [range.drop.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6345)
+
+drop_view produces a view
+excluding the first N elements from another view, or
+an empty range if the adapted view contains fewer than N elements[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6350)
+
+The name views​::​drop denotes
+a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#2.sentence-1)
+
+Let E and F be expressions,
+let T be remove_cvref_t<decltype((E))>, and
+let D be range_difference_t<decltype((E))>[.](#2.sentence-2)
+
+If decltype((F)) does not model[convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<D>,views​::​drop(E, F) is ill-formed[.](#2.sentence-3)
+
+Otherwise, the expression views​::​drop(E, F) is expression-equivalent to:
+
+- [(2.1)](#2.1)
+
+  If T is a specialization ofempty_view ([[range.empty.view]](range.empty.view "25.6.2.2 Class template empty_­view")),
+then ((void)F, *decay-copy*(E)),
+except that the evaluations of E and F are indeterminately sequenced[.](#2.1.sentence-1)
+
+- [(2.2)](#2.2)
+
+  Otherwise, if T models[random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]") and [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]") and is
+  * [(2.2.1)](#2.2.1)
+
+a specialization of span ([[views.span]](views.span "23.7.2.2 Class template span")),
+
+  * [(2.2.2)](#2.2.2)
+
+a specialization of basic_string_view ([[string.view]](string.view "27.3 String view classes")),
+
+  * [(2.2.3)](#2.2.3)
+
+a specialization of iota_view ([[range.iota.view]](range.iota.view "25.6.4.2 Class template iota_­view")), or
+
+  * [(2.2.4)](#2.2.4)
+
+a specialization of subrange ([[range.subrange]](range.subrange "25.5.4 Sub-ranges"))
+where T​::​*StoreSize* is false,
+
+then U(ranges​::​begin(E) + std​::​min<D>(ranges​::​distance(E), F), ranges​::​end(E)),
+except that E is evaluated only once,
+where U is span<typename T​::​element_type> if T is a specialization of span and T otherwise[.](#2.2.sentence-1)
+
+- [(2.3)](#2.3)
+
+  Otherwise,
+if T is
+a specialization of subrange that models [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]") and [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]"),
+thenT(ranges​::​begin(E) + std​::​min<D>(ranges​::​distance(E), F), ranges​::​end(E),*to-unsigned-like*(ranges​::​distance(E) - std​::​min<D>(ranges​::​distance(E), F))),
+except that E and F are each evaluated only once[.](#2.3.sentence-1)
+
+- [(2.4)](#2.4)
+
+  Otherwise, if T is
+a specialization of repeat_view ([[range.repeat.view]](range.repeat.view "25.6.5.2 Class template repeat_­view")):
+  * [(2.4.1)](#2.4.1)
+
+if T models [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]"),
+thenviews::repeat(*E.*value_*, ranges::distance(E) - std::min<D>(ranges::distance(E), F)) except that E is evaluated only once;
+
+  * [(2.4.2)](#2.4.2)
+
+otherwise, ((void)F, *decay-copy*(E)),
+except that the evaluations of E and F are indeterminately sequenced[.](#2.4.sentence-1)
+
+- [(2.5)](#2.5)
+
+  Otherwise, drop_view(E, F)[.](#2.5.sentence-1)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6417)
+
+[*Example [1](#example-1)*: auto ints = views::iota(0) | views::take(10);for (auto i : ints | views::drop(5)) { cout << i << ' '; // prints 5 6 7 8 9} — *end example*]

cppdraft/range/drop/view.md

@@ -0,0 +1,61 @@
+[range.drop.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.drop.view)
+
+### 25.7.12 Drop view [[range.drop]](range.drop#view)
+
+#### 25.7.12.2 Class template drop_view [range.drop.view]
+
+[🔗](#lib:drop_view)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>class drop_view : public view_interface<drop_view<V>> {public: drop_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> = default; constexpr explicit drop_view(V base, range_difference_t<V> count); 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()requires (!([*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V> &&[random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<const V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>)); constexpr auto begin() constrequires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<const V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>; constexpr auto end() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>){ return ranges::end(*base_*); }constexpr auto end() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V>{ return ranges::end(*base_*); }constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<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](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<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](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<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](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<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(); // *exposition only* range_difference_t<V> *count_* = 0; // *exposition only*}; template<class R> drop_view(R&&, range_difference_t<R>) -> drop_view<views::all_t<R>>;}
+
+[🔗](#lib:drop_view,constructor)
+
+`constexpr explicit drop_view(V base, range_difference_t<V> count);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6494)
+
+*Preconditions*: count >= 0 is true[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6498)
+
+*Effects*: Initializes *base_* with std​::​move(base) and*count_* with count[.](#2.sentence-1)
+
+[🔗](#lib:begin,drop_view)
+
+`constexpr auto begin()
+  requires (!([simple-view](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V> &&
+              [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<const V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>));
+constexpr auto begin() const
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<const V> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>;
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6514)
+
+*Returns*: ranges​::​next(ranges​::​begin(*base_*), *count_*, ranges​::​end(*base_*))[.](#3.sentence-1)
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6518)
+
+*Remarks*: In order to provide the amortized constant-time complexity required
+by the [range](range.range#concept:range "25.4.2 Ranges [range.range]") concept
+when drop_view models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]"),
+the first overload caches the result within the drop_view for use on subsequent calls[.](#4.sentence-1)
+
+[*Note [1](#note-1)*:
+
+Without this,
+applying a reverse_view over a drop_view would have quadratic iteration complexity[.](#4.sentence-2)
+
+— *end note*]

cppdraft/range/drop/while.md

@@ -0,0 +1,92 @@
+[range.drop.while]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.drop.while)
+
+### 25.7.13 Drop while view [range.drop.while]
+
+#### [25.7.13.1](#overview) Overview [[range.drop.while.overview]](range.drop.while.overview)
+
+[1](#overview-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6536)
+
+Given a unary predicate pred and a view r,drop_while_view produces a view
+of the range [ranges​::​find_if_not(r, pred), ranges​::​end(r))[.](#overview-1.sentence-1)
+
+[2](#overview-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6541)
+
+The name views​::​drop_while 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​::​drop_while(E, F) is expression-equivalent to drop_while_view(E, F)[.](#overview-2.sentence-2)
+
+[3](#overview-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6549)
+
+[*Example [1](#overview-example-1)*: constexpr auto source = " \t \t \t hello there"sv;auto is_invisible = [](const auto x) { return x == ' ' || x == '\t'; };auto skip_ws = views::drop_while(source, is_invisible);for (auto c : skip_ws) { cout << c; // prints hello there with no leading space} — *end example*]
+
+#### [25.7.13.2](#view) Class template drop_while_view [[range.drop.while.view]](range.drop.while.view)
+
+[🔗](#lib:drop_while_view)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V, class Pred>requires [input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]")<V> && is_object_v<Pred> &&[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect_unary_predicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<const Pred, iterator_t<V>>class drop_while_view : public view_interface<drop_while_view<V, Pred>> {public: drop_while_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]")<Pred> = default; constexpr explicit drop_while_view(V base, Pred pred); 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 const Pred& pred() const; constexpr auto begin(); constexpr auto end() { return ranges::end(*base_*); }private: V *base_* = V(); // *exposition only**movable-box*<Pred> *pred_*; // *exposition only*}; template<class R, class Pred> drop_while_view(R&&, Pred) -> drop_while_view<views::all_t<R>, Pred>;}
+
+[🔗](#lib:drop_while_view,constructor)
+
+`constexpr explicit drop_while_view(V base, Pred pred);
+`
+
+[1](#view-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6601)
+
+*Effects*: Initializes *base_* with std​::​move(base) and*pred_* with std​::​move(pred)[.](#view-1.sentence-1)
+
+[🔗](#lib:pred,drop_while_view)
+
+`constexpr const Pred& pred() const;
+`
+
+[2](#view-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6613)
+
+*Effects*: Equivalent to: return **pred_*;
+
+[🔗](#lib:begin,drop_while_view)
+
+`constexpr auto begin();
+`
+
+[3](#view-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6624)
+
+*Preconditions*: *pred_*.has_value() is true[.](#view-3.sentence-1)
+
+[4](#view-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6628)
+
+*Returns*: ranges​::​find_if_not(*base_*, cref(**pred_*))[.](#view-4.sentence-1)
+
+[5](#view-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6632)
+
+*Remarks*: In order to provide the amortized constant-time complexity
+required by the [range](range.range#concept:range "25.4.2 Ranges [range.range]") concept
+when drop_while_view models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]"),
+the first call caches the result within the drop_while_view for use on subsequent calls[.](#view-5.sentence-1)
+
+[*Note [1](#view-note-1)*:
+
+Without this,
+applying a reverse_view over a drop_while_view would have quadratic iteration complexity[.](#view-5.sentence-2)
+
+— *end note*]

cppdraft/range/drop/while/overview.md

@@ -0,0 +1,31 @@
+[range.drop.while.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.drop.while.overview)
+
+### 25.7.13 Drop while view [[range.drop.while]](range.drop.while#overview)
+
+#### 25.7.13.1 Overview [range.drop.while.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6536)
+
+Given a unary predicate pred and a view r,drop_while_view produces a view
+of the range [ranges​::​find_if_not(r, pred), ranges​::​end(r))[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6541)
+
+The name views​::​drop_while denotes a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#2.sentence-1)
+
+Given subexpressions E and F,
+the expression views​::​drop_while(E, F) is expression-equivalent to drop_while_view(E, F)[.](#2.sentence-2)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6549)
+
+[*Example [1](#example-1)*: constexpr auto source = " \t \t \t hello there"sv;auto is_invisible = [](const auto x) { return x == ' ' || x == '\t'; };auto skip_ws = views::drop_while(source, is_invisible);for (auto c : skip_ws) { cout << c; // prints hello there with no leading space} — *end example*]

cppdraft/range/drop/while/view.md

@@ -0,0 +1,68 @@
+[range.drop.while.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.drop.while.view)
+
+### 25.7.13 Drop while view [[range.drop.while]](range.drop.while#view)
+
+#### 25.7.13.2 Class template drop_while_view [range.drop.while.view]
+
+[🔗](#lib:drop_while_view)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V, class Pred>requires [input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]")<V> && is_object_v<Pred> &&[indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect_unary_predicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<const Pred, iterator_t<V>>class drop_while_view : public view_interface<drop_while_view<V, Pred>> {public: drop_while_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]")<Pred> = default; constexpr explicit drop_while_view(V base, Pred pred); 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 const Pred& pred() const; constexpr auto begin(); constexpr auto end() { return ranges::end(*base_*); }private: V *base_* = V(); // *exposition only**movable-box*<Pred> *pred_*; // *exposition only*}; template<class R, class Pred> drop_while_view(R&&, Pred) -> drop_while_view<views::all_t<R>, Pred>;}
+
+[🔗](#lib:drop_while_view,constructor)
+
+`constexpr explicit drop_while_view(V base, Pred pred);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6601)
+
+*Effects*: Initializes *base_* with std​::​move(base) and*pred_* with std​::​move(pred)[.](#1.sentence-1)
+
+[🔗](#lib:pred,drop_while_view)
+
+`constexpr const Pred& pred() const;
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6613)
+
+*Effects*: Equivalent to: return **pred_*;
+
+[🔗](#lib:begin,drop_while_view)
+
+`constexpr auto begin();
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6624)
+
+*Preconditions*: *pred_*.has_value() is true[.](#3.sentence-1)
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6628)
+
+*Returns*: ranges​::​find_if_not(*base_*, cref(**pred_*))[.](#4.sentence-1)
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L6632)
+
+*Remarks*: In order to provide the amortized constant-time complexity
+required by the [range](range.range#concept:range "25.4.2 Ranges [range.range]") concept
+when drop_while_view models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]"),
+the first call caches the result within the drop_while_view for use on subsequent calls[.](#5.sentence-1)
+
+[*Note [1](#note-1)*:
+
+Without this,
+applying a reverse_view over a drop_while_view would have quadratic iteration complexity[.](#5.sentence-2)
+
+— *end note*]

cppdraft/range/elements/overview.md

@@ -0,0 +1,51 @@
+[range.elements.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.elements.overview)
+
+### 25.7.23 Elements view [[range.elements]](range.elements#overview)
+
+#### 25.7.23.1 Overview [range.elements.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10131)
+
+elements_view takes
+a view of tuple-like values and a size_t, and
+produces a view with a value-type of the Nth element
+of the adapted view's value-type[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10137)
+
+The name views​::​elements<N> denotes
+a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#2.sentence-1)
+
+Given a subexpression E and constant expression N,
+the expression views​::​elements<N>(E) is expression-equivalent toelements_view<views​::​all_t<decltype((E))>, N>{E}[.](#2.sentence-2)
+
+[*Example [1](#example-1)*: auto historical_figures = map{ pair{"Lovelace"sv, 1815}, {"Turing"sv, 1912}, {"Babbage"sv, 1791}, {"Hamilton"sv, 1936}};
+
+auto names = historical_figures | views::elements<0>;for (auto&& name : names) { cout << name << ' '; // prints Babbage Hamilton Lovelace Turing }auto birth_years = historical_figures | views::elements<1>;for (auto&& born : birth_years) { cout << born << ' '; // prints 1791 1936 1815 1912 } — *end example*]
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10166)
+
+keys_view is an alias for elements_view<R, 0>, and
+is useful for extracting keys from associative containers[.](#3.sentence-1)
+
+[*Example [2](#example-2)*: auto names = historical_figures | views::keys;for (auto&& name : names) { cout << name << ' '; // prints Babbage Hamilton Lovelace Turing } — *end example*]
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10179)
+
+values_view is an alias for elements_view<R, 1>, and
+is useful for extracting values from associative containers[.](#4.sentence-1)
+
+[*Example [3](#example-3)*: auto is_even = [](const auto x) { return x % 2 == 0; };
+cout << ranges::count_if(historical_figures | views::values, is_even); // prints 2 — *end example*]

cppdraft/range/elements/sentinel.md

@@ -0,0 +1,88 @@
+[range.elements.sentinel]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.elements.sentinel)
+
+### 25.7.23 Elements view [[range.elements]](range.elements#sentinel)
+
+#### 25.7.23.4 Class template elements_view​::​*sentinel* [range.elements.sentinel]
+
+[🔗](#lib:elements_view::sentinel)
+
+namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V, size_t N>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && [*has-tuple-element*](range.elements.view#concept:has-tuple-element "25.7.23.2 Class template elements_­view [range.elements.view]")<range_value_t<V>, N> &&[*has-tuple-element*](range.elements.view#concept:has-tuple-element "25.7.23.2 Class template elements_­view [range.elements.view]")<remove_reference_t<range_reference_t<V>>, N> &&[*returnable-element*](range.elements.view#concept:returnable-element "25.7.23.2 Class template elements_­view [range.elements.view]")<range_reference_t<V>, N>template<bool Const>class elements_view<V, N>::*sentinel* {private:using *Base* = *maybe-const*<Const, V>; // *exposition only* sentinel_t<*Base*> *end_* = sentinel_t<*Base*>(); // *exposition only*public:*sentinel*() = default; constexpr explicit *sentinel*(sentinel_t<*Base*> end); constexpr *sentinel*(*sentinel*<!Const> other)requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<sentinel_t<V>, sentinel_t<*Base*>>; constexpr sentinel_t<*Base*> base() const; template<bool OtherConst>requires [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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); };}
+
+[🔗](#lib:elements_view::sentinel,constructor)
+
+`constexpr explicit sentinel(sentinel_t<Base> end);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10717)
+
+*Effects*: Initializes *end_* with end[.](#1.sentence-1)
+
+[🔗](#lib:elements_view::sentinel,constructor_)
+
+`constexpr sentinel(sentinel<!Const> other)
+  requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<sentinel_t<V>, sentinel_t<Base>>;
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10729)
+
+*Effects*: Initializes *end_* with std​::​move(other.*end_*)[.](#2.sentence-1)
+
+[🔗](#lib:base,elements_view::sentinel)
+
+`constexpr sentinel_t<Base> base() const;
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10740)
+
+*Effects*: Equivalent to: return *end_*;
+
+[🔗](#lib:operator==,elements_view::sentinel)
+
+`template<bool OtherConst>
+  requires [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10753)
+
+*Effects*: Equivalent to: return x.*current_* == y.*end_*;
+
+[🔗](#lib:operator-,elements_view::sentinel)
+
+`template<bool OtherConst>
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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);
+`
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10767)
+
+*Effects*: Equivalent to: return x.*current_* - y.*end_*;
+
+[🔗](#lib:operator-,elements_view::sentinel_)
+
+`template<bool OtherConst>
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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);
+`
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10781)
+
+*Effects*: Equivalent to: return x.*end_* - y.*current_*;

cppdraft/range/elements/view.md

@@ -0,0 +1,24 @@
+[range.elements.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.elements.view)
+
+### 25.7.23 Elements view [[range.elements]](range.elements#view)
+
+#### 25.7.23.2 Class template elements_view [range.elements.view]
+
+[🔗](#lib:elements_view)
+
+namespace std::ranges {template<class T, size_t N>concept [*has-tuple-element*](#concept:has-tuple-element "25.7.23.2 Class template elements_­view [range.elements.view]") = // *exposition only*[*tuple-like*](tuple.like#concept:tuple-like "22.4.3 Concept tuple-like [tuple.like]")<T> && N < tuple_size_v<T>; template<class T, size_t N>concept [*returnable-element*](#concept:returnable-element "25.7.23.2 Class template elements_­view [range.elements.view]") = // *exposition only* is_reference_v<T> || [move_constructible](concept.moveconstructible#concept:move_constructible "18.4.13 Concept move_­constructible [concept.moveconstructible]")<tuple_element_t<N, T>>; template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V, size_t N>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && [*has-tuple-element*](#concept:has-tuple-element "25.7.23.2 Class template elements_­view [range.elements.view]")<range_value_t<V>, N> &&[*has-tuple-element*](#concept:has-tuple-element "25.7.23.2 Class template elements_­view [range.elements.view]")<remove_reference_t<range_reference_t<V>>, N> &&[*returnable-element*](#concept:returnable-element "25.7.23.2 Class template elements_­view [range.elements.view]")<range_reference_t<V>, N>class elements_view : public view_interface<elements_view<V, N>> {public: elements_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> = default; constexpr explicit elements_view(V base); 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() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>){ return *iterator*<false>(ranges::begin(*base_*)); }constexpr auto begin() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V>{ return *iterator*<true>(ranges::begin(*base_*)); }constexpr auto end() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V> && ![common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<V>){ return *sentinel*<false>{ranges::end(*base_*)}; }constexpr auto end() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V> && [common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<V>){ return *iterator*<false>{ranges::end(*base_*)}; }constexpr auto end() const requires [range](range.range#concept:range "25.4.2 Ranges [range.range]")<const V>{ return *sentinel*<true>{ranges::end(*base_*)}; }constexpr auto end() const requires [common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<const V>{ return *iterator*<true>{ranges::end(*base_*)}; }constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>{ return ranges::size(*base_*); }constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>{ return ranges::size(*base_*); }constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>{ return ranges::reserve_hint(*base_*); }constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>{ return ranges::reserve_hint(*base_*); }private:// [[range.elements.iterator]](range.elements.iterator "25.7.23.3 Class template elements_­view​::​iterator"), class template elements_view​::​*iterator*template<bool> class *iterator*; // *exposition only*// [[range.elements.sentinel]](range.elements.sentinel "25.7.23.4 Class template elements_­view​::​sentinel"), class template elements_view​::​*sentinel*template<bool> class *sentinel*; // *exposition only* V *base_* = V(); // *exposition only*};}
+
+[🔗](#lib:elements_view,constructor)
+
+`constexpr explicit elements_view(V base);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10267)
+
+*Effects*: Initializes *base_* with std​::​move(base)[.](#1.sentence-1)

cppdraft/range/elementsof.md

@@ -0,0 +1,16 @@
+[range.elementsof]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.5 Range utilities [[range.utility]](range.utility#range.elementsof)
+
+### 25.5.6 Class template elements_of [range.elementsof]
+
+Specializations of elements_of encapsulate a range and
+act as a tag in overload sets to disambiguate
+when a range should be treated as a sequence
+rather than a single value[.](#sentence-1)
+
+[*Example [1](#example-1)*: template<bool YieldElements> generator<any> f(ranges::[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") auto&& r) {if constexpr (YieldElements)co_yield ranges::elements_of(r); // yield each element of relseco_yield r; // yield r as a single value} — *end example*]
+
+namespace std::ranges {template<[range](range.range#concept:range "25.4.2 Ranges [range.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>;}

cppdraft/range/empty.md

@@ -0,0 +1,28 @@
+[range.empty]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.6 Range factories [[range.factories]](range.factories#range.empty)
+
+### 25.6.2 Empty view [range.empty]
+
+#### [25.6.2.1](#overview) Overview [[range.empty.overview]](range.empty.overview)
+
+[1](#overview-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2591)
+
+empty_view produces a view of no elements of
+a particular type[.](#overview-1.sentence-1)
+
+[2](#overview-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2595)
+
+[*Example [1](#overview-example-1)*: auto e = views::empty<int>;static_assert(ranges::empty(e));static_assert(0 == e.size()); — *end example*]
+
+#### [25.6.2.2](#view) Class template empty_view [[range.empty.view]](range.empty.view)
+
+[🔗](#lib: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; }};}

cppdraft/range/empty/overview.md

@@ -0,0 +1,22 @@
+[range.empty.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.6 Range factories [[range.factories]](range.factories#range.empty.overview)
+
+### 25.6.2 Empty view [[range.empty]](range.empty#overview)
+
+#### 25.6.2.1 Overview [range.empty.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2591)
+
+empty_view produces a view of no elements of
+a particular type[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2595)
+
+[*Example [1](#example-1)*: auto e = views::empty<int>;static_assert(ranges::empty(e));static_assert(0 == e.size()); — *end example*]

cppdraft/range/empty/view.md

@@ -0,0 +1,13 @@
+[range.empty.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.6 Range factories [[range.factories]](range.factories#range.empty.view)
+
+### 25.6.2 Empty view [[range.empty]](range.empty#view)
+
+#### 25.6.2.2 Class template empty_view [range.empty.view]
+
+[🔗](#lib: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; }};}

cppdraft/range/enumerate.md

@@ -0,0 +1,365 @@
+[range.enumerate]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.enumerate)
+
+### 25.7.24 Enumerate view [range.enumerate]
+
+#### [25.7.24.1](#overview) Overview [[range.enumerate.overview]](range.enumerate.overview)
+
+[1](#overview-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10790)
+
+enumerate_view is a view whose
+elements represent both the position and value from
+a sequence of elements[.](#overview-1.sentence-1)
+
+[2](#overview-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10796)
+
+The name views​::​enumerate denotes a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#overview-2.sentence-1)
+
+Given a subexpression E,
+the expression views​::​enumerate(E) is expression-equivalent toenumerate_view<views​::​all_t<decltype((E))>>(E)[.](#overview-2.sentence-2)
+
+[*Example [1](#overview-example-1)*: vector<int> vec{ 1, 2, 3 };for (auto [index, value] : views::enumerate(vec)) cout << index << ":" << value << ' '; // prints 0:1 1:2 2:3 — *end example*]
+
+#### [25.7.24.2](#view) Class template enumerate_view [[range.enumerate.view]](range.enumerate.view)
+
+[🔗](#lib:enumerate_view_)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires [*range-with-movable-references*](range.utility.helpers#concept:range-with-movable-references "25.5.2 Helper concepts [range.utility.helpers]")<V>class enumerate_view : public view_interface<enumerate_view<V>> { V *base_* = V(); // *exposition only*// [[range.enumerate.iterator]](#iterator "25.7.24.3 Class template enumerate_­view​::​iterator"), class template enumerate_view​::​*iterator*template<bool Const>class *iterator*; // *exposition only*// [[range.enumerate.sentinel]](#sentinel "25.7.24.4 Class template enumerate_­view​::​sentinel"), class template enumerate_view​::​*sentinel*template<bool Const>class *sentinel*; // *exposition only*public:constexpr enumerate_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> = default; constexpr explicit enumerate_view(V base); constexpr auto begin() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>){ return *iterator*<false>(ranges::begin(*base_*), 0); }constexpr auto begin() const requires [*range-with-movable-references*](range.utility.helpers#concept:range-with-movable-references "25.5.2 Helper concepts [range.utility.helpers]")<const V>{ return *iterator*<true>(ranges::begin(*base_*), 0); }constexpr auto end() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) {if constexpr ([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> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>)return *iterator*<false>(ranges::end(*base_*), ranges::distance(*base_*)); elsereturn *sentinel*<false>(ranges::end(*base_*)); }constexpr auto end() const requires [*range-with-movable-references*](range.utility.helpers#concept:range-with-movable-references "25.5.2 Helper concepts [range.utility.helpers]")<const V> {if constexpr ([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> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>)return *iterator*<true>(ranges::end(*base_*), ranges::distance(*base_*)); elsereturn *sentinel*<true>(ranges::end(*base_*)); }constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>{ return ranges::size(*base_*); }constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>{ return ranges::size(*base_*); }constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>{ return ranges::reserve_hint(*base_*); }constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>{ return ranges::reserve_hint(*base_*); }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_*); }}; template<class R> enumerate_view(R&&) -> enumerate_view<views::all_t<R>>;}
+
+[🔗](#lib:enumerate_view,constructor)
+
+`constexpr explicit enumerate_view(V base);
+`
+
+[1](#view-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10878)
+
+*Effects*: Initializes *base_* with std​::​move(base)[.](#view-1.sentence-1)
+
+#### [25.7.24.3](#iterator) Class template enumerate_view​::​*iterator* [[range.enumerate.iterator]](range.enumerate.iterator)
+
+[🔗](#lib:enumerate_view::iterator)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires [*range-with-movable-references*](range.utility.helpers#concept:range-with-movable-references "25.5.2 Helper concepts [range.utility.helpers]")<V>template<bool Const>class enumerate_view<V>::*iterator* {using *Base* = *maybe-const*<Const, V>; // *exposition only*public:using iterator_category = input_iterator_tag; using iterator_concept = *see below*; using difference_type = range_difference_t<*Base*>; using value_type = tuple<difference_type, range_value_t<*Base*>>; private:using *reference-type* = // *exposition only* tuple<difference_type, range_reference_t<*Base*>>;
+ iterator_t<*Base*> *current_* = iterator_t<*Base*>(); // *exposition only* difference_type *pos_* = 0; // *exposition only*constexpr explicit*iterator*(iterator_t<*Base*> current, difference_type pos); // *exposition only*public:*iterator*() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<iterator_t<*Base*>> = default; constexpr *iterator*(*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 const iterator_t<*Base*>& base() const & noexcept; constexpr iterator_t<*Base*> base() &&; constexpr difference_type index() const noexcept; constexpr auto operator*() const {return *reference-type*(*pos_*, **current_*); }constexpr *iterator*& operator++(); constexpr void operator++(int); constexpr *iterator* operator++(int) requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr *iterator*& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr *iterator* operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr *iterator*& operator+=(difference_type x)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr *iterator*& operator-=(difference_type x)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr auto operator[](difference_type n) constrequires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>{ return *reference-type*(*pos_* + n, *current_*[n]); }friend constexpr bool operator==(const *iterator*& x, const *iterator*& y) noexcept; friend constexpr strong_ordering operator<=>(const *iterator*& x, const *iterator*& y) noexcept; friend constexpr *iterator* operator+(const *iterator*& x, difference_type y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr *iterator* operator+(difference_type x, const *iterator*& y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr *iterator* operator-(const *iterator*& x, difference_type y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr difference_type operator-(const *iterator*& x, const *iterator*& y) noexcept; friend constexpr auto iter_move(const *iterator*& i)noexcept(noexcept(ranges::iter_move(i.*current_*)) && is_nothrow_move_constructible_v<range_rvalue_reference_t<*Base*>>) {return tuple<difference_type,
+ range_rvalue_reference_t<*Base*>>(i.*pos_*, ranges::iter_move(i.*current_*)); }};}
+
+[1](#iterator-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10960)
+
+The member [*typedef-name*](dcl.typedef#nt:typedef-name "9.2.4 The typedef specifier [dcl.typedef]")*iterator*​::​iterator_concept is defined as follows:
+
+- [(1.1)](#iterator-1.1)
+
+  If *Base* models [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]"),
+then iterator_concept denotes random_access_iterator_tag[.](#iterator-1.1.sentence-1)
+
+- [(1.2)](#iterator-1.2)
+
+  Otherwise, if *Base* models [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]"),
+then iterator_concept denotes bidirectional_iterator_tag[.](#iterator-1.2.sentence-1)
+
+- [(1.3)](#iterator-1.3)
+
+  Otherwise, if *Base* models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]"),
+then iterator_concept denotes forward_iterator_tag[.](#iterator-1.3.sentence-1)
+
+- [(1.4)](#iterator-1.4)
+
+  Otherwise, iterator_concept denotes input_iterator_tag[.](#iterator-1.4.sentence-1)
+
+[🔗](#lib:enumerate_view::iterator,constructor)
+
+`constexpr explicit iterator(iterator_t<Base> current, difference_type pos);
+`
+
+[2](#iterator-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10984)
+
+*Effects*: Initializes *current_* with std​::​move(current) and*pos_* with pos[.](#iterator-2.sentence-1)
+
+[🔗](#lib:enumerate_view::iterator,constructor_)
+
+`constexpr iterator(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>>;
+`
+
+[3](#iterator-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10997)
+
+*Effects*: Initializes *current_* with std​::​move(i.*current_*) and*pos_* with i.*pos_*[.](#iterator-3.sentence-1)
+
+[🔗](#lib:base,enumerate_view::iterator)
+
+`constexpr const iterator_t<Base>& base() const & noexcept;
+`
+
+[4](#iterator-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11009)
+
+*Effects*: Equivalent to: return *current_*;
+
+[🔗](#lib:base,enumerate_view::iterator_)
+
+`constexpr iterator_t<Base> base() &&;
+`
+
+[5](#iterator-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11020)
+
+*Effects*: Equivalent to: return std​::​move(*current_*);
+
+[🔗](#lib:index,enumerate_view::iterator)
+
+`constexpr difference_type index() const noexcept;
+`
+
+[6](#iterator-6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11031)
+
+*Effects*: Equivalent to: return *pos_*;
+
+[🔗](#lib:operator++,enumerate_view::iterator)
+
+`constexpr iterator& operator++();
+`
+
+[7](#iterator-7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11042)
+
+*Effects*: Equivalent to:++*current_*;++*pos_*;return *this;
+
+[🔗](#lib:operator++,enumerate_view::iterator_)
+
+`constexpr void operator++(int);
+`
+
+[8](#iterator-8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11058)
+
+*Effects*: Equivalent to ++*this[.](#iterator-8.sentence-1)
+
+[🔗](#lib:operator++,enumerate_view::iterator__)
+
+`constexpr iterator operator++(int) requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[9](#iterator-9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11069)
+
+*Effects*: Equivalent to:auto temp = *this;++*this;return temp;
+
+[🔗](#lib:operator--,enumerate_view::iterator)
+
+`constexpr iterator& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[10](#iterator-10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11085)
+
+*Effects*: Equivalent to:--*current_*;--*pos_*;return *this;
+
+[🔗](#lib:operator--,enumerate_view::iterator_)
+
+`constexpr iterator operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[11](#iterator-11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11101)
+
+*Effects*: Equivalent to:auto temp = *this;--*this;return temp;
+
+[🔗](#lib:operator+=,enumerate_view::iterator)
+
+`constexpr iterator& operator+=(difference_type n)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[12](#iterator-12)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11118)
+
+*Effects*: Equivalent to:*current_* += n;*pos_* += n;return *this;
+
+[🔗](#lib:operator-=,enumerate_view::iterator)
+
+`constexpr iterator& operator-=(difference_type n)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[13](#iterator-13)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11135)
+
+*Effects*: Equivalent to:*current_* -= n;*pos_* -= n;return *this;
+
+[🔗](#lib:operator==,enumerate_view::iterator)
+
+`friend constexpr bool operator==(const iterator& x, const iterator& y) noexcept;
+`
+
+[14](#iterator-14)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11151)
+
+*Effects*: Equivalent to: return x.*pos_* == y.*pos_*;
+
+[🔗](#lib:operator%3c=%3e,enumerate_view::iterator)
+
+`friend constexpr strong_ordering operator<=>(const iterator& x, const iterator& y) noexcept;
+`
+
+[15](#iterator-15)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11162)
+
+*Effects*: Equivalent to: return x.*pos_* <=> y.*pos_*;
+
+[🔗](#lib:operator+,enumerate_view::iterator)
+
+`friend constexpr iterator operator+(const iterator& x, difference_type y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[16](#iterator-16)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11174)
+
+*Effects*: Equivalent to:auto temp = x;
+temp += y;return temp;
+
+[🔗](#lib:operator+,enumerate_view::iterator_)
+
+`friend constexpr iterator operator+(difference_type x, const iterator& y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[17](#iterator-17)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11191)
+
+*Effects*: Equivalent to: return y + x;
+
+[🔗](#lib:operator-,enumerate_view::iterator)
+
+`friend constexpr iterator operator-(const iterator& x, difference_type y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[18](#iterator-18)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11203)
+
+*Effects*: Equivalent to:auto temp = x;
+temp -= y;return temp;
+
+[🔗](#lib:operator-,enumerate_view::iterator_)
+
+`friend constexpr difference_type operator-(const iterator& x, const iterator& y) noexcept;
+`
+
+[19](#iterator-19)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11219)
+
+*Effects*: Equivalent to: return x.*pos_* - y.*pos_*;
+
+#### [25.7.24.4](#sentinel) Class template enumerate_view​::​*sentinel* [[range.enumerate.sentinel]](range.enumerate.sentinel)
+
+[🔗](#lib:enumerate_view::sentinel)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires [*range-with-movable-references*](range.utility.helpers#concept:range-with-movable-references "25.5.2 Helper concepts [range.utility.helpers]")<V>template<bool Const>class enumerate_view<V>::*sentinel* {using *Base* = *maybe-const*<Const, V>; // *exposition only* sentinel_t<*Base*> *end_* = sentinel_t<*Base*>(); // *exposition only*constexpr explicit *sentinel*(sentinel_t<*Base*> end); // *exposition only*public:*sentinel*() = default; constexpr *sentinel*(*sentinel*<!Const> other)requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<sentinel_t<V>, sentinel_t<*Base*>>; constexpr sentinel_t<*Base*> base() const; template<bool OtherConst>requires [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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); };}
+
+[🔗](#lib:enumerate_view::sentinel,constructor)
+
+`constexpr explicit sentinel(sentinel_t<Base> end);
+`
+
+[1](#sentinel-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11267)
+
+*Effects*: Initializes *end_* with std​::​move(end)[.](#sentinel-1.sentence-1)
+
+[🔗](#lib:enumerate_view::sentinel,constructor_)
+
+`constexpr sentinel(sentinel<!Const> other)
+  requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<sentinel_t<V>, sentinel_t<Base>>;
+`
+
+[2](#sentinel-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11279)
+
+*Effects*: Initializes *end_* with std​::​move(other.*end_*)[.](#sentinel-2.sentence-1)
+
+[🔗](#lib:base,enumerate_view::sentinel)
+
+`constexpr sentinel_t<Base> base() const;
+`
+
+[3](#sentinel-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11290)
+
+*Effects*: Equivalent to: return *end_*;
+
+[🔗](#lib:operator==,enumerate_view::sentinel)
+
+`template<bool OtherConst>
+  requires [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
+`
+
+[4](#sentinel-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11303)
+
+*Effects*: Equivalent to: return x.*current_* == y.*end_*;
+
+[🔗](#lib:operator-,enumerate_view::sentinel)
+
+`template<bool OtherConst>
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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);
+`
+
+[5](#sentinel-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11317)
+
+*Effects*: Equivalent to: return x.*current_* - y.*end_*;
+
+[🔗](#lib:operator-,enumerate_view::sentinel_)
+
+`template<bool OtherConst>
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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);
+`
+
+[6](#sentinel-6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11331)
+
+*Effects*: Equivalent to: return x.*end_* - y.*current_*;

cppdraft/range/enumerate/iterator.md

@@ -0,0 +1,246 @@
+[range.enumerate.iterator]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.enumerate.iterator)
+
+### 25.7.24 Enumerate view [[range.enumerate]](range.enumerate#iterator)
+
+#### 25.7.24.3 Class template enumerate_view​::​*iterator* [range.enumerate.iterator]
+
+[🔗](#lib:enumerate_view::iterator)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires [*range-with-movable-references*](range.utility.helpers#concept:range-with-movable-references "25.5.2 Helper concepts [range.utility.helpers]")<V>template<bool Const>class enumerate_view<V>::*iterator* {using *Base* = *maybe-const*<Const, V>; // *exposition only*public:using iterator_category = input_iterator_tag; using iterator_concept = *see below*; using difference_type = range_difference_t<*Base*>; using value_type = tuple<difference_type, range_value_t<*Base*>>; private:using *reference-type* = // *exposition only* tuple<difference_type, range_reference_t<*Base*>>;
+ iterator_t<*Base*> *current_* = iterator_t<*Base*>(); // *exposition only* difference_type *pos_* = 0; // *exposition only*constexpr explicit*iterator*(iterator_t<*Base*> current, difference_type pos); // *exposition only*public:*iterator*() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<iterator_t<*Base*>> = default; constexpr *iterator*(*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 const iterator_t<*Base*>& base() const & noexcept; constexpr iterator_t<*Base*> base() &&; constexpr difference_type index() const noexcept; constexpr auto operator*() const {return *reference-type*(*pos_*, **current_*); }constexpr *iterator*& operator++(); constexpr void operator++(int); constexpr *iterator* operator++(int) requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr *iterator*& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr *iterator* operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr *iterator*& operator+=(difference_type x)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr *iterator*& operator-=(difference_type x)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; constexpr auto operator[](difference_type n) constrequires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>{ return *reference-type*(*pos_* + n, *current_*[n]); }friend constexpr bool operator==(const *iterator*& x, const *iterator*& y) noexcept; friend constexpr strong_ordering operator<=>(const *iterator*& x, const *iterator*& y) noexcept; friend constexpr *iterator* operator+(const *iterator*& x, difference_type y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr *iterator* operator+(difference_type x, const *iterator*& y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr *iterator* operator-(const *iterator*& x, difference_type y)requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<*Base*>; friend constexpr difference_type operator-(const *iterator*& x, const *iterator*& y) noexcept; friend constexpr auto iter_move(const *iterator*& i)noexcept(noexcept(ranges::iter_move(i.*current_*)) && is_nothrow_move_constructible_v<range_rvalue_reference_t<*Base*>>) {return tuple<difference_type,
+ range_rvalue_reference_t<*Base*>>(i.*pos_*, ranges::iter_move(i.*current_*)); }};}
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10960)
+
+The member [*typedef-name*](dcl.typedef#nt:typedef-name "9.2.4 The typedef specifier [dcl.typedef]")*iterator*​::​iterator_concept is defined as follows:
+
+- [(1.1)](#1.1)
+
+  If *Base* models [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]"),
+then iterator_concept denotes random_access_iterator_tag[.](#1.1.sentence-1)
+
+- [(1.2)](#1.2)
+
+  Otherwise, if *Base* models [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]"),
+then iterator_concept denotes bidirectional_iterator_tag[.](#1.2.sentence-1)
+
+- [(1.3)](#1.3)
+
+  Otherwise, if *Base* models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]"),
+then iterator_concept denotes forward_iterator_tag[.](#1.3.sentence-1)
+
+- [(1.4)](#1.4)
+
+  Otherwise, iterator_concept denotes input_iterator_tag[.](#1.4.sentence-1)
+
+[🔗](#lib:enumerate_view::iterator,constructor)
+
+`constexpr explicit iterator(iterator_t<Base> current, difference_type pos);
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10984)
+
+*Effects*: Initializes *current_* with std​::​move(current) and*pos_* with pos[.](#2.sentence-1)
+
+[🔗](#lib:enumerate_view::iterator,constructor_)
+
+`constexpr iterator(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>>;
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10997)
+
+*Effects*: Initializes *current_* with std​::​move(i.*current_*) and*pos_* with i.*pos_*[.](#3.sentence-1)
+
+[🔗](#lib:base,enumerate_view::iterator)
+
+`constexpr const iterator_t<Base>& base() const & noexcept;
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11009)
+
+*Effects*: Equivalent to: return *current_*;
+
+[🔗](#lib:base,enumerate_view::iterator_)
+
+`constexpr iterator_t<Base> base() &&;
+`
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11020)
+
+*Effects*: Equivalent to: return std​::​move(*current_*);
+
+[🔗](#lib:index,enumerate_view::iterator)
+
+`constexpr difference_type index() const noexcept;
+`
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11031)
+
+*Effects*: Equivalent to: return *pos_*;
+
+[🔗](#lib:operator++,enumerate_view::iterator)
+
+`constexpr iterator& operator++();
+`
+
+[7](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11042)
+
+*Effects*: Equivalent to:++*current_*;++*pos_*;return *this;
+
+[🔗](#lib:operator++,enumerate_view::iterator_)
+
+`constexpr void operator++(int);
+`
+
+[8](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11058)
+
+*Effects*: Equivalent to ++*this[.](#8.sentence-1)
+
+[🔗](#lib:operator++,enumerate_view::iterator__)
+
+`constexpr iterator operator++(int) requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[9](#9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11069)
+
+*Effects*: Equivalent to:auto temp = *this;++*this;return temp;
+
+[🔗](#lib:operator--,enumerate_view::iterator)
+
+`constexpr iterator& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[10](#10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11085)
+
+*Effects*: Equivalent to:--*current_*;--*pos_*;return *this;
+
+[🔗](#lib:operator--,enumerate_view::iterator_)
+
+`constexpr iterator operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[11](#11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11101)
+
+*Effects*: Equivalent to:auto temp = *this;--*this;return temp;
+
+[🔗](#lib:operator+=,enumerate_view::iterator)
+
+`constexpr iterator& operator+=(difference_type n)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[12](#12)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11118)
+
+*Effects*: Equivalent to:*current_* += n;*pos_* += n;return *this;
+
+[🔗](#lib:operator-=,enumerate_view::iterator)
+
+`constexpr iterator& operator-=(difference_type n)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[13](#13)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11135)
+
+*Effects*: Equivalent to:*current_* -= n;*pos_* -= n;return *this;
+
+[🔗](#lib:operator==,enumerate_view::iterator)
+
+`friend constexpr bool operator==(const iterator& x, const iterator& y) noexcept;
+`
+
+[14](#14)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11151)
+
+*Effects*: Equivalent to: return x.*pos_* == y.*pos_*;
+
+[🔗](#lib:operator%3c=%3e,enumerate_view::iterator)
+
+`friend constexpr strong_ordering operator<=>(const iterator& x, const iterator& y) noexcept;
+`
+
+[15](#15)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11162)
+
+*Effects*: Equivalent to: return x.*pos_* <=> y.*pos_*;
+
+[🔗](#lib:operator+,enumerate_view::iterator)
+
+`friend constexpr iterator operator+(const iterator& x, difference_type y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[16](#16)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11174)
+
+*Effects*: Equivalent to:auto temp = x;
+temp += y;return temp;
+
+[🔗](#lib:operator+,enumerate_view::iterator_)
+
+`friend constexpr iterator operator+(difference_type x, const iterator& y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[17](#17)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11191)
+
+*Effects*: Equivalent to: return y + x;
+
+[🔗](#lib:operator-,enumerate_view::iterator)
+
+`friend constexpr iterator operator-(const iterator& x, difference_type y)
+  requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;
+`
+
+[18](#18)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11203)
+
+*Effects*: Equivalent to:auto temp = x;
+temp -= y;return temp;
+
+[🔗](#lib:operator-,enumerate_view::iterator_)
+
+`friend constexpr difference_type operator-(const iterator& x, const iterator& y) noexcept;
+`
+
+[19](#19)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11219)
+
+*Effects*: Equivalent to: return x.*pos_* - y.*pos_*;

cppdraft/range/enumerate/overview.md

@@ -0,0 +1,28 @@
+[range.enumerate.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.enumerate.overview)
+
+### 25.7.24 Enumerate view [[range.enumerate]](range.enumerate#overview)
+
+#### 25.7.24.1 Overview [range.enumerate.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10790)
+
+enumerate_view is a view whose
+elements represent both the position and value from
+a sequence of elements[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10796)
+
+The name views​::​enumerate denotes a range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#2.sentence-1)
+
+Given a subexpression E,
+the expression views​::​enumerate(E) is expression-equivalent toenumerate_view<views​::​all_t<decltype((E))>>(E)[.](#2.sentence-2)
+
+[*Example [1](#example-1)*: vector<int> vec{ 1, 2, 3 };for (auto [index, value] : views::enumerate(vec)) cout << index << ":" << value << ' '; // prints 0:1 1:2 2:3 — *end example*]

cppdraft/range/enumerate/sentinel.md

@@ -0,0 +1,88 @@
+[range.enumerate.sentinel]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.enumerate.sentinel)
+
+### 25.7.24 Enumerate view [[range.enumerate]](range.enumerate#sentinel)
+
+#### 25.7.24.4 Class template enumerate_view​::​*sentinel* [range.enumerate.sentinel]
+
+[🔗](#lib:enumerate_view::sentinel)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires [*range-with-movable-references*](range.utility.helpers#concept:range-with-movable-references "25.5.2 Helper concepts [range.utility.helpers]")<V>template<bool Const>class enumerate_view<V>::*sentinel* {using *Base* = *maybe-const*<Const, V>; // *exposition only* sentinel_t<*Base*> *end_* = sentinel_t<*Base*>(); // *exposition only*constexpr explicit *sentinel*(sentinel_t<*Base*> end); // *exposition only*public:*sentinel*() = default; constexpr *sentinel*(*sentinel*<!Const> other)requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<sentinel_t<V>, sentinel_t<*Base*>>; constexpr sentinel_t<*Base*> base() const; template<bool OtherConst>requires [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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); };}
+
+[🔗](#lib:enumerate_view::sentinel,constructor)
+
+`constexpr explicit sentinel(sentinel_t<Base> end);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11267)
+
+*Effects*: Initializes *end_* with std​::​move(end)[.](#1.sentence-1)
+
+[🔗](#lib:enumerate_view::sentinel,constructor_)
+
+`constexpr sentinel(sentinel<!Const> other)
+  requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<sentinel_t<V>, sentinel_t<Base>>;
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11279)
+
+*Effects*: Initializes *end_* with std​::​move(other.*end_*)[.](#2.sentence-1)
+
+[🔗](#lib:base,enumerate_view::sentinel)
+
+`constexpr sentinel_t<Base> base() const;
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11290)
+
+*Effects*: Equivalent to: return *end_*;
+
+[🔗](#lib:operator==,enumerate_view::sentinel)
+
+`template<bool OtherConst>
+  requires [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11303)
+
+*Effects*: Equivalent to: return x.*current_* == y.*end_*;
+
+[🔗](#lib:operator-,enumerate_view::sentinel)
+
+`template<bool OtherConst>
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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);
+`
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11317)
+
+*Effects*: Equivalent to: return x.*current_* - y.*end_*;
+
+[🔗](#lib:operator-,enumerate_view::sentinel_)
+
+`template<bool OtherConst>
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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);
+`
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L11331)
+
+*Effects*: Equivalent to: return x.*end_* - y.*current_*;

cppdraft/range/enumerate/view.md

@@ -0,0 +1,24 @@
+[range.enumerate.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.enumerate.view)
+
+### 25.7.24 Enumerate view [[range.enumerate]](range.enumerate#view)
+
+#### 25.7.24.2 Class template enumerate_view [range.enumerate.view]
+
+[🔗](#lib:enumerate_view)
+
+namespace std::ranges {template<[view](range.view#concept:view "25.4.5 Views [range.view]") V>requires [*range-with-movable-references*](range.utility.helpers#concept:range-with-movable-references "25.5.2 Helper concepts [range.utility.helpers]")<V>class enumerate_view : public view_interface<enumerate_view<V>> { V *base_* = V(); // *exposition only*// [[range.enumerate.iterator]](range.enumerate.iterator "25.7.24.3 Class template enumerate_­view​::​iterator"), class template enumerate_view​::​*iterator*template<bool Const>class *iterator*; // *exposition only*// [[range.enumerate.sentinel]](range.enumerate.sentinel "25.7.24.4 Class template enumerate_­view​::​sentinel"), class template enumerate_view​::​*sentinel*template<bool Const>class *sentinel*; // *exposition only*public:constexpr enumerate_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<V> = default; constexpr explicit enumerate_view(V base); constexpr auto begin() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>){ return *iterator*<false>(ranges::begin(*base_*), 0); }constexpr auto begin() const requires [*range-with-movable-references*](range.utility.helpers#concept:range-with-movable-references "25.5.2 Helper concepts [range.utility.helpers]")<const V>{ return *iterator*<true>(ranges::begin(*base_*), 0); }constexpr auto end() requires (![*simple-view*](range.utility.helpers#concept:simple-view "25.5.2 Helper concepts [range.utility.helpers]")<V>) {if constexpr ([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> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>)return *iterator*<false>(ranges::end(*base_*), ranges::distance(*base_*)); elsereturn *sentinel*<false>(ranges::end(*base_*)); }constexpr auto end() const requires [*range-with-movable-references*](range.utility.helpers#concept:range-with-movable-references "25.5.2 Helper concepts [range.utility.helpers]")<const V> {if constexpr ([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> && [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>)return *iterator*<true>(ranges::end(*base_*), ranges::distance(*base_*)); elsereturn *sentinel*<true>(ranges::end(*base_*)); }constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>{ return ranges::size(*base_*); }constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>{ return ranges::size(*base_*); }constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>{ return ranges::reserve_hint(*base_*); }constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>{ return ranges::reserve_hint(*base_*); }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_*); }}; template<class R> enumerate_view(R&&) -> enumerate_view<views::all_t<R>>;}
+
+[🔗](#lib:enumerate_view,constructor)
+
+`constexpr explicit enumerate_view(V base);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L10878)
+
+*Effects*: Initializes *base_* with std​::​move(base)[.](#1.sentence-1)

cppdraft/range/error.md

@@ -0,0 +1,40 @@
+[range.error]
+
+# 19 Diagnostics library [[diagnostics]](./#diagnostics)
+
+## 19.2 Exception classes [[std.exceptions]](std.exceptions#range.error)
+
+### 19.2.9 Class range_error [range.error]
+
+[🔗](#lib:range_error)
+
+namespace std {class range_error : public runtime_error {public:constexpr explicit range_error(const string& what_arg); constexpr explicit range_error(const char* what_arg); };}
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/diagnostics.tex#L340)
+
+The classrange_error defines the type of objects thrown as exceptions to report range errors
+in internal computations[.](#1.sentence-1)
+
+[🔗](#lib:range_error,constructor)
+
+`constexpr range_error(const string& what_arg);
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/diagnostics.tex#L352)
+
+*Postconditions*: strcmp(what(), what_arg.c_str()) == 0[.](#2.sentence-1)
+
+[🔗](#lib:range_error,constructor_)
+
+`constexpr range_error(const char* what_arg);
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/diagnostics.tex#L363)
+
+*Postconditions*: strcmp(what(), what_arg) == 0[.](#3.sentence-1)

cppdraft/range/factories/general.md

@@ -0,0 +1,20 @@
+[range.factories.general]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.6 Range factories [[range.factories]](range.factories#general)
+
+### 25.6.1 General [range.factories.general]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2580)
+
+Subclause [[range.factories]](range.factories "25.6 Range factories") defines [*range factories*](#def:range_factories),
+which are utilities to create a view[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2584)
+
+Range factories are declared in namespace std​::​ranges​::​views[.](#2.sentence-1)

cppdraft/range/filter.md

@@ -0,0 +1,333 @@
+[range.filter]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.filter)
+
+### 25.7.8 Filter view [range.filter]
+
+#### [25.7.8.1](#overview) Overview [[range.filter.overview]](range.filter.overview)
+
+[1](#overview-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4751)
+
+filter_view presents a view of the elements
+of an underlying sequence that satisfy a predicate[.](#overview-1.sentence-1)
+
+[2](#overview-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4755)
+
+The name views​::​filter 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 P,
+the expression views​::​filter(E, P) is expression-equivalent tofilter_view(E, P)[.](#overview-2.sentence-2)
+
+[3](#overview-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4763)
+
+[*Example [1](#overview-example-1)*: vector<int> is{ 0, 1, 2, 3, 4, 5, 6 };auto evens = views::filter(is, [](int i) { return 0 == i % 2; });for (int i : evens) cout << i << ' '; // prints 0 2 4 6 — *end example*]
+
+#### [25.7.8.2](#view) Class template filter_view [[range.filter.view]](range.filter.view)
+
+[🔗](#lib:filter_view)
+
+namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V, [indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect_unary_predicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<iterator_t<V>> Pred>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && is_object_v<Pred>class filter_view : public view_interface<filter_view<V, Pred>> {private: V *base_* = V(); // *exposition only**movable-box*<Pred> *pred_*; // *exposition only*// [[range.filter.iterator]](#iterator "25.7.8.3 Class filter_­view​::​iterator"), class filter_view​::​*iterator*class *iterator*; // *exposition only*// [[range.filter.sentinel]](#sentinel "25.7.8.4 Class filter_­view​::​sentinel"), class filter_view​::​*sentinel*class *sentinel*; // *exposition only*public: filter_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]")<Pred> = default; constexpr explicit filter_view(V base, Pred pred); 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 const Pred& pred() const; constexpr *iterator* begin(); constexpr auto end() {if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<V>)return *iterator*{*this, ranges::end(*base_*)}; elsereturn *sentinel*{*this}; }}; template<class R, class Pred> filter_view(R&&, Pred) -> filter_view<views::all_t<R>, Pred>;}
+
+[🔗](#lib:filter_view,constructor)
+
+`constexpr explicit filter_view(V base, Pred pred);
+`
+
+[1](#view-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4822)
+
+*Effects*: Initializes *base_* with std​::​move(base) and initializes*pred_* with std​::​move(pred)[.](#view-1.sentence-1)
+
+[🔗](#lib:pred,filter_view)
+
+`constexpr const Pred& pred() const;
+`
+
+[2](#view-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4834)
+
+*Effects*: Equivalent to: return **pred_*;
+
+[🔗](#lib:begin,filter_view)
+
+`constexpr iterator begin();
+`
+
+[3](#view-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4845)
+
+*Preconditions*: *pred_*.has_value() is true[.](#view-3.sentence-1)
+
+[4](#view-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4849)
+
+*Returns*: {*this, ranges​::​find_if(*base_*, ref(**pred_*))}[.](#view-4.sentence-1)
+
+[5](#view-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4853)
+
+*Remarks*: In order to provide the amortized constant time complexity required by
+the [range](range.range#concept:range "25.4.2 Ranges [range.range]") concept
+when filter_view models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]"),
+this function caches the result within thefilter_view for use on subsequent calls[.](#view-5.sentence-1)
+
+#### [25.7.8.3](#iterator) Class filter_view​::​*iterator* [[range.filter.iterator]](range.filter.iterator)
+
+[🔗](#lib:filter_view::iterator)
+
+namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V, [indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect_unary_predicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<iterator_t<V>> Pred>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && is_object_v<Pred>class filter_view<V, Pred>::*iterator* {private: iterator_t<V> *current_* = iterator_t<V>(); // *exposition only* filter_view* *parent_* = nullptr; // *exposition only*public:using iterator_concept = *see below*; using iterator_category = *see below*; // not always presentusing value_type = range_value_t<V>; using difference_type = range_difference_t<V>; *iterator*() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<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->() constrequires [*has-arrow*](range.utility.helpers#concept:has-arrow "25.5.2 Helper concepts [range.utility.helpers]")<iterator_t<V>> && [copyable](concepts.object#concept:copyable "18.6 Object concepts [concepts.object]")<iterator_t<V>>; constexpr *iterator*& operator++(); constexpr void operator++(int); constexpr *iterator* operator++(int) requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V>; constexpr *iterator*& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>; constexpr *iterator* operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>; 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<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](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<V>>; };}
+
+[1](#iterator-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4910)
+
+Modification of the element a filter_view​::​*iterator* denotes is
+permitted, but results in undefined behavior if the resulting value does not
+satisfy the filter predicate[.](#iterator-1.sentence-1)
+
+[2](#iterator-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4915)
+
+*iterator*​::​iterator_concept is defined as follows:
+
+- [(2.1)](#iterator-2.1)
+
+  If V models [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]"), theniterator_concept denotes bidirectional_iterator_tag[.](#iterator-2.1.sentence-1)
+
+- [(2.2)](#iterator-2.2)
+
+  Otherwise, if V models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]"), theniterator_concept denotes forward_iterator_tag[.](#iterator-2.2.sentence-1)
+
+- [(2.3)](#iterator-2.3)
+
+  Otherwise, iterator_concept denotes input_iterator_tag[.](#iterator-2.3.sentence-1)
+
+[3](#iterator-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4927)
+
+The member [*typedef-name*](dcl.typedef#nt:typedef-name "9.2.4 The typedef specifier [dcl.typedef]") iterator_category is defined
+if and only if V models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")[.](#iterator-3.sentence-1)
+
+In that case,*iterator*​::​iterator_category is defined as follows:
+
+- [(3.1)](#iterator-3.1)
+
+  Let C denote the typeiterator_traits<iterator_t<V>>​::​iterator_category[.](#iterator-3.1.sentence-1)
+
+- [(3.2)](#iterator-3.2)
+
+  If C models[derived_from](concept.derived#concept:derived_from "18.4.3 Concept derived_­from [concept.derived]")<bidirectional_iterator_tag>,
+then iterator_category denotes bidirectional_iterator_tag[.](#iterator-3.2.sentence-1)
+
+- [(3.3)](#iterator-3.3)
+
+  Otherwise, if C models[derived_from](concept.derived#concept:derived_from "18.4.3 Concept derived_­from [concept.derived]")<forward_iterator_tag>,
+then iterator_category denotes forward_iterator_tag[.](#iterator-3.3.sentence-1)
+
+- [(3.4)](#iterator-3.4)
+
+  Otherwise, iterator_category denotes C[.](#iterator-3.4.sentence-1)
+
+[🔗](#lib:filter_view::iterator,constructor)
+
+`constexpr iterator(filter_view& parent, iterator_t<V> current);
+`
+
+[4](#iterator-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4953)
+
+*Effects*: Initializes *current_* with std​::​move(current) and*parent_* with addressof(parent)[.](#iterator-4.sentence-1)
+
+[🔗](#lib:base,filter_view::iterator)
+
+`constexpr const iterator_t<V>& base() const & noexcept;
+`
+
+[5](#iterator-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4965)
+
+*Effects*: Equivalent to: return *current_*;
+
+[🔗](#lib:base,filter_view::iterator_)
+
+`constexpr iterator_t<V> base() &&;
+`
+
+[6](#iterator-6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4976)
+
+*Effects*: Equivalent to: return std​::​move(*current_*);
+
+[🔗](#lib:operator*,filter_view::iterator)
+
+`constexpr range_reference_t<V> operator*() const;
+`
+
+[7](#iterator-7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4987)
+
+*Effects*: Equivalent to: return **current_*;
+
+[🔗](#lib:operator-%3e,filter_view::iterator)
+
+`constexpr iterator_t<V> operator->() const
+  requires [has-arrow](range.utility.helpers#concept:has-arrow "25.5.2 Helper concepts [range.utility.helpers]")<iterator_t<V>> && [copyable](concepts.object#concept:copyable "18.6 Object concepts [concepts.object]")<iterator_t<V>>;
+`
+
+[8](#iterator-8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4999)
+
+*Effects*: Equivalent to: return *current_*;
+
+[🔗](#lib:operator++,filter_view::iterator)
+
+`constexpr iterator& operator++();
+`
+
+[9](#iterator-9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5010)
+
+*Effects*: Equivalent to:*current_* = ranges::find_if(std::move(++*current_*), ranges::end(*parent_*->*base_*),
+ ref(**parent_*->*pred_*));return *this;
+
+[🔗](#lib:operator++,filter_view::iterator_)
+
+`constexpr void operator++(int);
+`
+
+[10](#iterator-10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5026)
+
+*Effects*: Equivalent to ++*this[.](#iterator-10.sentence-1)
+
+[🔗](#lib:operator++,filter_view::iterator__)
+
+`constexpr iterator operator++(int) requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V>;
+`
+
+[11](#iterator-11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5037)
+
+*Effects*: Equivalent to:auto tmp = *this;++*this;return tmp;
+
+[🔗](#lib:operator--,filter_view::iterator)
+
+`constexpr iterator& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>;
+`
+
+[12](#iterator-12)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5053)
+
+*Effects*: Equivalent to:do--*current_*;while (!invoke(**parent_*->*pred_*, **current_*));return *this;
+
+[🔗](#lib:operator--,filter_view::iterator_)
+
+`constexpr iterator operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>;
+`
+
+[13](#iterator-13)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5070)
+
+*Effects*: Equivalent to:auto tmp = *this;--*this;return tmp;
+
+[🔗](#lib:operator==,filter_view::iterator)
+
+`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<V>>;
+`
+
+[14](#iterator-14)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5087)
+
+*Effects*: Equivalent to: return x.*current_* == y.*current_*;
+
+[🔗](#lib:iter_move,filter_view::iterator)
+
+`friend constexpr range_rvalue_reference_t<V> iter_move(const iterator& i)
+  noexcept(noexcept(ranges::iter_move(i.current_)));
+`
+
+[15](#iterator-15)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5099)
+
+*Effects*: Equivalent to: return ranges​::​iter_move(i.*current_*);
+
+[🔗](#lib:iter_swap,filter_view::iterator)
+
+`friend constexpr void iter_swap(const iterator& x, const iterator& y)
+  noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
+  requires [indirectly_swappable](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<V>>;
+`
+
+[16](#iterator-16)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5112)
+
+*Effects*: Equivalent to ranges​::​iter_swap(x.*current_*, y.*current_*)[.](#iterator-16.sentence-1)
+
+#### [25.7.8.4](#sentinel) Class filter_view​::​*sentinel* [[range.filter.sentinel]](range.filter.sentinel)
+
+[🔗](#lib:filter_view::sentinel)
+
+namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V, [indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect_unary_predicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<iterator_t<V>> Pred>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && is_object_v<Pred>class filter_view<V, Pred>::*sentinel* {private: sentinel_t<V> *end_* = sentinel_t<V>(); // *exposition only*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); };}
+
+[🔗](#lib:filter_view::sentinel,constructor)
+
+`constexpr explicit sentinel(filter_view& parent);
+`
+
+[1](#sentinel-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5146)
+
+*Effects*: Initializes *end_* with ranges​::​end(parent.*base_*)[.](#sentinel-1.sentence-1)
+
+[🔗](#lib:base,filter_view::sentinel)
+
+`constexpr sentinel_t<V> base() const;
+`
+
+[2](#sentinel-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5157)
+
+*Effects*: Equivalent to: return *end_*;
+
+[🔗](#lib:operator==,filter_view::sentinel)
+
+`friend constexpr bool operator==(const iterator& x, const sentinel& y);
+`
+
+[3](#sentinel-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5168)
+
+*Effects*: Equivalent to: return x.*current_* == y.*end_*;

cppdraft/range/filter/iterator.md

@@ -0,0 +1,215 @@
+[range.filter.iterator]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.filter.iterator)
+
+### 25.7.8 Filter view [[range.filter]](range.filter#iterator)
+
+#### 25.7.8.3 Class filter_view​::​*iterator* [range.filter.iterator]
+
+[🔗](#lib:filter_view::iterator)
+
+namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V, [indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect_unary_predicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<iterator_t<V>> Pred>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && is_object_v<Pred>class filter_view<V, Pred>::*iterator* {private: iterator_t<V> *current_* = iterator_t<V>(); // *exposition only* filter_view* *parent_* = nullptr; // *exposition only*public:using iterator_concept = *see below*; using iterator_category = *see below*; // not always presentusing value_type = range_value_t<V>; using difference_type = range_difference_t<V>; *iterator*() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<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->() constrequires [*has-arrow*](range.utility.helpers#concept:has-arrow "25.5.2 Helper concepts [range.utility.helpers]")<iterator_t<V>> && [copyable](concepts.object#concept:copyable "18.6 Object concepts [concepts.object]")<iterator_t<V>>; constexpr *iterator*& operator++(); constexpr void operator++(int); constexpr *iterator* operator++(int) requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V>; constexpr *iterator*& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>; constexpr *iterator* operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>; 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<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](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<V>>; };}
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4910)
+
+Modification of the element a filter_view​::​*iterator* denotes is
+permitted, but results in undefined behavior if the resulting value does not
+satisfy the filter predicate[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4915)
+
+*iterator*​::​iterator_concept is defined as follows:
+
+- [(2.1)](#2.1)
+
+  If V models [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]"), theniterator_concept denotes bidirectional_iterator_tag[.](#2.1.sentence-1)
+
+- [(2.2)](#2.2)
+
+  Otherwise, if V models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]"), theniterator_concept denotes forward_iterator_tag[.](#2.2.sentence-1)
+
+- [(2.3)](#2.3)
+
+  Otherwise, iterator_concept denotes input_iterator_tag[.](#2.3.sentence-1)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4927)
+
+The member [*typedef-name*](dcl.typedef#nt:typedef-name "9.2.4 The typedef specifier [dcl.typedef]") iterator_category is defined
+if and only if V models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")[.](#3.sentence-1)
+
+In that case,*iterator*​::​iterator_category is defined as follows:
+
+- [(3.1)](#3.1)
+
+  Let C denote the typeiterator_traits<iterator_t<V>>​::​iterator_category[.](#3.1.sentence-1)
+
+- [(3.2)](#3.2)
+
+  If C models[derived_from](concept.derived#concept:derived_from "18.4.3 Concept derived_­from [concept.derived]")<bidirectional_iterator_tag>,
+then iterator_category denotes bidirectional_iterator_tag[.](#3.2.sentence-1)
+
+- [(3.3)](#3.3)
+
+  Otherwise, if C models[derived_from](concept.derived#concept:derived_from "18.4.3 Concept derived_­from [concept.derived]")<forward_iterator_tag>,
+then iterator_category denotes forward_iterator_tag[.](#3.3.sentence-1)
+
+- [(3.4)](#3.4)
+
+  Otherwise, iterator_category denotes C[.](#3.4.sentence-1)
+
+[🔗](#lib:filter_view::iterator,constructor)
+
+`constexpr iterator(filter_view& parent, iterator_t<V> current);
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4953)
+
+*Effects*: Initializes *current_* with std​::​move(current) and*parent_* with addressof(parent)[.](#4.sentence-1)
+
+[🔗](#lib:base,filter_view::iterator)
+
+`constexpr const iterator_t<V>& base() const & noexcept;
+`
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4965)
+
+*Effects*: Equivalent to: return *current_*;
+
+[🔗](#lib:base,filter_view::iterator_)
+
+`constexpr iterator_t<V> base() &&;
+`
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4976)
+
+*Effects*: Equivalent to: return std​::​move(*current_*);
+
+[🔗](#lib:operator*,filter_view::iterator)
+
+`constexpr range_reference_t<V> operator*() const;
+`
+
+[7](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4987)
+
+*Effects*: Equivalent to: return **current_*;
+
+[🔗](#lib:operator-%3e,filter_view::iterator)
+
+`constexpr iterator_t<V> operator->() const
+  requires [has-arrow](range.utility.helpers#concept:has-arrow "25.5.2 Helper concepts [range.utility.helpers]")<iterator_t<V>> && [copyable](concepts.object#concept:copyable "18.6 Object concepts [concepts.object]")<iterator_t<V>>;
+`
+
+[8](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4999)
+
+*Effects*: Equivalent to: return *current_*;
+
+[🔗](#lib:operator++,filter_view::iterator)
+
+`constexpr iterator& operator++();
+`
+
+[9](#9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5010)
+
+*Effects*: Equivalent to:*current_* = ranges::find_if(std::move(++*current_*), ranges::end(*parent_*->*base_*),
+ ref(**parent_*->*pred_*));return *this;
+
+[🔗](#lib:operator++,filter_view::iterator_)
+
+`constexpr void operator++(int);
+`
+
+[10](#10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5026)
+
+*Effects*: Equivalent to ++*this[.](#10.sentence-1)
+
+[🔗](#lib:operator++,filter_view::iterator__)
+
+`constexpr iterator operator++(int) requires [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]")<V>;
+`
+
+[11](#11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5037)
+
+*Effects*: Equivalent to:auto tmp = *this;++*this;return tmp;
+
+[🔗](#lib:operator--,filter_view::iterator)
+
+`constexpr iterator& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>;
+`
+
+[12](#12)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5053)
+
+*Effects*: Equivalent to:do--*current_*;while (!invoke(**parent_*->*pred_*, **current_*));return *this;
+
+[🔗](#lib:operator--,filter_view::iterator_)
+
+`constexpr iterator operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<V>;
+`
+
+[13](#13)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5070)
+
+*Effects*: Equivalent to:auto tmp = *this;--*this;return tmp;
+
+[🔗](#lib:operator==,filter_view::iterator)
+
+`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<V>>;
+`
+
+[14](#14)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5087)
+
+*Effects*: Equivalent to: return x.*current_* == y.*current_*;
+
+[🔗](#lib:iter_move,filter_view::iterator)
+
+`friend constexpr range_rvalue_reference_t<V> iter_move(const iterator& i)
+  noexcept(noexcept(ranges::iter_move(i.current_)));
+`
+
+[15](#15)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5099)
+
+*Effects*: Equivalent to: return ranges​::​iter_move(i.*current_*);
+
+[🔗](#lib:iter_swap,filter_view::iterator)
+
+`friend constexpr void iter_swap(const iterator& x, const iterator& y)
+  noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
+  requires [indirectly_swappable](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<V>>;
+`
+
+[16](#16)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5112)
+
+*Effects*: Equivalent to ranges​::​iter_swap(x.*current_*, y.*current_*)[.](#16.sentence-1)

cppdraft/range/filter/overview.md

@@ -0,0 +1,32 @@
+[range.filter.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.filter.overview)
+
+### 25.7.8 Filter view [[range.filter]](range.filter#overview)
+
+#### 25.7.8.1 Overview [range.filter.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4751)
+
+filter_view presents a view of the elements
+of an underlying sequence that satisfy a predicate[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4755)
+
+The name views​::​filter denotes a
+range adaptor object ([[range.adaptor.object]](range.adaptor.object "25.7.2 Range adaptor objects"))[.](#2.sentence-1)
+
+Given subexpressions E and P,
+the expression views​::​filter(E, P) is expression-equivalent tofilter_view(E, P)[.](#2.sentence-2)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4763)
+
+[*Example [1](#example-1)*: vector<int> is{ 0, 1, 2, 3, 4, 5, 6 };auto evens = views::filter(is, [](int i) { return 0 == i % 2; });for (int i : evens) cout << i << ' '; // prints 0 2 4 6 — *end example*]

cppdraft/range/filter/sentinel.md

@@ -0,0 +1,46 @@
+[range.filter.sentinel]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.filter.sentinel)
+
+### 25.7.8 Filter view [[range.filter]](range.filter#sentinel)
+
+#### 25.7.8.4 Class filter_view​::​*sentinel* [range.filter.sentinel]
+
+[🔗](#lib:filter_view::sentinel)
+
+namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V, [indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect_unary_predicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<iterator_t<V>> Pred>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && is_object_v<Pred>class filter_view<V, Pred>::*sentinel* {private: sentinel_t<V> *end_* = sentinel_t<V>(); // *exposition only*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); };}
+
+[🔗](#lib:filter_view::sentinel,constructor)
+
+`constexpr explicit sentinel(filter_view& parent);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5146)
+
+*Effects*: Initializes *end_* with ranges​::​end(parent.*base_*)[.](#1.sentence-1)
+
+[🔗](#lib:base,filter_view::sentinel)
+
+`constexpr sentinel_t<V> base() const;
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5157)
+
+*Effects*: Equivalent to: return *end_*;
+
+[🔗](#lib:operator==,filter_view::sentinel)
+
+`friend constexpr bool operator==(const iterator& x, const sentinel& y);
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L5168)
+
+*Effects*: Equivalent to: return x.*current_* == y.*end_*;

cppdraft/range/filter/view.md

@@ -0,0 +1,61 @@
+[range.filter.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.7 Range adaptors [[range.adaptors]](range.adaptors#range.filter.view)
+
+### 25.7.8 Filter view [[range.filter]](range.filter#view)
+
+#### 25.7.8.2 Class template filter_view [range.filter.view]
+
+[🔗](#lib:filter_view)
+
+namespace std::ranges {template<[input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") V, [indirect_unary_predicate](indirectcallable.indirectinvocable#concept:indirect_unary_predicate "24.3.6.3 Indirect callables [indirectcallable.indirectinvocable]")<iterator_t<V>> Pred>requires [view](range.view#concept:view "25.4.5 Views [range.view]")<V> && is_object_v<Pred>class filter_view : public view_interface<filter_view<V, Pred>> {private: V *base_* = V(); // *exposition only**movable-box*<Pred> *pred_*; // *exposition only*// [[range.filter.iterator]](range.filter.iterator "25.7.8.3 Class filter_­view​::​iterator"), class filter_view​::​*iterator*class *iterator*; // *exposition only*// [[range.filter.sentinel]](range.filter.sentinel "25.7.8.4 Class filter_­view​::​sentinel"), class filter_view​::​*sentinel*class *sentinel*; // *exposition only*public: filter_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]")<Pred> = default; constexpr explicit filter_view(V base, Pred pred); 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 const Pred& pred() const; constexpr *iterator* begin(); constexpr auto end() {if constexpr ([common_range](range.refinements#concept:common_range "25.4.6 Other range refinements [range.refinements]")<V>)return *iterator*{*this, ranges::end(*base_*)}; elsereturn *sentinel*{*this}; }}; template<class R, class Pred> filter_view(R&&, Pred) -> filter_view<views::all_t<R>, Pred>;}
+
+[🔗](#lib:filter_view,constructor)
+
+`constexpr explicit filter_view(V base, Pred pred);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4822)
+
+*Effects*: Initializes *base_* with std​::​move(base) and initializes*pred_* with std​::​move(pred)[.](#1.sentence-1)
+
+[🔗](#lib:pred,filter_view)
+
+`constexpr const Pred& pred() const;
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4834)
+
+*Effects*: Equivalent to: return **pred_*;
+
+[🔗](#lib:begin,filter_view)
+
+`constexpr iterator begin();
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4845)
+
+*Preconditions*: *pred_*.has_value() is true[.](#3.sentence-1)
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4849)
+
+*Returns*: {*this, ranges​::​find_if(*base_*, ref(**pred_*))}[.](#4.sentence-1)
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4853)
+
+*Remarks*: In order to provide the amortized constant time complexity required by
+the [range](range.range#concept:range "25.4.2 Ranges [range.range]") concept
+when filter_view models [forward_range](range.refinements#concept:forward_range "25.4.6 Other range refinements [range.refinements]"),
+this function caches the result within thefilter_view for use on subsequent calls[.](#5.sentence-1)

cppdraft/range/iota.md

@@ -0,0 +1,662 @@
+[range.iota]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.6 Range factories [[range.factories]](range.factories#range.iota)
+
+### 25.6.4 Iota view [range.iota]
+
+#### [25.6.4.1](#overview) Overview [[range.iota.overview]](range.iota.overview)
+
+[1](#overview-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2778)
+
+iota_view generates a
+sequence of elements by repeatedly incrementing an initial value[.](#overview-1.sentence-1)
+
+[2](#overview-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2782)
+
+The name views​::​iota denotes a
+customization point object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#overview-2.sentence-1)
+
+Given subexpressions E and F, the expressionsviews​::​iota(E) and views​::​iota(E, F) are expression-equivalent toiota_view<decay_t<decltype((E))>>(E) and iota_view(E, F),
+respectively[.](#overview-2.sentence-2)
+
+[3](#overview-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2792)
+
+[*Example [1](#overview-example-1)*: for (int i : views::iota(1, 10)) cout << i << ' '; // prints 1 2 3 4 5 6 7 8 9 — *end example*]
+
+[4](#overview-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2800)
+
+The name views​::​indices denotes a
+customization point object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#overview-4.sentence-1)
+
+Given subexpression E,
+let T be remove_cvref_t<decltype((E))>[.](#overview-4.sentence-2)
+
+views​::​indices(E) is expression-equivalent toviews​::​iota(T(0), E) if *is-integer-like*<T> is true,
+and ill-formed otherwise[.](#overview-4.sentence-3)
+
+#### [25.6.4.2](#view) Class template iota_view [[range.iota.view]](range.iota.view)
+
+[🔗](#lib:iota_view)
+
+namespace std::ranges {template<class I>concept [*decrementable*](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]") = *see below*; // *exposition only*template<class I>concept [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]") = *see below*; // *exposition only*template<[weakly_incrementable](iterator.concept.winc#concept:weakly_incrementable "24.3.4.4 Concept weakly_­incrementable [iterator.concept.winc]") W, [semiregular](concepts.object#concept:semiregular "18.6 Object concepts [concepts.object]") Bound = unreachable_sentinel_t>requires [*weakly-equality-comparable-with*](concept.equalitycomparable#concept:weakly-equality-comparable-with "18.5.4 Concept equality_­comparable [concept.equalitycomparable]")<W, Bound> && [copyable](concepts.object#concept:copyable "18.6 Object concepts [concepts.object]")<W>class iota_view : public view_interface<iota_view<W, Bound>> {private:// [[range.iota.iterator]](#iterator "25.6.4.3 Class iota_­view​::​iterator"), class iota_view​::​*iterator*struct *iterator*; // *exposition only*// [[range.iota.sentinel]](#sentinel "25.6.4.4 Class iota_­view​::​sentinel"), class iota_view​::​*sentinel*struct *sentinel*; // *exposition only* W *value_* = W(); // *exposition only* Bound *bound_* = Bound(); // *exposition only*public: iota_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<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 below* last); constexpr *iterator* begin() const; constexpr auto end() const; constexpr *iterator* end() const requires [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<W, Bound>; constexpr bool empty() const; constexpr auto size() const requires *see below*; }; 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>;}
+
+[1](#view-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2856)
+
+Let *IOTA-DIFF-T*(W) be defined as follows:
+
+- [(1.1)](#view-1.1)
+
+  If W is not an integral type, or
+ if it is an integral type and sizeof(iter_difference_t<W>) is greater than sizeof(W),
+ then *IOTA-DIFF-T*(W) denotes iter_difference_t<W>[.](#view-1.1.sentence-1)
+
+- [(1.2)](#view-1.2)
+
+  Otherwise, *IOTA-DIFF-T*(W) is a signed integer type of width greater than the width of W if such a type exists[.](#view-1.2.sentence-1)
+
+- [(1.3)](#view-1.3)
+
+  Otherwise, *IOTA-DIFF-T*(W) is an unspecified signed-integer-like type ([[iterator.concept.winc]](iterator.concept.winc "24.3.4.4 Concept weakly_­incrementable"))
+ of width not less than the width of W[.](#view-1.3.sentence-1)
+  [*Note [1](#view-note-1)*:
+  It is unspecified
+ whether this type satisfies [weakly_incrementable](iterator.concept.winc#concept:weakly_incrementable "24.3.4.4 Concept weakly_­incrementable [iterator.concept.winc]")[.](#view-1.3.sentence-2)
+ — *end note*]
+
+[2](#view-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2878)
+
+The exposition-only [*decrementable*](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]") concept is equivalent to:
+
+[🔗](#concept:decrementable)
+
+`template<class I>
+  concept [decrementable](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]") =               // exposition only
+    [incrementable](iterator.concept.inc#concept:incrementable "24.3.4.5 Concept incrementable [iterator.concept.inc]")<I> && requires(I i) {
+      { --i } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<I&>;
+      { i-- } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<I>;
+    };
+`
+
+[3](#view-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2890)
+
+When an object is in the domain of both pre- and post-decrement,
+the object is said to be [*decrementable*](#def:decrementable)[.](#view-3.sentence-1)
+
+[4](#view-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2894)
+
+Let a and b be equal objects of type I[.](#view-4.sentence-1)
+
+I models [*decrementable*](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]") only if
+
+- [(4.1)](#view-4.1)
+
+  If a and b are decrementable,
+ then the following are all true:
+  * [(4.1.1)](#view-4.1.1)
+
+addressof(--a) == addressof(a)
+
+  * [(4.1.2)](#view-4.1.2)
+
+bool(a-- == b)
+
+  * [(4.1.3)](#view-4.1.3)
+
+bool(((void)a--, a) == --b)
+
+  * [(4.1.4)](#view-4.1.4)
+
+bool(++(--a) == b)[.](#view-4.1.sentence-1)
+
+- [(4.2)](#view-4.2)
+
+  If a and b are incrementable,
+ then bool(--(++a) == b)[.](#view-4.2.sentence-1)
+
+[5](#view-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2911)
+
+The exposition-only [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]") concept is equivalent to:
+
+[🔗](#concept:advanceable)
+
+`template<class I>
+  concept [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]") =                 // exposition only
+    [decrementable](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]")<I> && [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<I> &&
+    requires(I i, const I j, const IOTA-DIFF-T(I) n) {
+      { i += n } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<I&>;
+      { i -= n } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<I&>;
+      I(j + n);
+      I(n + j);
+      I(j - n);
+      { j - j } -> [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<IOTA-DIFF-T(I)>;
+    };
+`
+
+Let D be *IOTA-DIFF-T*(I)[.](#view-sentence-1)
+
+Let a and b be objects of type I such thatb is reachable from a after n applications of ++a,
+for some value n of type D[.](#view-sentence-2)
+
+I models [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]") only if
+
+- (a += n) is equal to b[.](#view-sentence-1)
+
+- addressof(a += n) is equal to addressof(a)[.](#view-sentence-1)
+
+- I(a + n) is equal to (a += n)[.](#view-sentence-1)
+
+- For any two positive values x and y of type D,
+ if I(a + D(x + y)) is well-defined, then I(a + D(x + y)) is equal to I(I(a + x) + y)[.](#view-sentence-1)
+
+- I(a + D(0)) is equal to a[.](#view-sentence-1)
+
+- If I(a + D(n - 1)) is well-defined, then I(a + n) is equal to [](I c) { return ++c; }(I(a + D(n - 1)))[.](#view-sentence-1)
+
+- (b += -n) is equal to a[.](#view-sentence-1)
+
+- (b -= n) is equal to a[.](#view-sentence-1)
+
+- addressof(b -= n) is equal to addressof(b)[.](#view-sentence-1)
+
+- I(b - n) is equal to (b -= n)[.](#view-sentence-1)
+
+- D(b - a) is equal to n[.](#view-sentence-1)
+
+- D(a - b) is equal to D(-n)[.](#view-sentence-1)
+
+- bool(a <= b) is true[.](#view-sentence-1)
+
+[🔗](#lib:iota_view,constructor)
+
+`constexpr explicit iota_view(W value);
+`
+
+[6](#view-6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2959)
+
+*Preconditions*: Bound denotes unreachable_sentinel_t orBound() is reachable from value[.](#view-6.sentence-1)
+
+When W and Bound model [totally_ordered_with](concept.totallyordered#concept:totally_ordered_with "18.5.5 Concept totally_­ordered [concept.totallyordered]"),
+then bool(value <= Bound()) is true[.](#view-6.sentence-2)
+
+[7](#view-7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2966)
+
+*Effects*: Initializes *value_* with value[.](#view-7.sentence-1)
+
+[🔗](#lib:iota_view,constructor_)
+
+`constexpr explicit iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);
+`
+
+[8](#view-8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2977)
+
+*Preconditions*: Bound denotes unreachable_sentinel_t orbound is reachable from value[.](#view-8.sentence-1)
+
+When W and Bound model [totally_ordered_with](concept.totallyordered#concept:totally_ordered_with "18.5.5 Concept totally_­ordered [concept.totallyordered]"),
+then bool(value <= bound) is true[.](#view-8.sentence-2)
+
+[9](#view-9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2984)
+
+*Effects*: Initializes *value_* with value and*bound_* with bound[.](#view-9.sentence-1)
+
+[🔗](#lib:iota_view,constructor__)
+
+`constexpr explicit iota_view(iterator first, see below last);
+`
+
+[10](#view-10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2996)
+
+*Effects*: Equivalent to:
+
+- [(10.1)](#view-10.1)
+
+  If [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<W, Bound> is true,iota_view(first.*value_*, last.*value_*)[.](#view-10.1.sentence-1)
+
+- [(10.2)](#view-10.2)
+
+  Otherwise, if Bound denotes unreachable_sentinel_t,iota_view(first.*value_*, last)[.](#view-10.2.sentence-1)
+
+- [(10.3)](#view-10.3)
+
+  Otherwise, iota_view(first.*value_*, last.*bound_*)[.](#view-10.3.sentence-1)
+
+[11](#view-11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3010)
+
+*Remarks*: The type of last is:
+
+- [(11.1)](#view-11.1)
+
+  If [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<W, Bound> is true, *iterator*[.](#view-11.1.sentence-1)
+
+- [(11.2)](#view-11.2)
+
+  Otherwise, if Bound denotes unreachable_sentinel_t,Bound[.](#view-11.2.sentence-1)
+
+- [(11.3)](#view-11.3)
+
+  Otherwise, *sentinel*[.](#view-11.3.sentence-1)
+
+[🔗](#lib:begin,iota_view)
+
+`constexpr iterator begin() const;
+`
+
+[12](#view-12)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3030)
+
+*Effects*: Equivalent to: return *iterator*{*value_*};
+
+[🔗](#lib:end,iota_view)
+
+`constexpr auto end() const;
+`
+
+[13](#view-13)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3041)
+
+*Effects*: Equivalent to:if constexpr ([same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<Bound, unreachable_sentinel_t>)return unreachable_sentinel;elsereturn *sentinel*{*bound_*};
+
+[🔗](#lib:end,iota_view_)
+
+`constexpr iterator end() const requires [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<W, Bound>;
+`
+
+[14](#view-14)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3058)
+
+*Effects*: Equivalent to: return *iterator*{*bound_*};
+
+[🔗](#lib:empty,iota_view)
+
+`constexpr bool empty() const;
+`
+
+[15](#view-15)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3069)
+
+*Effects*: Equivalent to: return *value_* == *bound_*;
+
+[🔗](#lib:size,iota_view)
+
+`constexpr auto size() const requires see below;
+`
+
+[16](#view-16)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3080)
+
+*Effects*: Equivalent to:if constexpr (*is-integer-like*<W> && *is-integer-like*<Bound>)return (*value_* < 0)? ((*bound_* < 0)? *to-unsigned-like*(-*value_*) - *to-unsigned-like*(-*bound_*): *to-unsigned-like*(*bound_*) + *to-unsigned-like*(-*value_*)): *to-unsigned-like*(*bound_*) - *to-unsigned-like*(*value_*);elsereturn *to-unsigned-like*(*bound_* - *value_*);
+
+[17](#view-17)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3094)
+
+*Remarks*: The expression in the [*requires-clause*](temp.pre#nt:requires-clause "13.1 Preamble [temp.pre]") is equivalent to:([same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<W, Bound> && [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>) || (*is-integer-like*<W> && *is-integer-like*<Bound>) ||[sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<Bound, W>
+
+#### [25.6.4.3](#iterator) Class iota_view​::​*iterator* [[range.iota.iterator]](range.iota.iterator)
+
+[🔗](#lib:iota_view::iterator)
+
+namespace std::ranges {template<[weakly_incrementable](iterator.concept.winc#concept:weakly_incrementable "24.3.4.4 Concept weakly_­incrementable [iterator.concept.winc]") W, [semiregular](concepts.object#concept:semiregular "18.6 Object concepts [concepts.object]") Bound>requires [*weakly-equality-comparable-with*](concept.equalitycomparable#concept:weakly-equality-comparable-with "18.5.4 Concept equality_­comparable [concept.equalitycomparable]")<W, Bound> && [copyable](concepts.object#concept:copyable "18.6 Object concepts [concepts.object]")<W>struct iota_view<W, Bound>::*iterator* {private: W *value_* = W(); // *exposition only*public:using iterator_concept = *see below*; using iterator_category = input_iterator_tag; // present only if W models [incrementable](iterator.concept.inc#concept:incrementable "24.3.4.5 Concept incrementable [iterator.concept.inc]") and// *IOTA-DIFF-T*(W) is an integral typeusing value_type = W; using difference_type = *IOTA-DIFF-T*(W); *iterator*() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<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](iterator.concept.inc#concept:incrementable "24.3.4.5 Concept incrementable [iterator.concept.inc]")<W>; constexpr *iterator*& operator--() requires [*decrementable*](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; constexpr *iterator* operator--(int) requires [*decrementable*](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; constexpr *iterator*& operator+=(difference_type n)requires [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; constexpr *iterator*& operator-=(difference_type n)requires [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; constexpr W operator[](difference_type n) constrequires [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; 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]")<W>; friend constexpr bool operator<(const *iterator*& x, const *iterator*& y)requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>; friend constexpr bool operator>(const *iterator*& x, const *iterator*& y)requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>; friend constexpr bool operator<=(const *iterator*& x, const *iterator*& y)requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>; friend constexpr bool operator>=(const *iterator*& x, const *iterator*& y)requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>; friend constexpr auto operator<=>(const *iterator*& x, const *iterator*& y)requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W> && [three_way_comparable](cmp.concept#concept:three_way_comparable "17.12.4 Concept three_­way_­comparable [cmp.concept]")<W>; friend constexpr *iterator* operator+(*iterator* i, difference_type n)requires [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; friend constexpr *iterator* operator+(difference_type n, *iterator* i)requires [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; friend constexpr *iterator* operator-(*iterator* i, difference_type n)requires [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; friend constexpr difference_type operator-(const *iterator*& x, const *iterator*& y)requires [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; };}
+
+[1](#iterator-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3167)
+
+*iterator*​::​iterator_concept is defined as follows:
+
+- [(1.1)](#iterator-1.1)
+
+  If W models [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]"), theniterator_concept is random_access_iterator_tag[.](#iterator-1.1.sentence-1)
+
+- [(1.2)](#iterator-1.2)
+
+  Otherwise, if W models [*decrementable*](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]"), theniterator_concept is bidirectional_iterator_tag[.](#iterator-1.2.sentence-1)
+
+- [(1.3)](#iterator-1.3)
+
+  Otherwise, if W models [incrementable](iterator.concept.inc#concept:incrementable "24.3.4.5 Concept incrementable [iterator.concept.inc]"), theniterator_concept is forward_iterator_tag[.](#iterator-1.3.sentence-1)
+
+- [(1.4)](#iterator-1.4)
+
+  Otherwise, iterator_concept is input_iterator_tag[.](#iterator-1.4.sentence-1)
+
+[2](#iterator-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3179)
+
+[*Note [1](#iterator-note-1)*:
+
+Overloads for iter_move and iter_swap are omitted intentionally[.](#iterator-2.sentence-1)
+
+— *end note*]
+
+[🔗](#lib:iota_view::iterator,constructor)
+
+`constexpr explicit iterator(W value);
+`
+
+[3](#iterator-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3190)
+
+*Effects*: Initializes *value_* with value[.](#iterator-3.sentence-1)
+
+[🔗](#lib:operator*,iota_view::iterator)
+
+`constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v<W>);
+`
+
+[4](#iterator-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3201)
+
+*Effects*: Equivalent to: return *value_*;
+
+[5](#iterator-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3205)
+
+[*Note [2](#iterator-note-2)*:
+
+The noexcept clause is needed by the default iter_move implementation[.](#iterator-5.sentence-1)
+
+— *end note*]
+
+[🔗](#lib:operator++,iota_view::iterator)
+
+`constexpr iterator& operator++();
+`
+
+[6](#iterator-6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3218)
+
+*Effects*: Equivalent to:++*value_*;return *this;
+
+[🔗](#lib:operator++,iota_view::iterator_)
+
+`constexpr void operator++(int);
+`
+
+[7](#iterator-7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3233)
+
+*Effects*: Equivalent to ++*this[.](#iterator-7.sentence-1)
+
+[🔗](#lib:operator++,iota_view::iterator__)
+
+`constexpr iterator operator++(int) requires [incrementable](iterator.concept.inc#concept:incrementable "24.3.4.5 Concept incrementable [iterator.concept.inc]")<W>;
+`
+
+[8](#iterator-8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3244)
+
+*Effects*: Equivalent to:auto tmp = *this;++*this;return tmp;
+
+[🔗](#lib:operator--,iota_view::iterator)
+
+`constexpr iterator& operator--() requires [decrementable](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[9](#iterator-9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3260)
+
+*Effects*: Equivalent to:--*value_*;return *this;
+
+[🔗](#lib:operator--,iota_view::iterator_)
+
+`constexpr iterator operator--(int) requires [decrementable](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[10](#iterator-10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3275)
+
+*Effects*: Equivalent to:auto tmp = *this;--*this;return tmp;
+
+[🔗](#lib:operator+=,iota_view::iterator)
+
+`constexpr iterator& operator+=(difference_type n)
+  requires [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[11](#iterator-11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3292)
+
+*Effects*: Equivalent to:if constexpr (*is-integer-like*<W> && !*is-signed-integer-like*<W>) {if (n >= difference_type(0))*value_* += static_cast<W>(n); else*value_* -= static_cast<W>(-n);} else {*value_* += n;}return *this;
+
+[🔗](#lib:operator-=,iota_view::iterator)
+
+`constexpr iterator& operator-=(difference_type n)
+  requires [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[12](#iterator-12)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3315)
+
+*Effects*: Equivalent to:if constexpr (*is-integer-like*<W> && !*is-signed-integer-like*<W>) {if (n >= difference_type(0))*value_* -= static_cast<W>(n); else*value_* += static_cast<W>(-n);} else {*value_* -= n;}return *this;
+
+[🔗](#lib:operator%5b%5d,iota_view::iterator)
+
+`constexpr W operator[](difference_type n) const
+  requires [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[13](#iterator-13)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3338)
+
+*Effects*: Equivalent to: return W(*value_* + n);
+
+[🔗](#lib:operator==,iota_view::iterator)
+
+`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]")<W>;
+`
+
+[14](#iterator-14)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3350)
+
+*Effects*: Equivalent to: return x.*value_* == y.*value_*;
+
+[🔗](#lib:operator%3c,iota_view::iterator)
+
+`friend constexpr bool operator<(const iterator& x, const iterator& y)
+  requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>;
+`
+
+[15](#iterator-15)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3362)
+
+*Effects*: Equivalent to: return x.*value_* < y.*value_*;
+
+[🔗](#lib:operator%3e,iota_view::iterator)
+
+`friend constexpr bool operator>(const iterator& x, const iterator& y)
+  requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>;
+`
+
+[16](#iterator-16)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3374)
+
+*Effects*: Equivalent to: return y < x;
+
+[🔗](#lib:operator%3c=,iota_view::iterator)
+
+`friend constexpr bool operator<=(const iterator& x, const iterator& y)
+  requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>;
+`
+
+[17](#iterator-17)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3386)
+
+*Effects*: Equivalent to: return !(y < x);
+
+[🔗](#lib:operator%3e=,iota_view::iterator)
+
+`friend constexpr bool operator>=(const iterator& x, const iterator& y)
+  requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>;
+`
+
+[18](#iterator-18)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3398)
+
+*Effects*: Equivalent to: return !(x < y);
+
+[🔗](#lib:operator%3c=%3e,iota_view::iterator)
+
+`friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+  requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W> && [three_way_comparable](cmp.concept#concept:three_way_comparable "17.12.4 Concept three_­way_­comparable [cmp.concept]")<W>;
+`
+
+[19](#iterator-19)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3410)
+
+*Effects*: Equivalent to: return x.*value_* <=> y.*value_*;
+
+[🔗](#lib:operator+,iota_view::iterator)
+
+`friend constexpr iterator operator+(iterator i, difference_type n)
+  requires [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[20](#iterator-20)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3422)
+
+*Effects*: Equivalent to:i += n;return i;
+
+[🔗](#lib:operator+,iota_view::iterator_)
+
+`friend constexpr iterator operator+(difference_type n, iterator i)
+  requires [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[21](#iterator-21)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3438)
+
+*Effects*: Equivalent to: return i + n;
+
+[🔗](#lib:operator-,iota_view::iterator)
+
+`friend constexpr iterator operator-(iterator i, difference_type n)
+  requires [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[22](#iterator-22)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3450)
+
+*Effects*: Equivalent to:i -= n;return i;
+
+[🔗](#lib:operator-,iota_view::iterator_)
+
+`friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+  requires [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[23](#iterator-23)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3466)
+
+*Effects*: Equivalent to:using D = difference_type;if constexpr (*is-integer-like*<W>) {if constexpr (*is-signed-integer-like*<W>)return D(D(x.*value_*) - D(y.*value_*)); elsereturn (y.*value_* > x.*value_*)? D(-D(y.*value_* - x.*value_*)): D(x.*value_* - y.*value_*);} else {return x.*value_* - y.*value_*;}
+
+#### [25.6.4.4](#sentinel) Class iota_view​::​*sentinel* [[range.iota.sentinel]](range.iota.sentinel)
+
+[🔗](#lib:iota_view::sentinel)
+
+namespace std::ranges {template<[weakly_incrementable](iterator.concept.winc#concept:weakly_incrementable "24.3.4.4 Concept weakly_­incrementable [iterator.concept.winc]") W, [semiregular](concepts.object#concept:semiregular "18.6 Object concepts [concepts.object]") Bound>requires [*weakly-equality-comparable-with*](concept.equalitycomparable#concept:weakly-equality-comparable-with "18.5.4 Concept equality_­comparable [concept.equalitycomparable]")<W, Bound> && [copyable](concepts.object#concept:copyable "18.6 Object concepts [concepts.object]")<W>struct iota_view<W, Bound>::*sentinel* {private: Bound *bound_* = Bound(); // *exposition only*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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<Bound, W>; friend constexpr iter_difference_t<W> operator-(const *sentinel*& x, const *iterator*& y)requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<Bound, W>; };}
+
+[🔗](#lib:iota_view::sentinel,constructor)
+
+`constexpr explicit sentinel(Bound bound);
+`
+
+[1](#sentinel-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3515)
+
+*Effects*: Initializes *bound_* with bound[.](#sentinel-1.sentence-1)
+
+[🔗](#lib:operator==,iota_view::sentinel)
+
+`friend constexpr bool operator==(const iterator& x, const sentinel& y);
+`
+
+[2](#sentinel-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3526)
+
+*Effects*: Equivalent to: return x.*value_* == y.*bound_*;
+
+[🔗](#lib:operator-,iota_view::sentinel)
+
+`friend constexpr iter_difference_t<W> operator-(const iterator& x, const sentinel& y)
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<Bound, W>;
+`
+
+[3](#sentinel-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3538)
+
+*Effects*: Equivalent to: return x.*value_* - y.*bound_*;
+
+[🔗](#lib:operator-,iota_view::sentinel_)
+
+`friend constexpr iter_difference_t<W> operator-(const sentinel& x, const iterator& y)
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<Bound, W>;
+`
+
+[4](#sentinel-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3550)
+
+*Effects*: Equivalent to: return -(y - x);

cppdraft/range/iota/iterator.md

@@ -0,0 +1,288 @@
+[range.iota.iterator]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.6 Range factories [[range.factories]](range.factories#range.iota.iterator)
+
+### 25.6.4 Iota view [[range.iota]](range.iota#iterator)
+
+#### 25.6.4.3 Class iota_view​::​*iterator* [range.iota.iterator]
+
+[🔗](#lib:iota_view::iterator)
+
+namespace std::ranges {template<[weakly_incrementable](iterator.concept.winc#concept:weakly_incrementable "24.3.4.4 Concept weakly_­incrementable [iterator.concept.winc]") W, [semiregular](concepts.object#concept:semiregular "18.6 Object concepts [concepts.object]") Bound>requires [*weakly-equality-comparable-with*](concept.equalitycomparable#concept:weakly-equality-comparable-with "18.5.4 Concept equality_­comparable [concept.equalitycomparable]")<W, Bound> && [copyable](concepts.object#concept:copyable "18.6 Object concepts [concepts.object]")<W>struct iota_view<W, Bound>::*iterator* {private: W *value_* = W(); // *exposition only*public:using iterator_concept = *see below*; using iterator_category = input_iterator_tag; // present only if W models [incrementable](iterator.concept.inc#concept:incrementable "24.3.4.5 Concept incrementable [iterator.concept.inc]") and// *IOTA-DIFF-T*(W) is an integral typeusing value_type = W; using difference_type = *IOTA-DIFF-T*(W); *iterator*() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<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](iterator.concept.inc#concept:incrementable "24.3.4.5 Concept incrementable [iterator.concept.inc]")<W>; constexpr *iterator*& operator--() requires [*decrementable*](range.iota.view#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; constexpr *iterator* operator--(int) requires [*decrementable*](range.iota.view#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; constexpr *iterator*& operator+=(difference_type n)requires [*advanceable*](range.iota.view#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; constexpr *iterator*& operator-=(difference_type n)requires [*advanceable*](range.iota.view#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; constexpr W operator[](difference_type n) constrequires [*advanceable*](range.iota.view#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; 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]")<W>; friend constexpr bool operator<(const *iterator*& x, const *iterator*& y)requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>; friend constexpr bool operator>(const *iterator*& x, const *iterator*& y)requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>; friend constexpr bool operator<=(const *iterator*& x, const *iterator*& y)requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>; friend constexpr bool operator>=(const *iterator*& x, const *iterator*& y)requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>; friend constexpr auto operator<=>(const *iterator*& x, const *iterator*& y)requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W> && [three_way_comparable](cmp.concept#concept:three_way_comparable "17.12.4 Concept three_­way_­comparable [cmp.concept]")<W>; friend constexpr *iterator* operator+(*iterator* i, difference_type n)requires [*advanceable*](range.iota.view#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; friend constexpr *iterator* operator+(difference_type n, *iterator* i)requires [*advanceable*](range.iota.view#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; friend constexpr *iterator* operator-(*iterator* i, difference_type n)requires [*advanceable*](range.iota.view#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; friend constexpr difference_type operator-(const *iterator*& x, const *iterator*& y)requires [*advanceable*](range.iota.view#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>; };}
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3167)
+
+*iterator*​::​iterator_concept is defined as follows:
+
+- [(1.1)](#1.1)
+
+  If W models [*advanceable*](range.iota.view#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]"), theniterator_concept is random_access_iterator_tag[.](#1.1.sentence-1)
+
+- [(1.2)](#1.2)
+
+  Otherwise, if W models [*decrementable*](range.iota.view#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]"), theniterator_concept is bidirectional_iterator_tag[.](#1.2.sentence-1)
+
+- [(1.3)](#1.3)
+
+  Otherwise, if W models [incrementable](iterator.concept.inc#concept:incrementable "24.3.4.5 Concept incrementable [iterator.concept.inc]"), theniterator_concept is forward_iterator_tag[.](#1.3.sentence-1)
+
+- [(1.4)](#1.4)
+
+  Otherwise, iterator_concept is input_iterator_tag[.](#1.4.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3179)
+
+[*Note [1](#note-1)*:
+
+Overloads for iter_move and iter_swap are omitted intentionally[.](#2.sentence-1)
+
+— *end note*]
+
+[🔗](#lib:iota_view::iterator,constructor)
+
+`constexpr explicit iterator(W value);
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3190)
+
+*Effects*: Initializes *value_* with value[.](#3.sentence-1)
+
+[🔗](#lib:operator*,iota_view::iterator)
+
+`constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v<W>);
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3201)
+
+*Effects*: Equivalent to: return *value_*;
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3205)
+
+[*Note [2](#note-2)*:
+
+The noexcept clause is needed by the default iter_move implementation[.](#5.sentence-1)
+
+— *end note*]
+
+[🔗](#lib:operator++,iota_view::iterator)
+
+`constexpr iterator& operator++();
+`
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3218)
+
+*Effects*: Equivalent to:++*value_*;return *this;
+
+[🔗](#lib:operator++,iota_view::iterator_)
+
+`constexpr void operator++(int);
+`
+
+[7](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3233)
+
+*Effects*: Equivalent to ++*this[.](#7.sentence-1)
+
+[🔗](#lib:operator++,iota_view::iterator__)
+
+`constexpr iterator operator++(int) requires [incrementable](iterator.concept.inc#concept:incrementable "24.3.4.5 Concept incrementable [iterator.concept.inc]")<W>;
+`
+
+[8](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3244)
+
+*Effects*: Equivalent to:auto tmp = *this;++*this;return tmp;
+
+[🔗](#lib:operator--,iota_view::iterator)
+
+`constexpr iterator& operator--() requires [decrementable](range.iota.view#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[9](#9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3260)
+
+*Effects*: Equivalent to:--*value_*;return *this;
+
+[🔗](#lib:operator--,iota_view::iterator_)
+
+`constexpr iterator operator--(int) requires [decrementable](range.iota.view#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[10](#10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3275)
+
+*Effects*: Equivalent to:auto tmp = *this;--*this;return tmp;
+
+[🔗](#lib:operator+=,iota_view::iterator)
+
+`constexpr iterator& operator+=(difference_type n)
+  requires [advanceable](range.iota.view#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[11](#11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3292)
+
+*Effects*: Equivalent to:if constexpr (*is-integer-like*<W> && !*is-signed-integer-like*<W>) {if (n >= difference_type(0))*value_* += static_cast<W>(n); else*value_* -= static_cast<W>(-n);} else {*value_* += n;}return *this;
+
+[🔗](#lib:operator-=,iota_view::iterator)
+
+`constexpr iterator& operator-=(difference_type n)
+  requires [advanceable](range.iota.view#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[12](#12)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3315)
+
+*Effects*: Equivalent to:if constexpr (*is-integer-like*<W> && !*is-signed-integer-like*<W>) {if (n >= difference_type(0))*value_* -= static_cast<W>(n); else*value_* += static_cast<W>(-n);} else {*value_* -= n;}return *this;
+
+[🔗](#lib:operator%5b%5d,iota_view::iterator)
+
+`constexpr W operator[](difference_type n) const
+  requires [advanceable](range.iota.view#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[13](#13)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3338)
+
+*Effects*: Equivalent to: return W(*value_* + n);
+
+[🔗](#lib:operator==,iota_view::iterator)
+
+`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]")<W>;
+`
+
+[14](#14)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3350)
+
+*Effects*: Equivalent to: return x.*value_* == y.*value_*;
+
+[🔗](#lib:operator%3c,iota_view::iterator)
+
+`friend constexpr bool operator<(const iterator& x, const iterator& y)
+  requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>;
+`
+
+[15](#15)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3362)
+
+*Effects*: Equivalent to: return x.*value_* < y.*value_*;
+
+[🔗](#lib:operator%3e,iota_view::iterator)
+
+`friend constexpr bool operator>(const iterator& x, const iterator& y)
+  requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>;
+`
+
+[16](#16)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3374)
+
+*Effects*: Equivalent to: return y < x;
+
+[🔗](#lib:operator%3c=,iota_view::iterator)
+
+`friend constexpr bool operator<=(const iterator& x, const iterator& y)
+  requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>;
+`
+
+[17](#17)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3386)
+
+*Effects*: Equivalent to: return !(y < x);
+
+[🔗](#lib:operator%3e=,iota_view::iterator)
+
+`friend constexpr bool operator>=(const iterator& x, const iterator& y)
+  requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W>;
+`
+
+[18](#18)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3398)
+
+*Effects*: Equivalent to: return !(x < y);
+
+[🔗](#lib:operator%3c=%3e,iota_view::iterator)
+
+`friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+  requires [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<W> && [three_way_comparable](cmp.concept#concept:three_way_comparable "17.12.4 Concept three_­way_­comparable [cmp.concept]")<W>;
+`
+
+[19](#19)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3410)
+
+*Effects*: Equivalent to: return x.*value_* <=> y.*value_*;
+
+[🔗](#lib:operator+,iota_view::iterator)
+
+`friend constexpr iterator operator+(iterator i, difference_type n)
+  requires [advanceable](range.iota.view#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[20](#20)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3422)
+
+*Effects*: Equivalent to:i += n;return i;
+
+[🔗](#lib:operator+,iota_view::iterator_)
+
+`friend constexpr iterator operator+(difference_type n, iterator i)
+  requires [advanceable](range.iota.view#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[21](#21)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3438)
+
+*Effects*: Equivalent to: return i + n;
+
+[🔗](#lib:operator-,iota_view::iterator)
+
+`friend constexpr iterator operator-(iterator i, difference_type n)
+  requires [advanceable](range.iota.view#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[22](#22)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3450)
+
+*Effects*: Equivalent to:i -= n;return i;
+
+[🔗](#lib:operator-,iota_view::iterator_)
+
+`friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+  requires [advanceable](range.iota.view#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>;
+`
+
+[23](#23)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3466)
+
+*Effects*: Equivalent to:using D = difference_type;if constexpr (*is-integer-like*<W>) {if constexpr (*is-signed-integer-like*<W>)return D(D(x.*value_*) - D(y.*value_*)); elsereturn (y.*value_* > x.*value_*)? D(-D(y.*value_* - x.*value_*)): D(x.*value_* - y.*value_*);} else {return x.*value_* - y.*value_*;}

cppdraft/range/iota/overview.md

@@ -0,0 +1,45 @@
+[range.iota.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.6 Range factories [[range.factories]](range.factories#range.iota.overview)
+
+### 25.6.4 Iota view [[range.iota]](range.iota#overview)
+
+#### 25.6.4.1 Overview [range.iota.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2778)
+
+iota_view generates a
+sequence of elements by repeatedly incrementing an initial value[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2782)
+
+The name views​::​iota denotes a
+customization point object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#2.sentence-1)
+
+Given subexpressions E and F, the expressionsviews​::​iota(E) and views​::​iota(E, F) are expression-equivalent toiota_view<decay_t<decltype((E))>>(E) and iota_view(E, F),
+respectively[.](#2.sentence-2)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2792)
+
+[*Example [1](#example-1)*: for (int i : views::iota(1, 10)) cout << i << ' '; // prints 1 2 3 4 5 6 7 8 9 — *end example*]
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2800)
+
+The name views​::​indices denotes a
+customization point object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#4.sentence-1)
+
+Given subexpression E,
+let T be remove_cvref_t<decltype((E))>[.](#4.sentence-2)
+
+views​::​indices(E) is expression-equivalent toviews​::​iota(T(0), E) if *is-integer-like*<T> is true,
+and ill-formed otherwise[.](#4.sentence-3)

cppdraft/range/iota/sentinel.md

@@ -0,0 +1,59 @@
+[range.iota.sentinel]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.6 Range factories [[range.factories]](range.factories#range.iota.sentinel)
+
+### 25.6.4 Iota view [[range.iota]](range.iota#sentinel)
+
+#### 25.6.4.4 Class iota_view​::​*sentinel* [range.iota.sentinel]
+
+[🔗](#lib:iota_view::sentinel)
+
+namespace std::ranges {template<[weakly_incrementable](iterator.concept.winc#concept:weakly_incrementable "24.3.4.4 Concept weakly_­incrementable [iterator.concept.winc]") W, [semiregular](concepts.object#concept:semiregular "18.6 Object concepts [concepts.object]") Bound>requires [*weakly-equality-comparable-with*](concept.equalitycomparable#concept:weakly-equality-comparable-with "18.5.4 Concept equality_­comparable [concept.equalitycomparable]")<W, Bound> && [copyable](concepts.object#concept:copyable "18.6 Object concepts [concepts.object]")<W>struct iota_view<W, Bound>::*sentinel* {private: Bound *bound_* = Bound(); // *exposition only*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](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<Bound, W>; friend constexpr iter_difference_t<W> operator-(const *sentinel*& x, const *iterator*& y)requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<Bound, W>; };}
+
+[🔗](#lib:iota_view::sentinel,constructor)
+
+`constexpr explicit sentinel(Bound bound);
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3515)
+
+*Effects*: Initializes *bound_* with bound[.](#1.sentence-1)
+
+[🔗](#lib:operator==,iota_view::sentinel)
+
+`friend constexpr bool operator==(const iterator& x, const sentinel& y);
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3526)
+
+*Effects*: Equivalent to: return x.*value_* == y.*bound_*;
+
+[🔗](#lib:operator-,iota_view::sentinel)
+
+`friend constexpr iter_difference_t<W> operator-(const iterator& x, const sentinel& y)
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<Bound, W>;
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3538)
+
+*Effects*: Equivalent to: return x.*value_* - y.*bound_*;
+
+[🔗](#lib:operator-,iota_view::sentinel_)
+
+`friend constexpr iter_difference_t<W> operator-(const sentinel& x, const iterator& y)
+  requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<Bound, W>;
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3550)
+
+*Effects*: Equivalent to: return -(y - x);

cppdraft/range/iota/view.md

@@ -0,0 +1,291 @@
+[range.iota.view]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.6 Range factories [[range.factories]](range.factories#range.iota.view)
+
+### 25.6.4 Iota view [[range.iota]](range.iota#view)
+
+#### 25.6.4.2 Class template iota_view [range.iota.view]
+
+[🔗](#lib:iota_view)
+
+namespace std::ranges {template<class I>concept [*decrementable*](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]") = *see below*; // *exposition only*template<class I>concept [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]") = *see below*; // *exposition only*template<[weakly_incrementable](iterator.concept.winc#concept:weakly_incrementable "24.3.4.4 Concept weakly_­incrementable [iterator.concept.winc]") W, [semiregular](concepts.object#concept:semiregular "18.6 Object concepts [concepts.object]") Bound = unreachable_sentinel_t>requires [*weakly-equality-comparable-with*](concept.equalitycomparable#concept:weakly-equality-comparable-with "18.5.4 Concept equality_­comparable [concept.equalitycomparable]")<W, Bound> && [copyable](concepts.object#concept:copyable "18.6 Object concepts [concepts.object]")<W>class iota_view : public view_interface<iota_view<W, Bound>> {private:// [[range.iota.iterator]](range.iota.iterator "25.6.4.3 Class iota_­view​::​iterator"), class iota_view​::​*iterator*struct *iterator*; // *exposition only*// [[range.iota.sentinel]](range.iota.sentinel "25.6.4.4 Class iota_­view​::​sentinel"), class iota_view​::​*sentinel*struct *sentinel*; // *exposition only* W *value_* = W(); // *exposition only* Bound *bound_* = Bound(); // *exposition only*public: iota_view() requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<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 below* last); constexpr *iterator* begin() const; constexpr auto end() const; constexpr *iterator* end() const requires [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<W, Bound>; constexpr bool empty() const; constexpr auto size() const requires *see below*; }; 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>;}
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2856)
+
+Let *IOTA-DIFF-T*(W) be defined as follows:
+
+- [(1.1)](#1.1)
+
+  If W is not an integral type, or
+ if it is an integral type and sizeof(iter_difference_t<W>) is greater than sizeof(W),
+ then *IOTA-DIFF-T*(W) denotes iter_difference_t<W>[.](#1.1.sentence-1)
+
+- [(1.2)](#1.2)
+
+  Otherwise, *IOTA-DIFF-T*(W) is a signed integer type of width greater than the width of W if such a type exists[.](#1.2.sentence-1)
+
+- [(1.3)](#1.3)
+
+  Otherwise, *IOTA-DIFF-T*(W) is an unspecified signed-integer-like type ([[iterator.concept.winc]](iterator.concept.winc "24.3.4.4 Concept weakly_­incrementable"))
+ of width not less than the width of W[.](#1.3.sentence-1)
+  [*Note [1](#note-1)*:
+  It is unspecified
+ whether this type satisfies [weakly_incrementable](iterator.concept.winc#concept:weakly_incrementable "24.3.4.4 Concept weakly_­incrementable [iterator.concept.winc]")[.](#1.3.sentence-2)
+ — *end note*]
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2878)
+
+The exposition-only [*decrementable*](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]") concept is equivalent to:
+
+[🔗](#concept:decrementable)
+
+`template<class I>
+  concept [decrementable](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]") =               // exposition only
+    [incrementable](iterator.concept.inc#concept:incrementable "24.3.4.5 Concept incrementable [iterator.concept.inc]")<I> && requires(I i) {
+      { --i } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<I&>;
+      { i-- } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<I>;
+    };
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2890)
+
+When an object is in the domain of both pre- and post-decrement,
+the object is said to be [*decrementable*](#def:decrementable)[.](#3.sentence-1)
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2894)
+
+Let a and b be equal objects of type I[.](#4.sentence-1)
+
+I models [*decrementable*](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]") only if
+
+- [(4.1)](#4.1)
+
+  If a and b are decrementable,
+ then the following are all true:
+  * [(4.1.1)](#4.1.1)
+
+addressof(--a) == addressof(a)
+
+  * [(4.1.2)](#4.1.2)
+
+bool(a-- == b)
+
+  * [(4.1.3)](#4.1.3)
+
+bool(((void)a--, a) == --b)
+
+  * [(4.1.4)](#4.1.4)
+
+bool(++(--a) == b)[.](#4.1.sentence-1)
+
+- [(4.2)](#4.2)
+
+  If a and b are incrementable,
+ then bool(--(++a) == b)[.](#4.2.sentence-1)
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2911)
+
+The exposition-only [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]") concept is equivalent to:
+
+[🔗](#concept:advanceable)
+
+`template<class I>
+  concept [advanceable](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]") =                 // exposition only
+    [decrementable](#concept:decrementable "25.6.4.2 Class template iota_­view [range.iota.view]")<I> && [totally_ordered](concept.totallyordered#concept:totally_ordered "18.5.5 Concept totally_­ordered [concept.totallyordered]")<I> &&
+    requires(I i, const I j, const IOTA-DIFF-T(I) n) {
+      { i += n } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<I&>;
+      { i -= n } -> [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<I&>;
+      I(j + n);
+      I(n + j);
+      I(j - n);
+      { j - j } -> [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<IOTA-DIFF-T(I)>;
+    };
+`
+
+Let D be *IOTA-DIFF-T*(I)[.](#sentence-1)
+
+Let a and b be objects of type I such thatb is reachable from a after n applications of ++a,
+for some value n of type D[.](#sentence-2)
+
+I models [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]") only if
+
+- (a += n) is equal to b[.](#sentence-1)
+
+- addressof(a += n) is equal to addressof(a)[.](#sentence-1)
+
+- I(a + n) is equal to (a += n)[.](#sentence-1)
+
+- For any two positive values x and y of type D,
+ if I(a + D(x + y)) is well-defined, then I(a + D(x + y)) is equal to I(I(a + x) + y)[.](#sentence-1)
+
+- I(a + D(0)) is equal to a[.](#sentence-1)
+
+- If I(a + D(n - 1)) is well-defined, then I(a + n) is equal to [](I c) { return ++c; }(I(a + D(n - 1)))[.](#sentence-1)
+
+- (b += -n) is equal to a[.](#sentence-1)
+
+- (b -= n) is equal to a[.](#sentence-1)
+
+- addressof(b -= n) is equal to addressof(b)[.](#sentence-1)
+
+- I(b - n) is equal to (b -= n)[.](#sentence-1)
+
+- D(b - a) is equal to n[.](#sentence-1)
+
+- D(a - b) is equal to D(-n)[.](#sentence-1)
+
+- bool(a <= b) is true[.](#sentence-1)
+
+[🔗](#lib:iota_view,constructor)
+
+`constexpr explicit iota_view(W value);
+`
+
+[6](#6)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2959)
+
+*Preconditions*: Bound denotes unreachable_sentinel_t orBound() is reachable from value[.](#6.sentence-1)
+
+When W and Bound model [totally_ordered_with](concept.totallyordered#concept:totally_ordered_with "18.5.5 Concept totally_­ordered [concept.totallyordered]"),
+then bool(value <= Bound()) is true[.](#6.sentence-2)
+
+[7](#7)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2966)
+
+*Effects*: Initializes *value_* with value[.](#7.sentence-1)
+
+[🔗](#lib:iota_view,constructor_)
+
+`constexpr explicit iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);
+`
+
+[8](#8)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2977)
+
+*Preconditions*: Bound denotes unreachable_sentinel_t orbound is reachable from value[.](#8.sentence-1)
+
+When W and Bound model [totally_ordered_with](concept.totallyordered#concept:totally_ordered_with "18.5.5 Concept totally_­ordered [concept.totallyordered]"),
+then bool(value <= bound) is true[.](#8.sentence-2)
+
+[9](#9)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2984)
+
+*Effects*: Initializes *value_* with value and*bound_* with bound[.](#9.sentence-1)
+
+[🔗](#lib:iota_view,constructor__)
+
+`constexpr explicit iota_view(iterator first, see below last);
+`
+
+[10](#10)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L2996)
+
+*Effects*: Equivalent to:
+
+- [(10.1)](#10.1)
+
+  If [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<W, Bound> is true,iota_view(first.*value_*, last.*value_*)[.](#10.1.sentence-1)
+
+- [(10.2)](#10.2)
+
+  Otherwise, if Bound denotes unreachable_sentinel_t,iota_view(first.*value_*, last)[.](#10.2.sentence-1)
+
+- [(10.3)](#10.3)
+
+  Otherwise, iota_view(first.*value_*, last.*bound_*)[.](#10.3.sentence-1)
+
+[11](#11)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3010)
+
+*Remarks*: The type of last is:
+
+- [(11.1)](#11.1)
+
+  If [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<W, Bound> is true, *iterator*[.](#11.1.sentence-1)
+
+- [(11.2)](#11.2)
+
+  Otherwise, if Bound denotes unreachable_sentinel_t,Bound[.](#11.2.sentence-1)
+
+- [(11.3)](#11.3)
+
+  Otherwise, *sentinel*[.](#11.3.sentence-1)
+
+[🔗](#lib:begin,iota_view)
+
+`constexpr iterator begin() const;
+`
+
+[12](#12)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3030)
+
+*Effects*: Equivalent to: return *iterator*{*value_*};
+
+[🔗](#lib:end,iota_view)
+
+`constexpr auto end() const;
+`
+
+[13](#13)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3041)
+
+*Effects*: Equivalent to:if constexpr ([same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<Bound, unreachable_sentinel_t>)return unreachable_sentinel;elsereturn *sentinel*{*bound_*};
+
+[🔗](#lib:end,iota_view_)
+
+`constexpr iterator end() const requires [same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<W, Bound>;
+`
+
+[14](#14)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3058)
+
+*Effects*: Equivalent to: return *iterator*{*bound_*};
+
+[🔗](#lib:empty,iota_view)
+
+`constexpr bool empty() const;
+`
+
+[15](#15)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3069)
+
+*Effects*: Equivalent to: return *value_* == *bound_*;
+
+[🔗](#lib:size,iota_view)
+
+`constexpr auto size() const requires see below;
+`
+
+[16](#16)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3080)
+
+*Effects*: Equivalent to:if constexpr (*is-integer-like*<W> && *is-integer-like*<Bound>)return (*value_* < 0)? ((*bound_* < 0)? *to-unsigned-like*(-*value_*) - *to-unsigned-like*(-*bound_*): *to-unsigned-like*(*bound_*) + *to-unsigned-like*(-*value_*)): *to-unsigned-like*(*bound_*) - *to-unsigned-like*(*value_*);elsereturn *to-unsigned-like*(*bound_* - *value_*);
+
+[17](#17)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3094)
+
+*Remarks*: The expression in the [*requires-clause*](temp.pre#nt:requires-clause "13.1 Preamble [temp.pre]") is equivalent to:([same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<W, Bound> && [*advanceable*](#concept:advanceable "25.6.4.2 Class template iota_­view [range.iota.view]")<W>) || (*is-integer-like*<W> && *is-integer-like*<Bound>) ||[sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<Bound, W>

cppdraft/range/istream.md

@@ -0,0 +1,127 @@
+[range.istream]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.6 Range factories [[range.factories]](range.factories#range.istream)
+
+### 25.6.6 Istream view [range.istream]
+
+#### [25.6.6.1](#overview) Overview [[range.istream.overview]](range.istream.overview)
+
+[1](#overview-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3997)
+
+basic_istream_view models [input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") and
+reads (using operator>>) successive elements
+from its corresponding input stream[.](#overview-1.sentence-1)
+
+[2](#overview-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4002)
+
+The name views​::​istream<T> denotes
+a customization point object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#overview-2.sentence-1)
+
+Given a type T and a subexpression E of type U,
+if U models[derived_from](concept.derived#concept:derived_from "18.4.3 Concept derived_­from [concept.derived]")<basic_istream<typename U​::​char_type,typename U​::​traits_type>>,
+then the expression views​::​istream<T>(E) is expression-equivalent tobasic_istream_view<T, typename U​::​char_type,typename U​::​traits_type>(E);
+otherwise, views​::​istream<T>(E) is ill-formed[.](#overview-2.sentence-2)
+
+[3](#overview-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4014)
+
+[*Example [1](#overview-example-1)*: auto ints = istringstream{"0 1 2 3 4"};
+ranges::copy(views::istream<int>(ints), ostream_iterator<int>{cout, "-"});// prints 0-1-2-3-4- — *end example*]
+
+#### [25.6.6.2](#view) Class template basic_istream_view [[range.istream.view]](range.istream.view)
+
+[🔗](#lib:basic_istream_view)
+
+namespace std::ranges {template<class Val, class CharT, class Traits>concept [*stream-extractable*](#concept:stream-extractable "25.6.6.2 Class template basic_­istream_­view [range.istream.view]") = // *exposition only*requires(basic_istream<CharT, Traits>& is, Val& t) { is >> t; }; template<[movable](concepts.object#concept:movable "18.6 Object concepts [concepts.object]") Val, class CharT, class Traits = char_traits<CharT>>requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<Val> &&[*stream-extractable*](#concept:stream-extractable "25.6.6.2 Class template basic_­istream_­view [range.istream.view]")<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:// [[range.istream.iterator]](#iterator "25.6.6.3 Class basic_­istream_­view​::​iterator"), class basic_istream_view​::​*iterator*struct *iterator*; // *exposition only* basic_istream<CharT, Traits>* *stream_*; // *exposition only* Val *value_* = Val(); // *exposition only*};}
+
+[🔗](#lib:basic_istream_view,constructor)
+
+`constexpr explicit basic_istream_view(basic_istream<CharT, Traits>& stream);
+`
+
+[1](#view-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4063)
+
+*Effects*: Initializes *stream_* with addressof(stream)[.](#view-1.sentence-1)
+
+[🔗](#lib:end,basic_istream_view)
+
+`constexpr default_sentinel_t end() const noexcept;
+`
+
+[2](#view-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4074)
+
+*Effects*: Equivalent to: return default_sentinel;
+
+#### [25.6.6.3](#iterator) Class basic_istream_view​::​*iterator* [[range.istream.iterator]](range.istream.iterator)
+
+[🔗](#lib:basic_istream_view::iterator)
+
+namespace std::ranges {template<[movable](concepts.object#concept:movable "18.6 Object concepts [concepts.object]") Val, class CharT, class Traits>requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<Val> &&[*stream-extractable*](#concept:stream-extractable "25.6.6.2 Class template basic_­istream_­view [range.istream.view]")<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_*; // *exposition only*};}
+
+[🔗](#lib:basic_istream_view::iterator,constructor)
+
+`constexpr explicit iterator(basic_istream_view& parent) noexcept;
+`
+
+[1](#iterator-1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4120)
+
+*Effects*: Initializes *parent_* with addressof(parent)[.](#iterator-1.sentence-1)
+
+[🔗](#lib:operator++,basic_istream_view::iterator)
+
+`iterator& operator++();
+`
+
+[2](#iterator-2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4131)
+
+*Effects*: Equivalent to:**parent_*->*stream_* >> *parent_*->*value_*;return *this;
+
+[🔗](#lib:operator++,basic_istream_view::iterator_)
+
+`void operator++(int);
+`
+
+[3](#iterator-3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4146)
+
+*Effects*: Equivalent to ++*this[.](#iterator-3.sentence-1)
+
+[🔗](#lib:operator*,basic_istream_view::iterator)
+
+`Val& operator*() const;
+`
+
+[4](#iterator-4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4157)
+
+*Effects*: Equivalent to: return *parent_*->*value_*;
+
+[🔗](#lib:operator==,basic_istream_view::iterator)
+
+`friend bool operator==(const iterator& x, default_sentinel_t);
+`
+
+[5](#iterator-5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4168)
+
+*Effects*: Equivalent to: return !*x.*parent_*->*stream_*;

cppdraft/range/istream/iterator.md

@@ -0,0 +1,70 @@
+[range.istream.iterator]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.6 Range factories [[range.factories]](range.factories#range.istream.iterator)
+
+### 25.6.6 Istream view [[range.istream]](range.istream#iterator)
+
+#### 25.6.6.3 Class basic_istream_view​::​*iterator* [range.istream.iterator]
+
+[🔗](#lib:basic_istream_view::iterator)
+
+namespace std::ranges {template<[movable](concepts.object#concept:movable "18.6 Object concepts [concepts.object]") Val, class CharT, class Traits>requires [default_initializable](concept.default.init#concept:default_initializable "18.4.12 Concept default_­initializable [concept.default.init]")<Val> &&[*stream-extractable*](range.istream.view#concept:stream-extractable "25.6.6.2 Class template basic_­istream_­view [range.istream.view]")<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_*; // *exposition only*};}
+
+[🔗](#lib:basic_istream_view::iterator,constructor)
+
+`constexpr explicit iterator(basic_istream_view& parent) noexcept;
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4120)
+
+*Effects*: Initializes *parent_* with addressof(parent)[.](#1.sentence-1)
+
+[🔗](#lib:operator++,basic_istream_view::iterator)
+
+`iterator& operator++();
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4131)
+
+*Effects*: Equivalent to:**parent_*->*stream_* >> *parent_*->*value_*;return *this;
+
+[🔗](#lib:operator++,basic_istream_view::iterator_)
+
+`void operator++(int);
+`
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4146)
+
+*Effects*: Equivalent to ++*this[.](#3.sentence-1)
+
+[🔗](#lib:operator*,basic_istream_view::iterator)
+
+`Val& operator*() const;
+`
+
+[4](#4)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4157)
+
+*Effects*: Equivalent to: return *parent_*->*value_*;
+
+[🔗](#lib:operator==,basic_istream_view::iterator)
+
+`friend bool operator==(const iterator& x, default_sentinel_t);
+`
+
+[5](#5)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4168)
+
+*Effects*: Equivalent to: return !*x.*parent_*->*stream_*;

cppdraft/range/istream/overview.md

@@ -0,0 +1,36 @@
+[range.istream.overview]
+
+# 25 Ranges library [[ranges]](./#ranges)
+
+## 25.6 Range factories [[range.factories]](range.factories#range.istream.overview)
+
+### 25.6.6 Istream view [[range.istream]](range.istream#overview)
+
+#### 25.6.6.1 Overview [range.istream.overview]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L3997)
+
+basic_istream_view models [input_range](range.refinements#concept:input_range "25.4.6 Other range refinements [range.refinements]") and
+reads (using operator>>) successive elements
+from its corresponding input stream[.](#1.sentence-1)
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4002)
+
+The name views​::​istream<T> denotes
+a customization point object ([[customization.point.object]](customization.point.object "16.3.3.3.5 Customization Point Object types"))[.](#2.sentence-1)
+
+Given a type T and a subexpression E of type U,
+if U models[derived_from](concept.derived#concept:derived_from "18.4.3 Concept derived_­from [concept.derived]")<basic_istream<typename U​::​char_type,typename U​::​traits_type>>,
+then the expression views​::​istream<T>(E) is expression-equivalent tobasic_istream_view<T, typename U​::​char_type,typename U​::​traits_type>(E);
+otherwise, views​::​istream<T>(E) is ill-formed[.](#2.sentence-2)
+
+[3](#3)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/ranges.tex#L4014)
+
+[*Example [1](#example-1)*: auto ints = istringstream{"0 1 2 3 4"};
+ranges::copy(views::istream<int>(ints), ostream_iterator<int>{cout, "-"});// prints 0-1-2-3-4- — *end example*]