forked from boostorg/mp11
Remove unnecessary C++14 use from examples
This commit is contained in:
Peter Dimov
@@ -304,8 +304,8 @@
|
||||
Let's suppose that we have written a metafunction <code class="computeroutput"><span class="identifier">result</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span>
|
||||
<span class="identifier">U</span><span class="special">></span></code>:
|
||||
</p>
|
||||
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> <span class="keyword">using</span> <span class="identifier">promote</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">common_type_t</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>;</span>
|
||||
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> <span class="keyword">using</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">common_type_t</span><span class="special"><</span><span class="identifier">promote</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="identifier">promote</span><span class="special"><</span><span class="identifier">U</span><span class="special">>>;</span>
|
||||
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> <span class="keyword">using</span> <span class="identifier">promote</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span><span class="special">;</span>
|
||||
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> <span class="keyword">using</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">promote</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="identifier">promote</span><span class="special"><</span><span class="identifier">U</span><span class="special">>>::</span><span class="identifier">type</span><span class="special">;</span>
|
||||
</pre>
|
||||
<p>
|
||||
that ought to represent the result of an arithmetic operation on the integer
|
||||
@@ -353,8 +353,8 @@
|
||||
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">core</span><span class="special">::</span><span class="identifier">demangle</span><span class="special">(</span> <span class="keyword">typeid</span><span class="special">(</span><span class="identifier">T</span><span class="special">).</span><span class="identifier">name</span><span class="special">()</span> <span class="special">);</span>
|
||||
<span class="special">}</span>
|
||||
|
||||
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> <span class="keyword">using</span> <span class="identifier">promote</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">common_type_t</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>;</span>
|
||||
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> <span class="keyword">using</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">common_type_t</span><span class="special"><</span><span class="identifier">promote</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="identifier">promote</span><span class="special"><</span><span class="identifier">U</span><span class="special">>>;</span>
|
||||
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">></span> <span class="keyword">using</span> <span class="identifier">promote</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">int</span><span class="special">>::</span><span class="identifier">type</span><span class="special">;</span>
|
||||
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">></span> <span class="keyword">using</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">promote</span><span class="special"><</span><span class="identifier">T</span><span class="special">>,</span> <span class="identifier">promote</span><span class="special"><</span><span class="identifier">U</span><span class="special">>>::</span><span class="identifier">type</span><span class="special">;</span>
|
||||
|
||||
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">></span> <span class="keyword">void</span> <span class="identifier">test_result</span><span class="special">(</span> <span class="identifier">mp_list</span><span class="special"><</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">></span> <span class="keyword">const</span><span class="special">&</span> <span class="special">)</span>
|
||||
<span class="special">{</span>
|
||||
@@ -396,11 +396,33 @@
|
||||
<p>
|
||||
We then default-construct this tuple and pass it to <code class="computeroutput"><span class="identifier">tuple_for_each</span></code>.
|
||||
<code class="computeroutput"><span class="identifier">tuple_for_each</span><span class="special">(</span><span class="identifier">tp</span><span class="special">,</span> <span class="identifier">f</span><span class="special">)</span></code> calls <code class="computeroutput"><span class="identifier">f</span></code>
|
||||
for every tuple element; we use a (C++14) lambda that calls <code class="computeroutput"><span class="identifier">test_result</span></code>. (In pure C++11, we'd need
|
||||
to make <code class="computeroutput"><span class="identifier">test_result</span></code> a function
|
||||
object with a templated <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> and pass that to <code class="computeroutput"><span class="identifier">tuple_for_each</span></code>
|
||||
directly.)
|
||||
for every tuple element; we use a (C++14) lambda that calls <code class="computeroutput"><span class="identifier">test_result</span></code>.
|
||||
</p>
|
||||
<p>
|
||||
In pure C++11, we can't use a lambda with an <code class="computeroutput"><span class="keyword">auto</span><span class="special">&&</span></code> parameter, so we'll have to make
|
||||
<code class="computeroutput"><span class="identifier">test_result</span></code> a function object
|
||||
with a templated <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>
|
||||
and pass that to <code class="computeroutput"><span class="identifier">tuple_for_each</span></code>
|
||||
directly:
|
||||
</p>
|
||||
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">test_result</span>
|
||||
<span class="special">{</span>
|
||||
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">></span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="identifier">mp_list</span><span class="special"><</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">></span> <span class="keyword">const</span><span class="special">&</span> <span class="special">)</span> <span class="keyword">const</span>
|
||||
<span class="special">{</span>
|
||||
<span class="keyword">using</span> <span class="identifier">T3</span> <span class="special">=</span> <span class="keyword">decltype</span><span class="special">(</span> <span class="identifier">T1</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">T2</span><span class="special">()</span> <span class="special">);</span>
|
||||
<span class="keyword">using</span> <span class="identifier">T4</span> <span class="special">=</span> <span class="identifier">result</span><span class="special"><</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">>;</span>
|
||||
|
||||
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special"><<</span> <span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special"><</span><span class="identifier">T3</span><span class="special">,</span> <span class="identifier">T4</span><span class="special">>::</span><span class="identifier">value</span><span class="special">?</span> <span class="string">"[PASS] "</span><span class="special">:</span> <span class="string">"[FAIL] "</span> <span class="special">)</span>
|
||||
<span class="special"><<</span> <span class="identifier">name</span><span class="special"><</span><span class="identifier">T1</span><span class="special">>()</span> <span class="special"><<</span> <span class="string">" + "</span> <span class="special"><<</span> <span class="identifier">name</span><span class="special"><</span><span class="identifier">T2</span><span class="special">>()</span> <span class="special"><<</span> <span class="string">" -> "</span> <span class="special"><<</span> <span class="identifier">name</span><span class="special"><</span><span class="identifier">T3</span><span class="special">>()</span> <span class="special"><<</span> <span class="string">", result: "</span> <span class="special"><<</span> <span class="identifier">name</span><span class="special"><</span><span class="identifier">T4</span><span class="special">>()</span> <span class="special"><<</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
|
||||
<span class="special">}</span>
|
||||
<span class="special">};</span>
|
||||
|
||||
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
|
||||
<span class="special">{</span>
|
||||
<span class="keyword">using</span> <span class="identifier">L</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special"><</span><span class="keyword">char</span><span class="special">,</span> <span class="keyword">short</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">unsigned</span><span class="special">,</span> <span class="keyword">long</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">long</span><span class="special">>;</span>
|
||||
<span class="identifier">tuple_for_each</span><span class="special">(</span> <span class="identifier">mp_product</span><span class="special"><</span><span class="identifier">mp_list</span><span class="special">,</span> <span class="identifier">L</span><span class="special">,</span> <span class="identifier">L</span><span class="special">>(),</span> <span class="identifier">test_result</span><span class="special">()</span> <span class="special">);</span>
|
||||
<span class="special">}</span>
|
||||
</pre>
|
||||
</div>
|
||||
<div class="section">
|
||||
<div class="titlepage"><div><div><h3 class="title">
|
||||
@@ -419,7 +441,9 @@
|
||||
arguments. For that, we need a metafunction that applies <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">common_type</span></code>
|
||||
to each pair of elements and gathers the results into a tuple:
|
||||
</p>
|
||||
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">Tp1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Tp2</span><span class="special">></span> <span class="keyword">using</span> <span class="identifier">common_tuple</span> <span class="special">=</span> <span class="identifier">mp_transform</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">common_type_t</span><span class="special">,</span> <span class="identifier">Tp1</span><span class="special">,</span> <span class="identifier">Tp2</span><span class="special">>;</span>
|
||||
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span><span class="special">...</span> <span class="identifier">T</span><span class="special">></span> <span class="keyword">using</span> <span class="identifier">common_type_t</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">common_type</span><span class="special"><</span><span class="identifier">T</span><span class="special">...>::</span><span class="identifier">type</span><span class="special">;</span> <span class="comment">// standard in C++14</span>
|
||||
|
||||
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">Tp1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Tp2</span><span class="special">></span> <span class="keyword">using</span> <span class="identifier">common_tuple</span> <span class="special">=</span> <span class="identifier">mp_transform</span><span class="special"><</span><span class="identifier">common_type_t</span><span class="special">,</span> <span class="identifier">Tp1</span><span class="special">,</span> <span class="identifier">Tp2</span><span class="special">>;</span>
|
||||
</pre>
|
||||
<p>
|
||||
then specialize <code class="computeroutput"><span class="identifier">common_type</span></code>
|
||||
@@ -463,16 +487,15 @@
|
||||
<span class="identifier">E2</span><span class="special">,</span> <span class="identifier">E3</span><span class="special">></span></code>
|
||||
and <code class="computeroutput"><span class="identifier">expected</span><span class="special"><</span><span class="identifier">T2</span><span class="special">,</span> <span class="identifier">E1</span><span class="special">,</span> <span class="identifier">E4</span><span class="special">,</span>
|
||||
<span class="identifier">E5</span><span class="special">></span></code>
|
||||
is <code class="computeroutput"><span class="identifier">expected</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">common_type_t</span><span class="special"><</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">>,</span>
|
||||
<span class="identifier">E1</span><span class="special">,</span> <span class="identifier">E2</span><span class="special">,</span> <span class="identifier">E3</span><span class="special">,</span> <span class="identifier">E4</span><span class="special">,</span>
|
||||
<span class="identifier">E5</span><span class="special">></span></code>.
|
||||
That is, the possible return values are combined into their common type,
|
||||
and we take the union of the set of error types.
|
||||
is <code class="computeroutput"><span class="identifier">expected</span><span class="special"><</span><span class="identifier">common_type_t</span><span class="special"><</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">>,</span> <span class="identifier">E1</span><span class="special">,</span> <span class="identifier">E2</span><span class="special">,</span>
|
||||
<span class="identifier">E3</span><span class="special">,</span> <span class="identifier">E4</span><span class="special">,</span> <span class="identifier">E5</span><span class="special">></span></code>. That is, the possible return values
|
||||
are combined into their common type, and we take the union of the set of
|
||||
error types.
|
||||
</p>
|
||||
<p>
|
||||
Therefore,
|
||||
</p>
|
||||
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">E1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">E2</span><span class="special">></span> <span class="keyword">using</span> <span class="identifier">common_expected</span> <span class="special">=</span> <span class="identifier">mp_rename</span><span class="special"><</span><span class="identifier">mp_push_front</span><span class="special"><</span><span class="identifier">mp_unique</span><span class="special"><</span><span class="identifier">mp_append</span><span class="special"><</span><span class="identifier">E1</span><span class="special">,</span> <span class="identifier">E2</span><span class="special">>>,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">common_type_t</span><span class="special"><</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">>>,</span> <span class="identifier">expected</span><span class="special">>;</span>
|
||||
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">E1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">E2</span><span class="special">></span> <span class="keyword">using</span> <span class="identifier">common_expected</span> <span class="special">=</span> <span class="identifier">mp_rename</span><span class="special"><</span><span class="identifier">mp_push_front</span><span class="special"><</span><span class="identifier">mp_unique</span><span class="special"><</span><span class="identifier">mp_append</span><span class="special"><</span><span class="identifier">E1</span><span class="special">,</span> <span class="identifier">E2</span><span class="special">>>,</span> <span class="identifier">common_type_t</span><span class="special"><</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">>>,</span> <span class="identifier">expected</span><span class="special">>;</span>
|
||||
|
||||
<span class="keyword">namespace</span> <span class="identifier">std</span>
|
||||
<span class="special">{</span>
|
||||
@@ -491,7 +514,7 @@
|
||||
This makes our job easier. <code class="computeroutput"><span class="identifier">mp_unique</span><span class="special"><</span><span class="identifier">mp_append</span><span class="special"><</span><span class="identifier">E1</span><span class="special">,</span> <span class="identifier">E2</span><span class="special">>></span></code>
|
||||
gives us the concatenation of <code class="computeroutput"><span class="identifier">E1</span></code>
|
||||
and <code class="computeroutput"><span class="identifier">E2</span></code> with the duplicates
|
||||
removed; we then add <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">common_type_t</span><span class="special"><</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">></span></code>
|
||||
removed; we then add <code class="computeroutput"><span class="identifier">common_type_t</span><span class="special"><</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">></span></code>
|
||||
to the front via <code class="computeroutput"><span class="identifier">mp_push_front</span></code>;
|
||||
and finally, we <code class="computeroutput"><span class="identifier">mp_rename</span></code>
|
||||
the resultant <code class="computeroutput"><span class="identifier">mp_list</span></code> to
|
||||
@@ -2421,7 +2444,7 @@
|
||||
</div>
|
||||
</div>
|
||||
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
|
||||
<td align="left"><p><small>Last revised: May 23, 2017 at 17:21:43 GMT</small></p></td>
|
||||
<td align="left"><p><small>Last revised: May 23, 2017 at 17:37:57 GMT</small></p></td>
|
||||
<td align="right"><div class="copyright-footer"></div></td>
|
||||
</tr></table>
|
||||
<hr>
|
||||
|
||||
@@ -12,8 +12,8 @@
|
||||
|
||||
Let's suppose that we have written a metafunction `result<T, U>`:
|
||||
|
||||
template<class T> using promote = std::common_type_t<T, int>;
|
||||
template<class T, class U> using result = std::common_type_t<promote<T>, promote<U>>;
|
||||
template<class T> using promote = typename std::common_type<T, int>::type;
|
||||
template<class T, class U> using result = typename std::common_type<promote<T>, promote<U>>::type;
|
||||
|
||||
that ought to represent the result of an arithmetic operation on the integer types `T` and `U`,
|
||||
for example `t + u`. We want to test whether `result<T, U>` gives correct results for various combinations
|
||||
@@ -54,8 +54,8 @@ how we can leverage Mp11 to automate the task:
|
||||
return boost::core::demangle( typeid(T).name() );
|
||||
}
|
||||
|
||||
template<class T> using promote = std::common_type_t<T, int>;
|
||||
template<class T, class U> using result = std::common_type_t<promote<T>, promote<U>>;
|
||||
template<class T> using promote = typename std::common_type<T, int>::type;
|
||||
template<class T, class U> using result = typename std::common_type<promote<T>, promote<U>>::type;
|
||||
|
||||
template<class T1, class T2> void test_result( mp_list<T1, T2> const& )
|
||||
{
|
||||
@@ -82,8 +82,29 @@ In our case, both lists are the same `std::tuple`, and `F` is `mp_list`, so `mp_
|
||||
`std::tuple<mp_list<char, char>, mp_list<char, short>, mp_list<char, int>, ..., mp_list<unsigned long, long>, mp_list<unsigned long, unsigned long>>`.
|
||||
|
||||
We then default-construct this tuple and pass it to `tuple_for_each`. `tuple_for_each(tp, f)` calls `f` for every
|
||||
tuple element; we use a (C++14) lambda that calls `test_result`. (In pure C++11, we'd need to make `test_result` a
|
||||
function object with a templated `operator()` and pass that to `tuple_for_each` directly.)
|
||||
tuple element; we use a (C++14) lambda that calls `test_result`.
|
||||
|
||||
In pure C++11, we can't use a lambda with an `auto&&` parameter, so we'll have to make `test_result` a function object with
|
||||
a templated `operator()` and pass that to `tuple_for_each` directly:
|
||||
|
||||
struct test_result
|
||||
{
|
||||
template<class T1, class T2> void operator()( mp_list<T1, T2> const& ) const
|
||||
{
|
||||
using T3 = decltype( T1() + T2() );
|
||||
using T4 = result<T1, T2>;
|
||||
|
||||
std::cout << ( std::is_same<T3, T4>::value? "[PASS] ": "[FAIL] " )
|
||||
<< name<T1>() << " + " << name<T2>() << " -> " << name<T3>() << ", result: " << name<T4>() << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
using L = std::tuple<char, short, int, unsigned, long, unsigned long>;
|
||||
tuple_for_each( mp_product<mp_list, L, L>(), test_result() );
|
||||
}
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Writing `common_type` specializations]
|
||||
@@ -95,7 +116,9 @@ operator) is unsuitable.
|
||||
Let's write a `common_type` specialization for two `std::tuple` arguments. For that, we need a metafunction that
|
||||
applies `std::common_type` to each pair of elements and gathers the results into a tuple:
|
||||
|
||||
template<class Tp1, class Tp2> using common_tuple = mp_transform<std::common_type_t, Tp1, Tp2>;
|
||||
template<class... T> using common_type_t = typename std::common_type<T...>::type; // standard in C++14
|
||||
|
||||
template<class Tp1, class Tp2> using common_tuple = mp_transform<common_type_t, Tp1, Tp2>;
|
||||
|
||||
then specialize `common_type` to use it:
|
||||
|
||||
@@ -119,12 +142,12 @@ and `common_type_t`, which is defined as `typename common_type<...>::type`, will
|
||||
|
||||
As another example, consider the hypothetical type `expected<T, E...>` that represents either a successful return with a value of `T`,
|
||||
or an unsucessful return with an error code of some type in the list `E...`. The common type of `expected<T1, E1, E2, E3>` and
|
||||
`expected<T2, E1, E4, E5>` is `expected<std::common_type_t<T1, T2>, E1, E2, E3, E4, E5>`. That is, the possible return values are
|
||||
`expected<T2, E1, E4, E5>` is `expected<common_type_t<T1, T2>, E1, E2, E3, E4, E5>`. That is, the possible return values are
|
||||
combined into their common type, and we take the union of the set of error types.
|
||||
|
||||
Therefore,
|
||||
|
||||
template<class T1, class E1, class T2, class E2> using common_expected = mp_rename<mp_push_front<mp_unique<mp_append<E1, E2>>, std::common_type_t<T1, T2>>, expected>;
|
||||
template<class T1, class E1, class T2, class E2> using common_expected = mp_rename<mp_push_front<mp_unique<mp_append<E1, E2>>, common_type_t<T1, T2>>, expected>;
|
||||
|
||||
namespace std
|
||||
{
|
||||
@@ -137,7 +160,7 @@ Therefore,
|
||||
|
||||
Here we've taken a different tack; instead of passing the `expected` types to `common_expected`, we're passing the `T` types and lists of
|
||||
the `E` types. This makes our job easier. `mp_unique<mp_append<E1, E2>>` gives us the concatenation of `E1` and `E2` with the duplicates
|
||||
removed; we then add `std::common_type_t<T1, T2>` to the front via `mp_push_front`; and finally, we `mp_rename` the resultant `mp_list`
|
||||
removed; we then add `common_type_t<T1, T2>` to the front via `mp_push_front`; and finally, we `mp_rename` the resultant `mp_list`
|
||||
to `expected`.
|
||||
|
||||
[endsect]
|
||||
@@ -191,10 +214,10 @@ trying to concatenate tuples containing move-only elements such as `unique_ptr`
|
||||
|
||||
Trying to concatenate `const` tuples fails:
|
||||
|
||||
std::tuple<int> const t1;
|
||||
std::tuple<float> const t2;
|
||||
std::tuple<int> const t1;
|
||||
std::tuple<float> const t2;
|
||||
|
||||
auto result = ::tuple_cat( t1, t2 );
|
||||
auto result = ::tuple_cat( t1, t2 );
|
||||
|
||||
And finally, the standard `tuple_cat` is specified to work on arbitrary tuple-like types (that is, all types
|
||||
that support `tuple_size`, `tuple_element`, and `get`), while our implementation only works with `tuple` and
|
||||
|
||||
Reference in New Issue
Block a user