CTAD_alias_examples.html

<!DOCTYPE html>
<html><head>
<meta http-equiv="content-type" content="text/html; charset=utf-8">
 <link href="http://alexgorbatchev.com/pub/sh/current/styles/shThemeDefault.css" rel="stylesheet" type="text/css" />
<script src="https://cdn.rawgit.com/google/code-prettify/master/loader/run_prettify.js"></script>
<script src="http://alexgorbatchev.com/pub/sh/current/scripts/shCore.js" type="text/javascript"></script>
<!--<script src="http://alexgorbatchev.com/pub/sh/current/scripts/shAutoloader.js" type="text/javascript"></script>-->
<script src='http://alexgorbatchev.com/pub/sh/current/scripts/shBrushCpp.js' type='text/javascript'></script>
    <style>
.syntaxhighlighter div.toolbar span a.toolbar_item{
   display: none !important;
} 
body .syntaxhighlighter .line {
    white-space: pre !important;
}

    </style>

<title>CTAD for alias templates algorithm examples</title>
</head>

<body>
<p>Mike Spertus, Symantec<br>
<a href="mailto:mike_spertus@symantec.com">mike_spertus@symantec.com</a><br>
</p>
<h1>CTAD for alias templates algorithm examples</h1>
<h1>Algorithm Overview</h1>
For deriving deduction guides for the alias templates from guides in the class, we use the following approach (for which we are very grateful for the invaluable assistance of Richard Smith):
<ol><li>Deduce template parameters for the deduction guide by deducing the right hand side of
    the deduction guide from the alias template. We do not require that this deduces all the template
    parameters as nondeducible contexts may of course occur in general</li>
    <li>Substitute any deductions made back into the deduction guides</li>
    <li>Derive the corresponding deduction guide for the alias template by 
    deducing the alias from the result type. Note that a constraint may be necessary
    as whether and how to deduce the alias from the result type may depend on the
    actual argument types.</li></ol>
<h1>Conceptual description and example</h1>
<p>This section gives Richard's nice discussion on how to think about the algorithm.</p>
Perhaps a nice way to think about the algorithm here is that we're applying (bidirectional) type unification between the produced type of the deduction guide and the alias template. Specifically, we're attempting to find a set of equalities between type expressions involving deduction guide template parameters and type expressions involving alias template parameters. Example: 

<blockquote><pre class="brush:cpp">template&lt;typename T, typename U, typename V&gt; struct Z {
  Z(typename T:::template R&lt;U&gt;, ...);
}; 
struct Q { template&lt;typename U&gt; struct R {}; };
template&lt;typename T, typename U, typename V&gt;
  Z(typename T:::template R&lt;U&gt;, V&amp;) -> Z&lt;T, U, V*&gt;
template&lt;typename X, typename Y&gt; using W = Z&lt;Q, X*, Y&gt;;

W w = {Q::X&lt;int*&gt;(), w};</pre></blockquote>

We take the

<blockquote><pre class="brush:cpp">template&lt;typename T, typename U, typename V&gt;
  Z(typename T:::template R&lt;U&gt;, V&amp;) -> Z&lt;T, U, V*&gt;</pre></blockquote>

deduction guide and we want to rewrite it as

<blockquote><pre class="brush:cpp">template&lt;typename T, typename U, typename V, typename X, typename Y&gt;
  W(typename T:::template R&lt;U&gt;, V&amp;) -> W&lt;X, Y&gt;;</pre></blockquote>

subject to some equivalences between <code>T</code>, <code>U</code>, <code>V</code>, <code>X</code>, <code>Y</code>. So we attempt to unify <code>Z&lt;Q, X*, Y&gt;</code> with <code>Z&lt;T, U, V*&gt;</code>. This gives:
<blockquote>
<code>T = Q<br>
U = X<br>
V = ???<br>
X = ???<br>
Y = V*</code></blockquote>

[We only care about cases where one side can be reduced to a template parameter. The other cases are:<ul>
 <li> both sides are non-deduced contexts: we can't deduce anything here (eg, <code>std::decay_t&lt;T&gt; == std::decay_t&lt;U&gt;</code>)</li>
 <li> one side is non-deduced and the other side is a non-trivial type/non-type expression: we can't deduce anything here (eg, <code>T* = std::decay_t&lt;U&gt;</code>)</li>
 <li>both sides are non-trivial type/non-type expressions and can't both be reduced: deduction fails (eg, <code>T* = U&amp;</code>)</li></ul><br>
]

<p>Now, complete the unification:<ul>
 <li>for each parameter in the deduction guide whose value is expressed in terms of a parameter of the alias template, substitute that away everywhere (including in the RHS of substitutions<a href="#fn1">*</a>):

<blockquote><pre class="brush:cpp">template&lt;typename V, typename X, typename Y&gt;
  W(Q:::R&lt;X&gt;, V&amp;) -> W&lt;X, Y&gt;;</pre></blockquote></li>
 <li> and likewise for each parameter in the alias template whose value is expressed in terms of a parameter of the deduction guide:

<blockquote><pre class="brush:cpp">template&lt;typename V, typename X&gt;
  W(Q:::R&lt;X&gt;, V&amp;) -> W&lt;X, V*&gt;;</pre></blockquote>

... and I believe that's the deduction guide we're looking for.</li>


</ul>
    <a name="fn1">* In the actual algorithm we get -- essentially -- this effect by doing the first round of substitutions before we do the deduction in the opposite direction.</a>
<h1>Additional examples</h1>

<h2>Fixing an argument</h2>
    <blockquote><pre class="brush:cpp">template&lt;class T&gt; using P = pair&lt;int, T&gt;;</pre></blockquote>
Naively using the deduction guides from pair is not ideal because they
    cannot necessarily deduce objects of type <tt>P</tt> even
    from arguments that should obviously work, like <tt>P({}, 0)</tt>. However,
    let us apply the above procedure. The relevant deduction guide is
<blockquote><pre class="brush:cpp">template&lt;class A, class B&gt; pair(A, B) -&gt; pair&lt;A, B&gt;</pre></blockquote>
Deducing <code>(A, B)</code> from <code>(int, T)</code> yield <code>int</code> for <code>A</code>
    and <code>T</code> for <code>B</code>. Now substitute back into the deduction guide to get
    a new deduction guide
<blockquote><pre class="brush:cpp">template&lt;class T&gt; pair(int, T) -&gt; pair&lt;int, T&gt;;</pre></blockquote>
Deducing the template arguments for the alias template from this gives us the following deduction guide for the alias template 
<blockquote><pre class="brush:cpp">template&lt;class T&gt; P(int, T) -&gt; P&lt;T&gt;;</pre></blockquote>
<h2>Renaming</h2>
In the following example, the programmer just wants to give a class template a shorter name
without changing behavior
<blockquote><pre class="brush:cpp">template&lt;class T&gt; class VeryLongNameXXXXX { /* ... */ };
template&lt;class T&gt; class VeryLongNameXXXXX(T) -> VeryLongNameXXXXX&lt;decay_t&lt;T&gt;&gt;;

// Alias that programmer expects to be the same as original type
template&lt;class T&gt; using MyAbbrev = VeryLongNameXXXXXX&lt;T&gt;;</pre></blockquote>
In this case, plugging in <code>(A)</code> for the nondeducible context <code>(decay_t&lt;T&gt;)</code> does not deduce anything, so the deduction guide remains the same. Deducing the template arguments
for the (identical!) alias template is easy, yielding the desired deduction guide for the alias template.
<blockquote><pre class="brush:cpp">template&lt;class T&gt; class MyAbbrev(T) -> MyAbbrev&lt;decay_t&lt;T&gt;&gt;;</pre></blockquote>
<script type="text/javascript">
	SyntaxHighlighter.defaults['gutter'] = false;
     SyntaxHighlighter.all()
</script>
	</body></html>