Merge branch 'develop'

doc/Jamfile.v2

@@ -10,7 +10,7 @@ project doc/mp11 ;
 import boostbook ;
 import quickbook ;
 
-xml mp11_ : mp11.qbk ;
+xml mp11_ : mp11.qbk : <quickbook-strict-mode>on ;
 boostbook standalone_mp11
     :
         mp11_

doc/html/mp11.html

@@ -70,6 +70,8 @@
         <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_apply_f_l"><code class="computeroutput"><span class="identifier">mp_apply</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.list.mp_apply_q_q_l"><code class="computeroutput"><span class="identifier">mp_apply_q</span><span class="special">&lt;</span><span class="identifier">Q</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.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>
@@ -90,7 +92,7 @@
         <span class="identifier">U</span><span class="special">...&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="mp11.html#mp11.reference.utility.mp_valid_f_t"><code class="computeroutput"><span class="identifier">mp_valid</span><span class="special">&lt;</span><span class="identifier">F</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.utility.mp_defer_f_t"><code class="computeroutput"><span class="identifier">mp_defer</span><span class="special">&lt;</span><span class="identifier">F</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.utility.mp_quote_f_t"><code class="computeroutput"><span class="identifier">mp_quote</span><span class="special">&lt;</span><span class="identifier">F</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.utility.mp_quote_f"><code class="computeroutput"><span class="identifier">mp_quote</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">&gt;</span></code></a></span></dt>
 <dt><span class="section"><a href="mp11.html#mp11.reference.utility.mp_invoke_q_t"><code class="computeroutput"><span class="identifier">mp_invoke</span><span class="special">&lt;</span><span class="identifier">Q</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.algorithm">Algorithms, <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">algorithm</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a></span></dt>
@@ -98,6 +100,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_q_q_l"><code class="computeroutput"><span class="identifier">mp_transform_q</span><span class="special">&lt;</span><span class="identifier">Q</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>
@@ -164,6 +167,12 @@
         ..., <code class="computeroutput"><span class="identifier">_9</span></code></a></span></dt>
 <dt><span class="section"><a href="mp11.html#mp11.reference.bind.mp_bind_f_t"><code class="computeroutput"><span class="identifier">mp_bind</span><span class="special">&lt;</span><span class="identifier">F</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.bind.mp_bind_q_q_t"><code class="computeroutput"><span class="identifier">mp_bind_q</span><span class="special">&lt;</span><span class="identifier">Q</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.bind.mp_bind_front_f_t"><code class="computeroutput"><span class="identifier">mp_bind_front</span><span class="special">&lt;</span><span class="identifier">F</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.bind.mp_bind_front_q_q_t"><code class="computeroutput"><span class="identifier">mp_bind_front_q</span><span class="special">&lt;</span><span class="identifier">Q</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.bind.mp_bind_back_f_t"><code class="computeroutput"><span class="identifier">mp_bind_back</span><span class="special">&lt;</span><span class="identifier">F</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.bind.mp_bind_back_q_q_t"><code class="computeroutput"><span class="identifier">mp_bind_back_q</span><span class="special">&lt;</span><span class="identifier">Q</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.integer_sequence">Integer Sequences,
       <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer_sequence</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a></span></dt>
@@ -244,7 +253,7 @@
 </pre>
 <p>
       A <span class="emphasis"><em>quoted metafunction</em></span> is a class with a public metafunction
-      called <code class="computeroutput"><span class="identifier">fn</span></code>, for example
+      member called <code class="computeroutput"><span class="identifier">fn</span></code>, for example
     </p>
 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Q1</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">using</span> <span class="identifier">fn</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">;</span> <span class="special">};</span>
 <span class="keyword">struct</span> <span class="identifier">Q2</span> <span class="special">{</span> <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">fn</span> <span class="special">=</span> <span class="identifier">T</span><span class="special">*;</span> <span class="special">};</span>
@@ -727,7 +736,7 @@
 <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">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_apply</span> <span class="special">=</span> <span class="identifier">mp_rename</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">F</span><span class="special">&gt;;</span>
 </pre>
 <p>
-          <code class="computeroutput"><span class="identifier">mp_apply</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> applies the metafunction <code class="computeroutput"><span class="identifier">F</span></code> to the contents of the list <code class="computeroutput"><span class="identifier">L</span></code>, that is, <code class="computeroutput"><span class="identifier">mp_rename</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">,</span> <span class="identifier">L</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;&gt;</span></code>
+          <code class="computeroutput"><span class="identifier">mp_apply</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> applies the metafunction <code class="computeroutput"><span class="identifier">F</span></code> to the contents of the list <code class="computeroutput"><span class="identifier">L</span></code>, that is, <code class="computeroutput"><span class="identifier">mp_apply</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">,</span> <span class="identifier">L</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;&gt;</span></code>
           is an alias for <code class="computeroutput"><span class="identifier">F</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;</span></code>.
           (<code class="computeroutput"><span class="identifier">mp_apply</span></code> is the same as
           <code class="computeroutput"><span class="identifier">mp_rename</span></code> with the arguments
@@ -736,6 +745,18 @@
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
+<a name="mp11.reference.list.mp_apply_q_q_l"></a><a class="link" href="mp11.html#mp11.reference.list.mp_apply_q_q_l" title="mp_apply_q&lt;Q, L&gt;"><code class="computeroutput"><span class="identifier">mp_apply_q</span><span class="special">&lt;</span><span class="identifier">Q</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">class</span> <span class="identifier">Q</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_apply_q</span> <span class="special">=</span> <span class="identifier">mp_apply</span><span class="special">&lt;</span><span class="identifier">Q</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">fn</span><span class="special">,</span> <span class="identifier">L</span><span class="special">&gt;;</span>
+</pre>
+<p>
+          Same as <code class="computeroutput"><span class="identifier">mp_apply</span></code>, but takes
+          a quoted metafunction.
+        </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
 <a name="mp11.reference.list.mp_append_l"></a><a class="link" href="mp11.html#mp11.reference.list.mp_append_l" title="mp_append&lt;L...&gt;"><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>
 </h4></div></div></div>
 <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> <span class="identifier">L</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_append</span> <span class="special">=</span> <span class="comment">/*...*/</span><span class="special">;</span>
@@ -913,20 +934,19 @@
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
-<a name="mp11.reference.utility.mp_quote_f_t"></a><a class="link" href="mp11.html#mp11.reference.utility.mp_quote_f_t" title="mp_quote&lt;F, T...&gt;"><code class="computeroutput"><span class="identifier">mp_quote</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">,</span> <span class="identifier">T</span><span class="special">...&gt;</span></code></a>
+<a name="mp11.reference.utility.mp_quote_f"></a><a class="link" href="mp11.html#mp11.reference.utility.mp_quote_f" title="mp_quote&lt;F&gt;"><code class="computeroutput"><span class="identifier">mp_quote</span><span class="special">&lt;</span><span class="identifier">F</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">F</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">mp_quote</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">F</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">mp_quote</span>
 <span class="special">{</span>
-    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">fn</span> <span class="special">=</span> <span class="identifier">F</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>
+    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">fn</span> <span class="special">=</span> <span class="identifier">F</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;;</span>
 <span class="special">};</span>
 </pre>
 <p>
-          <code class="computeroutput"><span class="identifier">mp_quote</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">,</span> <span class="identifier">T</span><span class="special">...&gt;</span></code> transforms the template <code class="computeroutput"><span class="identifier">F</span></code> into a type. In the common case <code class="computeroutput"><span class="identifier">mp_quote</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">&gt;</span></code>,
+          <code class="computeroutput"><span class="identifier">mp_quote</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">&gt;</span></code>
-          the nested template <code class="computeroutput"><span class="identifier">fn</span></code>
+          transforms the template <code class="computeroutput"><span class="identifier">F</span></code>
-          of the result is an alias for <code class="computeroutput"><span class="identifier">F</span></code>;
+          into a type with a nested template <code class="computeroutput"><span class="identifier">fn</span></code>
-          otherwise, <code class="computeroutput"><span class="identifier">fn</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">...&gt;</span></code>
+          such that <code class="computeroutput"><span class="identifier">fn</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;</span></code>
-          is an alias for <code class="computeroutput"><span class="identifier">F</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>,
+          returns <code class="computeroutput"><span class="identifier">F</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;</span></code>.
-          allowing partial application.
         </p>
 </div>
 <div class="section">
@@ -937,8 +957,7 @@
 </pre>
 <p>
           <code class="computeroutput"><span class="identifier">mp_invoke</span><span class="special">&lt;</span><span class="identifier">Q</span><span class="special">,</span> <span class="identifier">T</span><span class="special">...&gt;</span></code> evaluates the nested template <code class="computeroutput"><span class="identifier">fn</span></code> of a quoted metafunction. <code class="computeroutput"><span class="identifier">mp_invoke</span><span class="special">&lt;</span><span class="identifier">mp_quote</span><span class="special">&lt;</span><span class="identifier">F</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">F</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;</span></code>.
+          returns <code class="computeroutput"><span class="identifier">F</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;</span></code>.
-          <code class="computeroutput"><span class="identifier">mp_invoke</span><span class="special">&lt;</span><span class="identifier">mp_quote</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">,</span> <span class="identifier">T</span><span class="special">...&gt;,</span> <span class="identifier">U</span><span class="special">...&gt;</span></code> is an alias for <code class="computeroutput"><span class="identifier">F</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>
@@ -987,6 +1006,17 @@
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
+<a name="mp11.reference.algorithm.mp_transform_q_q_l"></a><a class="link" href="mp11.html#mp11.reference.algorithm.mp_transform_q_q_l" title="mp_transform_q&lt;Q, L...&gt;"><code class="computeroutput"><span class="identifier">mp_transform_q</span><span class="special">&lt;</span><span class="identifier">Q</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">class</span> <span class="identifier">Q</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">L</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_transform_q</span> <span class="special">=</span> <span class="identifier">mp_transform</span><span class="special">&lt;</span><span class="identifier">Q</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">fn</span><span class="special">,</span> <span class="identifier">L</span><span class="special">...&gt;;</span>
+</pre>
+<p>
+          As <code class="computeroutput"><span class="identifier">mp_transform</span></code>, but takes
+          a quoted metafunction.
+        </p>
+</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>
 </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>
@@ -1680,6 +1710,62 @@
           is <code class="computeroutput"><span class="identifier">F</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">G</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">&gt;&gt;</span></code>.
         </p>
 </div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="mp11.reference.bind.mp_bind_q_q_t"></a><a class="link" href="mp11.html#mp11.reference.bind.mp_bind_q_q_t" title="mp_bind_q&lt;Q, T...&gt;"><code class="computeroutput"><span class="identifier">mp_bind_q</span><span class="special">&lt;</span><span class="identifier">Q</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">Q</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_bind_q</span> <span class="special">=</span> <span class="identifier">mp_bind</span><span class="special">&lt;</span><span class="identifier">Q</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">fn</span><span class="special">,</span> <span class="identifier">T</span><span class="special">...&gt;;</span>
+</pre>
+<p>
+          As <code class="computeroutput"><span class="identifier">mp_bind</span></code>, but takes a
+          quoted metafunction.
+        </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="mp11.reference.bind.mp_bind_front_f_t"></a><a class="link" href="mp11.html#mp11.reference.bind.mp_bind_front_f_t" title="mp_bind_front&lt;F, T...&gt;"><code class="computeroutput"><span class="identifier">mp_bind_front</span><span class="special">&lt;</span><span class="identifier">F</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">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="special">...</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">mp_bind_front</span><span class="special">;</span>
+</pre>
+<p>
+          <code class="computeroutput"><span class="identifier">mp_bind_front</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">,</span> <span class="identifier">T</span><span class="special">...&gt;</span></code> binds the leftmost arguments of
+          <code class="computeroutput"><span class="identifier">F</span></code> to <code class="computeroutput"><span class="identifier">T</span><span class="special">...</span></code>. Its nested template <code class="computeroutput"><span class="identifier">fn</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">...&gt;</span></code> returns <code class="computeroutput"><span class="identifier">F</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.bind.mp_bind_front_q_q_t"></a><a class="link" href="mp11.html#mp11.reference.bind.mp_bind_front_q_q_t" title="mp_bind_front_q&lt;Q, T...&gt;"><code class="computeroutput"><span class="identifier">mp_bind_front_q</span><span class="special">&lt;</span><span class="identifier">Q</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">Q</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_bind_front_q</span> <span class="special">=</span> <span class="identifier">mp_bind_front</span><span class="special">&lt;</span><span class="identifier">Q</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">fn</span><span class="special">,</span> <span class="identifier">T</span><span class="special">...&gt;;</span>
+</pre>
+<p>
+          As <code class="computeroutput"><span class="identifier">mp_bind_front</span></code>, but takes
+          a quoted metafunction.
+        </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="mp11.reference.bind.mp_bind_back_f_t"></a><a class="link" href="mp11.html#mp11.reference.bind.mp_bind_back_f_t" title="mp_bind_back&lt;F, T...&gt;"><code class="computeroutput"><span class="identifier">mp_bind_back</span><span class="special">&lt;</span><span class="identifier">F</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">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="special">...</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">mp_bind_back</span><span class="special">;</span>
+</pre>
+<p>
+          <code class="computeroutput"><span class="identifier">mp_bind_back</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">,</span> <span class="identifier">T</span><span class="special">...&gt;</span></code> binds the rightmost arguments of
+          <code class="computeroutput"><span class="identifier">F</span></code> to <code class="computeroutput"><span class="identifier">T</span><span class="special">...</span></code>. Its nested template <code class="computeroutput"><span class="identifier">fn</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">...&gt;</span></code> returns <code class="computeroutput"><span class="identifier">F</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">...,</span> <span class="identifier">T</span><span class="special">...&gt;</span></code>.
+        </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="mp11.reference.bind.mp_bind_back_q_q_t"></a><a class="link" href="mp11.html#mp11.reference.bind.mp_bind_back_q_q_t" title="mp_bind_back_q&lt;Q, T...&gt;"><code class="computeroutput"><span class="identifier">mp_bind_back_q</span><span class="special">&lt;</span><span class="identifier">Q</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">Q</span><span class="special">,</span> <span class="keyword">class</span><span class="special">...</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_bind_back_q</span> <span class="special">=</span> <span class="identifier">mp_bind_back</span><span class="special">&lt;</span><span class="identifier">Q</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">fn</span><span class="special">,</span> <span class="identifier">T</span><span class="special">...&gt;;</span>
+</pre>
+<p>
+          As <code class="computeroutput"><span class="identifier">mp_bind_back</span></code>, but takes
+          a quoted metafunction.
+        </p>
+</div>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h3 class="title">
@@ -1780,7 +1866,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: April 01, 2017 at 16:43:16 GMT</small></p></td>
+<td align="left"><p><small>Last revised: May 12, 2017 at 16:48:16 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

doc/mp11/algorithm.qbk

@@ -26,6 +26,12 @@
 `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_q<Q, L...>`]
+    template<class Q, class... L> using mp_transform_q = mp_transform<Q::template fn, L...>;
+
+As `mp_transform`, but takes a quoted metafunction.
+[endsect]
+
 [section `mp_transform_if<P, F, L...>`]
     template<template<class...> class P, template<class...> class F, class L...> using mp_transform_if = /*...*/;
 
@@ -238,4 +244,4 @@ for the elements of `L<U1...>` and `mp_false` for the elements of `L<U2...>`. Re
 `mp_any_of<L, P>` is `mp_true` when `P` holds for at least one element of `L`, `mp_false` otherwise. When `L` is empty, the result is `mp_false`.
 [endsect]
 
-[endsect]
+[endsect:algorithm]

doc/mp11/bind.qbk

@@ -38,4 +38,34 @@ of `U...` and the `mp_bind` expressions replaced with their corresponding evalua
 For example, `mp_bind<F, int, _2, mp_bind<G, _1>>::fn<float, void>` is `F<int, void, G<float>>`.
 [endsect]
 
+[section `mp_bind_q<Q, T...>`]
+    template<class Q, class... T> using mp_bind_q = mp_bind<Q::template fn, T...>;
+
+As `mp_bind`, but takes a quoted metafunction.
 [endsect]
+
+[section `mp_bind_front<F, T...>`]
+    template<template<class...> class F, class... T> struct mp_bind_front;
+
+`mp_bind_front<F, T...>` binds the leftmost arguments of `F` to `T...`. Its nested template `fn<U...>` returns `F<T..., U...>`.
+[endsect]
+
+[section `mp_bind_front_q<Q, T...>`]
+    template<class Q, class... T> using mp_bind_front_q = mp_bind_front<Q::template fn, T...>;
+
+As `mp_bind_front`, but takes a quoted metafunction.
+[endsect]
+
+[section `mp_bind_back<F, T...>`]
+    template<template<class...> class F, class... T> struct mp_bind_back;
+
+`mp_bind_back<F, T...>` binds the rightmost arguments of `F` to `T...`. Its nested template `fn<U...>` returns `F<U..., T...>`.
+[endsect]
+
+[section `mp_bind_back_q<Q, T...>`]
+    template<class Q, class... T> using mp_bind_back_q = mp_bind_back<Q::template fn, T...>;
+
+As `mp_bind_back`, but takes a quoted metafunction.
+[endsect]
+
+[endsect:bind]

doc/mp11/definitions.qbk

@@ -6,7 +6,7 @@
  / http://www.boost.org/LICENSE_1_0.txt)
  /]
 
-[section Definitions]
+[section:definitions Definitions]
 
 A /list/ is a '''—''' usually but not necessarily variadic '''—''' template class whose parameters are all types,
 for example `mp_list<char[], void>`, `mp_list<>`, `std::tuple<int, float, char>`, `std::pair<int, float>`, `std::shared_ptr<X>`.
@@ -18,7 +18,7 @@ A /metafunction/ is a class template or a template alias whose parameters are al
   template<class T> using F2 = T*;
   template<class... T> using F3 = std::integral_constant<std::size_t, sizeof...(T)>;
 
-A /quoted metafunction/ is a class with a public metafunction called `fn`, for example
+A /quoted metafunction/ is a class with a public metafunction member called `fn`, for example
 
   struct Q1 { template<class...> using fn = void; };
   struct Q2 { template<class T> using fn = T*; };
@@ -36,4 +36,4 @@ A /map/ is a list of lists, the inner lists having at least one element (the key
   using M1 = std::tuple<std::pair<int, int*>, std::pair<float, float*>, std::pair<void, void*>>;
   using M2 = mp_list<mp_list<int, int*>, mp_list<float>, mp_list<char, char[1], char[2]>>;
 
-[endsect]
+[endsect:definitions]

doc/mp11/examples.qbk

@@ -6,7 +6,7 @@
  / http://www.boost.org/LICENSE_1_0.txt)
  /]
 
-[section Examples]
+[section:examples Examples]
 
 [section Generating Test Cases]
 
@@ -173,4 +173,4 @@ and we're done:
 
 [endsect]
 
-[endsect]
+[endsect:examples]

doc/mp11/function.qbk

@@ -37,4 +37,4 @@ If no such type exists, the last one is returned. `mp_or<>` is `mp_false`. Simil
 `mp_or`, but does not perform short-circuit evaluation.
 [endsect]
 
-[endsect]
+[endsect:function]

doc/mp11/integer_sequence.qbk

@@ -42,4 +42,4 @@ The contents of this header are defined in namespace `boost`.
 `index_sequence_for<N>` is `make_index_sequence<sizeof...(T)>`. Same as C++14's `std::index_sequence_for`.
 [endsect]
 
-[endsect]
+[endsect:integer_sequence]

doc/mp11/integral.qbk

@@ -38,4 +38,4 @@ For an Mp11 integral constant type `T`, `T::value` is an integral constant in th
     template<std::size_t N> using mp_size_t = std::integral_constant<std::size_t, N>;
 [endsect]
 
-[endsect]
+[endsect:integral]

doc/mp11/list.qbk

@@ -88,10 +88,16 @@ is an alias for `L<U..., T...>`.
 [section `mp_apply<F, L>`]
     template<template<class...> class F, class L> using mp_apply = mp_rename<L, F>;
 
-`mp_apply<F, L>` applies the metafunction `F` to the contents of the list `L`, that is, `mp_rename<F, L<T...>>` is an alias for `F<T...>`.
+`mp_apply<F, L>` applies the metafunction `F` to the contents of the list `L`, that is, `mp_apply<F, L<T...>>` is an alias for `F<T...>`.
 (`mp_apply` is the same as `mp_rename` with the arguments reversed.)
 [endsect]
 
+[section `mp_apply_q<Q, L>`]
+    template<class Q, class L> using mp_apply_q = mp_apply<Q::template fn, L>;
+
+Same as `mp_apply`, but takes a quoted metafunction.
+[endsect]
+
 [section `mp_append<L...>`]
     template<class... L> using mp_append = /*...*/;
 
@@ -126,4 +132,4 @@ is an alias for `L<U1, T, U...>`.
 is an alias for `L<U1, U2, T, U...>`.
 [endsect]
 
-[endsect]
+[endsect:list]

doc/mp11/map.qbk

@@ -48,4 +48,4 @@ replaces the existing element `L<X, Y...>` with `L<X, F<X, Y...>>`.
 If the map `M` contains an element with a key `K`, removes it.
 [endsect]
 
-[endsect]
+[endsect:map]

doc/mp11/overview.qbk

@@ -6,7 +6,7 @@
  / http://www.boost.org/LICENSE_1_0.txt)
  /]
 
-[section Overview]
+[section:overview Overview]
 
 Mp11 is a C++11 metaprogramming library based on template aliases and variadic templates.
 It implements the approach outlined in the article
@@ -31,4 +31,4 @@ gives us `std::tuple<int*, float*>`, but we can also apply `mp_list` to the same
 
 and get `std::tuple<mp_list<int>, mp_list<float>>`.
 
-[endsect]
+[endsect:overview]

doc/mp11/set.qbk

@@ -28,4 +28,4 @@ For each `T1` in `T...`, `mp_set_push_back<S, T...>` appends `T1` to the end of
 `mp_set_push_front<S, T...>` inserts at the front of `S` those elements of `T...` for which `S` does not already contain the same type.
 [endsect]
 
-[endsect]
+[endsect:set]

doc/mp11/tuple_for_each.qbk

@@ -19,4 +19,4 @@ expression `f(std::get<J>(std::forward<Tp>(tp)))` for `J` in 0..`N-1`, where `N`
 Returns `std::forward<F>(f)`.
 [endsect]
 
-[endsect]
+[endsect:tuple_for_each]

doc/mp11/utility.qbk

@@ -61,20 +61,19 @@ When `mp_valid<F, T...>` is `mp_true`, `mp_defer<F, T...>` is a struct with a ne
 `mp_defer<F, T...>` is an empty struct.
 [endsect]
 
-[section `mp_quote<F, T...>`]
+[section `mp_quote<F>`]
-    template<template<class...> class F, class... T> struct mp_quote
+    template<template<class...> class F> struct mp_quote
     {
-        template<class... U> using fn = F<T..., U...>;
+        template<class... T> using fn = F<T...>;
     };
 
-`mp_quote<F, T...>` transforms the template `F` into a type. In the common case `mp_quote<F>`, the nested template `fn` of the result is an alias for `F`;
+`mp_quote<F>` transforms the template `F` into a type with a nested template `fn` such that `fn<T...>` returns `F<T...>`.
-otherwise, `fn<U...>` is an alias for `F<T..., U...>`, allowing partial application.
 [endsect]
 
 [section `mp_invoke<Q, T...>`]
     template<class Q, class... T> using mp_invoke = typename Q::template fn<T...>;
 
-`mp_invoke<Q, T...>` evaluates the nested template `fn` of a quoted metafunction. `mp_invoke<mp_quote<F>, T...>` is an alias for `F<T...>`. `mp_invoke<mp_quote<F, T...>, U...>` is an alias for `F<T..., U...>`.
+`mp_invoke<Q, T...>` evaluates the nested template `fn` of a quoted metafunction. `mp_invoke<mp_quote<F>, T...>` returns `F<T...>`.
 [endsect]
 
-[endsect]
+[endsect:utility]

include/boost/mp11/algorithm.hpp

@@ -80,6 +80,7 @@ template<template<class...> class F, template<class...> class L1, class... T1, t
 } // namespace detail
 
 template<template<class...> class F, class... L> using mp_transform = typename detail::mp_transform_impl<F, L...>::type;
+template<class Q, class... L> using mp_transform_q = mp_transform<Q::template fn, L...>;
 
 namespace detail
 {

include/boost/mp11/bind.hpp

@@ -16,6 +16,7 @@ namespace boost
 namespace mp11
 {
 
+// mp_arg
 template<std::size_t I> struct mp_arg
 {
     template<class... T> using fn = mp_at_c<mp_list<T...>, I>;
@@ -31,6 +32,7 @@ using _7 = mp_arg<6>;
 using _8 = mp_arg<7>;
 using _9 = mp_arg<8>;
 
+// mp_bind
 template<template<class...> class F, class... T> struct mp_bind;
 
 namespace detail
@@ -58,6 +60,45 @@ template<template<class...> class F, class... T> struct mp_bind
     template<class... U> using fn = F<typename detail::eval_bound_arg<T, U...>::type...>;
 };
 
+template<class Q, class... T> using mp_bind_q = mp_bind<Q::template fn, T...>;
+
+// mp_bind_front
+template<template<class...> class F, class... T> struct mp_bind_front
+{
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1910 && BOOST_MSVC >= 1900 )
+#else
+private:
+#endif
+
+	template<class... U> struct _fn { using type = F<T..., U...>; };
+
+public:
+
+	// the indirection through _fn works around the language inability
+	// to expand U... into a fixed parameter list of an alias template
+
+	template<class... U> using fn = typename _fn<U...>::type;
+};
+
+template<class Q, class... T> using mp_bind_front_q = mp_bind_front<Q::template fn, T...>;
+
+// mp_bind_back
+template<template<class...> class F, class... T> struct mp_bind_back
+{
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1910 && BOOST_MSVC >= 1900 )
+#else
+private:
+#endif
+
+	template<class... U> struct _fn { using type = F<U..., T...>; };
+
+public:
+
+	template<class... U> using fn = typename _fn<U...>::type;
+};
+
+template<class Q, class... T> using mp_bind_back_q = mp_bind_back<Q::template fn, T...>;
+
 } // namespace mp11
 } // namespace boost
 

include/boost/mp11/list.hpp

@@ -150,6 +150,8 @@ template<class A, template<class...> class B> using mp_rename = typename detail:
 
 template<template<class...> class F, class L> using mp_apply = typename detail::mp_rename_impl<L, F>::type;
 
+template<class Q, class L> using mp_apply_q = typename detail::mp_rename_impl<L, Q::template fn>::type;
+
 // mp_replace_front<L, T>
 namespace detail
 {

include/boost/mp11/utility.hpp

@@ -9,6 +9,8 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/mp11/integral.hpp>
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
 
 namespace boost
 {
@@ -104,18 +106,21 @@ struct mp_no_type
 template<template<class...> class F, class... T> using mp_defer = mp_if<mp_valid<F, T...>, detail::mp_defer_impl<F, T...>, detail::mp_no_type>;
 
 // mp_quote
-template<template<class...> class F, class... T> struct mp_quote
+template<template<class...> class F> struct mp_quote
 {
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1910 && BOOST_MSVC >= 1900 )
+#else
 private:
+#endif
 
-    template<class... U> struct _fn { using type = F<T..., U...>; };
+    template<class... T> struct _fn { using type = F<T...>; };
 
 public:
 
     // the indirection through _fn works around the language inability
-    // to expand T.. to expand into a fixed parameter list of an alias template
+    // to expand T... into a fixed parameter list of an alias template
 
-    template<class... U> using fn = typename _fn<U...>::type;
+    template<class... T> using fn = typename _fn<T...>::type;
 };
 
 // mp_unquote
@@ -127,11 +132,6 @@ template<class Q, class... T> struct mp_invoke_impl
     using type = typename Q::template fn<T...>;
 };
 
-template<template<class...> class F, class... T, class... U> struct mp_invoke_impl<mp_quote<F, T...>, U...>
-{
-    using type = F<T..., U...>;
-};
-
 } // namespace detail
 
 template<class Q, class... T> using mp_invoke = typename detail::mp_invoke_impl<Q, T...>::type;

include/boost/tuple_for_each.hpp

@@ -17,7 +17,7 @@ namespace detail
 template<class Tp, std::size_t... J, class F> BOOST_CONSTEXPR F tuple_for_each_impl( Tp && tp, boost::integer_sequence<std::size_t, J...>, F && f )
 {
     using A = int[sizeof...(J)];
-    return (void)A{ (f(std::get<J>(std::forward<Tp>(tp))), 0)... }, std::forward<F>(f);
+    return (void)A{ ((void)f(std::get<J>(std::forward<Tp>(tp))), 0)... }, std::forward<F>(f);
 }
 
 } // namespace detail

test/Jamfile.v2

@@ -29,6 +29,7 @@ run mp_append_2.cpp : : : $(REQ) ;
 run mp_replace_front.cpp : : : $(REQ) ;
 run mp_replace_second.cpp : : : $(REQ) ;
 run mp_replace_third.cpp : : : $(REQ) ;
+run mp_apply_q.cpp : : : $(REQ) ;
 
 # algorithm
 run mp_assign.cpp : : : $(REQ) ;
@@ -106,3 +107,6 @@ run mp_map_update.cpp : : : $(REQ) ;
 
 # bind
 run mp_bind.cpp : : : $(REQ) ;
+run mp_bind_q.cpp : : : $(REQ) ;
+run mp_bind_front.cpp : : : $(REQ) ;
+run mp_bind_back.cpp : : : $(REQ) ;

test/mp_apply_q.cpp

@@ -0,0 +1,113 @@
+
+//  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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+template<class... T> struct X {};
+template<class... T> using Y = X<T...>;
+
+struct Q
+{
+    template<class... T> using fn = X<T...>;
+};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_quote;
+    using boost::mp11::mp_apply_q;
+
+    using L1 = mp_list<>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L1>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L1>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L1>, X<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L1>, Y<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L1>, X<>>));
+
+    using L2 = mp_list<char>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L2>, mp_list<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L2>, std::tuple<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L2>, X<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L2>, Y<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L2>, X<char>>));
+
+    using L3 = mp_list<char, double>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L3>, mp_list<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L3>, std::tuple<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L3>, X<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L3>, Y<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::pair>, L3>, std::pair<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L3>, X<char, double>>));
+
+    using L4 = mp_list<int, char, float>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L4>, mp_list<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L4>, std::tuple<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L4>, X<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L4>, Y<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L4>, X<int, char, float>>));
+
+    //
+
+    using L5 = std::tuple<>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L5>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L5>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L5>, X<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L5>, Y<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L5>, X<>>));
+
+    using L6 = std::tuple<char>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L6>, mp_list<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L6>, std::tuple<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L6>, X<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L6>, Y<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L6>, X<char>>));
+
+    using L7 = std::tuple<char, double>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L7>, mp_list<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L7>, std::tuple<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L7>, X<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L7>, Y<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::pair>, L7>, std::pair<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L7>, X<char, double>>));
+
+    using L8 = std::tuple<int, char, float>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L8>, mp_list<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L8>, std::tuple<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L8>, X<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L8>, Y<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L8>, X<int, char, float>>));
+
+    //
+
+    using L9 = std::pair<char, double>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L9>, mp_list<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L9>, std::tuple<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L9>, X<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L9>, Y<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::pair>, L9>, std::pair<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L9>, X<char, double>>));
+
+    //
+
+    return boost::report_errors();
+}

test/mp_bind_back.cpp

@@ -0,0 +1,63 @@
+
+// Copyright 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/bind.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+template<class...> struct L {};
+template<class, class> struct P {};
+
+template<class T, class U> using is_base_of_t = typename std::is_base_of<T, U>::type;
+
+struct B1 {};
+struct B2 {};
+struct D: B1, B2 {};
+struct NB {};
+
+int main()
+{
+    using namespace boost::mp11;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_back<L, char[1], char[2]>::fn<int[1], int[2], int[3]>, L<int[1], int[2], int[3], char[1], char[2]>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_back_q<mp_quote<L>, char[1], char[2]>::fn<int[1], int[2], int[3]>, L<int[1], int[2], int[3], char[1], char[2]>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_back<P, char[1]>::fn<int[1]>, P<int[1], char[1]>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_back_q<mp_quote<P>, char[1]>::fn<int[1]>, P<int[1], char[1]>>));
+
+    //
+
+    using L1 = L<B1, B2, NB>;
+
+    {
+        using L2 = mp_transform<mp_bind_back<is_base_of_t, D>::fn, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    {
+        using L2 = mp_transform_q<mp_bind_back<is_base_of_t, D>, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    {
+        using L2 = mp_transform<mp_bind_back_q<mp_quote<is_base_of_t>, D>::fn, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    {
+        using L2 = mp_transform_q<mp_bind_back_q<mp_quote<is_base_of_t>, D>, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    //
+
+    return boost::report_errors();
+}

test/mp_bind_front.cpp

@@ -0,0 +1,63 @@
+
+// Copyright 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/bind.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+template<class...> struct L {};
+template<class, class> struct P {};
+
+template<class T, class U> using is_base_of_t = typename std::is_base_of<T, U>::type;
+
+struct B {};
+struct D1: B {};
+struct D2: B {};
+struct ND {};
+
+int main()
+{
+    using namespace boost::mp11;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_front<L, char[1], char[2]>::fn<int[1], int[2], int[3]>, L<char[1], char[2], int[1], int[2], int[3]>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_front_q<mp_quote<L>, char[1], char[2]>::fn<int[1], int[2], int[3]>, L<char[1], char[2], int[1], int[2], int[3]>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_front<P, char[1]>::fn<int[1]>, P<char[1], int[1]>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_front_q<mp_quote<P>, char[1]>::fn<int[1]>, P<char[1], int[1]>>));
+
+    //
+
+    using L1 = L<D1, D2, ND>;
+
+    {
+        using L2 = mp_transform<mp_bind_front<is_base_of_t, B>::fn, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    {
+        using L2 = mp_transform_q<mp_bind_front<is_base_of_t, B>, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    {
+        using L2 = mp_transform<mp_bind_front_q<mp_quote<is_base_of_t>, B>::fn, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    {
+        using L2 = mp_transform_q<mp_bind_front_q<mp_quote<is_base_of_t>, B>, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    //
+
+    return boost::report_errors();
+}

test/mp_bind_q.cpp

@@ -0,0 +1,62 @@
+
+// Copyright 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/bind.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+struct X6 {};
+struct X7 {};
+struct X8 {};
+struct X9 {};
+
+template<class T> using add_pointer = typename std::add_pointer<T>::type;
+
+int main()
+{
+    using namespace boost::mp11;
+
+    using Q_addp = mp_quote<add_pointer>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _1>::fn<X1>, X1*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _1>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X1*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _2>::fn<X1, X2>, X2*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _2>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X2*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _3>::fn<X1, X2, X3>, X3*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _3>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X3*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _4>::fn<X1, X2, X3, X4>, X4*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _4>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X4*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _5>::fn<X1, X2, X3, X4, X5>, X5*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _5>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X5*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _6>::fn<X1, X2, X3, X4, X5, X6>, X6*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _6>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X6*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _7>::fn<X1, X2, X3, X4, X5, X6, X7>, X7*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _7>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X7*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _8>::fn<X1, X2, X3, X4, X5, X6, X7, X8>, X8*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _8>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X8*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _9>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X9*>));
+
+    //
+
+    return boost::report_errors();
+}

test/mp_quote.cpp

@@ -19,12 +19,9 @@ template<template<class...> class F, class... T> using Y = X<F<T>...>;
 
 template<class Q, class... T> using Z = X<mp_invoke<Q, T>...>;
 
-struct B {};
+template<class T, class U> struct P {};
-struct D1: B {};
-struct D2: B {};
-struct ND {};
 
-template<class T, class U> using is_base_of_t = typename std::is_base_of<T, U>::type;
+template<class T, class U> using first = T;
 
 int main()
 {
@@ -38,19 +35,6 @@ int main()
         BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke<Q, int[]>, int[]>));
     }
 
-    {
-        using Q = mp_quote<std::is_same, void>;
-
-        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke<Q, void>, std::is_same<void, void>>));
-        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke<Q, int[]>, std::is_same<void, int[]>>));
-    }
-
-    {
-        using Q = mp_quote<X, char[1], char[2], char[3]>;
-
-        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke<Q, int[1], int[2], int[3]>, X<char[1], char[2], char[3], int[1], int[2], int[3]>>));
-    }
-
     {
         using Q = mp_quote<mp_identity_t>;
 
@@ -68,19 +52,17 @@ int main()
     }
 
     {
-        using Q = mp_quote<is_base_of_t, B>;
+        using Q = mp_quote<P>;
 
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1800 )
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke<Q, void, void>, P<void, void>>));
-#else
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke<Q, char[], int[]>, P<char[], int[]>>));
-        using R1 = Y<Q::fn, D1, D2, ND, int>;
+    }
-        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, X<std::true_type, std::true_type, std::false_type, std::false_type>>));
-#endif
 
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1910 && BOOST_MSVC >= 1900 )
+    {
-#else
+        using Q = mp_quote<first>;
-        using R2 = Z<Q, D1, D2, ND, int>;
+
-        BOOST_TEST_TRAIT_TRUE((std::is_same<R2, X<std::true_type, std::true_type, std::false_type, std::false_type>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke<Q, void, int>, void>));
-#endif
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke<Q, char[], int[]>, char[]>));
     }
 
     return boost::report_errors();