Merge branch 'develop'

2017-03-20 01:03:04 +02:00
parent 627f6a9b6b 51540fa632
commit 3a645cc6bb
12 changed files with 576 additions and 15 deletions
--- a/doc/html/mp11.html
+++ b/doc/html/mp11.html
@@ -69,6 +69,10 @@
 <dt><span class="section"><a href="mp11.html#mp11.reference.list.mp_rename_l_y"><code class="computeroutput"><span class="identifier">mp_rename</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span>
        <span class="identifier">Y</span><span class="special">&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="mp11.html#mp11.reference.list.mp_append_l"><code class="computeroutput"><span class="identifier">mp_append</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">...&gt;</span></code></a></span></dt>
+<dt><span class="section"><a href="mp11.html#mp11.reference.list.mp_replace_front_l_t"><code class="computeroutput"><span class="identifier">mp_replace_front</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span></code></a></span></dt>
+<dt><span class="section"><a href="mp11.html#mp11.reference.list.mp_replace_first_l_t"><code class="computeroutput"><span class="identifier">mp_replace_first</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span></code></a></span></dt>
+<dt><span class="section"><a href="mp11.html#mp11.reference.list.mp_replace_second_l_t"><code class="computeroutput"><span class="identifier">mp_replace_second</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span></code></a></span></dt>
+<dt><span class="section"><a href="mp11.html#mp11.reference.list.mp_replace_third_l_t"><code class="computeroutput"><span class="identifier">mp_replace_third</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span></code></a></span></dt>
 </dl></dd>
 <dt><span class="section"><a href="mp11.html#mp11.reference.utility">Utility Components, <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">mp11</span><span class="special">/</span><span class="identifier">utility</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a></span></dt>
 <dd><dl>
@@ -92,7 +96,7 @@
 <dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_assign_l1_l2"><code class="computeroutput"><span class="identifier">mp_assign</span><span class="special">&lt;</span><span class="identifier">L1</span><span class="special">,</span> <span class="identifier">L2</span><span class="special">&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_clear_l"><code class="computeroutput"><span class="identifier">mp_clear</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_transform_f_l"><code class="computeroutput"><span class="identifier">mp_transform</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">,</span> <span class="identifier">L</span><span class="special">...&gt;</span></code></a></span></dt>
-<dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_transform_if_p_f_l"><code class="computeroutput"><span class="identifier">mp_transform_if</span><span class="special">&lt;</span><span class="identifier">P</span><span class="special">,</span> <span class="identifier">F</span><span class="special">,</span> <span class="identifier">L</span><span class="special">&gt;</span></code></a></span></dt>
+<dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_transform_if_p_f_l"><code class="computeroutput"><span class="identifier">mp_transform_if</span><span class="special">&lt;</span><span class="identifier">P</span><span class="special">,</span> <span class="identifier">F</span><span class="special">,</span> <span class="identifier">L</span><span class="special">...&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_fill_l_v"><code class="computeroutput"><span class="identifier">mp_fill</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">V</span><span class="special">&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_count_l_v"><code class="computeroutput"><span class="identifier">mp_count</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">V</span><span class="special">&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_count_if_l_p"><code class="computeroutput"><span class="identifier">mp_count_if</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">P</span><span class="special">&gt;</span></code></a></span></dt>
@@ -111,6 +115,8 @@
 <dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_take_l_n"><code class="computeroutput"><span class="identifier">mp_take</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">N</span><span class="special">&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_replace_l_v_w"><code class="computeroutput"><span class="identifier">mp_replace</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">V</span><span class="special">,</span> <span class="identifier">W</span><span class="special">&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_replace_if_l_p_w"><code class="computeroutput"><span class="identifier">mp_replace_if</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">P</span><span class="special">,</span> <span class="identifier">W</span><span class="special">&gt;</span></code></a></span></dt>
+<dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_replace_at_c_l_i_w"><code class="computeroutput"><span class="identifier">mp_replace_at_c</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">I</span><span class="special">,</span> <span class="identifier">W</span><span class="special">&gt;</span></code></a></span></dt>
+<dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_replace_at_l_i_w"><code class="computeroutput"><span class="identifier">mp_replace_at</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">I</span><span class="special">,</span> <span class="identifier">W</span><span class="special">&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_copy_if_l_p"><code class="computeroutput"><span class="identifier">mp_copy_if</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">P</span><span class="special">&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_remove_l_v"><code class="computeroutput"><span class="identifier">mp_remove</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">V</span><span class="special">&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="mp11.html#mp11.reference.algorithm.mp_remove_if_l_p"><code class="computeroutput"><span class="identifier">mp_remove_if</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">P</span><span class="special">&gt;</span></code></a></span></dt>
@@ -705,6 +711,58 @@
          is an alias for <code class="computeroutput"><span class="identifier">L1</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">...,</span> <span class="identifier">T2</span><span class="special">...,</span> <span class="special">...,</span> <span class="identifier">Tn</span><span class="special">...&gt;</span></code>.
        </p>
 </div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="mp11.reference.list.mp_replace_front_l_t"></a><a class="link" href="mp11.html#mp11.reference.list.mp_replace_front_l_t" title="mp_replace_front&lt;L, T&gt;"><code class="computeroutput"><span class="identifier">mp_replace_front</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span></code></a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">L</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_replace_front</span> <span class="special">=</span> <span class="comment">/*...*/</span><span class="special">;</span>
+</pre>
+<p>
+          <code class="computeroutput"><span class="identifier">mp_replace_front</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span></code> replaces the first element of the list
+          <code class="computeroutput"><span class="identifier">L</span></code> with <code class="computeroutput"><span class="identifier">T</span></code>.
+          That is, <code class="computeroutput"><span class="identifier">mp_replace_front</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">&lt;</span><span class="identifier">U1</span><span class="special">,</span> <span class="identifier">U</span><span class="special">...&gt;,</span>
+          <span class="identifier">T</span><span class="special">&gt;</span></code>
+          is an alias for <code class="computeroutput"><span class="identifier">L</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">...&gt;</span></code>.
+        </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="mp11.reference.list.mp_replace_first_l_t"></a><a class="link" href="mp11.html#mp11.reference.list.mp_replace_first_l_t" title="mp_replace_first&lt;L, T&gt;"><code class="computeroutput"><span class="identifier">mp_replace_first</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span></code></a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">L</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_replace_first</span> <span class="special">=</span> <span class="identifier">mp_replace_front</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;;</span>
+</pre>
+<p>
+          <code class="computeroutput"><span class="identifier">mp_replace_first</span></code> is another
+          name for <code class="computeroutput"><span class="identifier">mp_replace_front</span></code>.
+        </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="mp11.reference.list.mp_replace_second_l_t"></a><a class="link" href="mp11.html#mp11.reference.list.mp_replace_second_l_t" title="mp_replace_second&lt;L, T&gt;"><code class="computeroutput"><span class="identifier">mp_replace_second</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span></code></a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">L</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_replace_second</span> <span class="special">=</span> <span class="comment">/*...*/</span><span class="special">;</span>
+</pre>
+<p>
+          <code class="computeroutput"><span class="identifier">mp_replace_second</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span></code> replaces the second element of the
+          list <code class="computeroutput"><span class="identifier">L</span></code> with <code class="computeroutput"><span class="identifier">T</span></code>. That is, <code class="computeroutput"><span class="identifier">mp_replace_second</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">&lt;</span><span class="identifier">U1</span><span class="special">,</span> <span class="identifier">U2</span><span class="special">,</span> <span class="identifier">U</span><span class="special">...&gt;,</span>
+          <span class="identifier">T</span><span class="special">&gt;</span></code>
+          is an alias for <code class="computeroutput"><span class="identifier">L</span><span class="special">&lt;</span><span class="identifier">U1</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">...&gt;</span></code>.
+        </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="mp11.reference.list.mp_replace_third_l_t"></a><a class="link" href="mp11.html#mp11.reference.list.mp_replace_third_l_t" title="mp_replace_third&lt;L, T&gt;"><code class="computeroutput"><span class="identifier">mp_replace_third</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span></code></a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">L</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_replace_third</span> <span class="special">=</span> <span class="comment">/*...*/</span><span class="special">;</span>
+</pre>
+<p>
+          <code class="computeroutput"><span class="identifier">mp_replace_third</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span></code> replaces the third element of the list
+          <code class="computeroutput"><span class="identifier">L</span></code> with <code class="computeroutput"><span class="identifier">T</span></code>.
+          That is, <code class="computeroutput"><span class="identifier">mp_replace_third</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">&lt;</span><span class="identifier">U1</span><span class="special">,</span> <span class="identifier">U2</span><span class="special">,</span> <span class="identifier">U3</span><span class="special">,</span> <span class="identifier">U</span><span class="special">...&gt;,</span>
+          <span class="identifier">T</span><span class="special">&gt;</span></code>
+          is an alias for <code class="computeroutput"><span class="identifier">L</span><span class="special">&lt;</span><span class="identifier">U1</span><span class="special">,</span> <span class="identifier">U2</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">...&gt;</span></code>.
+        </p>
+</div>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -892,15 +950,17 @@
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
-<a name="mp11.reference.algorithm.mp_transform_if_p_f_l"></a><a class="link" href="mp11.html#mp11.reference.algorithm.mp_transform_if_p_f_l" title="mp_transform_if&lt;P, F, L&gt;"><code class="computeroutput"><span class="identifier">mp_transform_if</span><span class="special">&lt;</span><span class="identifier">P</span><span class="special">,</span> <span class="identifier">F</span><span class="special">,</span> <span class="identifier">L</span><span class="special">&gt;</span></code></a>
+<a name="mp11.reference.algorithm.mp_transform_if_p_f_l"></a><a class="link" href="mp11.html#mp11.reference.algorithm.mp_transform_if_p_f_l" title="mp_transform_if&lt;P, F, L...&gt;"><code class="computeroutput"><span class="identifier">mp_transform_if</span><span class="special">&lt;</span><span class="identifier">P</span><span class="special">,</span> <span class="identifier">F</span><span class="special">,</span> <span class="identifier">L</span><span class="special">...&gt;</span></code></a>
 </h4></div></div></div>
-<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">P</span><span class="special">,</span> <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">L</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_transform_if</span> <span class="special">=</span> <span class="comment">/*...*/</span><span class="special">;</span>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">P</span><span class="special">,</span> <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">L</span><span class="special">...&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_transform_if</span> <span class="special">=</span> <span class="comment">/*...*/</span><span class="special">;</span>
 </pre>
 <p>
-          <code class="computeroutput"><span class="identifier">mp_transform_if</span></code> replaces
-          the elements <code class="computeroutput"><span class="identifier">T</span></code> of <code class="computeroutput"><span class="identifier">L</span></code> for which <code class="computeroutput"><span class="identifier">mp_to_bool</span><span class="special">&lt;</span><span class="identifier">P</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&gt;</span></code> is <code class="computeroutput"><span class="identifier">mp_true</span></code>
-          with <code class="computeroutput"><span class="identifier">F</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>,
-          and returns the result.
+          <code class="computeroutput"><span class="identifier">mp_transform_if</span><span class="special">&lt;</span><span class="identifier">P</span><span class="special">,</span> <span class="identifier">F</span><span class="special">,</span> <span class="identifier">L1</span><span class="special">,</span> <span class="identifier">L2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">Ln</span><span class="special">&gt;</span></code>
+          replaces the elements <code class="computeroutput"><span class="identifier">T</span></code>
+          of the list <code class="computeroutput"><span class="identifier">L1</span></code> for which
+          <code class="computeroutput"><span class="identifier">mp_to_bool</span><span class="special">&lt;</span><span class="identifier">P</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">Tn</span><span class="special">&gt;&gt;</span></code> is <code class="computeroutput"><span class="identifier">mp_true</span></code>
+          with <code class="computeroutput"><span class="identifier">F</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">Tn</span><span class="special">&gt;</span></code>, and returns the result, where <code class="computeroutput"><span class="identifier">Ti</span></code> are the corresponding elements of
+          <code class="computeroutput"><span class="identifier">Li</span></code>.
        </p>
 </div>
 <div class="section">
@@ -1119,6 +1179,30 @@
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
+<a name="mp11.reference.algorithm.mp_replace_at_c_l_i_w"></a><a class="link" href="mp11.html#mp11.reference.algorithm.mp_replace_at_c_l_i_w" title="mp_replace_at_c&lt;L, I, W&gt;"><code class="computeroutput"><span class="identifier">mp_replace_at_c</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">I</span><span class="special">,</span> <span class="identifier">W</span><span class="special">&gt;</span></code></a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">L</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">W</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_replace_at_c</span> <span class="special">=</span> <span class="comment">/*...*/</span><span class="special">;</span>
+</pre>
+<p>
+          Replaces the element of <code class="computeroutput"><span class="identifier">L</span></code>
+          at zero-based index <code class="computeroutput"><span class="identifier">I</span></code> with
+          <code class="computeroutput"><span class="identifier">W</span></code> and returns the result.
+        </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="mp11.reference.algorithm.mp_replace_at_l_i_w"></a><a class="link" href="mp11.html#mp11.reference.algorithm.mp_replace_at_l_i_w" title="mp_replace_at&lt;L, I, W&gt;"><code class="computeroutput"><span class="identifier">mp_replace_at</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">I</span><span class="special">,</span> <span class="identifier">W</span><span class="special">&gt;</span></code></a>
+</h4></div></div></div>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">L</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">W</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_replace_at</span> <span class="special">=</span> <span class="comment">/*...*/</span><span class="special">;</span>
+</pre>
+<p>
+          Same as <code class="computeroutput"><span class="identifier">mp_replace_at_c</span></code>,
+          but with a type argument <code class="computeroutput"><span class="identifier">I</span></code>.
+          <code class="computeroutput"><span class="identifier">I</span><span class="special">::</span><span class="identifier">value</span></code> must be a nonnegative number.
+        </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
 <a name="mp11.reference.algorithm.mp_copy_if_l_p"></a><a class="link" href="mp11.html#mp11.reference.algorithm.mp_copy_if_l_p" title="mp_copy_if&lt;L, P&gt;"><code class="computeroutput"><span class="identifier">mp_copy_if</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">P</span><span class="special">&gt;</span></code></a>
 </h4></div></div></div>
 <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">L</span><span class="special">,</span> <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">P</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_copy_if</span> <span class="special">=</span> <span class="comment">/*...*/</span><span class="special">;</span>
@@ -1604,7 +1688,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: March 17, 2017 at 03:26:57 GMT</small></p></td>
+<td align="left"><p><small>Last revised: March 18, 2017 at 18:33:25 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>
--- a/doc/mp11/algorithm.qbk
+++ b/doc/mp11/algorithm.qbk
@@ -26,10 +26,11 @@
 `mp_transform<F, L1<T1...>, L2<T2...>, ..., Ln<Tn...>>` applies `F` to each successive tuple of elements and returns `L1<F<T1, T2, ..., Tn>...>`.
 [endsect]

-[section `mp_transform_if<P, F, L>`]
-    template<template<class...> class P, template<class...> class F, class L> using mp_transform_if = /*...*/;
+[section `mp_transform_if<P, F, L...>`]
+    template<template<class...> class P, template<class...> class F, class L...> using mp_transform_if = /*...*/;

-`mp_transform_if` replaces the elements `T` of `L` for which `mp_to_bool<P<T>>` is `mp_true` with `F<T>`, and returns the result.
+`mp_transform_if<P, F, L1, L2, ..., Ln>` replaces the elements `T` of the list `L1` for which `mp_to_bool<P<T1, T2, ..., Tn>>` is `mp_true` with
+`F<T1, T2, ..., Tn>`, and returns the result, where `Ti` are the corresponding elements of `Li`.
 [endsect]

 [section `mp_fill<L, V>`]
@@ -138,6 +139,18 @@ Replaces all `V` elements of `L` with `W` and returns the result.
 Replaces all `T` elements of `L` for which `mp_to_bool<P<T>>` is `mp_true` with `W` and returns the result.
 [endsect]

+[section `mp_replace_at_c<L, I, W>`]
+    template<class L, std::size_t I, class W> using mp_replace_at_c = /*...*/;
+
+Replaces the element of `L` at zero-based index `I` with `W` and returns the result.
+[endsect]
+
+[section `mp_replace_at<L, I, W>`]
+    template<class L, class I, class W> using mp_replace_at = /*...*/;
+
+Same as `mp_replace_at_c`, but with a type argument `I`. `I::value` must be a nonnegative number.
+[endsect]
+
 [section `mp_copy_if<L, P>`]
    template<class L, template<class...> class P> using mp_copy_if = /*...*/;

--- a/doc/mp11/list.qbk
+++ b/doc/mp11/list.qbk
@@ -92,4 +92,31 @@ is an alias for `L<U..., T...>`.
 is an alias for `mp_list<>`. `mp_append<L1<T1...>, L2<T2...>, ..., Ln<Tn...>>` is an alias for `L1<T1..., T2..., ..., Tn...>`.
 [endsect]

+[section `mp_replace_front<L, T>`]
+    template<class L, class T> using mp_replace_front = /*...*/;
+
+`mp_replace_front<L, T>` replaces the first element of the list `L` with `T`. That is, `mp_replace_front<L<U1, U...>, T>` is
+an alias for `L<T, U...>`.
+[endsect]
+
+[section `mp_replace_first<L, T>`]
+    template<class L, class T> using mp_replace_first = mp_replace_front<L, T>;
+
+`mp_replace_first` is another name for `mp_replace_front`.
+[endsect]
+
+[section `mp_replace_second<L, T>`]
+    template<class L, class T> using mp_replace_second = /*...*/;
+
+`mp_replace_second<L, T>` replaces the second element of the list `L` with `T`. That is, `mp_replace_second<L<U1, U2, U...>, T>`
+is an alias for `L<U1, T, U...>`.
+[endsect]
+
+[section `mp_replace_third<L, T>`]
+    template<class L, class T> using mp_replace_third = /*...*/;
+
+`mp_replace_third<L, T>` replaces the third element of the list `L` with `T`. That is, `mp_replace_third<L<U1, U2, U3, U...>, T>`
+is an alias for `L<U1, U2, T, U...>`.
+[endsect]
+
 [endsect]
--- a/include/boost/mp11/algorithm.hpp
+++ b/include/boost/mp11/algorithm.hpp
@@ -71,11 +71,20 @@ template<template<class...> class F, template<class...> class L1, class... T1, t

 template<template<class...> class F, class... L> using mp_transform = typename detail::mp_transform_impl<F, L...>::type;

-// mp_transform_if<P, F, L>
+// mp_transform_if<P, F, L...>
 namespace detail
 {

-template<template<class...> class P, template<class...> class F, class L> struct mp_transform_if_impl;
+/*
+template<template<class...> class P, template<class...> class F, class... L> struct mp_transform_if_impl
+{
+    // error: pack expansion used as argument for non-pack parameter of alias template
+    template<class... U> using _f = mp_eval_if<mp_not<P<U...>>, mp_first<mp_list<U...>>, F, U...>;
+    using type = mp_transform<_f, L...>;
+};
+*/
+
+template<template<class...> class P, template<class...> class F, class... L> struct mp_transform_if_impl;

 template<template<class...> class P, template<class...> class F, template<class...> class L, class... T> struct mp_transform_if_impl<P, F, L<T...>>
 {
@@ -92,9 +101,43 @@ template<template<class...> class P, template<class...> class F, template<class.
 #endif
 };

+template<template<class...> class P, template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2> struct mp_transform_if_impl<P, F, L1<T1...>, L2<T2...>>
+{
+    static_assert( sizeof...(T1) == sizeof...(T2), "The arguments of mp_transform_if should be of the same size" );
+
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1910 )
+
+    template<class U1, class U2> struct _f { using type = mp_eval_if<mp_not<P<U1, U2>>, U1, F, U1, U2>; };
+    using type = L1<typename _f<T1, T2>::type...>;
+
+#else
+
+    template<class U1, class U2> using _f = mp_eval_if<mp_not<P<U1, U2>>, U1, F, U1, U2>;
+    using type = L1<_f<T1, T2>...>;
+
+#endif
+};
+
+template<template<class...> class P, template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3> struct mp_transform_if_impl<P, F, L1<T1...>, L2<T2...>, L3<T3...>>
+{
+    static_assert( sizeof...(T1) == sizeof...(T2) && sizeof...(T1) == sizeof...(T3), "The arguments of mp_transform_if should be of the same size" );
+
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1910 )
+
+    template<class U1, class U2, class U3> struct _f { using type = mp_eval_if<mp_not<P<U1, U2, U3>>, U1, F, U1, U2, U3>; };
+    using type = L1<typename _f<T1, T2, T3>::type...>;
+
+#else
+
+    template<class U1, class U2, class U3> using _f = mp_eval_if<mp_not<P<U1, U2, U3>>, U1, F, U1, U2, U3>;
+    using type = L1<_f<T1, T2, T3>...>;
+
+#endif
+};
+
 } // namespace detail

-template<template<class...> class P, template<class...> class F, class L> using mp_transform_if = typename detail::mp_transform_if_impl<P, F, L>::type;
+template<template<class...> class P, template<class...> class F, class... L> using mp_transform_if = typename detail::mp_transform_if_impl<P, F, L...>::type;

 // mp_fill<L, V>
 namespace detail
@@ -791,6 +834,25 @@ template<class L, template<class...> class P> using mp_none_of = mp_bool< mp_cou
 // mp_any_of<L, P>
 template<class L, template<class...> class P> using mp_any_of = mp_bool< mp_count_if<L, P>::value != 0 >;

+// mp_replace_at_c<L, I, W>
+namespace detail
+{
+
+template<class L, class I, class W> struct mp_replace_at_impl
+{
+    static_assert( I::value >= 0, "mp_replace_at<L, I, W>: I must not be negative" );
+
+    template<class T1, class T2> using _p = std::is_same<T2, mp_size_t<I::value>>;
+    template<class T1, class T2> using _f = W;
+
+    using type = mp_transform_if<_p, _f, L, mp_iota<mp_size<L>>>;
+};
+
+} // namespace detail
+
+template<class L, class I, class W> using mp_replace_at = typename detail::mp_replace_at_impl<L, I, W>::type;
+template<class L, std::size_t I, class W> using mp_replace_at_c = typename detail::mp_replace_at_impl<L, mp_size_t<I>, W>::type;
+
 } // namespace mp11
 } // namespace boost

--- a/include/boost/mp11/list.hpp
+++ b/include/boost/mp11/list.hpp
@@ -170,6 +170,54 @@ template<template<class...> class L1, class... T1, template<class...> class L2,

 template<class... L> using mp_append = typename detail::mp_append_impl<L...>::type;

+// mp_replace_front<L, T>
+namespace detail
+{
+
+template<class L, class T> struct mp_replace_front_impl;
+
+template<template<class...> class L, class U1, class... U, class T> struct mp_replace_front_impl<L<U1, U...>, T>
+{
+    using type = L<T, U...>;
+};
+
+} // namespace detail
+
+template<class L, class T> using mp_replace_front = typename detail::mp_replace_front_impl<L, T>::type;
+
+// mp_replace_first<L, T>
+template<class L, class T> using mp_replace_first = typename detail::mp_replace_front_impl<L, T>::type;
+
+// mp_replace_second<L, T>
+namespace detail
+{
+
+template<class L, class T> struct mp_replace_second_impl;
+
+template<template<class...> class L, class U1, class U2, class... U, class T> struct mp_replace_second_impl<L<U1, U2, U...>, T>
+{
+    using type = L<U1, T, U...>;
+};
+
+} // namespace detail
+
+template<class L, class T> using mp_replace_second = typename detail::mp_replace_second_impl<L, T>::type;
+
+// mp_replace_third<L, T>
+namespace detail
+{
+
+template<class L, class T> struct mp_replace_third_impl;
+
+template<template<class...> class L, class U1, class U2, class U3, class... U, class T> struct mp_replace_third_impl<L<U1, U2, U3, U...>, T>
+{
+    using type = L<U1, U2, T, U...>;
+};
+
+} // namespace detail
+
+template<class L, class T> using mp_replace_third = typename detail::mp_replace_third_impl<L, T>::type;
+
 } // namespace mp11
 } // namespace boost

--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -25,6 +25,9 @@ run mp_push_front.cpp : : : $(REQ) ;
 run mp_push_back.cpp : : : $(REQ) ;
 run mp_rename.cpp : : : $(REQ) ;
 run mp_append.cpp : : : $(REQ) ;
+run mp_replace_front.cpp : : : $(REQ) ;
+run mp_replace_second.cpp : : : $(REQ) ;
+run mp_replace_third.cpp : : : $(REQ) ;

 # algorithm
 run mp_assign.cpp : : : $(REQ) ;
@@ -57,6 +60,8 @@ run mp_unique.cpp : : : $(REQ) ;
 run mp_all_of.cpp : : : $(REQ) ;
 run mp_any_of.cpp : : : $(REQ) ;
 run mp_none_of.cpp : : : $(REQ) ;
+run mp_replace_at.cpp : : : $(REQ) ;
+run mp_replace_at_c.cpp : : : $(REQ) ;

 # integral
 run integral.cpp : : : $(REQ) ;
--- a/test/mp_replace_at.cpp
+++ b/test/mp_replace_at.cpp
@@ -0,0 +1,60 @@
+
+//  Copyright 2015, 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_replace_at;
+    using boost::mp11::mp_int;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    {
+        using L = mp_list<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<0>, void>, mp_list<void, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<1>, void>, mp_list<X1, void, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<2>, void>, mp_list<X1, X2, void, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<3>, void>, mp_list<X1, X2, X3, void, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<4>, void>, mp_list<X1, X2, X3, X4, void>>));
+    }
+
+    {
+        using L = std::tuple<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<0>, void>, std::tuple<void, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<1>, void>, std::tuple<X1, void, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<2>, void>, std::tuple<X1, X2, void, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<3>, void>, std::tuple<X1, X2, X3, void, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<4>, void>, std::tuple<X1, X2, X3, X4, void>>));
+    }
+
+    {
+        using L = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_false, void>, std::pair<void, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_true, void>, std::pair<X1, void>>));
+    }
+
+    return boost::report_errors();
+}
--- a/test/mp_replace_at_c.cpp
+++ b/test/mp_replace_at_c.cpp
@@ -0,0 +1,56 @@
+
+//  Copyright 2015, 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_replace_at_c;
+
+    {
+        using L = mp_list<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 0, void>, mp_list<void, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 1, void>, mp_list<X1, void, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 2, void>, mp_list<X1, X2, void, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 3, void>, mp_list<X1, X2, X3, void, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 4, void>, mp_list<X1, X2, X3, X4, void>>));
+    }
+
+    {
+        using L = std::tuple<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 0, void>, std::tuple<void, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 1, void>, std::tuple<X1, void, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 2, void>, std::tuple<X1, X2, void, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 3, void>, std::tuple<X1, X2, X3, void, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 4, void>, std::tuple<X1, X2, X3, X4, void>>));
+    }
+
+    {
+        using L = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 0, void>, std::pair<void, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 1, void>, std::pair<X1, void>>));
+    }
+
+    return boost::report_errors();
+}
--- a/test/mp_replace_front.cpp
+++ b/test/mp_replace_front.cpp
@@ -0,0 +1,80 @@
+
+//  Copyright 2015, 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_replace_front;
+    using boost::mp11::mp_replace_first;
+
+    {
+        using L1 = mp_list<X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L1, void>, mp_list<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L1, void>, mp_list<void>>));
+
+        using L2 = mp_list<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L2, void>, mp_list<void, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L2, void>, mp_list<void, X2>>));
+
+        using L3 = mp_list<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L3, void>, mp_list<void, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L3, void>, mp_list<void, X2, X3>>));
+
+        using L4 = mp_list<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L4, void>, mp_list<void, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L4, void>, mp_list<void, X2, X3, X4>>));
+    }
+
+    {
+        using L1 = std::tuple<X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L1, void>, std::tuple<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L1, void>, std::tuple<void>>));
+
+        using L2 = std::tuple<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L2, void>, std::tuple<void, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L2, void>, std::tuple<void, X2>>));
+
+        using L3 = std::tuple<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L3, void>, std::tuple<void, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L3, void>, std::tuple<void, X2, X3>>));
+
+        using L4 = std::tuple<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L4, void>, std::tuple<void, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L4, void>, std::tuple<void, X2, X3, X4>>));
+    }
+
+    {
+        using L2 = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L2, void>, std::pair<void, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L2, void>, std::pair<void, X2>>));
+    }
+
+    return boost::report_errors();
+}
--- a/test/mp_replace_second.cpp
+++ b/test/mp_replace_second.cpp
@@ -0,0 +1,62 @@
+
+//  Copyright 2015, 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_replace_second;
+
+    {
+        using L2 = mp_list<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_second<L2, void>, mp_list<X1, void>>));
+
+        using L3 = mp_list<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_second<L3, void>, mp_list<X1, void, X3>>));
+
+        using L4 = mp_list<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_second<L4, void>, mp_list<X1, void, X3, X4>>));
+    }
+
+    {
+        using L2 = std::tuple<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_second<L2, void>, std::tuple<X1, void>>));
+
+        using L3 = std::tuple<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_second<L3, void>, std::tuple<X1, void, X3>>));
+
+        using L4 = std::tuple<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_second<L4, void>, std::tuple<X1, void, X3, X4>>));
+    }
+
+    {
+        using L2 = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_second<L2, void>, std::pair<X1, void>>));
+    }
+
+    return boost::report_errors();
+}
--- a/test/mp_replace_third.cpp
+++ b/test/mp_replace_third.cpp
@@ -0,0 +1,48 @@
+
+//  Copyright 2015, 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_replace_third;
+
+    {
+        using L3 = mp_list<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_third<L3, void>, mp_list<X1, X2, void>>));
+
+        using L4 = mp_list<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_third<L4, void>, mp_list<X1, X2, void, X4>>));
+    }
+
+    {
+        using L3 = std::tuple<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_third<L3, void>, std::tuple<X1, X2, void>>));
+
+        using L4 = std::tuple<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_third<L4, void>, std::tuple<X1, X2, void, X4>>));
+    }
+
+    return boost::report_errors();
+}
--- a/test/mp_transform_if.cpp
+++ b/test/mp_transform_if.cpp
@@ -23,12 +23,18 @@ struct X4 {};
 using boost::mp11::mp_not;

 template<class T> using add_pointer = T*;
-template<class T> using is_not_ref = mp_not<std::is_reference<T>>;
+template<class T, class...> using is_not_ref = mp_not<std::is_reference<T>>;
+template<class T1, class T2> using second = T2;
+template<class T1, class T2, class T3> using third = T3;

 int main()
 {
    using boost::mp11::mp_list;
    using boost::mp11::mp_transform_if;
+    using boost::mp11::mp_size_t;
+    using boost::mp11::mp_size;
+    using boost::mp11::mp_fill;
+    using boost::mp11::mp_iota;

    using L1 = mp_list<X1, X2&, X3 const, X4 const&>;

@@ -44,5 +50,15 @@ int main()

    //

+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, second, L1, mp_fill<L1, void>>, mp_list<void, X2&, void, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, second, L2, mp_fill<L2, void>>, std::tuple<void, X2&, void, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, second, L3, mp_fill<L3, void>>, std::pair<void, X2&>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, third, L1, L1, mp_iota<mp_size<L1>>>, mp_list<mp_size_t<0>, X2&, mp_size_t<2>, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, third, L2, L2, mp_iota<mp_size<L2>>>, std::tuple<mp_size_t<0>, X2&, mp_size_t<2>, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, third, L3, L3, mp_iota<mp_size<L3>>>, std::pair<mp_size_t<0>, X2&>>));
+
+    //
+
    return boost::report_errors();
 }