[range.take] - C++17 → C++20

Files changed (1) hide show

tmp/tmp7b75j605/{from.md → to.md} +176 -0

tmp/tmp7b75j605/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,176 @@

+### Take view <a id="range.take">[[range.take]]</a>
+#### Overview <a id="range.take.overview">[[range.take.overview]]</a>
+`take_view` produces a `view` of the first N elements from another
+`view`, or all the elements if the adapted `view` contains fewer than N.
+The name `views::take` denotes a range adaptor object
+[[range.adaptor.object]]. Let `E` and `F` be expressions, let `T` be
+`remove_cvref_t<decltype((E))>`, and let `D` be
+`range_difference_t<decltype((E))>`. If `decltype((F))` does not model
+`convertible_to<D>`, `views::take(E, F)` is ill-formed. Otherwise, the
+expression `views::take(E, F)` is expression-equivalent to:
+- If `T` is a specialization of `ranges::empty_view`
+  [[range.empty.view]], then `((void) F, decay-copy(E))`.
+- Otherwise, if `T` models `random_access_range` and `sized_range` and
+  is
+  - a specialization of `span` [[views.span]] where
+    `T::extent == dynamic_extent`,
+  - a specialization of `basic_string_view` [[string.view]],
+  - a specialization of `ranges::iota_view` [[range.iota.view]], or
+  - a specialization of `ranges::subrange` [[range.subrange]],
+  then
+  `T{ranges::begin(E), ranges::begin(E) + min<D>(ranges::size(E), F)}`,
+  except that `E` is evaluated only once.
+- Otherwise, `ranges::take_view{E, F}`.
+[*Example 1*:
+``` cpp
+vector<int> is{0,1,2,3,4,5,6,7,8,9};
+take_view few{is, 5};
+for (int i : few)
+  cout << i << ' '; // prints: 0 1 2 3 4
+```
+— *end example*]
+#### Class template `take_view` <a id="range.take.view">[[range.take.view]]</a>
+``` cpp
+namespace std::ranges {
+  template<view V>
+  class take_view : public view_interface<take_view<V>> {
+  private:
+    V base_ = V();                                      // exposition only
+    range_difference_t<V> count_ = 0;                   // exposition only
+    // [range.take.sentinel], class template take_view::sentinel
+    template<bool> struct sentinel;                     // exposition only
+  public:
+    take_view() = default;
+    constexpr take_view(V base, range_difference_t<V> count);
+    constexpr V base() const& requires copy_constructible<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr auto begin() requires (!simple-view<V>) {
+      if constexpr (sized_range<V>) {
+        if constexpr (random_access_range<V>)
+          return ranges::begin(base_);
+        else {
+          auto sz = size();
+          return counted_iterator{ranges::begin(base_), sz};
+        }
+      } else
+        return counted_iterator{ranges::begin(base_), count_};
+    }
+    constexpr auto begin() const requires range<const V> {
+      if constexpr (sized_range<const V>) {
+        if constexpr (random_access_range<const V>)
+          return ranges::begin(base_);
+        else {
+          auto sz = size();
+          return counted_iterator{ranges::begin(base_), sz};
+        }
+      } else
+        return counted_iterator{ranges::begin(base_), count_};
+    }
+    constexpr auto end() requires (!simple-view<V>) {
+      if constexpr (sized_range<V>) {
+        if constexpr (random_access_range<V>)
+          return ranges::begin(base_) + size();
+        else
+          return default_sentinel;
+      } else
+        return sentinel<false>{ranges::end(base_)};
+    }
+    constexpr auto end() const requires range<const V> {
+      if constexpr (sized_range<const V>) {
+        if constexpr (random_access_range<const V>)
+          return ranges::begin(base_) + size();
+        else
+          return default_sentinel;
+      } else
+        return sentinel<true>{ranges::end(base_)};
+    }
+    constexpr auto size() requires sized_range<V> {
+      auto n = ranges::size(base_);
+      return ranges::min(n, static_cast<decltype(n)>(count_));
+    }
+    constexpr auto size() const requires sized_range<const V> {
+      auto n = ranges::size(base_);
+      return ranges::min(n, static_cast<decltype(n)>(count_));
+    }
+  };
+  template<range R>
+    take_view(R&&, range_difference_t<R>)
+      -> take_view<views::all_t<R>>;
+}
+```
+``` cpp
+constexpr take_view(V base, range_difference_t<V> count);
+```
+*Effects:* Initializes *base\_* with `std::move(base)` and *count\_*
+with `count`.
+#### Class template `take_view::sentinel` <a id="range.take.sentinel">[[range.take.sentinel]]</a>
+``` cpp
+namespace std::ranges {
+  template<view V>
+  template<bool Const>
+  class take_view<V>::sentinel {
+  private:
+    using Base = conditional_t<Const, const V, V>;      // exposition only
+    using CI = counted_iterator<iterator_t<Base>>;      // 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> s)
+      requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+    constexpr sentinel_t<Base> base() const;
+    friend constexpr bool operator==(const CI& y, const sentinel& x);
+  };
+}
+```
+``` cpp
+constexpr explicit sentinel(sentinel_t<Base> end);
+```
+*Effects:* Initializes *end\_* with `end`.
+``` cpp
+constexpr sentinel(sentinel<!Const> s)
+  requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+```
+*Effects:* Initializes *end\_* with `std::move(s.`*`end_`*`)`.
+``` cpp
+constexpr sentinel_t<Base> base() const;
+```
+*Effects:* Equivalent to: `return `*`end_`*`;`
+``` cpp
+friend constexpr bool operator==(const CI& y, const sentinel& x);
+```
+*Effects:* Equivalent to:
+`return y.count() == 0 || y.base() == x.`*`end_`*`;`

Diff to HTML by rtfpessoa