[range.chunk] - C++20 → C++23

Files changed (1) hide show

tmp/tmp40v2a17h/{from.md → to.md} +778 -0

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

	@@ -0,0 +1,778 @@

+### Chunk view <a id="range.chunk">[[range.chunk]]</a>
+#### Overview <a id="range.chunk.overview">[[range.chunk.overview]]</a>
+`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. The last view in the range can have fewer
+than N elements.
+The name `views::chunk` denotes a range adaptor object
+[[range.adaptor.object]]. Given subexpressions `E` and `N`, the
+expression `views::chunk(E, N)` is expression-equivalent to
+`chunk_view(E, N)`.
+[*Example 1*:
+``` cpp
+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*]
+#### Class template `chunk_view` for input ranges <a id="range.chunk.view.input">[[range.chunk.view.input]]</a>
+``` cpp
+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 V>
+    requires input_range<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], class chunk_view::outer-iterator
+    class outer-iterator;                                 // exposition only
+    // [range.chunk.inner.iter], 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<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<V>;
+    constexpr auto size() const requires sized_range<const V>;
+  };
+  template<class R>
+    chunk_view(R&&, range_difference_t<R>) -> chunk_view<views::all_t<R>>;
+}
+```
+``` cpp
+constexpr explicit chunk_view(V base, range_difference_t<V> n);
+```
+*Preconditions:* `n > 0` is `true`.
+*Effects:* Initializes *base\_* with `std::move(base)` and *n\_* with
+`n`.
+``` cpp
+constexpr outer-iterator begin();
+```
+*Effects:* Equivalent to:
+``` cpp
+current_ = ranges::begin(base_);
+remainder_ = n_;
+return outer-iterator(*this);
+```
+``` cpp
+constexpr default_sentinel_t end() const noexcept;
+```
+*Returns:* `default_sentinel`.
+``` cpp
+constexpr auto size() requires sized_range<V>;
+constexpr auto size() const requires sized_range<const V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return to-unsigned-like(div-ceil(ranges::distance(base_), n_));
+```
+#### Class `chunk_view::outer-iterator` <a id="range.chunk.outer.iter">[[range.chunk.outer.iter]]</a>
+``` cpp
+namespace std::ranges {
+  template<view V>
+    requires input_range<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], class chunk_view::outer-iterator::value_type
+    struct 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<sentinel_t<V>, iterator_t<V>>;
+    friend constexpr difference_type operator-(const outer-iterator& x, default_sentinel_t y)
+      requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+  };
+}
+```
+``` cpp
+constexpr explicit outer-iterator(chunk_view& parent);
+```
+*Effects:* Initializes *parent\_* with `addressof(parent)`.
+``` cpp
+constexpr value_type operator*() const;
+```
+*Preconditions:* `*this == default_sentinel` is `false`.
+*Returns:* `value_type(*`*`parent_`*`)`.
+``` cpp
+constexpr outer-iterator& operator++();
+```
+*Preconditions:* `*this == default_sentinel` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+ranges::advance(*parent_->current_, parent_->remainder_, ranges::end(parent_->base_));
+parent_->remainder_ = parent_->n_;
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to `++*this`.
+``` cpp
+friend constexpr bool operator==(const outer-iterator& x, default_sentinel_t);
+```
+*Effects:* Equivalent to:
+``` cpp
+return *x.parent_->current_ == ranges::end(x.parent_->base_) && x.parent_->remainder_ != 0;
+```
+``` cpp
+friend constexpr difference_type operator-(default_sentinel_t y, const outer-iterator& x)
+  requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+```
+*Effects:* Equivalent to:
+``` cpp
+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;
+```
+``` cpp
+friend constexpr difference_type operator-(const outer-iterator& x, default_sentinel_t y)
+  requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+```
+*Effects:* Equivalent to: `return -(y - x);`
+#### Class `chunk_view::outer-iterator::value_type` <a id="range.chunk.outer.value">[[range.chunk.outer.value]]</a>
+``` cpp
+namespace std::ranges {
+  template<view V>
+    requires input_range<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() const
+      requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+  };
+}
+```
+``` cpp
+constexpr explicit value_type(chunk_view& parent);
+```
+*Effects:* Initializes *parent\_* with `addressof(parent)`.
+``` cpp
+constexpr inner-iterator begin() const noexcept;
+```
+*Returns:* *`inner-iterator`*`(*`*`parent_`*`)`.
+``` cpp
+constexpr default_sentinel_t end() const noexcept;
+```
+*Returns:* `default_sentinel`.
+``` cpp
+constexpr auto size() const
+  requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return to-unsigned-like(ranges::min(parent_->remainder_,
+                                ranges::end(parent_->base_) - *parent_->current_));
+```
+#### Class `chunk_view::inner-iterator` <a id="range.chunk.inner.iter">[[range.chunk.inner.iter]]</a>
+``` cpp
+namespace std::ranges {
+  template<view V>
+    requires input_range<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<sentinel_t<V>, iterator_t<V>>;
+    friend constexpr difference_type operator-(const inner-iterator& x, default_sentinel_t y)
+      requires sized_sentinel_for<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<iterator_t<V>>;
+  };
+}
+```
+``` cpp
+constexpr explicit inner-iterator(chunk_view& parent) noexcept;
+```
+*Effects:* Initializes *parent\_* with `addressof(parent)`.
+``` cpp
+constexpr const iterator_t<V>& base() const &;
+```
+*Effects:* Equivalent to: `return *`*`parent_`*`->`*`current_`*`;`
+``` cpp
+constexpr range_reference_t<V> operator*() const;
+```
+*Preconditions:* `*this == default_sentinel` is `false`.
+*Effects:* Equivalent to: `return **`*`parent_`*`->`*`current_`*`;`
+``` cpp
+constexpr inner-iterator& operator++();
+```
+*Preconditions:* `*this == default_sentinel` is `false`.
+*Effects:* Equivalent to:
+``` cpp
+++*parent_->current_;
+if (*parent_->current_ == ranges::end(parent_->base_))
+  parent_->remainder_ = 0;
+else
+  --parent_->remainder_;
+return *this;
+```
+``` cpp
+constexpr void operator++(int);
+```
+*Effects:* Equivalent to `++*this`.
+``` cpp
+friend constexpr bool operator==(const inner-iterator& x, default_sentinel_t);
+```
+*Returns:* `x.`*`parent_`*`->`*`remainder_`*` == 0`.
+``` cpp
+friend constexpr difference_type operator-(default_sentinel_t y, const inner-iterator& x)
+  requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return ranges::min(x.parent_->remainder_,
+                   ranges::end(x.parent_->base_) - *x.parent_->current_);
+```
+``` cpp
+friend constexpr difference_type operator-(const inner-iterator& x, default_sentinel_t y)
+  requires sized_sentinel_for<sentinel_t<V>, iterator_t<V>>;
+```
+*Effects:* Equivalent to: `return -(y - x);`
+``` cpp
+friend constexpr range_rvalue_reference_t<V> iter_move(const inner-iterator& i)
+  noexcept(noexcept(ranges::iter_move(*i.parent_->current_)));
+```
+*Effects:* Equivalent to:
+`return ranges::iter_move(*i.`*`parent_`*`->`*`current_`*`);`
+``` cpp
+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<iterator_t<V>>;
+```
+*Effects:* Equivalent to:
+`ranges::iter_swap(*x.`*`parent_`*`->`*`current_`*`, *y.`*`parent_`*`->`*`current_`*`);`
+#### Class template `chunk_view` for forward ranges <a id="range.chunk.view.fwd">[[range.chunk.view.fwd]]</a>
+``` cpp
+namespace std::ranges {
+  template<view V>
+    requires forward_range<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], 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<V> { return base_; }
+    constexpr V base() && { return std::move(base_); }
+    constexpr auto begin() requires (!simple-view<V>) {
+      return iterator<false>(this, ranges::begin(base_));
+    }
+    constexpr auto begin() const requires forward_range<const V> {
+      return iterator<true>(this, ranges::begin(base_));
+    }
+    constexpr auto end() requires (!simple-view<V>) {
+      if constexpr (common_range<V> && sized_range<V>) {
+        auto missing = (n_ - ranges::distance(base_) % n_) % n_;
+        return iterator<false>(this, ranges::end(base_), missing);
+      } else if constexpr (common_range<V> && !bidirectional_range<V>) {
+        return iterator<false>(this, ranges::end(base_));
+      } else {
+        return default_sentinel;
+      }
+    }
+    constexpr auto end() const requires forward_range<const V> {
+      if constexpr (common_range<const V> && sized_range<const V>) {
+        auto missing = (n_ - ranges::distance(base_) % n_) % n_;
+        return iterator<true>(this, ranges::end(base_), missing);
+      } else if constexpr (common_range<const V> && !bidirectional_range<const V>) {
+        return iterator<true>(this, ranges::end(base_));
+      } else {
+        return default_sentinel;
+      }
+    }
+    constexpr auto size() requires sized_range<V>;
+    constexpr auto size() const requires sized_range<const V>;
+  };
+}
+```
+``` cpp
+constexpr explicit chunk_view(V base, range_difference_t<V> n);
+```
+*Preconditions:* `n > 0` is `true`.
+*Effects:* Initializes *base\_* with `std::move(base)` and *n\_* with
+`n`.
+``` cpp
+constexpr auto size() requires sized_range<V>;
+constexpr auto size() const requires sized_range<const V>;
+```
+*Effects:* Equivalent to:
+``` cpp
+return to-unsigned-like(div-ceil(ranges::distance(base_), n_));
+```
+#### Class template `chunk_view::iterator` for forward ranges <a id="range.chunk.fwd.iter">[[range.chunk.fwd.iter]]</a>
+``` cpp
+namespace std::ranges {
+  template<view V>
+    requires forward_range<V>
+  template<bool Const>
+  class chunk_view<V>::iterator {
+    using Parent = maybe-const<Const, chunk_view>;                      // exposition only
+    using Base = maybe-const<Const, V>;                                 // exposition only
+    iterator_t<Base> current_ = iterator_t<Base>();                     // exposition only
+    sentinel_t<Base> end_ = sentinel_t<Base>();                         // exposition only
+    range_difference_t<Base> n_ = 0;                                    // exposition only
+    range_difference_t<Base> missing_ = 0;                              // exposition only
+    constexpr iterator(Parent* parent, iterator_t<Base> current,       // exposition only
+                       range_difference_t<Base> missing = 0);
+  public:
+    using iterator_category = input_iterator_tag;
+    using iterator_concept = see below;
+    using value_type = decltype(views::take(subrange(current_, end_), n_));
+    using difference_type = range_difference_t<Base>;
+    iterator() = default;
+    constexpr iterator(iterator<!Const> i)
+      requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>
+                     && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+    constexpr iterator_t<Base> base() const;
+    constexpr value_type operator*() const;
+    constexpr iterator& operator++();
+    constexpr iterator operator++(int);
+    constexpr iterator& operator--() requires bidirectional_range<Base>;
+    constexpr iterator operator--(int) requires bidirectional_range<Base>;
+    constexpr iterator& operator+=(difference_type x)
+      requires random_access_range<Base>;
+    constexpr iterator& operator-=(difference_type x)
+      requires random_access_range<Base>;
+    constexpr value_type operator[](difference_type n) const
+      requires random_access_range<Base>;
+    friend constexpr bool operator==(const iterator& x, const iterator& y);
+    friend constexpr bool operator==(const iterator& x, default_sentinel_t);
+    friend constexpr bool operator<(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr bool operator>(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr bool operator<=(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr bool operator>=(const iterator& x, const iterator& y)
+      requires random_access_range<Base>;
+    friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+      requires random_access_range<Base> &&
+               three_way_comparable<iterator_t<Base>>;
+    friend constexpr iterator operator+(const iterator& i, difference_type n)
+      requires random_access_range<Base>;
+    friend constexpr iterator operator+(difference_type n, const iterator& i)
+      requires random_access_range<Base>;
+    friend constexpr iterator operator-(const iterator& i, difference_type n)
+      requires random_access_range<Base>;
+    friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+      requires sized_sentinel_for<iterator_t<Base>, iterator_t<Base>>;
+    friend constexpr difference_type operator-(default_sentinel_t y, const iterator& x)
+      requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+    friend constexpr difference_type operator-(const iterator& x, default_sentinel_t y)
+      requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+  };
+}
+```
+`iterator::iterator_concept` is defined as follows:
+- If *`Base`* models `random_access_range`, then `iterator_concept`
+  denotes `random_access_iterator_tag`.
+- Otherwise, if *`Base`* models `bidirectional_range`, then
+  `iterator_concept` denotes `bidirectional_iterator_tag`.
+- Otherwise, `iterator_concept` denotes `forward_iterator_tag`.
+``` cpp
+constexpr iterator(Parent* parent, iterator_t<Base> current,
+                   range_difference_t<Base> missing = 0);
+```
+*Effects:* Initializes *current\_* with `current`, *end\_* with
+`ranges::end(parent->`*`base_`*`)`, *n\_* with `parent->`*`n_`*, and
+*missing\_* with `missing`.
+``` cpp
+constexpr iterator(iterator<!Const> i)
+  requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>
+                 && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+```
+*Effects:* Initializes *current\_* with `std::move(i.`*`current_`*`)`,
+*end\_* with `std::move(i.`*`end_`*`)`, *n\_* with `i.`*`n_`*, and
+*missing\_* with `i.`*`missing_`*.
+``` cpp
+constexpr iterator_t<Base> base() const;
+```
+*Returns:* *current\_*.
+``` cpp
+constexpr value_type operator*() const;
+```
+*Preconditions:* *`current_`*` != `*`end_`* is `true`.
+*Returns:*
+`views::take(subrange(`*`current_`*`, `*`end_`*`), `*`n_`*`)`.
+``` cpp
+constexpr iterator& operator++();
+```
+*Preconditions:* *`current_`*` != `*`end_`* is `true`.
+*Effects:* Equivalent to:
+``` cpp
+missing_ = ranges::advance(current_, n_, end_);
+return *this;
+```
+``` cpp
+constexpr iterator operator++(int);
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+++*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator--() requires bidirectional_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+ranges::advance(current_, missing_ - n_);
+missing_ = 0;
+return *this;
+```
+``` cpp
+constexpr iterator operator--(int) requires bidirectional_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto tmp = *this;
+--*this;
+return tmp;
+```
+``` cpp
+constexpr iterator& operator+=(difference_type x)
+  requires random_access_range<Base>;
+```
+*Preconditions:* If `x` is positive,
+`ranges::distance(`*`current_`*`, `*`end_`*`) > `*`n_`*` * (x - 1)` is
+`true`.
+[*Note 1*: If `x` is negative, the *Effects* paragraph implies a
+precondition. — *end note*]
+*Effects:* Equivalent to:
+``` cpp
+if (x > 0) {
+  ranges::advance(current_, n_ * (x - 1));
+  missing_ = ranges::advance(current_, n_, end_);
+} else if (x < 0) {
+  ranges::advance(current_, n_ * x + missing_);
+  missing_ = 0;
+}
+return *this;
+```
+``` cpp
+constexpr iterator& operator-=(difference_type x)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return *this += -x;`
+``` cpp
+constexpr value_type operator[](difference_type n) const
+  requires random_access_range<Base>;
+```
+*Returns:* `*(*this + n)`.
+``` cpp
+friend constexpr bool operator==(const iterator& x, const iterator& y);
+```
+*Returns:* `x.`*`current_`*` == y.`*`current_`*.
+``` cpp
+friend constexpr bool operator==(const iterator& x, default_sentinel_t);
+```
+*Returns:* `x.`*`current_`*` == x.`*`end_`*.
+``` cpp
+friend constexpr bool operator<(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Returns:* `x.`*`current_`*` < y.`*`current_`*.
+``` cpp
+friend constexpr bool operator>(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return y < x;`
+``` cpp
+friend constexpr bool operator<=(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return !(y < x);`
+``` cpp
+friend constexpr bool operator>=(const iterator& x, const iterator& y)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to: `return !(x < y);`
+``` cpp
+friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+  requires random_access_range<Base> &&
+           three_way_comparable<iterator_t<Base>>;
+```
+*Returns:* `x.`*`current_`*` <=> y.`*`current_`*.
+``` cpp
+friend constexpr iterator operator+(const iterator& i, difference_type n)
+  requires random_access_range<Base>;
+friend constexpr iterator operator+(difference_type n, const iterator& i)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto r = i;
+r += n;
+return r;
+```
+``` cpp
+friend constexpr iterator operator-(const iterator& i, difference_type n)
+  requires random_access_range<Base>;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto r = i;
+r -= n;
+return r;
+```
+``` cpp
+friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+  requires sized_sentinel_for<iterator_t<Base>, iterator_t<Base>>;
+```
+*Returns:*
+`(x.`*`current_`*` - y.`*`current_`*` + x.`*`missing_`*` - y.`*`missing_`*`) / x.`*`n_`*.
+``` cpp
+friend constexpr difference_type operator-(default_sentinel_t y, const iterator& x)
+  requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+```
+*Returns:* *`div-ceil`*`(x.`*`end_`*` - x.`*`current_`*`, x.`*`n_`*`)`.
+``` cpp
+friend constexpr difference_type operator-(const iterator& x, default_sentinel_t y)
+  requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
+```
+*Effects:* Equivalent to: `return -(y - x);`

Diff to HTML by rtfpessoa