Merge pull request #108 from iris-cpp/optimize-rvariant

Fix type-changing bugs

Author: saki7

doc/rvariant.adoc

@@ -795,13 +795,13 @@ where `_I_` is the zero-based index of `T` in [.underline]#`{unwrap_recursive_t}
 +
 *_Returns:_* [.underline]#Let `o` denote# a reference to the new contained value. [.underline]#Returns `{unwrap_recursive}(o)`.#
 +
-*_Remarks:_* [.underline]#If `T~_I_~` is a specialization of `{recursive_wrapper}` or `{recursive_wrapper_alloca}`, this function is permitted to construct an intermediate variable `tmp` as if by passing `std::forward<Args>(args)\...` to ``T~_I_~``'s constructor. Then `rvariant` direct-non-list-initializes the contained value of `T~_I_~` with the argument `std::move(tmp)`. (_Note:_ This allows optimization where `rvariant` can be assumed to become never valueless on certain cases.)#
+*_Remarks:_* [.underline]#If `T~_I_~` is a specialization of `{recursive_wrapper}` or `{recursive_wrapper_alloca}`, this function is permitted to construct an intermediate variable `tmp` as if by passing `std::forward<Args>(args)\...` to ``T~_I_~``'s constructor. Then `rvariant` direct-non-list-initializes the contained value of `T~_I_~` with the argument `std::move(tmp)`. Additionally, if `*this` holds a value of a specialization of `{recursive_wrapper}` or `{recursive_wrapper_alloca}`, this function is permitted to destroy that value after constructing such an intermediate variable, for any `T~_I_~`. (_Note:_ This allows optimization where `rvariant` can be assumed to become never valueless on certain cases.)#
 
 * [.candidate]#4)# Equivalent to the `std::variant` counterpart, ^https://eel.is/c++draft/variant.mod[[spec\]]^ except:
 +
 *_Returns:_* [.underline]#Let `o` denote# a reference to the new contained value. [.underline]#Returns `{unwrap_recursive}(o)`.#
 +
-*_Remarks:_* [.underline]#If `T~_I_~` is a specialization of `{recursive_wrapper}` or `{recursive_wrapper_alloca}`, this function is permitted to construct an intermediate variable `tmp` as if by passing `il, std::forward<Args>(args)\...` to ``T~_I_~``'s constructor. Then `rvariant` direct-non-list-initializes the contained value of `T~_I_~` with the argument `std::move(tmp)`. (_Note:_ This allows optimization where `rvariant` can be assumed to become never valueless on certain cases.)#
+*_Remarks:_* [.underline]#If `T~_I_~` is a specialization of `{recursive_wrapper}` or `{recursive_wrapper_alloca}`, this function is permitted to construct an intermediate variable `tmp` as if by passing `il, std::forward<Args>(args)\...` to ``T~_I_~``'s constructor. Then `rvariant` direct-non-list-initializes the contained value of `T~_I_~` with the argument `std::move(tmp)`. Additionally, if `*this` holds a value of a specialization of `{recursive_wrapper}` or `{recursive_wrapper_alloca}`, this function is permitted to destroy that value after constructing such an intermediate variable, for any `T~_I_~`. (_Note:_ This allows optimization where `rvariant` can be assumed to become never valueless on certain cases.)#
 
 [[rvariant.status]]
 === Value status [.slug]##<<rvariant.status,[rvariant.status]>>##
@@ -1451,6 +1451,29 @@ _Note 2:_ It is currently unknown whether the recursive instantiation scenario d
 *_Effects:_* Equivalent to the `std::indirect` counterpart. ^link:pass:[https://eel.is/c++draft/indirect.ctor#lib:indirect,constructor______][[spec\]]^
 
 
+[[rvariant.recursive.relops]]
+=== Comparisons
+Effectively overrides only the ones listed below; rest are the same as `std::indirect` counterparts. ^https://eel.is/c++draft/indirect.relops[[spec\]]^ ^https://eel.is/c++draft/indirect.comp.with.t[[spec\]]^
+
+[,cpp,subs="+macros,+attributes"]
+----
+template<class T, class A, class U, class AA>
+constexpr bool operator==(recursive_wrapper_alloca<T, A> const& lhs, recursive_wrapper_alloca<U, AA> const& rhs)
+  pass:quotes[[.underline\]#/* no noexcept-specifier */#];pass:quotes[[.candidate\]#// 1#]
+
+template<class T, class A, class U>
+constexpr bool operator==(recursive_wrapper_alloca<T, A> const& lhs, U const& rhs)
+  pass:quotes[[.underline\]#/* no noexcept-specifier */#];pass:quotes[[.candidate\]#// 2#]
+----
+
+[.candidates]
+* [.candidate]#1-2)# Equivalent to the `std::indirect` counterparts, except that [.underline]#they have no _noexcept-specifier_#.
++
+*_Note:_* The _noexcept-specifier_ of the `std::indirect` counterparts depends on the comparison of `T`. Since an exception specification is needed whenever the function is selected by overload resolution, such a _noexcept-specifier_ makes the comparison of a recursive type depend on itself; for example, if a class `X` has a defaulted `operator==` and contains `rvariant<..., recursive_wrapper<X>>`, checking the constraints of ``rvariant``'s `operator==` requires the comparison of `X`, which in turn requires checking the same constraints. Some compilers (e.g. GCC) reject such a program. The _noexcept-specifier_ is omitted to break this recursion.
+
+WARNING: [.underline]#Recursive types must implement their own *non-defaulted* `operatorpass:quotes[&lt;=&gt;]`.# For a class `X` that contains `rvariant<..., recursive_wrapper<X>>`, a defaulted `operatorpass:quotes[&lt;=&gt;]` of `X` requires the result of ``rvariant``'s `operatorpass:quotes[&lt;=&gt;]`, whose constraints and return type in turn require the result of comparing `X` through `recursive_wrapper<X>`. This leads to infinite recursive instantiation, regardless of whether the return type of the defaulted `operatorpass:quotes[&lt;=&gt;]` is `auto` or a specific comparison category type. This is a limitation of the language itself; standard containers have a similar limitation (e.g. a class `X` that contains `std::vector<X>` cannot have a defaulted `operatorpass:quotes[&lt;=&gt;]` whose return type is `auto`).
+
+
 [[rvariant.recursive.helper]]
 == `recursive_wrapper` helper utilities [.slug]##<<rvariant.recursive.helper,[rvariant.recursive.helper]>>##
 

doc/rvariant.html

@@ -902,6 +902,7 @@ <h1>rvariant<a href="https://github.com/iris-cpp/iris" target="_blank" rel="noop
 <ul class="sectlevel2">
 <li><a href="#rvariant.recursive.general">General <span class="slug">[rvariant.recursive.general]</span></a></li>
 <li><a href="#rvariant.recursive.ctor">Constructors</a></li>
+<li><a href="#rvariant.recursive.relops">Comparisons</a></li>
 </ul>
 </li>
 <li><a href="#rvariant.recursive.helper"><code>recursive_wrapper</code> helper utilities <span class="slug">[rvariant.recursive.helper]</span></a></li>
@@ -1939,7 +1940,7 @@ <h3 id="rvariant.mod"><a class="anchor" href="#rvariant.mod"></a>Modifiers <span
 <p><strong><em>Returns:</em></strong> <span class="underline">Let <code>o</code> denote</span> a reference to the new contained value. <span class="underline">Returns <code><a href="#rvariant.recursive.helper">unwrap_recursive</a>(o)</code>.</span></p>
 </div>
 <div class="paragraph">
-<p><strong><em>Remarks:</em></strong> <span class="underline">If <code>T<sub><em>I</em></sub></code> is a specialization of <code><a href="#rvariant.recursive">recursive_wrapper</a></code> or <code><a href="#rvariant.recursive">recursive_wrapper_alloca</a></code>, this function is permitted to construct an intermediate variable <code>tmp</code> as if by passing <code>std::forward&lt;Args&gt;(args)...</code> to <code>T<sub><em>I</em></sub></code>'s constructor. Then <code>rvariant</code> direct-non-list-initializes the contained value of <code>T<sub><em>I</em></sub></code> with the argument <code>std::move(tmp)</code>. (<em>Note:</em> This allows optimization where <code>rvariant</code> can be assumed to become never valueless on certain cases.)</span></p>
+<p><strong><em>Remarks:</em></strong> <span class="underline">If <code>T<sub><em>I</em></sub></code> is a specialization of <code><a href="#rvariant.recursive">recursive_wrapper</a></code> or <code><a href="#rvariant.recursive">recursive_wrapper_alloca</a></code>, this function is permitted to construct an intermediate variable <code>tmp</code> as if by passing <code>std::forward&lt;Args&gt;(args)...</code> to <code>T<sub><em>I</em></sub></code>'s constructor. Then <code>rvariant</code> direct-non-list-initializes the contained value of <code>T<sub><em>I</em></sub></code> with the argument <code>std::move(tmp)</code>. Additionally, if <code>*this</code> holds a value of a specialization of <code><a href="#rvariant.recursive">recursive_wrapper</a></code> or <code><a href="#rvariant.recursive">recursive_wrapper_alloca</a></code>, this function is permitted to destroy that value after constructing such an intermediate variable, for any <code>T<sub><em>I</em></sub></code>. (<em>Note:</em> This allows optimization where <code>rvariant</code> can be assumed to become never valueless on certain cases.)</span></p>
 </div>
 </li>
 <li>
@@ -1948,7 +1949,7 @@ <h3 id="rvariant.mod"><a class="anchor" href="#rvariant.mod"></a>Modifiers <span
 <p><strong><em>Returns:</em></strong> <span class="underline">Let <code>o</code> denote</span> a reference to the new contained value. <span class="underline">Returns <code><a href="#rvariant.recursive.helper">unwrap_recursive</a>(o)</code>.</span></p>
 </div>
 <div class="paragraph">
-<p><strong><em>Remarks:</em></strong> <span class="underline">If <code>T<sub><em>I</em></sub></code> is a specialization of <code><a href="#rvariant.recursive">recursive_wrapper</a></code> or <code><a href="#rvariant.recursive">recursive_wrapper_alloca</a></code>, this function is permitted to construct an intermediate variable <code>tmp</code> as if by passing <code>il, std::forward&lt;Args&gt;(args)...</code> to <code>T<sub><em>I</em></sub></code>'s constructor. Then <code>rvariant</code> direct-non-list-initializes the contained value of <code>T<sub><em>I</em></sub></code> with the argument <code>std::move(tmp)</code>. (<em>Note:</em> This allows optimization where <code>rvariant</code> can be assumed to become never valueless on certain cases.)</span></p>
+<p><strong><em>Remarks:</em></strong> <span class="underline">If <code>T<sub><em>I</em></sub></code> is a specialization of <code><a href="#rvariant.recursive">recursive_wrapper</a></code> or <code><a href="#rvariant.recursive">recursive_wrapper_alloca</a></code>, this function is permitted to construct an intermediate variable <code>tmp</code> as if by passing <code>il, std::forward&lt;Args&gt;(args)...</code> to <code>T<sub><em>I</em></sub></code>'s constructor. Then <code>rvariant</code> direct-non-list-initializes the contained value of <code>T<sub><em>I</em></sub></code> with the argument <code>std::move(tmp)</code>. Additionally, if <code>*this</code> holds a value of a specialization of <code><a href="#rvariant.recursive">recursive_wrapper</a></code> or <code><a href="#rvariant.recursive">recursive_wrapper_alloca</a></code>, this function is permitted to destroy that value after constructing such an intermediate variable, for any <code>T<sub><em>I</em></sub></code>. (<em>Note:</em> This allows optimization where <code>rvariant</code> can be assumed to become never valueless on certain cases.)</span></p>
 </div>
 </li>
 </ul>
@@ -2820,6 +2821,45 @@ <h3 id="rvariant.recursive.ctor"><a class="anchor" href="#rvariant.recursive.cto
 </ul>
 </div>
 </div>
+<div class="sect2">
+<h3 id="rvariant.recursive.relops"><a class="anchor" href="#rvariant.recursive.relops"></a>Comparisons</h3>
+<div class="paragraph">
+<p>Effectively overrides only the ones listed below; rest are the same as <code>std::indirect</code> counterparts. <sup><a href="https://eel.is/cdraft/indirect.relops[[spec\]]^ ^https://eel.is/cdraft/indirect.comp.with.t">[spec]</a></sup></p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="highlightjs highlight"><code class="language-cpp hljs" data-lang="cpp">template&lt;class T, class A, class U, class AA&gt;
+constexpr bool operator==(recursive_wrapper_alloca&lt;T, A&gt; const&amp; lhs, recursive_wrapper_alloca&lt;U, AA&gt; const&amp; rhs)
+  <span class="underline">/* no noexcept-specifier */</span>;<span class="candidate">// 1</span>
+
+template&lt;class T, class A, class U&gt;
+constexpr bool operator==(recursive_wrapper_alloca&lt;T, A&gt; const&amp; lhs, U const&amp; rhs)
+  <span class="underline">/* no noexcept-specifier */</span>;<span class="candidate">// 2</span></code></pre>
+</div>
+</div>
+<div class="ulist candidates">
+<ul>
+<li>
+<p><span class="candidate">1-2)</span> Equivalent to the <code>std::indirect</code> counterparts, except that <span class="underline">they have no <em>noexcept-specifier</em></span>.</p>
+<div class="paragraph">
+<p><strong><em>Note:</em></strong> The <em>noexcept-specifier</em> of the <code>std::indirect</code> counterparts depends on the comparison of <code>T</code>. Since an exception specification is needed whenever the function is selected by overload resolution, such a <em>noexcept-specifier</em> makes the comparison of a recursive type depend on itself; for example, if a class <code>X</code> has a defaulted <code>operator==</code> and contains <code>rvariant&lt;&#8230;&#8203;, recursive_wrapper&lt;X&gt;&gt;</code>, checking the constraints of <code>rvariant</code>'s <code>operator==</code> requires the comparison of <code>X</code>, which in turn requires checking the same constraints. Some compilers (e.g. GCC) reject such a program. The <em>noexcept-specifier</em> is omitted to break this recursion.</p>
+</div>
+</li>
+</ul>
+</div>
+<div class="admonitionblock warning">
+<table>
+<tr>
+<td class="icon">
+<i class="fa icon-warning" title="Warning"></i>
+</td>
+<td class="content">
+<span class="underline">Recursive types must implement their own <strong>non-defaulted</strong> <code>operator&lt;=&gt;</code>.</span> For a class <code>X</code> that contains <code>rvariant&lt;&#8230;&#8203;, recursive_wrapper&lt;X&gt;&gt;</code>, a defaulted <code>operator&lt;=&gt;</code> of <code>X</code> requires the result of <code>rvariant</code>'s <code>operator&lt;=&gt;</code>, whose constraints and return type in turn require the result of comparing <code>X</code> through <code>recursive_wrapper&lt;X&gt;</code>. This leads to infinite recursive instantiation, regardless of whether the return type of the defaulted <code>operator&lt;=&gt;</code> is <code>auto</code> or a specific comparison category type. This is a limitation of the language itself; standard containers have a similar limitation (e.g. a class <code>X</code> that contains <code>std::vector&lt;X&gt;</code> cannot have a defaulted <code>operator&lt;=&gt;</code> whose return type is <code>auto</code>).
+</td>
+</tr>
+</table>
+</div>
+</div>
 </div>
 </div>
 <div class="sect1">