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

Files changed (1) hide show

tmp/tmp7l8brh45/{from.md → to.md} +128 -91

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

@@ -1,66 +1,74 @@
 ### Join view <a id="range.join">[[range.join]]</a>
 #### Overview <a id="range.join.overview">[[range.join.overview]]</a>
-`join_view` flattens a `view` of ranges into a `view`.
 The name `views::join` denotes a range adaptor object
 [[range.adaptor.object]]. Given a subexpression `E`, the expression
-`views::join(E)` is expression-equivalent to `join_view{E}`.
 [*Example 1*:
 ``` cpp
 vector<string> ss{"hello", " ", "world", "!"};
-join_view greeting{ss};
-for (char ch : greeting)
-  cout << ch;                                   // prints: hello world!
 ```
 — *end example*]
 #### Class template `join_view` <a id="range.join.view">[[range.join.view]]</a>
 ``` cpp
 namespace std::ranges {
   template<input_range V>
-    requires view<V> && input_range<range_reference_t<V>> &&
-             (is_reference_v<range_reference_t<V>> ||
-              view<range_value_t<V>>)
   class join_view : public view_interface<join_view<V>> {
   private:
-    using InnerRng = // exposition only
-      range_reference_t<V>;
     // [range.join.iterator], class template join_view::iterator
     template<bool Const>
       struct iterator;                                      // exposition only
     // [range.join.sentinel], class template join_view::sentinel
     template<bool Const>
       struct sentinel;                                      // exposition only
     V base_ = V();                                          // exposition only
-    views::all_t<InnerRng> inner_ =     // exposition only, present only when !is_reference_v<InnerRng>
-      views::all_t<InnerRng>();
   public:
-    join_view() = default;
     constexpr explicit join_view(V base);
     constexpr V base() const & requires copy_constructible<V> { return base_; }
     constexpr V base() && { return std::move(base_); }
     constexpr auto begin() {
         constexpr bool use_const = simple-view<V> &&
- is_reference_v<range_reference_t<V>>;
         return iterator<use_const>{*this, ranges::begin(base_)};
     }
     constexpr auto begin() const
- requires input_range<const V> &&
- is_reference_v<range_reference_t<const V>> {
-      return iterator<true>{*this, ranges::begin(base_)};
-    }
     constexpr auto end() {
       if constexpr (forward_range<V> &&
                     is_reference_v<InnerRng> && forward_range<InnerRng> &&
                     common_range<V> && common_range<InnerRng>)
@@ -68,15 +76,14 @@ namespace std::ranges {
       else
         return sentinel<simple-view<V>>{*this};
     }
     constexpr auto end() const
- requires input_range<const V> &&
-             is_reference_v<range_reference_t<const V>> {
-      if constexpr (forward_range<const V> &&
                is_reference_v<range_reference_t<const V>> &&
-                    forward_range<range_reference_t<const V>> &&
                     common_range<const V> &&
                     common_range<range_reference_t<const V>>)
         return iterator<true>{*this, ranges::end(base_)};
       else
         return sentinel<true>{*this};
@@ -97,47 +104,53 @@ constexpr explicit join_view(V base);
 #### Class template `join_view::iterator` <a id="range.join.iterator">[[range.join.iterator]]</a>
 ``` cpp
 namespace std::ranges {
   template<input_range V>
-    requires view<V> && input_range<range_reference_t<V>> &&
-             (is_reference_v<range_reference_t<V>> ||
-              view<range_value_t<V>>)
   template<bool Const>
   struct join_view<V>::iterator {
   private:
-    using Parent = // exposition only
- conditional_t<Const, const join_view, join_view>;
-    using Base   = conditional_t<Const, const V, V>; // exposition only
     static constexpr bool ref-is-glvalue =                      // exposition only
       is_reference_v<range_reference_t<Base>>;
- iterator_t<Base> outer_ = iterator_t<Base>(); // exposition only
-    iterator_t<range_reference_t<Base>> inner_ =                // exposition only
-      iterator_t<range_reference_t<Base>>();
     Parent* parent_  = nullptr;                                 // exposition only
     constexpr void satisfy();                                   // exposition only
   public:
     using iterator_concept  = see below;
-    using iterator_category = see below;
     using value_type        = range_value_t<range_reference_t<Base>>;
     using difference_type   = see below;
     iterator() = default;
-    constexpr iterator(Parent& parent, iterator_t<Base> outer);
     constexpr iterator(iterator<!Const> i)
       requires Const &&
-               convertible_to<iterator_t<V>, iterator_t<Base>> &&
-               convertible_to<iterator_t<InnerRng>,
-                              iterator_t<range_reference_t<Base>>>;
-    constexpr decltype(auto) operator*() const { return *inner_; }
-    constexpr iterator_t<Base> operator->() const
-      requires has-arrow<iterator_t<Base>> && copyable<iterator_t<Base>>;
     constexpr iterator& operator++();
     constexpr void operator++(int);
     constexpr iterator operator++(int)
       requires ref-is-glvalue && forward_range<Base> &&
@@ -152,50 +165,53 @@ namespace std::ranges {
       requires ref-is-glvalue && bidirectional_range<Base> &&
                bidirectional_range<range_reference_t<Base>> &&
                common_range<range_reference_t<Base>>;
     friend constexpr bool operator==(const iterator& x, const iterator& y)
-      requires ref-is-glvalue && equality_comparable<iterator_t<Base>> &&
                equality_comparable<iterator_t<range_reference_t<Base>>>;
     friend constexpr decltype(auto) iter_move(const iterator& i)
-    noexcept(noexcept(ranges::iter_move(i.inner_))) {
-      return ranges::iter_move(i.inner_);
     }
     friend constexpr void iter_swap(const iterator& x, const iterator& y)
-      noexcept(noexcept(ranges::iter_swap(x.inner_, y.inner_)));
   };
 }
 ```
 `iterator::iterator_concept` is defined as follows:
-- If *`ref-is-glvalue`* is `true` and *`Base`* and
-  `range_reference_t<Base>` each model `bidirectional_range`, then
-  `iterator_concept` denotes `bidirectional_iterator_tag`.
 - Otherwise, if *`ref-is-glvalue`* is `true` and *`Base`* and
   `range_reference_t<Base>` each model , then `iterator_concept` denotes
   `forward_iterator_tag`.
 - Otherwise, `iterator_concept` denotes `input_iterator_tag`.
 `iterator::iterator_category` is defined as follows:
 - Let *OUTERC* denote
   `iterator_traits<iterator_t<Base>>::iterator_category`, and let
   *INNERC* denote
   `iterator_traits<iterator_t<range_reference_t<Base>>>::iterator_category`.
-- If *`ref-is-glvalue`* is `true` and *OUTERC* and *INNERC* each model
-  `derived_from<bidirectional_iterator_tag>`, `iterator_category`
   denotes `bidirectional_iterator_tag`.
-- Otherwise, if *`ref-is-glvalue`* is `true` and *OUTERC* and *INNERC*
-  each model `derived_from<forward_iterator_tag>`, `iterator_category`
-  denotes `forward_iterator_tag`.
 - Otherwise, if *OUTERC* and *INNERC* each model
-  `derived_from<input_iterator_tag>`, `iterator_category` denotes
-  `input_iterator_tag`.
-- Otherwise, `iterator_category` denotes `output_iterator_tag`.
 `iterator::difference_type` denotes the type:
 ``` cpp
 common_type_t<
@@ -205,74 +221,92 @@ common_type_t<
 `join_view` iterators use the *`satisfy`* function to skip over empty
 inner ranges.
 ``` cpp
-constexpr void satisfy();       // exposition only
 ```
 *Effects:* Equivalent to:
 ``` cpp
-auto update_inner = [this](range_reference_t<Base> x) -> auto& {
-  if constexpr (ref-is-glvalue) // x is a reference
-    return x;
   else
-    return (parent_->inner_ = views::all(std::move(x)));
 };
-for (; outer_ != ranges::end(parent_->base_); ++outer_) {
-  auto& inner = update_inner(*outer_);
   inner_ = ranges::begin(inner);
-  if (inner_ != ranges::end(inner))
     return;
 }
 if constexpr (ref-is-glvalue)
-  inner_ = iterator_t<range_reference_t<Base>>();
 ```
 ``` cpp
-constexpr iterator(Parent& parent, iterator_t<Base> outer);
 ```
 *Effects:* Initializes *outer\_* with `std::move(outer)` and *parent\_*
 with `addressof(parent)`; then calls *`satisfy`*`()`.
 ``` cpp
 constexpr iterator(iterator<!Const> i)
   requires Const &&
-           convertible_to<iterator_t<V>, iterator_t<Base>> &&
-           convertible_to<iterator_t<InnerRng>,
-                          iterator_t<range_reference_t<Base>>>;
 ```
 *Effects:* Initializes *outer\_* with `std::move(i.`*`outer_`*`)`,
 *inner\_* with `std::move(i.`*`inner_`*`)`, and *parent\_* with
 `i.`*`parent_`*.
 ``` cpp
-constexpr iterator_t<Base> operator->() const
-  requires has-arrow<iterator_t<Base>> && copyable<iterator_t<Base>>;
 ```
-*Effects:* Equivalent to `return `*`inner_`*`;`
 ``` cpp
 constexpr iterator& operator++();
 ```
 Let *`inner-range`* be:
-- If *ref-is-glvalue* is `true`, `*`*`outer_`*.
-- Otherwise, *`parent_`*`->`*`inner_`*.
 *Effects:* Equivalent to:
 ``` cpp
-auto&& inner_rng = inner-range;
-if (++inner_ == ranges::end(inner_rng)) {
-  ++outer_;
   satisfy();
 }
 return *this;
 ```
@@ -305,14 +339,14 @@ constexpr iterator& operator--()
 *Effects:* Equivalent to:
 ``` cpp
 if (outer_ == ranges::end(parent_->base_))
-  inner_ = ranges::end(*--outer_);
-while (inner_ == ranges::begin(*outer_))
-  inner_ = ranges::end(*--outer_);
---inner_;
 return *this;
 ```
 ``` cpp
 constexpr iterator operator--(int)
@@ -329,48 +363,49 @@ auto tmp = *this;
 return tmp;
 ```
 ``` cpp
 friend constexpr bool operator==(const iterator& x, const iterator& y)
-  requires ref-is-glvalue && equality_comparable<iterator_t<Base>> &&
            equality_comparable<iterator_t<range_reference_t<Base>>>;
 ```
 *Effects:* Equivalent to:
 `return x.`*`outer_`*` == y.`*`outer_`*` && x.`*`inner_`*` == y.`*`inner_`*`;`
 ``` cpp
 friend constexpr void iter_swap(const iterator& x, const iterator& y)
-  noexcept(noexcept(ranges::iter_swap(x.inner_, y.inner_)));
 ```
 *Effects:* Equivalent to:
-`return ranges::iter_swap(x.`*`inner_`*`, y.`*`inner_`*`);`
 #### Class template `join_view::sentinel` <a id="range.join.sentinel">[[range.join.sentinel]]</a>
 ``` cpp
 namespace std::ranges {
   template<input_range V>
-    requires view<V> && input_range<range_reference_t<V>> &&
-             (is_reference_v<range_reference_t<V>> ||
-              view<range_value_t<V>>)
   template<bool Const>
   struct join_view<V>::sentinel {
   private:
-    using Parent = // exposition only
-      conditional_t<Const, const join_view, join_view>;
-    using Base   = conditional_t<Const, const V, V>;    // exposition only
     sentinel_t<Base> end_ = sentinel_t<Base>();         // exposition only
   public:
     sentinel() = default;
     constexpr explicit sentinel(Parent& parent);
     constexpr sentinel(sentinel<!Const> s)
       requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
- friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
   };
 }
 ```
 ``` cpp
@@ -385,10 +420,12 @@ constexpr sentinel(sentinel<!Const> s)
 ```
 *Effects:* Initializes *end\_* with `std::move(s.`*`end_`*`)`.
 ``` cpp
-friend constexpr bool operator==(const iterator<Const>& x, const sentinel& y);
 ```
-*Effects:* Equivalent to: `return x.`*`outer_`*` == y.`*`end_`*`;`

 ### Join view <a id="range.join">[[range.join]]</a>
 #### Overview <a id="range.join.overview">[[range.join.overview]]</a>
+`join_view` flattens a view of ranges into a view.
 The name `views::join` denotes a range adaptor object
 [[range.adaptor.object]]. Given a subexpression `E`, the expression
+`views::join(E)` is expression-equivalent to
+`join_view<views::all_t<decltype((E))>>{E}`.
 [*Example 1*:
 ``` cpp
 vector<string> ss{"hello", " ", "world", "!"};
+for (char ch : ss | views::join)
+  cout << ch;                                   // prints hello world!
 ```
 — *end example*]
 #### Class template `join_view` <a id="range.join.view">[[range.join.view]]</a>
 ``` cpp
 namespace std::ranges {
   template<input_range V>
+    requires view<V> && input_range<range_reference_t<V>>
   class join_view : public view_interface<join_view<V>> {
   private:
+    using InnerRng = range_reference_t<V>;                  // exposition only
     // [range.join.iterator], class template join_view::iterator
     template<bool Const>
       struct iterator;                                      // exposition only
     // [range.join.sentinel], class template join_view::sentinel
     template<bool Const>
       struct sentinel;                                      // exposition only
     V base_ = V();                                          // exposition only
+    non-propagating-cache<iterator_t<V>> outer_;            // exposition only, present only
+                                                            // when !forward_range<V>
+    non-propagating-cache<remove_cv_t<InnerRng>> inner_;    // exposition only, present only
+                                                            // if is_reference_v<InnerRng> is false
   public:
+    join_view() requires default_initializable<V> = default;
     constexpr explicit join_view(V base);
     constexpr V base() const & requires copy_constructible<V> { return base_; }
     constexpr V base() && { return std::move(base_); }
     constexpr auto begin() {
+      if constexpr (forward_range<V>) {
         constexpr bool use_const = simple-view<V> &&
+ is_reference_v<InnerRng>;
         return iterator<use_const>{*this, ranges::begin(base_)};
+      } else {
+        outer_ = ranges::begin(base_);
+        return iterator<false>{*this};
+      }
     }
     constexpr auto begin() const
+ requires forward_range<const V> &&
+ is_reference_v<range_reference_t<const V>> &&
+               input_range<range_reference_t<const V>>
+ { return iterator<true>{*this, ranges::begin(base_)}; }
     constexpr auto end() {
       if constexpr (forward_range<V> &&
                     is_reference_v<InnerRng> && forward_range<InnerRng> &&
                     common_range<V> && common_range<InnerRng>)
       else
         return sentinel<simple-view<V>>{*this};
     }
     constexpr auto end() const
+ requires forward_range<const V> &&
                is_reference_v<range_reference_t<const V>> &&
+               input_range<range_reference_t<const V>> {
+      if constexpr (forward_range<range_reference_t<const V>> &&
                     common_range<const V> &&
                     common_range<range_reference_t<const V>>)
         return iterator<true>{*this, ranges::end(base_)};
       else
         return sentinel<true>{*this};
 #### Class template `join_view::iterator` <a id="range.join.iterator">[[range.join.iterator]]</a>
 ``` cpp
 namespace std::ranges {
   template<input_range V>
+    requires view<V> && input_range<range_reference_t<V>>
   template<bool Const>
   struct join_view<V>::iterator {
   private:
+    using Parent = maybe-const<Const, join_view>;            // exposition only
+    using Base = maybe-const<Const, V>;                    // exposition only
+    using OuterIter = iterator_t<Base>; // exposition only
+    using InnerIter = iterator_t<range_reference_t<Base>>;      // exposition only
     static constexpr bool ref-is-glvalue =                      // exposition only
       is_reference_v<range_reference_t<Base>>;
+ OuterIter outer_ = OuterIter(); // exposition only, present only
+ // if Base models forward_range
+    optional<InnerIter> inner_;                                 // exposition only
     Parent* parent_  = nullptr;                                 // exposition only
     constexpr void satisfy();                                   // exposition only
+    constexpr OuterIter& outer();                               // exposition only
+    constexpr const OuterIter& outer() const;                   // exposition only
+    constexpr iterator(Parent& parent, OuterIter outer)
+      requires forward_range<Base>;                             // exposition only
+    constexpr explicit iterator(Parent& parent)
+      requires (!forward_range<Base>);                          // exposition only
   public:
     using iterator_concept  = see below;
+    using iterator_category = see below;                        // not always present
     using value_type        = range_value_t<range_reference_t<Base>>;
     using difference_type   = see below;
     iterator() = default;
     constexpr iterator(iterator<!Const> i)
       requires Const &&
+               convertible_to<iterator_t<V>, OuterIter> &&
+               convertible_to<iterator_t<InnerRng>, InnerIter>;
+    constexpr decltype(auto) operator*() const { return **inner_; }
+    constexpr InnerIter operator->() const
+      requires has-arrow<InnerIter> && copyable<InnerIter>;
     constexpr iterator& operator++();
     constexpr void operator++(int);
     constexpr iterator operator++(int)
       requires ref-is-glvalue && forward_range<Base> &&
       requires ref-is-glvalue && bidirectional_range<Base> &&
                bidirectional_range<range_reference_t<Base>> &&
                common_range<range_reference_t<Base>>;
     friend constexpr bool operator==(const iterator& x, const iterator& y)
+      requires ref-is-glvalue && forward_range<Base> &&
                equality_comparable<iterator_t<range_reference_t<Base>>>;
     friend constexpr decltype(auto) iter_move(const iterator& i)
+    noexcept(noexcept(ranges::iter_move(*i.inner_))) {
+      return ranges::iter_move(*i.inner_);
     }
     friend constexpr void iter_swap(const iterator& x, const iterator& y)
+      noexcept(noexcept(ranges::iter_swap(*x.inner_, *y.inner_)))
+      requires indirectly_swappable<InnerIter>;
   };
 }
 ```
 `iterator::iterator_concept` is defined as follows:
+- If *`ref-is-glvalue`* is `true`, *`Base`* models
+  `bidirectional_range`, and `range_reference_t<Base>` models both
+  `bidirectional_range` and `common_range`, then `iterator_concept`
+  denotes `bidirectional_iterator_tag`.
 - Otherwise, if *`ref-is-glvalue`* is `true` and *`Base`* and
   `range_reference_t<Base>` each model , then `iterator_concept` denotes
   `forward_iterator_tag`.
 - Otherwise, `iterator_concept` denotes `input_iterator_tag`.
+The member *typedef-name* `iterator_category` is defined if and only if
+*`ref-is-glvalue`* is `true`, *`Base`* models `forward_range`, and
+`range_reference_t<Base>` models `forward_range`. In that case,
 `iterator::iterator_category` is defined as follows:
 - Let *OUTERC* denote
   `iterator_traits<iterator_t<Base>>::iterator_category`, and let
   *INNERC* denote
   `iterator_traits<iterator_t<range_reference_t<Base>>>::iterator_category`.
+- If *OUTERC* and *INNERC* each model
+  `derived_from<bidirectional_iterator_tag>` and
+  `range_reference_t<Base>` models `common_range`, `iterator_category`
   denotes `bidirectional_iterator_tag`.
 - Otherwise, if *OUTERC* and *INNERC* each model
+  `derived_from<forward_iterator_tag>`, `iterator_category` denotes
+  `forward_iterator_tag`.
+- Otherwise, `iterator_category` denotes `input_iterator_tag`.
 `iterator::difference_type` denotes the type:
 ``` cpp
 common_type_t<
 `join_view` iterators use the *`satisfy`* function to skip over empty
 inner ranges.
 ``` cpp
+constexpr OuterIter& outer();
+constexpr const OuterIter& outer() const;
+```
+*Returns:* *outer\_* if *Base* models `forward_range`; otherwise,
+`*`*`parent_`*`->`*`outer_`*.
+``` cpp
+constexpr void satisfy();
 ```
 *Effects:* Equivalent to:
 ``` cpp
+auto update_inner = [this](const iterator_t<Base>& x) -> auto&& {
+  if constexpr (ref-is-glvalue) // *x is a reference
+    return *x;
   else
+    return parent_->inner_.emplace-deref(x);
 };
+for (; outer() != ranges::end(parent_->base_); ++outer()) {
+  auto&& inner = update_inner(outer());
   inner_ = ranges::begin(inner);
+  if (*inner_ != ranges::end(inner))
     return;
 }
 if constexpr (ref-is-glvalue)
+  inner_.reset();
 ```
 ``` cpp
+constexpr iterator(Parent& parent, OuterIter outer)
+  requires forward_range<Base>;
 ```
 *Effects:* Initializes *outer\_* with `std::move(outer)` and *parent\_*
 with `addressof(parent)`; then calls *`satisfy`*`()`.
+``` cpp
+constexpr explicit iterator(Parent& parent)
+  requires (!forward_range<Base>);
+```
+*Effects:* Initializes *parent\_* with `addressof(parent)`; then calls
+*`satisfy`*`()`.
 ``` cpp
 constexpr iterator(iterator<!Const> i)
   requires Const &&
+           convertible_to<iterator_t<V>, OuterIter> &&
+           convertible_to<iterator_t<InnerRng>, InnerIter>;
 ```
 *Effects:* Initializes *outer\_* with `std::move(i.`*`outer_`*`)`,
 *inner\_* with `std::move(i.`*`inner_`*`)`, and *parent\_* with
 `i.`*`parent_`*.
+[*Note 1*: `Const` can only be `true` when *Base* models
+`forward_range`. — *end note*]
 ``` cpp
+constexpr InnerIter operator->() const
+  requires has-arrow<InnerIter> && copyable<InnerIter>;
 ```
+*Effects:* Equivalent to: `return *`*`inner_`*`;`
 ``` cpp
 constexpr iterator& operator++();
 ```
 Let *`inner-range`* be:
+- If *ref-is-glvalue* is `true`, `*`*`outer`*`()`.
+- Otherwise, `*`*`parent_`*`->`*`inner_`*.
 *Effects:* Equivalent to:
 ``` cpp
+if (++*inner_ == ranges::end(as-lvalue(inner-range))) {
+ ++outer();
   satisfy();
 }
 return *this;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 if (outer_ == ranges::end(parent_->base_))
+  inner_ = ranges::end(as-lvalue(*--outer_));
+while (*inner_ == ranges::begin(as-lvalue(*outer_)))
+ *inner_ = ranges::end(as-lvalue(*--outer_));
+--*inner_;
 return *this;
 ```
 ``` cpp
 constexpr iterator operator--(int)
 return tmp;
 ```
 ``` cpp
 friend constexpr bool operator==(const iterator& x, const iterator& y)
+  requires ref-is-glvalue && forward_range<Base> &&
            equality_comparable<iterator_t<range_reference_t<Base>>>;
 ```
 *Effects:* Equivalent to:
 `return x.`*`outer_`*` == y.`*`outer_`*` && x.`*`inner_`*` == y.`*`inner_`*`;`
 ``` cpp
 friend constexpr void iter_swap(const iterator& x, const iterator& y)
+  noexcept(noexcept(ranges::iter_swap(*x.inner_, *y.inner_)))
+  requires indirectly_swappable<InnerIter>;
 ```
 *Effects:* Equivalent to:
+`return ranges::iter_swap(*x.`*`inner_`*`, *y.`*`inner_`*`);`
 #### Class template `join_view::sentinel` <a id="range.join.sentinel">[[range.join.sentinel]]</a>
 ``` cpp
 namespace std::ranges {
   template<input_range V>
+    requires view<V> && input_range<range_reference_t<V>>
   template<bool Const>
   struct join_view<V>::sentinel {
   private:
+    using Parent = maybe-const<Const, join_view>;       // exposition only
+    using Base = maybe-const<Const, V>;                 // exposition only
     sentinel_t<Base> end_ = sentinel_t<Base>();         // exposition only
   public:
     sentinel() = default;
     constexpr explicit sentinel(Parent& parent);
     constexpr sentinel(sentinel<!Const> s)
       requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+ template<bool OtherConst>
+      requires sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+    friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
   };
 }
 ```
 ``` cpp
 ```
 *Effects:* Initializes *end\_* with `std::move(s.`*`end_`*`)`.
 ``` cpp
+template<bool OtherConst>
+  requires sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
 ```
+*Effects:* Equivalent to: `return x.`*`outer`*`() == y.`*`end_`*`;`

Diff to HTML by rtfpessoa