From Jason Turner

[range.join.with]

C++23 → Trunk 7.3 KB 50 lines
Current Draft | LaTeX Source
Archived: C++23
Markdown: C++23 | Trunk
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmptn6qo9g3/{from.md → to.md} +17 -21
tmp/tmptn6qo9g3/{from.md → to.md} RENAMED
@@ -25,23 +25,17 @@ for (char c : vs | views::join_with('-')) {
25
 
26
  #### Class template `join_with_view` <a id="range.join.with.view">[[range.join.with.view]]</a>
27
 
28
  ``` cpp
29
  namespace std::ranges {
30
- template<class R, class P>
31
- concept compatible-joinable-ranges = // exposition only
32
- common_with<range_value_t<R>, range_value_t<P>> &&
33
- common_reference_with<range_reference_t<R>, range_reference_t<P>> &&
34
- common_reference_with<range_rvalue_reference_t<R>, range_rvalue_reference_t<P>>;
35
-
36
  template<class R>
37
  concept bidirectional-common = bidirectional_range<R> && common_range<R>; // exposition only
38
 
39
  template<input_range V, forward_range Pattern>
40
  requires view<V> && input_range<range_reference_t<V>>
41
  && view<Pattern>
42
- && compatible-joinable-ranges<range_reference_t<V>, Pattern>
43
  class join_with_view : public view_interface<join_with_view<V, Pattern>> {
44
  using InnerRng = range_reference_t<V>; // exposition only
45
 
46
  V base_ = V(); // exposition only
47
  non-propagating-cache<iterator_t<V>> outer_it_; // exposition only, present only
@@ -83,11 +77,12 @@ namespace std::ranges {
83
  }
84
  constexpr auto begin() const
85
  requires forward_range<const V> &&
86
  forward_range<const Pattern> &&
87
  is_reference_v<range_reference_t<const V>> &&
88
- input_range<range_reference_t<const V>> {
 
89
  return iterator<true>{*this, ranges::begin(base_)};
90
  }
91
 
92
  constexpr auto end() {
93
  if constexpr (forward_range<V> &&
@@ -98,11 +93,12 @@ namespace std::ranges {
98
  return sentinel<simple-view<V> && simple-view<Pattern>>{*this};
99
  }
100
  constexpr auto end() const
101
  requires forward_range<const V> && forward_range<const Pattern> &&
102
  is_reference_v<range_reference_t<const V>> &&
103
- input_range<range_reference_t<const V>> {
 
104
  using InnerConstRng = range_reference_t<const V>;
105
  if constexpr (forward_range<InnerConstRng> &&
106
  common_range<const V> && common_range<InnerConstRng>)
107
  return iterator<true>{*this, ranges::end(base_)};
108
  else
@@ -140,11 +136,11 @@ and *pattern\_* with `views::single(std::move(e))`.
140
 
141
  ``` cpp
142
  namespace std::ranges {
143
  template<input_range V, forward_range Pattern>
144
  requires view<V> && input_range<range_reference_t<V>>
145
- && view<Pattern> && compatible-joinable-ranges<range_reference_t<V>, Pattern>
146
  template<bool Const>
147
  class join_with_view<V, Pattern>::iterator {
148
  using Parent = maybe-const<Const, join_with_view>; // exposition only
149
  using Base = maybe-const<Const, V>; // exposition only
150
  using InnerBase = range_reference_t<Base>; // exposition only
@@ -243,11 +239,11 @@ as follows:
243
  iter_reference_t<PatternIter>>>
244
  ```
245
 
246
  is `false`, `iterator_category` denotes `input_iterator_tag`.
247
  - Otherwise, if *OUTERC*, *INNERC*, and *PATTERNC* each model
248
- `derived_from<bidirectional_iterator_category>` and *`InnerBase`* and
249
  *`PatternBase`* each model `common_range`, `iterator_category` denotes
250
  `bidirectional_iterator_tag`.
251
  - Otherwise, if *OUTERC*, *INNERC*, and *PATTERNC* each model
252
  `derived_from<forward_iterator_tag>`, `iterator_category` denotes
253
  `forward_iterator_tag`.
@@ -311,20 +307,20 @@ constexpr void satisfy();
311
  ``` cpp
312
  while (true) {
313
  if (inner_it_.index() == 0) {
314
  if (std::get<0>(inner_it_) != ranges::end(parent_->pattern_))
315
  break;
316
- inner_it_.emplace<1>(ranges::begin(update-inner()));
317
  } else {
318
  if (std::get<1>(inner_it_) != ranges::end(get-inner()))
319
  break;
320
  if (++outer() == ranges::end(parent_->base_)) {
321
  if constexpr (ref-is-glvalue)
322
- inner_it_.emplace<0>();
323
  break;
324
  }
325
- inner_it_.emplace<0>(ranges::begin(parent_->pattern_));
326
  }
327
  }
328
  ```
329
 
330
  [*Note 1*: `join_with_view` iterators use the *satisfy* function to
@@ -341,11 +337,11 @@ constexpr explicit iterator(Parent& parent)
341
  first overload, also initializes *outer_it\_* with `std::move(outer)`.
342
  Then, equivalent to:
343
 
344
  ``` cpp
345
  if (outer() != ranges::end(parent_->base_)) {
346
- inner_it_.emplace<1>(ranges::begin(update-inner()));
347
  satisfy();
348
  }
349
  ```
350
 
351
  ``` cpp
@@ -358,13 +354,13 @@ constexpr iterator(iterator<!Const> i)
358
  *Effects:* Initializes *outer_it\_* with `std::move(i.`*`outer_it_`*`)`
359
  and *parent\_* with `i.`*`parent_`*. Then, equivalent to:
360
 
361
  ``` cpp
362
  if (i.inner_it_.index() == 0)
363
- inner_it_.emplace<0>(std::get<0>(std::move(i.inner_it_)));
364
  else
365
- inner_it_.emplace<1>(std::get<1>(std::move(i.inner_it_)));
366
  ```
367
 
368
  [*Note 2*: `Const` can only be `true` when *Base* models
369
  `forward_range`. — *end note*]
370
 
@@ -420,27 +416,27 @@ constexpr iterator& operator--()
420
  *Effects:* Equivalent to:
421
 
422
  ``` cpp
423
  if (outer_it_ == ranges::end(parent_->base_)) {
424
  auto&& inner = *--outer_it_;
425
- inner_it_.emplace<1>(ranges::end(inner));
426
  }
427
 
428
  while (true) {
429
  if (inner_it_.index() == 0) {
430
  auto& it = std::get<0>(inner_it_);
431
  if (it == ranges::begin(parent_->pattern_)) {
432
  auto&& inner = *--outer_it_;
433
- inner_it_.emplace<1>(ranges::end(inner));
434
  } else {
435
  break;
436
  }
437
  } else {
438
  auto& it = std::get<1>(inner_it_);
439
  auto&& inner = *outer_it_;
440
  if (it == ranges::begin(inner)) {
441
- inner_it_.emplace<0>(ranges::end(parent_->pattern_));
442
  } else {
443
  break;
444
  }
445
  }
446
  }
@@ -478,11 +474,11 @@ return x.outer_it_ == y.outer_it_ && x.inner_it_ == y.inner_it_;
478
 
479
  ``` cpp
480
  namespace std::ranges {
481
  template<input_range V, forward_range Pattern>
482
  requires view<V> && input_range<range_reference_t<V>>
483
- && view<Pattern> && compatible-joinable-ranges<range_reference_t<V>, Pattern>
484
  template<bool Const>
485
  class join_with_view<V, Pattern>::sentinel {
486
  using Parent = maybe-const<Const, join_with_view>; // exposition only
487
  using Base = maybe-const<Const, V>; // exposition only
488
  sentinel_t<Base> end_ = sentinel_t<Base>(); // exposition only
 
25
 
26
  #### Class template `join_with_view` <a id="range.join.with.view">[[range.join.with.view]]</a>
27
 
28
  ``` cpp
29
  namespace std::ranges {
 
 
 
 
 
 
30
  template<class R>
31
  concept bidirectional-common = bidirectional_range<R> && common_range<R>; // exposition only
32
 
33
  template<input_range V, forward_range Pattern>
34
  requires view<V> && input_range<range_reference_t<V>>
35
  && view<Pattern>
36
+ && concatable<range_reference_t<V>, Pattern>
37
  class join_with_view : public view_interface<join_with_view<V, Pattern>> {
38
  using InnerRng = range_reference_t<V>; // exposition only
39
 
40
  V base_ = V(); // exposition only
41
  non-propagating-cache<iterator_t<V>> outer_it_; // exposition only, present only
 
77
  }
78
  constexpr auto begin() const
79
  requires forward_range<const V> &&
80
  forward_range<const Pattern> &&
81
  is_reference_v<range_reference_t<const V>> &&
82
+ input_range<range_reference_t<const V>> &&
83
+ concatable<range_reference_t<const V>, const Pattern> {
84
  return iterator<true>{*this, ranges::begin(base_)};
85
  }
86
 
87
  constexpr auto end() {
88
  if constexpr (forward_range<V> &&
 
93
  return sentinel<simple-view<V> && simple-view<Pattern>>{*this};
94
  }
95
  constexpr auto end() const
96
  requires forward_range<const V> && forward_range<const Pattern> &&
97
  is_reference_v<range_reference_t<const V>> &&
98
+ input_range<range_reference_t<const V>> &&
99
+ concatable<range_reference_t<const V>, const Pattern> {
100
  using InnerConstRng = range_reference_t<const V>;
101
  if constexpr (forward_range<InnerConstRng> &&
102
  common_range<const V> && common_range<InnerConstRng>)
103
  return iterator<true>{*this, ranges::end(base_)};
104
  else
 
136
 
137
  ``` cpp
138
  namespace std::ranges {
139
  template<input_range V, forward_range Pattern>
140
  requires view<V> && input_range<range_reference_t<V>>
141
+ && view<Pattern> && concatable<range_reference_t<V>, Pattern>
142
  template<bool Const>
143
  class join_with_view<V, Pattern>::iterator {
144
  using Parent = maybe-const<Const, join_with_view>; // exposition only
145
  using Base = maybe-const<Const, V>; // exposition only
146
  using InnerBase = range_reference_t<Base>; // exposition only
 
239
  iter_reference_t<PatternIter>>>
240
  ```
241
 
242
  is `false`, `iterator_category` denotes `input_iterator_tag`.
243
  - Otherwise, if *OUTERC*, *INNERC*, and *PATTERNC* each model
244
+ `derived_from<bidirectional_iterator_tag>` and *`InnerBase`* and
245
  *`PatternBase`* each model `common_range`, `iterator_category` denotes
246
  `bidirectional_iterator_tag`.
247
  - Otherwise, if *OUTERC*, *INNERC*, and *PATTERNC* each model
248
  `derived_from<forward_iterator_tag>`, `iterator_category` denotes
249
  `forward_iterator_tag`.
 
307
  ``` cpp
308
  while (true) {
309
  if (inner_it_.index() == 0) {
310
  if (std::get<0>(inner_it_) != ranges::end(parent_->pattern_))
311
  break;
312
+ inner_it_.template emplace<1>(ranges::begin(update-inner()));
313
  } else {
314
  if (std::get<1>(inner_it_) != ranges::end(get-inner()))
315
  break;
316
  if (++outer() == ranges::end(parent_->base_)) {
317
  if constexpr (ref-is-glvalue)
318
+ inner_it_.template emplace<0>();
319
  break;
320
  }
321
+ inner_it_.template emplace<0>(ranges::begin(parent_->pattern_));
322
  }
323
  }
324
  ```
325
 
326
  [*Note 1*: `join_with_view` iterators use the *satisfy* function to
 
337
  first overload, also initializes *outer_it\_* with `std::move(outer)`.
338
  Then, equivalent to:
339
 
340
  ``` cpp
341
  if (outer() != ranges::end(parent_->base_)) {
342
+ inner_it_.template emplace<1>(ranges::begin(update-inner()));
343
  satisfy();
344
  }
345
  ```
346
 
347
  ``` cpp
 
354
  *Effects:* Initializes *outer_it\_* with `std::move(i.`*`outer_it_`*`)`
355
  and *parent\_* with `i.`*`parent_`*. Then, equivalent to:
356
 
357
  ``` cpp
358
  if (i.inner_it_.index() == 0)
359
+ inner_it_.template emplace<0>(std::get<0>(std::move(i.inner_it_)));
360
  else
361
+ inner_it_.template emplace<1>(std::get<1>(std::move(i.inner_it_)));
362
  ```
363
 
364
  [*Note 2*: `Const` can only be `true` when *Base* models
365
  `forward_range`. — *end note*]
366
 
 
416
  *Effects:* Equivalent to:
417
 
418
  ``` cpp
419
  if (outer_it_ == ranges::end(parent_->base_)) {
420
  auto&& inner = *--outer_it_;
421
+ inner_it_.template emplace<1>(ranges::end(inner));
422
  }
423
 
424
  while (true) {
425
  if (inner_it_.index() == 0) {
426
  auto& it = std::get<0>(inner_it_);
427
  if (it == ranges::begin(parent_->pattern_)) {
428
  auto&& inner = *--outer_it_;
429
+ inner_it_.template emplace<1>(ranges::end(inner));
430
  } else {
431
  break;
432
  }
433
  } else {
434
  auto& it = std::get<1>(inner_it_);
435
  auto&& inner = *outer_it_;
436
  if (it == ranges::begin(inner)) {
437
+ inner_it_.template emplace<0>(ranges::end(parent_->pattern_));
438
  } else {
439
  break;
440
  }
441
  }
442
  }
 
474
 
475
  ``` cpp
476
  namespace std::ranges {
477
  template<input_range V, forward_range Pattern>
478
  requires view<V> && input_range<range_reference_t<V>>
479
+ && view<Pattern> && concatable<range_reference_t<V>, Pattern>
480
  template<bool Const>
481
  class join_with_view<V, Pattern>::sentinel {
482
  using Parent = maybe-const<Const, join_with_view>; // exposition only
483
  using Base = maybe-const<Const, V>; // exposition only
484
  sentinel_t<Base> end_ = sentinel_t<Base>(); // exposition only