From Jason Turner

[range.elements]

C++17 → C++20 18.2 KB 567 lines
Current Draft | LaTeX Source
Archived: C++17 | C++20
Markdown: C++17 | C++20
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmp26ct_90m/{from.md → to.md} +564 -0
tmp/tmp26ct_90m/{from.md → to.md} RENAMED
@@ -0,0 +1,564 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ ### Elements view <a id="range.elements">[[range.elements]]</a>
2
+
3
+ #### Overview <a id="range.elements.overview">[[range.elements.overview]]</a>
4
+
5
+ `elements_view` takes a `view` of tuple-like values and a `size_t`, and
6
+ produces a `view` with a value-type of the Nᵗʰ element of the adapted
7
+ `view`’s value-type.
8
+
9
+ The name `views::elements<N>` denotes a range adaptor object
10
+ [[range.adaptor.object]]. Given a subexpression `E` and constant
11
+ expression `N`, the expression `views::elements<N>(E)` is
12
+ expression-equivalent to
13
+ `elements_view<views::all_t<decltype((E))>, N>{E}`.
14
+
15
+ [*Example 1*:
16
+
17
+ ``` cpp
18
+ auto historical_figures = map{
19
+ {"Lovelace"sv, 1815},
20
+ {"Turing"sv, 1912},
21
+ {"Babbage"sv, 1791},
22
+ {"Hamilton"sv, 1936}
23
+ };
24
+
25
+ auto names = historical_figures | views::elements<0>;
26
+ for (auto&& name : names) {
27
+ cout << name << ' '; // prints Babbage Hamilton Lovelace Turing
28
+ }
29
+
30
+ auto birth_years = historical_figures | views::elements<1>;
31
+ for (auto&& born : birth_years) {
32
+ cout << born << ' '; // prints 1791 1936 1815 1912
33
+ }
34
+ ```
35
+
36
+ — *end example*]
37
+
38
+ `keys_view` is an alias for `elements_view<views::all_t<R>, 0>`, and is
39
+ useful for extracting keys from associative containers.
40
+
41
+ [*Example 2*:
42
+
43
+ ``` cpp
44
+ auto names = keys_view{historical_figures};
45
+ for (auto&& name : names) {
46
+ cout << name << ' '; // prints Babbage Hamilton Lovelace Turing
47
+ }
48
+ ```
49
+
50
+ — *end example*]
51
+
52
+ `values_view` is an alias for `elements_view<views::all_t<R>, 1>`, and
53
+ is useful for extracting values from associative containers.
54
+
55
+ [*Example 3*:
56
+
57
+ ``` cpp
58
+ auto is_even = [](const auto x) { return x % 2 == 0; };
59
+ cout << ranges::count_if(values_view{historical_figures}, is_even); // prints 2
60
+ ```
61
+
62
+ — *end example*]
63
+
64
+ #### Class template `elements_view` <a id="range.elements.view">[[range.elements.view]]</a>
65
+
66
+ ``` cpp
67
+ namespace std::ranges {
68
+ template<class T, size_t N>
69
+ concept has-tuple-element = // exposition only
70
+ requires(T t) {
71
+ typename tuple_size<T>::type;
72
+ requires N < tuple_size_v<T>;
73
+ typename tuple_element_t<N, T>;
74
+ { get<N>(t) } -> convertible_to<const tuple_element_t<N, T>&>;
75
+ };
76
+
77
+
78
+ template<input_range V, size_t N>
79
+ requires view<V> && has-tuple-element<range_value_t<V>, N> &&
80
+ has-tuple-element<remove_reference_t<range_reference_t<V>>, N>
81
+ class elements_view : public view_interface<elements_view<V, N>> {
82
+ public:
83
+ elements_view() = default;
84
+ constexpr explicit elements_view(V base);
85
+
86
+ constexpr V base() const& requires copy_constructible<V> { return base_; }
87
+ constexpr V base() && { return std::move(base_); }
88
+
89
+ constexpr auto begin() requires (!simple-view<V>)
90
+ { return iterator<false>(ranges::begin(base_)); }
91
+
92
+ constexpr auto begin() const requires simple-view<V>
93
+ { return iterator<true>(ranges::begin(base_)); }
94
+
95
+ constexpr auto end()
96
+ { return sentinel<false>{ranges::end(base_)}; }
97
+
98
+ constexpr auto end() requires common_range<V>
99
+ { return iterator<false>{ranges::end(base_)}; }
100
+
101
+ constexpr auto end() const requires range<const V>
102
+ { return sentinel<true>{ranges::end(base_)}; }
103
+
104
+ constexpr auto end() const requires common_range<const V>
105
+ { return iterator<true>{ranges::end(base_)}; }
106
+
107
+ constexpr auto size() requires sized_range<V>
108
+ { return ranges::size(base_); }
109
+
110
+ constexpr auto size() const requires sized_range<const V>
111
+ { return ranges::size(base_); }
112
+
113
+ private:
114
+ // [range.elements.iterator], class template elements_view::iterator
115
+ template<bool> struct iterator; // exposition only
116
+ // [range.elements.sentinel], class template elements_view::sentinel
117
+ template<bool> struct sentinel; // exposition only
118
+ V base_ = V(); // exposition only
119
+ };
120
+ }
121
+ ```
122
+
123
+ ``` cpp
124
+ constexpr explicit elements_view(V base);
125
+ ```
126
+
127
+ *Effects:* Initializes *base\_* with `std::move(base)`.
128
+
129
+ #### Class template `elements_view::iterator` <a id="range.elements.iterator">[[range.elements.iterator]]</a>
130
+
131
+ ``` cpp
132
+ namespace std::ranges {
133
+ template<input_range V, size_t N>
134
+ requires view<V> && has-tuple-element<range_value_t<V>, N> &&
135
+ has-tuple-element<remove_reference_t<range_reference_t<V>>, N>
136
+ template<bool Const>
137
+ class elements_view<V, N>::iterator { // exposition only
138
+ using Base = conditional_t<Const, const V, V>; // exposition only
139
+
140
+ iterator_t<Base> current_ = iterator_t<Base>();
141
+ public:
142
+ using iterator_category = typename iterator_traits<iterator_t<Base>>::iterator_category;
143
+ using value_type = remove_cvref_t<tuple_element_t<N, range_value_t<Base>>>;
144
+ using difference_type = range_difference_t<Base>;
145
+
146
+ iterator() = default;
147
+ constexpr explicit iterator(iterator_t<Base> current);
148
+ constexpr iterator(iterator<!Const> i)
149
+ requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
150
+
151
+ constexpr iterator_t<Base> base() const&
152
+ requires copyable<iterator_t<Base>>;
153
+ constexpr iterator_t<Base> base() &&;
154
+
155
+ constexpr decltype(auto) operator*() const
156
+ { return get<N>(*current_); }
157
+
158
+ constexpr iterator& operator++();
159
+ constexpr void operator++(int) requires (!forward_range<Base>);
160
+ constexpr iterator operator++(int) requires forward_range<Base>;
161
+
162
+ constexpr iterator& operator--() requires bidirectional_range<Base>;
163
+ constexpr iterator operator--(int) requires bidirectional_range<Base>;
164
+
165
+ constexpr iterator& operator+=(difference_type x)
166
+ requires random_access_range<Base>;
167
+ constexpr iterator& operator-=(difference_type x)
168
+ requires random_access_range<Base>;
169
+
170
+ constexpr decltype(auto) operator[](difference_type n) const
171
+ requires random_access_range<Base>
172
+ { return get<N>(*(current_ + n)); }
173
+
174
+ friend constexpr bool operator==(const iterator& x, const iterator& y)
175
+ requires equality_comparable<iterator_t<Base>>;
176
+
177
+ friend constexpr bool operator<(const iterator& x, const iterator& y)
178
+ requires random_access_range<Base>;
179
+ friend constexpr bool operator>(const iterator& x, const iterator& y)
180
+ requires random_access_range<Base>;
181
+ friend constexpr bool operator<=(const iterator& y, const iterator& y)
182
+ requires random_access_range<Base>;
183
+ friend constexpr bool operator>=(const iterator& x, const iterator& y)
184
+ requires random_access_range<Base>;
185
+ friend constexpr auto operator<=>(const iterator& x, const iterator& y)
186
+ requires random_access_range<Base> && three_way_comparable<iterator_t<Base>>;
187
+
188
+ friend constexpr iterator operator+(const iterator& x, difference_type y)
189
+ requires random_access_range<Base>;
190
+ friend constexpr iterator operator+(difference_type x, const iterator& y)
191
+ requires random_access_range<Base>;
192
+ friend constexpr iterator operator-(const iterator& x, difference_type y)
193
+ requires random_access_range<Base>;
194
+ friend constexpr difference_type operator-(const iterator& x, const iterator& y)
195
+ requires random_access_range<Base>;
196
+ };
197
+ }
198
+ ```
199
+
200
+ ``` cpp
201
+ constexpr explicit iterator(iterator_t<Base> current);
202
+ ```
203
+
204
+ *Effects:* Initializes *current\_* with `std::move(current)`.
205
+
206
+ ``` cpp
207
+ constexpr iterator(iterator<!Const> i)
208
+ requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
209
+ ```
210
+
211
+ *Effects:* Initializes *current\_* with `std::move(i.`*`current_`*`)`.
212
+
213
+ ``` cpp
214
+ constexpr iterator_t<Base> base() const&
215
+ requires copyable<iterator_t<Base>>;
216
+ ```
217
+
218
+ *Effects:* Equivalent to: `return `*`current_`*`;`
219
+
220
+ ``` cpp
221
+ constexpr iterator_t<Base> base() &&;
222
+ ```
223
+
224
+ *Effects:* Equivalent to: `return std::move(`*`current_`*`);`
225
+
226
+ ``` cpp
227
+ constexpr iterator& operator++();
228
+ ```
229
+
230
+ *Effects:* Equivalent to:
231
+
232
+ ``` cpp
233
+ ++current_;
234
+ return *this;
235
+ ```
236
+
237
+ ``` cpp
238
+ constexpr void operator++(int) requires (!forward_range<Base>);
239
+ ```
240
+
241
+ *Effects:* Equivalent to: `++`*`current_`*.
242
+
243
+ ``` cpp
244
+ constexpr iterator operator++(int) requires forward_range<Base>;
245
+ ```
246
+
247
+ *Effects:* Equivalent to:
248
+
249
+ ``` cpp
250
+ auto temp = *this;
251
+ ++current_;
252
+ return temp;
253
+ ```
254
+
255
+ ``` cpp
256
+ constexpr iterator& operator--() requires bidirectional_range<Base>;
257
+ ```
258
+
259
+ *Effects:* Equivalent to:
260
+
261
+ ``` cpp
262
+ --current_;
263
+ return *this;
264
+ ```
265
+
266
+ ``` cpp
267
+ constexpr iterator operator--(int) requires bidirectional_range<Base>;
268
+ ```
269
+
270
+ *Effects:* Equivalent to:
271
+
272
+ ``` cpp
273
+ auto temp = *this;
274
+ --current_;
275
+ return temp;
276
+ ```
277
+
278
+ ``` cpp
279
+ constexpr iterator& operator+=(difference_type n);
280
+ requires random_access_range<Base>;
281
+ ```
282
+
283
+ *Effects:* Equivalent to:
284
+
285
+ ``` cpp
286
+ current_ += n;
287
+ return *this;
288
+ ```
289
+
290
+ ``` cpp
291
+ constexpr iterator& operator-=(difference_type n)
292
+ requires random_access_range<Base>;
293
+ ```
294
+
295
+ *Effects:* Equivalent to:
296
+
297
+ ``` cpp
298
+ current_ -= n;
299
+ return *this;
300
+ ```
301
+
302
+ ``` cpp
303
+ friend constexpr bool operator==(const iterator& x, const iterator& y)
304
+ requires equality_comparable<Base>;
305
+ ```
306
+
307
+ *Effects:* Equivalent to: `return x.`*`current_`*` == y.`*`current_`*`;`
308
+
309
+ ``` cpp
310
+ friend constexpr bool operator<(const iterator& x, const iterator& y)
311
+ requires random_access_range<Base>;
312
+ ```
313
+
314
+ *Effects:* Equivalent to: `return x.`*`current_`*` < y.`*`current_`*`;`
315
+
316
+ ``` cpp
317
+ friend constexpr bool operator>(const iterator& x, const iterator& y)
318
+ requires random_access_range<Base>;
319
+ ```
320
+
321
+ *Effects:* Equivalent to: `return y < x;`
322
+
323
+ ``` cpp
324
+ friend constexpr bool operator<=(const iterator& x, const iterator& y)
325
+ requires random_access_range<Base>;
326
+ ```
327
+
328
+ *Effects:* Equivalent to: `return !(y < x);`
329
+
330
+ ``` cpp
331
+ friend constexpr bool operator>=(const iterator& x, const iterator& y)
332
+ requires random_access_range<Base>;
333
+ ```
334
+
335
+ *Effects:* Equivalent to: `return !(x < y);`
336
+
337
+ ``` cpp
338
+ friend constexpr auto operator<=>(const iterator& x, const iterator& y)
339
+ requires random_access_range<Base> && three_way_comparable<iterator_t<Base>>;
340
+ ```
341
+
342
+ *Effects:* Equivalent to:
343
+ `return x.`*`current_`*` <=> y.`*`current_`*`;`
344
+
345
+ ``` cpp
346
+ friend constexpr iterator operator+(const iterator& x, difference_type y)
347
+ requires random_access_range<Base>;
348
+ ```
349
+
350
+ *Effects:* Equivalent to: `return iterator{x} += y;`
351
+
352
+ ``` cpp
353
+ friend constexpr iterator operator+(difference_type x, const iterator& y)
354
+ requires random_access_range<Base>;
355
+ ```
356
+
357
+ *Effects:* Equivalent to: `return y + x;`
358
+
359
+ ``` cpp
360
+ constexpr iterator operator-(const iterator& x, difference_type y)
361
+ requires random_access_range<Base>;
362
+ ```
363
+
364
+ *Effects:* Equivalent to: `return iterator{x} -= y;`
365
+
366
+ ``` cpp
367
+ constexpr difference_type operator-(const iterator& x, const iterator& y)
368
+ requires random_access_range<Base>;
369
+ ```
370
+
371
+ *Effects:* Equivalent to: `return x.`*`current_`*` - y.`*`current_`*`;`
372
+
373
+ #### Class template `elements_view::sentinel` <a id="range.elements.sentinel">[[range.elements.sentinel]]</a>
374
+
375
+ ``` cpp
376
+ namespace std::ranges {
377
+ template<input_range V, size_t N>
378
+ requires view<V> && has-tuple-element<range_value_t<V>, N> &&
379
+ has-tuple-element<remove_reference_t<range_reference_t<V>>, N>
380
+ template<bool Const>
381
+ class elements_view<V, N>::sentinel { // exposition only
382
+ private:
383
+ using Base = conditional_t<Const, const V, V>; // exposition only
384
+ sentinel_t<Base> end_ = sentinel_t<Base>(); // exposition only
385
+ public:
386
+ sentinel() = default;
387
+ constexpr explicit sentinel(sentinel_t<Base> end);
388
+ constexpr sentinel(sentinel<!Const> other)
389
+ requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
390
+
391
+ constexpr sentinel_t<Base> base() const;
392
+
393
+ friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
394
+
395
+ friend constexpr range_difference_t<Base>
396
+ operator-(const iterator<Const>& x, const sentinel& y)
397
+ requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
398
+
399
+ friend constexpr range_difference_t<Base>
400
+ operator-(const sentinel& x, const iterator<Const>& y)
401
+ requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
402
+ };
403
+ }
404
+ ```
405
+
406
+ ``` cpp
407
+ constexpr explicit sentinel(sentinel_t<Base> end);
408
+ ```
409
+
410
+ *Effects:* Initializes *end\_* with `end`.
411
+
412
+ ``` cpp
413
+ constexpr sentinel(sentinel<!Const> other)
414
+ requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
415
+ ```
416
+
417
+ *Effects:* Initializes *end\_* with `std::move(other.`*`end_`*`)`.
418
+
419
+ ``` cpp
420
+ constexpr sentinel_t<Base> base() const;
421
+ ```
422
+
423
+ *Effects:* Equivalent to: `return `*`end_`*`;`
424
+
425
+ ``` cpp
426
+ friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
427
+ ```
428
+
429
+ *Effects:* Equivalent to: `return x.`*`current_`*` == y.`*`end_`*`;`
430
+
431
+ ``` cpp
432
+ friend constexpr range_difference_t<Base>
433
+ operator-(const iterator<Const>& x, const sentinel& y)
434
+ requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
435
+ ```
436
+
437
+ *Effects:* Equivalent to: `return x.`*`current_`*` - y.`*`end_`*`;`
438
+
439
+ ``` cpp
440
+ friend constexpr range_difference_t<Base>
441
+ operator-(const sentinel& x, const iterator<Const>& y)
442
+ requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
443
+ ```
444
+
445
+ *Effects:* Equivalent to: `return x.`*`end_`*` - y.`*`current_`*`;`
446
+
447
+ <!-- Link reference definitions -->
448
+ [basic.compound]: basic.md#basic.compound
449
+ [concepts.equality]: concepts.md#concepts.equality
450
+ [containers]: containers.md#containers
451
+ [conv.rval]: expr.md#conv.rval
452
+ [customization.point.object]: library.md#customization.point.object
453
+ [dcl.array]: dcl.md#dcl.array
454
+ [expr.const]: expr.md#expr.const
455
+ [iterator.concept.bidir]: iterators.md#iterator.concept.bidir
456
+ [iterator.concept.iterator]: iterators.md#iterator.concept.iterator
457
+ [iterator.concept.output]: iterators.md#iterator.concept.output
458
+ [iterator.concept.random.access]: iterators.md#iterator.concept.random.access
459
+ [iterator.concept.sizedsentinel]: iterators.md#iterator.concept.sizedsentinel
460
+ [iterator.concept.winc]: iterators.md#iterator.concept.winc
461
+ [iterator.requirements.general]: iterators.md#iterator.requirements.general
462
+ [namespace.std]: library.md#namespace.std
463
+ [range.access]: #range.access
464
+ [range.access.begin]: #range.access.begin
465
+ [range.access.cbegin]: #range.access.cbegin
466
+ [range.access.cend]: #range.access.cend
467
+ [range.access.crbegin]: #range.access.crbegin
468
+ [range.access.crend]: #range.access.crend
469
+ [range.access.end]: #range.access.end
470
+ [range.access.rbegin]: #range.access.rbegin
471
+ [range.access.rend]: #range.access.rend
472
+ [range.adaptor.object]: #range.adaptor.object
473
+ [range.adaptors]: #range.adaptors
474
+ [range.all]: #range.all
475
+ [range.common]: #range.common
476
+ [range.common.overview]: #range.common.overview
477
+ [range.common.view]: #range.common.view
478
+ [range.counted]: #range.counted
479
+ [range.dangling]: #range.dangling
480
+ [range.drop]: #range.drop
481
+ [range.drop.overview]: #range.drop.overview
482
+ [range.drop.view]: #range.drop.view
483
+ [range.drop.while]: #range.drop.while
484
+ [range.drop.while.overview]: #range.drop.while.overview
485
+ [range.drop.while.view]: #range.drop.while.view
486
+ [range.elements]: #range.elements
487
+ [range.elements.iterator]: #range.elements.iterator
488
+ [range.elements.overview]: #range.elements.overview
489
+ [range.elements.sentinel]: #range.elements.sentinel
490
+ [range.elements.view]: #range.elements.view
491
+ [range.empty]: #range.empty
492
+ [range.empty.overview]: #range.empty.overview
493
+ [range.empty.view]: #range.empty.view
494
+ [range.factories]: #range.factories
495
+ [range.filter]: #range.filter
496
+ [range.filter.iterator]: #range.filter.iterator
497
+ [range.filter.overview]: #range.filter.overview
498
+ [range.filter.sentinel]: #range.filter.sentinel
499
+ [range.filter.view]: #range.filter.view
500
+ [range.iota]: #range.iota
501
+ [range.iota.iterator]: #range.iota.iterator
502
+ [range.iota.overview]: #range.iota.overview
503
+ [range.iota.sentinel]: #range.iota.sentinel
504
+ [range.iota.view]: #range.iota.view
505
+ [range.istream]: #range.istream
506
+ [range.istream.iterator]: #range.istream.iterator
507
+ [range.istream.overview]: #range.istream.overview
508
+ [range.istream.view]: #range.istream.view
509
+ [range.join]: #range.join
510
+ [range.join.iterator]: #range.join.iterator
511
+ [range.join.overview]: #range.join.overview
512
+ [range.join.sentinel]: #range.join.sentinel
513
+ [range.join.view]: #range.join.view
514
+ [range.prim.cdata]: #range.prim.cdata
515
+ [range.prim.data]: #range.prim.data
516
+ [range.prim.empty]: #range.prim.empty
517
+ [range.prim.size]: #range.prim.size
518
+ [range.prim.ssize]: #range.prim.ssize
519
+ [range.range]: #range.range
520
+ [range.ref.view]: #range.ref.view
521
+ [range.refinements]: #range.refinements
522
+ [range.req]: #range.req
523
+ [range.req.general]: #range.req.general
524
+ [range.reverse]: #range.reverse
525
+ [range.reverse.overview]: #range.reverse.overview
526
+ [range.reverse.view]: #range.reverse.view
527
+ [range.semi.wrap]: #range.semi.wrap
528
+ [range.single]: #range.single
529
+ [range.single.overview]: #range.single.overview
530
+ [range.single.view]: #range.single.view
531
+ [range.sized]: #range.sized
532
+ [range.split]: #range.split
533
+ [range.split.inner]: #range.split.inner
534
+ [range.split.outer]: #range.split.outer
535
+ [range.split.outer.value]: #range.split.outer.value
536
+ [range.split.overview]: #range.split.overview
537
+ [range.split.view]: #range.split.view
538
+ [range.subrange]: #range.subrange
539
+ [range.subrange.access]: #range.subrange.access
540
+ [range.subrange.ctor]: #range.subrange.ctor
541
+ [range.summary]: #range.summary
542
+ [range.take]: #range.take
543
+ [range.take.overview]: #range.take.overview
544
+ [range.take.sentinel]: #range.take.sentinel
545
+ [range.take.view]: #range.take.view
546
+ [range.take.while]: #range.take.while
547
+ [range.take.while.overview]: #range.take.while.overview
548
+ [range.take.while.sentinel]: #range.take.while.sentinel
549
+ [range.take.while.view]: #range.take.while.view
550
+ [range.transform]: #range.transform
551
+ [range.transform.iterator]: #range.transform.iterator
552
+ [range.transform.overview]: #range.transform.overview
553
+ [range.transform.sentinel]: #range.transform.sentinel
554
+ [range.transform.view]: #range.transform.view
555
+ [range.utility]: #range.utility
556
+ [range.utility.helpers]: #range.utility.helpers
557
+ [range.view]: #range.view
558
+ [ranges]: #ranges
559
+ [ranges.general]: #ranges.general
560
+ [ranges.syn]: #ranges.syn
561
+ [string.view]: strings.md#string.view
562
+ [view.interface]: #view.interface
563
+ [view.interface.members]: #view.interface.members
564
+ [views.span]: containers.md#views.span