diff --git a/doc/html/mp11.html b/doc/html/mp11.html
index 0fb5124..2095b7c 100644
--- a/doc/html/mp11.html
+++ b/doc/html/mp11.html
@@ -6,7 +6,7 @@
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <meta name="generator" content="Asciidoctor 1.5.5">
 <meta name="author" content="Peter Dimov">
-<title>Boost.Mp11</title>
+<title>Boost.Mp11: A C++11 metaprogramming library</title>
 <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Open+Sans:300,300italic,400,400italic,600,600italic%7CNoto+Serif:400,400italic,700,700italic%7CDroid+Sans+Mono:400,700">
 <style>
 /* Asciidoctor default stylesheet | MIT License | http://asciidoctor.org */
@@ -421,7 +421,7 @@ body.book #toc,body.book #preamble,body.book h1.sect0,body.book .sect1>h2{page-b
 </head>
 <body class="article toc2 toc-left">
 <div id="header">
-<h1>Boost.Mp11</h1>
+<h1>Boost.Mp11: A C++11 metaprogramming library</h1>
 <div class="details">
 <span id="author" class="author">Peter Dimov</span><br>
 </div>
@@ -433,8 +433,8 @@ body.book #toc,body.book #preamble,body.book h1.sect0,body.book .sect1>h2{page-b
 <li><a href="#examples">Examples</a>
 <ul class="sectlevel2">
 <li><a href="#generating_test_cases">Generating Test Cases</a></li>
-<li><a href="#writing_code_common_type_code_specializations">Writing <code>common_type</code> specializations</a></li>
-<li><a href="#fixing_code_tuple_cat_code">Fixing <code>tuple_cat</code></a></li>
+<li><a href="#writing_common_type_specializations">Writing common_type Specializations</a></li>
+<li><a href="#fixing_tuple_cat">Fixing tuple_cat</a></li>
 <li><a href="#computing_return_types">Computing Return Types</a></li>
 </ul>
 </li>
@@ -607,8 +607,9 @@ body.book #toc,body.book #preamble,body.book h1.sect0,body.book .sect1>h2{page-b
 <h2 id="overview">Overview</h2>
 <div class="sectionbody">
 <div class="paragraph">
-<p>Mp11 is a C++11 metaprogramming library based on template aliases and variadic templates.
-It implements the approach outlined in the article
+<p>Mp11 is a C++11 metaprogramming library for compile-time manipulation of data structures
+that contain types. It&#8217;s based on template aliases and variadic templates and implements the
+approach outlined in the article
 <a href="http://pdimov.com/cpp2/simple_cxx11_metaprogramming.html">"Simple C++ metaprogramming"</a>
 and <a href="http://pdimov.com/cpp2/simple_cxx11_metaprogramming_2.html">its sequel</a>. Reading these
 articles before proceeding with this documentation is <em>highly</em> recommended.</p>
@@ -649,21 +650,26 @@ for example <code>mp_list&lt;char[], void&gt;</code>, <code>mp_list&lt;&gt;</cod
 <p>A <em>metafunction</em> is a class template or a template alias whose parameters are all types, for example <code>std::add_pointer_t</code>,
 <code>std::is_const</code>, <code>mp_second</code>, <code>mp_push_front</code>, <code>mp_list</code>, <code>std::tuple</code>, <code>std::pair</code>, <code>std::shared_ptr</code>, or</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
 <div class="content">
-<pre>template&lt;class...&gt; using F1 = void;
+<pre class="highlight"><code>template&lt;class...&gt; using F1 = void;
+
 template&lt;class T&gt; using F2 = T*;
-template&lt;class... T&gt; using F3 = std::integral_constant&lt;std::size_t, sizeof...(T)&gt;;</pre>
+
+template&lt;class... T&gt; using F3 = std::integral_constant&lt;std::size_t, sizeof...(T)&gt;;</code></pre>
 </div>
 </div>
 <div class="paragraph">
 <p>A <em>quoted metafunction</em> is a class with a public metafunction member called <code>fn</code>, for example</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
 <div class="content">
-<pre>struct Q1 { template&lt;class...&gt; using fn = void; };
+<pre class="highlight"><code>struct Q1 { template&lt;class...&gt; using fn = void; };
+
 struct Q2 { template&lt;class T&gt; using fn = T*; };
-struct Q3 { template&lt;class... T&gt; using fn = std::integral_constant&lt;std::size_t, sizeof...(T)&gt;; };</pre>
+
+struct Q3 { template&lt;class... T&gt; using fn =
+  std::integral_constant&lt;std::size_t, sizeof...(T)&gt;; };</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -681,10 +687,13 @@ struct Q3 { template&lt;class... T&gt; using fn = std::integral_constant&lt;std:
 <div class="paragraph">
 <p>A <em>map</em> is a list of lists, the inner lists having at least one element (the key.) The keys of the map must be unique. For example,</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
 <div class="content">
-<pre>using M1 = std::tuple&lt;std::pair&lt;int, int*&gt;, std::pair&lt;float, float*&gt;, std::pair&lt;void, void*&gt;&gt;;
-using M2 = mp_list&lt;mp_list&lt;int, int*&gt;, mp_list&lt;float&gt;, mp_list&lt;char, char[1], char[2]&gt;&gt;;</pre>
+<pre class="highlight"><code>using M1 = std::tuple&lt;std::pair&lt;int, int*&gt;, std::pair&lt;float, float*&gt;,
+    std::pair&lt;void, void*&gt;&gt;;
+
+using M2 = mp_list&lt;mp_list&lt;int, int*&gt;, mp_list&lt;float&gt;,
+    mp_list&lt;char, char[1], char[2]&gt;&gt;;</code></pre>
 </div>
 </div>
 </div>
@@ -821,7 +830,7 @@ int main()
 </div>
 </div>
 <div class="sect2">
-<h3 id="writing_code_common_type_code_specializations">Writing <code>common_type</code> specializations</h3>
+<h3 id="writing_common_type_specializations">Writing common_type Specializations</h3>
 <div class="paragraph">
 <p>The standard trait <code>std::common_type</code>, used to obtain a type to which all of its arguments can convert without
 unnecessary loss of precision, can be user-specialized when its default implementation (based on the ternary <code>?:</code>
@@ -881,7 +890,8 @@ combined into their common type, and we take the union of the set of error types
 <div class="listingblock">
 <div class="content">
 <pre class="highlight"><code>template&lt;class T1, class E1, class T2, class E2&gt; using common_expected =
-    mp_rename&lt;mp_push_front&lt;mp_unique&lt;mp_append&lt;E1, E2&gt;&gt;, common_type_t&lt;T1, T2&gt;&gt;, expected&gt;;
+    mp_rename&lt;mp_push_front&lt;mp_unique&lt;mp_append&lt;E1, E2&gt;&gt;, common_type_t&lt;T1, T2&gt;&gt;,
+        expected&gt;;
 
 namespace std
 {
@@ -903,7 +913,7 @@ to <code>expected</code>.</p>
 </div>
 </div>
 <div class="sect2">
-<h3 id="fixing_code_tuple_cat_code">Fixing <code>tuple_cat</code></h3>
+<h3 id="fixing_tuple_cat">Fixing tuple_cat</h3>
 <div class="paragraph">
 <p>The article <a href="http://pdimov.com/cpp2/simple_cxx11_metaprogramming.html#">Simple C++11 metaprogramming</a> builds an
 implementation of the standard function <code>tuple_cat</code>, with the end result given below:</p>
@@ -926,7 +936,9 @@ template&lt;class... Tp,
 
     // inner
 
-    using list1 = mp_list&lt;mp_rename&lt;typename std::remove_reference&lt;Tp&gt;::type, mp_list&gt;...&gt;;
+    using list1 = mp_list&lt;
+        mp_rename&lt;typename std::remove_reference&lt;Tp&gt;::type, mp_list&gt;...&gt;;
+
     using list2 = mp_iota_c&lt;N&gt;;
 
     using list3 = mp_transform&lt;mp_fill, list1, list2&gt;;
@@ -941,7 +953,8 @@ template&lt;class... Tp,
 
     //
 
-    return tuple_cat_&lt;R&gt;( inner(), outer(), std::forward_as_tuple( std::forward&lt;Tp&gt;(tp)... ) );
+    return tuple_cat_&lt;R&gt;( inner(), outer(),
+        std::forward_as_tuple( std::forward&lt;Tp&gt;(tp)... ) );
 }</code></pre>
 </div>
 </div>
@@ -985,7 +998,7 @@ auto result = ::tuple_cat( t1, t2 );</code></pre>
 <p>Let&#8217;s fix these one by one. Support for move-only types is easy, if one knows where to look. The problem is
 that <code>Tp</code> that we&#8217;re passing to the helper <code>tuple_cat_</code> is (correctly) <code>tuple&lt;unique_ptr&lt;int&gt;&amp;&amp;, unique_ptr&lt;float&gt;&amp;&amp;&gt;</code>,
 but <code>std::get&lt;0&gt;(tp)</code> still returns <code>unique_ptr&lt;int&gt;&amp;</code>, because <code>tp</code> is an lvalue. This behavior is a bit
-surprising, but consistent with how rvalue reference members are treated by the language.</p>
+surprising, but is intended to prevent inadvertent double moves.</p>
 </div>
 <div class="paragraph">
 <p>Long story short, we need <code>std::move(tp)</code> in <code>tuple_cat_</code> to make <code>tp</code> an rvalue:</p>
@@ -1116,7 +1129,8 @@ template&lt;class... Tp,
 
     //
 
-    return tuple_cat_&lt;R&gt;( inner(), outer(), std::forward_as_tuple( std::forward&lt;Tp&gt;(tp)... ) );
+    return tuple_cat_&lt;R&gt;( inner(), outer(),
+        std::forward_as_tuple( std::forward&lt;Tp&gt;(tp)... ) );
 }</code></pre>
 </div>
 </div>
@@ -1171,7 +1185,8 @@ calling <code>f</code> with all possible combinations of variant values.</p>
 <div class="content">
 <pre>template&lt;class F&gt; struct Qret
 {
-    template&lt;class... T&gt; using fn = decltype( std::declval&lt;F&gt;()( std::declval&lt;T&gt;()... ) );
+    template&lt;class... T&gt; using fn =
+        decltype( std::declval&lt;F&gt;()( std::declval&lt;T&gt;()... ) );
 };</pre>
 </div>
 </div>
@@ -1194,7 +1209,7 @@ the same as <code>mp_product</code>, but for quoted metafunctions such as our <c
 <div class="paragraph">
 <p>One more step remains. Suppose that, as above, we&#8217;re passing two variants of type <code>std::variant&lt;short, int, float&gt;</code> and <code>F</code> is
 <code>[]( auto const&amp; x, auto const&amp; y ){ return x + y; }</code>. This will generate <code>R</code> of length 9, one per each combination, but many of those
-elements will be the same, either <code>int</code> or <code>float</code>, and we need to filter out the duplicates. So,</p>
+elements will be the same, either <code>int</code> or <code>float</code>, and we need to filter out the duplicates. So, we pass the result to <code>mp_unique</code>:</p>
 </div>
 <div class="literalblock">
 <div class="content">
@@ -1217,7 +1232,8 @@ using namespace boost::mp11;
 
 template&lt;class F&gt; struct Qret
 {
-    template&lt;class... T&gt; using fn = decltype( std::declval&lt;F&gt;()( std::declval&lt;T&gt;()... ) );
+    template&lt;class... T&gt; using fn =
+        decltype( std::declval&lt;F&gt;()( std::declval&lt;T&gt;()... ) );
 };
 
 template&lt;class F, class... V&gt; auto rvisit( F&amp;&amp; f, V&amp;&amp;... v )
@@ -1234,26 +1250,27 @@ template&lt;class T&gt; std::string name()
     return boost::core::demangle( typeid(T).name() );
 }
 
+template&lt;class V&gt; void print_variant( char const * n, V const&amp; v )
+{
+    std::cout &lt;&lt; "(" &lt;&lt; name&lt;decltype(v)&gt;() &lt;&lt; ")" &lt;&lt; n &lt;&lt; ": ";
+
+    std::visit( []( auto const&amp; x )
+        { std::cout &lt;&lt; "(" &lt;&lt; name&lt;decltype(x)&gt;() &lt;&lt; ")" &lt;&lt; x &lt;&lt; std::endl; }, v );
+}
+
 int main()
 {
-    std::variant&lt;signed char, unsigned char, signed short, unsigned short,
-        int, unsigned&gt; v1( 1 );
+    std::variant&lt;char, int, float&gt; v1( 1 );
 
-    std::cout &lt;&lt; "(" &lt;&lt; name&lt;decltype(v1)&gt;() &lt;&lt; ")v1: ";
-    std::visit( []( auto const&amp; x )
-        { std::cout &lt;&lt; "(" &lt;&lt; name&lt;decltype(x)&gt;() &lt;&lt; ")" &lt;&lt; x &lt;&lt; std::endl; }, v1 );
+    print_variant( "v1", v1 );
 
-    std::variant&lt;int, float, double&gt; v2( 2.0f );
+    std::variant&lt;short, int, double&gt; v2( 3.14 );
 
-    std::cout &lt;&lt; "(" &lt;&lt; name&lt;decltype(v2)&gt;() &lt;&lt; ")v2: ";
-    std::visit( []( auto const&amp; x )
-        { std::cout &lt;&lt; "(" &lt;&lt; name&lt;decltype(x)&gt;() &lt;&lt; ")" &lt;&lt; x &lt;&lt; std::endl; }, v2 );
+    print_variant( "v2", v2 );
 
     auto v3 = rvisit( []( auto const&amp; x, auto const&amp; y ){ return x + y; }, v1, v2 );
 
-    std::cout &lt;&lt; "(" &lt;&lt; name&lt;decltype(v3)&gt;() &lt;&lt; ")v3: ";
-    std::visit( []( auto const&amp; x )
-        { std::cout &lt;&lt; "(" &lt;&lt; name&lt;decltype(x)&gt;() &lt;&lt; ")" &lt;&lt; x &lt;&lt; std::endl; }, v3 );
+    print_variant( "v3", v3 );
 }</code></pre>
 </div>
 </div>
@@ -1278,6 +1295,9 @@ int main()
 <pre>template&lt;bool B&gt; using mp_bool = std::integral_constant&lt;bool, B&gt;;</pre>
 </div>
 </div>
+<div class="paragraph">
+<p>Same as <code>std::bool_constant</code> in C++17.</p>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_true">mp_true</h4>
@@ -1286,6 +1306,9 @@ int main()
 <pre>using mp_true = mp_bool&lt;true&gt;;</pre>
 </div>
 </div>
+<div class="paragraph">
+<p>Same as <code>std::true_type</code>.</p>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_false">mp_false</h4>
@@ -1294,6 +1317,9 @@ int main()
 <pre>using mp_false = mp_bool&lt;false&gt;;</pre>
 </div>
 </div>
+<div class="paragraph">
+<p>Same as <code>std::false_type</code>.</p>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_to_bool_t">mp_to_bool&lt;T&gt;</h4>
@@ -1354,22 +1380,25 @@ the list.</p>
 <p><code>mp_size&lt;L&gt;</code> returns the number of elements in the list <code>L</code>, as a <code>mp_size_t</code>. In other words, <code>mp_size&lt;L&lt;T&#8230;&#8203;&gt;&gt;</code> is an alias for
 <code>mp_size_t&lt;sizeof&#8230;&#8203;(T)&gt;</code>.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 1. Using mp_size with mp_list</div>
 <div class="content">
-<pre>using L1 = mp_list&lt;&gt;;
-using R1 = mp_size&lt;L1&gt;; // mp_size_t&lt;0&gt;</pre>
+<pre class="highlight"><code>using L1 = mp_list&lt;&gt;;
+using R1 = mp_size&lt;L1&gt;; // mp_size_t&lt;0&gt;</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 2. Using mp_size with std::pair</div>
 <div class="content">
-<pre>using L2 = std::pair&lt;int, int&gt;;
-using R2 = mp_size&lt;L2&gt;; // mp_size_t&lt;2&gt;</pre>
+<pre class="highlight"><code>using L2 = std::pair&lt;int, int&gt;;
+using R2 = mp_size&lt;L2&gt;; // mp_size_t&lt;2&gt;</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 3. Using mp_size with std::tuple</div>
 <div class="content">
-<pre>using L3 = std::tuple&lt;float&gt;;
-using R3 = mp_size&lt;L3&gt;; // mp_size_t&lt;1&gt;</pre>
+<pre class="highlight"><code>using L3 = std::tuple&lt;float&gt;;
+using R3 = mp_size&lt;L3&gt;; // mp_size_t&lt;1&gt;</code></pre>
 </div>
 </div>
 </div>
@@ -1383,6 +1412,16 @@ using R3 = mp_size&lt;L3&gt;; // mp_size_t&lt;1&gt;</pre>
 <div class="paragraph">
 <p><code>mp_empty&lt;L&gt;</code> is an alias for <code>mp_true</code> if the list <code>L</code> is empty, for <code>mp_false</code> otherwise.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 4. Using mp_empty with std::tuple</div>
+<div class="content">
+<pre class="highlight"><code>using L1 = std::tuple&lt;float&gt;;
+using R1 = mp_empty&lt;L1&gt;; // mp_false
+
+using L2 = std::tuple&lt;&gt;;
+using R2 = mp_empty&lt;L2&gt;; // mp_true</code></pre>
+</div>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_front_l">mp_front&lt;L&gt;</h4>
@@ -1394,22 +1433,25 @@ using R3 = mp_size&lt;L3&gt;; // mp_size_t&lt;1&gt;</pre>
 <div class="paragraph">
 <p><code>mp_front&lt;L&gt;</code> is the first element of the list <code>L</code>. That is, <code>mp_front&lt;L&lt;T1, T&#8230;&#8203;&gt;&gt;</code> is an alias for <code>T1</code>.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 5. Using mp_front with std::pair</div>
 <div class="content">
-<pre>using L1 = std::pair&lt;int, float&gt;;
-using R1 = mp_front&lt;L1&gt;; // int</pre>
+<pre class="highlight"><code>using L1 = std::pair&lt;int, float&gt;;
+using R1 = mp_front&lt;L1&gt;; // int</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 6. Using mp_front with std::tuple</div>
 <div class="content">
-<pre>using L2 = std::tuple&lt;float, double, long double&gt;;
-using R2 = mp_front&lt;L2&gt;; // float</pre>
+<pre class="highlight"><code>using L2 = std::tuple&lt;float, double, long double&gt;;
+using R2 = mp_front&lt;L2&gt;; // float</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 7. Using mp_front with mp_list</div>
 <div class="content">
-<pre>using L3 = mp_list&lt;char[1], char[2], char[3], char[4]&gt;;
-using R3 = mp_front&lt;L3&gt;; // char[1]</pre>
+<pre class="highlight"><code>using L3 = mp_list&lt;char[1], char[2], char[3], char[4]&gt;;
+using R3 = mp_front&lt;L3&gt;; // char[1]</code></pre>
 </div>
 </div>
 </div>
@@ -1423,16 +1465,18 @@ using R3 = mp_front&lt;L3&gt;; // char[1]</pre>
 <div class="paragraph">
 <p><code>mp_pop_front&lt;L&gt;</code> removes the first element of the list <code>L</code>. That is, <code>mp_pop_front&lt;L&lt;T1, T&#8230;&#8203;&gt;&gt;</code> is an alias for <code>L&lt;T&#8230;&#8203;&gt;</code>.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 8. Using mp_pop_front with std::tuple</div>
 <div class="content">
-<pre>using L1 = std::tuple&lt;float, double, long double&gt;;
-using R1 = mp_pop_front&lt;L1&gt;; // std::tuple&lt;double, long double&gt;</pre>
+<pre class="highlight"><code>using L1 = std::tuple&lt;float, double, long double&gt;;
+using R1 = mp_pop_front&lt;L1&gt;; // std::tuple&lt;double, long double&gt;</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 9. Using mp_pop_front with mp_list</div>
 <div class="content">
-<pre>using L2 = mp_list&lt;void&gt;;
-using R2 = mp_pop_front&lt;L2&gt;; // mp_list&lt;&gt;</pre>
+<pre class="highlight"><code>using L2 = mp_list&lt;void&gt;;
+using R2 = mp_pop_front&lt;L2&gt;; // mp_list&lt;&gt;</code></pre>
 </div>
 </div>
 </div>
@@ -1468,22 +1512,25 @@ using R2 = mp_pop_front&lt;L2&gt;; // mp_list&lt;&gt;</pre>
 <div class="paragraph">
 <p><code>mp_second&lt;L&gt;</code> is the second element of the list <code>L</code>. That is, <code>mp_second&lt;L&lt;T1, T2, T&#8230;&#8203;&gt;&gt;</code> is an alias for <code>T2</code>.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 10. Using mp_second with std::pair</div>
 <div class="content">
-<pre>using L1 = std::pair&lt;int, float&gt;;
-using R1 = mp_second&lt;L1&gt;; // float</pre>
+<pre class="highlight"><code>using L1 = std::pair&lt;int, float&gt;;
+using R1 = mp_second&lt;L1&gt;; // float</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 11. Using mp_second with std::tuple</div>
 <div class="content">
-<pre>using L2 = std::tuple&lt;float, double, long double&gt;;
-using R2 = mp_second&lt;L2&gt;; // double</pre>
+<pre class="highlight"><code>using L2 = std::tuple&lt;float, double, long double&gt;;
+using R2 = mp_second&lt;L2&gt;; // double</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 12. Using mp_second with mp_list</div>
 <div class="content">
-<pre>using L3 = mp_list&lt;char[1], char[2], char[3], char[4]&gt;;
-using R3 = mp_second&lt;L3&gt;; // char[2]</pre>
+<pre class="highlight"><code>using L3 = mp_list&lt;char[1], char[2], char[3], char[4]&gt;;
+using R3 = mp_second&lt;L3&gt;; // char[2]</code></pre>
 </div>
 </div>
 </div>
@@ -1497,16 +1544,18 @@ using R3 = mp_second&lt;L3&gt;; // char[2]</pre>
 <div class="paragraph">
 <p><code>mp_third&lt;L&gt;</code> is the third element of the list <code>L</code>. That is, <code>mp_third&lt;L&lt;T1, T2, T3, T&#8230;&#8203;&gt;&gt;</code> is an alias for <code>T3</code>.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 13. Using mp_third with std::tuple</div>
 <div class="content">
-<pre>using L1 = std::tuple&lt;float, double, long double&gt;;
-using R1 = mp_third&lt;L1&gt;; // long double</pre>
+<pre class="highlight"><code>using L1 = std::tuple&lt;float, double, long double&gt;;
+using R1 = mp_third&lt;L1&gt;; // long double</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 14. Using mp_third with mp_list</div>
 <div class="content">
-<pre>using L2 = mp_list&lt;char[1], char[2], char[3], char[4]&gt;;
-using R2 = mp_third&lt;L2&gt;; // char[3]</pre>
+<pre class="highlight"><code>using L2 = mp_list&lt;char[1], char[2], char[3], char[4]&gt;;
+using R2 = mp_third&lt;L2&gt;; // char[3]</code></pre>
 </div>
 </div>
 </div>
@@ -1521,16 +1570,18 @@ using R2 = mp_third&lt;L2&gt;; // char[3]</pre>
 <p><code>mp_push_front&lt;L, T&#8230;&#8203;&gt;</code> inserts the elements <code>T&#8230;&#8203;</code> at the front of the list <code>L</code>. That is, <code>mp_push_front&lt;L&lt;U&#8230;&#8203;&gt;, T&#8230;&#8203;&gt;</code>
 is an alias for <code>L&lt;T&#8230;&#8203;, U&#8230;&#8203;&gt;</code>.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 15. Using mp_push_front with std::tuple</div>
 <div class="content">
-<pre>using L1 = std::tuple&lt;double, long double&gt;;
-using R1 = mp_push_front&lt;L1, float&gt;; // std::tuple&lt;float, double, long double&gt;</pre>
+<pre class="highlight"><code>using L1 = std::tuple&lt;double, long double&gt;;
+using R1 = mp_push_front&lt;L1, float&gt;; // std::tuple&lt;float, double, long double&gt;</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 16. Using mp_push_front with mp_list</div>
 <div class="content">
-<pre>using L2 = mp_list&lt;void&gt;;
-using R2 = mp_push_front&lt;L2, char[1], char[2]&gt;; // mp_list&lt;char[1], char[2], void&gt;</pre>
+<pre class="highlight"><code>using L2 = mp_list&lt;void&gt;;
+using R2 = mp_push_front&lt;L2, char[1], char[2]&gt;; // mp_list&lt;char[1], char[2], void&gt;</code></pre>
 </div>
 </div>
 </div>
@@ -1545,16 +1596,18 @@ using R2 = mp_push_front&lt;L2, char[1], char[2]&gt;; // mp_list&lt;char[1], cha
 <p><code>mp_push_back&lt;L, T&#8230;&#8203;&gt;</code> inserts the elements <code>T&#8230;&#8203;</code> at the back of the list <code>L</code>. That is, <code>mp_push_back&lt;L&lt;U&#8230;&#8203;&gt;, T&#8230;&#8203;&gt;</code>
 is an alias for <code>L&lt;U&#8230;&#8203;, T&#8230;&#8203;&gt;</code>.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 17. Using mp_push_back with std::tuple</div>
 <div class="content">
-<pre>using L1 = std::tuple&lt;double, long double&gt;;
-using R1 = mp_push_back&lt;L1, float&gt;; // std::tuple&lt;double, long double, float&gt;</pre>
+<pre class="highlight"><code>using L1 = std::tuple&lt;double, long double&gt;;
+using R1 = mp_push_back&lt;L1, float&gt;; // std::tuple&lt;double, long double, float&gt;</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 18. Using mp_push_back with mp_list</div>
 <div class="content">
-<pre>using L2 = mp_list&lt;void&gt;;
-using R2 = mp_push_back&lt;L2, char[1], char[2]&gt;; // mp_list&lt;void, char[1], char[2]&gt;</pre>
+<pre class="highlight"><code>using L2 = mp_list&lt;void&gt;;
+using R2 = mp_push_back&lt;L2, char[1], char[2]&gt;; // mp_list&lt;void, char[1], char[2]&gt;</code></pre>
 </div>
 </div>
 </div>
@@ -1568,16 +1621,18 @@ using R2 = mp_push_back&lt;L2, char[1], char[2]&gt;; // mp_list&lt;void, char[1]
 <div class="paragraph">
 <p><code>mp_rename&lt;L, Y&gt;</code> changes the type of the list <code>L</code> to <code>Y</code>. That is, <code>mp_rename&lt;L&lt;T&#8230;&#8203;&gt;, Y&gt;</code> is an alias for <code>Y&lt;T&#8230;&#8203;&gt;</code>.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 19. Using mp_rename to rename std::pair to std::tuple</div>
 <div class="content">
-<pre>using L1 = std::pair&lt;double, long double&gt;;
-using R1 = mp_rename&lt;L1, std::tuple&gt;; // std::tuple&lt;double, long double&gt;</pre>
+<pre class="highlight"><code>using L1 = std::pair&lt;double, long double&gt;;
+using R1 = mp_rename&lt;L1, std::tuple&gt;; // std::tuple&lt;double, long double&gt;</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 20. Using mp_rename to rename std::tuple to mp_list</div>
 <div class="content">
-<pre>using L2 = std::tuple&lt;void&gt;;
-using R2 = mp_rename&lt;L2, mp_list&gt;; // mp_list&lt;void&gt;</pre>
+<pre class="highlight"><code>using L2 = std::tuple&lt;void&gt;;
+using R2 = mp_rename&lt;L2, mp_list&gt;; // mp_list&lt;void&gt;</code></pre>
 </div>
 </div>
 </div>
@@ -1592,10 +1647,11 @@ using R2 = mp_rename&lt;L2, mp_list&gt;; // mp_list&lt;void&gt;</pre>
 <p><code>mp_apply&lt;F, L&gt;</code> applies the metafunction <code>F</code> to the contents of the list <code>L</code>, that is, <code>mp_apply&lt;F, L&lt;T&#8230;&#8203;&gt;&gt;</code> is an alias for <code>F&lt;T&#8230;&#8203;&gt;</code>.
 (<code>mp_apply</code> is the same as <code>mp_rename</code> with the arguments reversed.)</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 21. Using mp_apply with std::pair</div>
 <div class="content">
-<pre>using L1 = std::pair&lt;double, long double&gt;;
-using R1 = mp_apply&lt;std::is_same, L1&gt;; // std::is_same&lt;double, long double&gt;</pre>
+<pre class="highlight"><code>using L1 = std::pair&lt;double, long double&gt;;
+using R1 = mp_apply&lt;std::is_same, L1&gt;; // std::is_same&lt;double, long double&gt;</code></pre>
 </div>
 </div>
 </div>
@@ -1610,12 +1666,13 @@ using R1 = mp_apply&lt;std::is_same, L1&gt;; // std::is_same&lt;double, long dou
 <p>Same as <code>mp_apply</code>, but takes a quoted metafunction.</p>
 </div>
 <div class="listingblock">
+<div class="title">Code Example 22. Using mp_apply_q with mp_bind_front</div>
 <div class="content">
 <pre class="highlight"><code>using L1 = std::tuple&lt;double, long double&gt;;
 using L2 = mp_list&lt;int, long&gt;;
 
 using R1 = mp_apply_q&lt;mp_bind_front&lt;mp_push_back, L1&gt;, L2&gt;;
-// R1 is std::tuple&lt;double, long double, int, long&gt;</code></pre>
+  // R1 is std::tuple&lt;double, long double, int, long&gt;</code></pre>
 </div>
 </div>
 </div>
@@ -1631,13 +1688,15 @@ using R1 = mp_apply_q&lt;mp_bind_front&lt;mp_push_back, L1&gt;, L2&gt;;
 is an alias for <code>mp_list&lt;&gt;</code>. <code>mp_append&lt;L1&lt;T1&#8230;&#8203;&gt;, L2&lt;T2&#8230;&#8203;&gt;, &#8230;&#8203;, Ln&lt;Tn&#8230;&#8203;&gt;&gt;</code> is an alias for <code>L1&lt;T1&#8230;&#8203;, T2&#8230;&#8203;, &#8230;&#8203;, Tn&#8230;&#8203;&gt;</code>.</p>
 </div>
 <div class="listingblock">
+<div class="title">Code Example 23. Using mp_append with lists of various types</div>
 <div class="content">
 <pre class="highlight"><code>using L1 = std::tuple&lt;double, long double&gt;;
 using L2 = mp_list&lt;int&gt;;
 using L3 = std::pair&lt;short, long&gt;;
 using L4 = mp_list&lt;&gt;;
 
-using R1 = mp_append&lt;L1, L2, L3, L4&gt;; // std::tuple&lt;double, long double, int, short, long&gt;</code></pre>
+using R1 = mp_append&lt;L1, L2, L3, L4&gt;;
+  // std::tuple&lt;double, long double, int, short, long&gt;</code></pre>
 </div>
 </div>
 </div>
@@ -1652,22 +1711,25 @@ using R1 = mp_append&lt;L1, L2, L3, L4&gt;; // std::tuple&lt;double, long double
 <p><code>mp_replace_front&lt;L, T&gt;</code> replaces the first element of the list <code>L</code> with <code>T</code>. That is, <code>mp_replace_front&lt;L&lt;U1, U&#8230;&#8203;&gt;, T&gt;</code> is
 an alias for <code>L&lt;T, U&#8230;&#8203;&gt;</code>.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 24. Using mp_replace_front with std::pair</div>
 <div class="content">
-<pre>using L1 = std::pair&lt;int, float&gt;;
-using R1 = mp_replace_front&lt;L1, void&gt;; // std::pair&lt;void, float&gt;</pre>
+<pre class="highlight"><code>using L1 = std::pair&lt;int, float&gt;;
+using R1 = mp_replace_front&lt;L1, void&gt;; // std::pair&lt;void, float&gt;</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 25. Using mp_replace_front with std::tuple</div>
 <div class="content">
-<pre>using L2 = std::tuple&lt;float, double, long double&gt;;
-using R2 = mp_replace_front&lt;L2, void&gt;; // std::tuple&lt;void, double, long double&gt;</pre>
+<pre class="highlight"><code>using L2 = std::tuple&lt;float, double, long double&gt;;
+using R2 = mp_replace_front&lt;L2, void&gt;; // std::tuple&lt;void, double, long double&gt;</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 26. Using mp_replace_front with mp_list</div>
 <div class="content">
-<pre>using L3 = mp_list&lt;char[1], char[2], char[3], char[4]&gt;;
-using R3 = mp_replace_front&lt;L3, void&gt;; // mp_list&lt;void, char[2], char[3], char[4]&gt;;</pre>
+<pre class="highlight"><code>using L3 = mp_list&lt;char[1], char[2], char[3], char[4]&gt;;
+using R3 = mp_replace_front&lt;L3, void&gt;; // mp_list&lt;void, char[2], char[3], char[4]&gt;;</code></pre>
 </div>
 </div>
 </div>
@@ -1693,22 +1755,25 @@ using R3 = mp_replace_front&lt;L3, void&gt;; // mp_list&lt;void, char[2], char[3
 <p><code>mp_replace_second&lt;L, T&gt;</code> replaces the second element of the list <code>L</code> with <code>T</code>. That is, <code>mp_replace_second&lt;L&lt;U1, U2, U&#8230;&#8203;&gt;, T&gt;</code>
 is an alias for <code>L&lt;U1, T, U&#8230;&#8203;&gt;</code>.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 27. Using mp_replace_second with std::pair</div>
 <div class="content">
-<pre>using L1 = std::pair&lt;int, float&gt;;
-using R1 = mp_replace_second&lt;L1, void&gt;; // std::pair&lt;int, void&gt;</pre>
+<pre class="highlight"><code>using L1 = std::pair&lt;int, float&gt;;
+using R1 = mp_replace_second&lt;L1, void&gt;; // std::pair&lt;int, void&gt;</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 28. Using mp_replace_second with std::tuple</div>
 <div class="content">
-<pre>using L2 = std::tuple&lt;float, double, long double&gt;;
-using R2 = mp_replace_second&lt;L2, void&gt;; // std::tuple&lt;float, void, long double&gt;</pre>
+<pre class="highlight"><code>using L2 = std::tuple&lt;float, double, long double&gt;;
+using R2 = mp_replace_second&lt;L2, void&gt;; // std::tuple&lt;float, void, long double&gt;</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 29. Using mp_replace_front with mp_list</div>
 <div class="content">
-<pre>using L3 = mp_list&lt;char[1], char[2], char[3], char[4]&gt;;
-using R3 = mp_replace_second&lt;L3, void&gt;; // mp_list&lt;char[1], void, char[3], char[4]&gt;;</pre>
+<pre class="highlight"><code>using L3 = mp_list&lt;char[1], char[2], char[3], char[4]&gt;;
+using R3 = mp_replace_second&lt;L3, void&gt;; // mp_list&lt;char[1], void, char[3], char[4]&gt;;</code></pre>
 </div>
 </div>
 </div>
@@ -1723,16 +1788,18 @@ using R3 = mp_replace_second&lt;L3, void&gt;; // mp_list&lt;char[1], void, char[
 <p><code>mp_replace_third&lt;L, T&gt;</code> replaces the third element of the list <code>L</code> with <code>T</code>. That is, <code>mp_replace_third&lt;L&lt;U1, U2, U3, U&#8230;&#8203;&gt;, T&gt;</code>
 is an alias for <code>L&lt;U1, U2, T, U&#8230;&#8203;&gt;</code>.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 30. Using mp_replace_third with std::tuple</div>
 <div class="content">
-<pre>using L1 = std::tuple&lt;float, double, long double&gt;;
-using R1 = mp_replace_third&lt;L1, void&gt;; // std::tuple&lt;float, double, void&gt;</pre>
+<pre class="highlight"><code>using L1 = std::tuple&lt;float, double, long double&gt;;
+using R1 = mp_replace_third&lt;L1, void&gt;; // std::tuple&lt;float, double, void&gt;</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 31. Using mp_replace_third with mp_list</div>
 <div class="content">
-<pre>using L2 = mp_list&lt;char[1], char[2], char[3], char[4]&gt;;
-using R2 = mp_replace_third&lt;L2, void&gt;; // mp_list&lt;char[1], char[2], void, char[4]&gt;;</pre>
+<pre class="highlight"><code>using L2 = mp_list&lt;char[1], char[2], char[3], char[4]&gt;;
+using R2 = mp_replace_third&lt;L2, void&gt;; // mp_list&lt;char[1], char[2], void, char[4]&gt;;</code></pre>
 </div>
 </div>
 </div>
@@ -1749,6 +1816,38 @@ using R2 = mp_replace_third&lt;L2, void&gt;; // mp_list&lt;char[1], char[2], voi
 };</pre>
 </div>
 </div>
+<div class="paragraph">
+<p><code>mp_identity</code> is a simple <em>transformation type trait</em> (as per the C++ standard)
+that just returns the same type. It&#8217;s useful both as such, and as a type wrapper
+useful for passing types as values to functions.</p>
+</div>
+<div class="listingblock">
+<div class="title">Code Example 32. Using mp_identity as a type trait</div>
+<div class="content">
+<pre class="highlight"><code>template&lt;class T&gt; using addp_if_not_ref =
+    typename mp_if&lt;std::is_reference&lt;T&gt;, mp_identity&lt;T&gt;, std::add_pointer&lt;T&gt;&gt;::type;</code></pre>
+</div>
+</div>
+<div class="listingblock">
+<div class="title">Code Example 33. Using mp_identity to protect qualifiers and references</div>
+<div class="content">
+<pre class="highlight"><code>template&lt;class T&gt; void print1()
+{
+    std::cout &lt;&lt; typeid(T).name() &lt;&lt; std::endl;
+}
+
+template&lt;class T&gt; void print2()
+{
+    std::cout &lt;&lt; typeid(mp_identity&lt;T&gt;).name() &lt;&lt; std::endl;
+}
+
+int main()
+{
+    print1&lt;int const&amp;&gt;(); // 'int'
+    print2&lt;int const&amp;&gt;(); // 'mp_identity&lt;int const &amp;&gt;'
+}</code></pre>
+</div>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_identity_t_t">mp_identity_t&lt;T&gt;</h4>
@@ -1776,57 +1875,101 @@ using R2 = mp_replace_third&lt;L2, void&gt;; // mp_list&lt;char[1], char[2], voi
 <div class="paragraph">
 <p><code>mp_if_c&lt;true, T, E&#8230;&#8203;&gt;</code> is an alias for <code>T</code>. <code>mp_if_c&lt;false, T, E&gt;</code> is an alias for <code>E</code>. Otherwise, the result is a substitution failure.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 34. Using mp_if_c to select between two alternatives</div>
 <div class="content">
-<pre>using R1 = mp_if_c&lt;true, int, void&gt;;  // int
-using R2 = mp_if_c&lt;flase, int, void&gt;; // void</pre>
+<pre class="highlight"><code>using R1 = mp_if_c&lt;true, int, void&gt;;  // int
+
+using R2 = mp_if_c&lt;false, int, void&gt;; // void</code></pre>
 </div>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 35. Using mp_if_c to fail substitution when a condition is not met</div>
 <div class="content">
-<pre>template&lt;class I&gt; using void_if_5 = mp_if_c&lt;I::value == 5, void&gt;; // `void` when `I::value` is 5, substitution failure otherwise</pre>
+<pre class="highlight"><code>template&lt;class I&gt; using void_if_5 = mp_if_c&lt;I::value == 5, void&gt;;</code></pre>
 </div>
 </div>
+<div class="paragraph">
+<p>This example returns <code>void</code> when <code>I::value</code> is 5, and generates a substitution failure
+otherwise. It&#8217;s the same as <code>std::enable_if_t&lt;I::value == 5&gt;</code> in C++14, or
+<code>typename std::enable_if&lt;I::value == 5&gt;::type</code> in C++11.</p>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_if_c_t_e">mp_if&lt;C, T, E&#8230;&#8203;&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class C, class T, class E...&gt; using mp_if = mp_if_c&lt;static_cast&lt;bool&gt;(C::value), T, E...&gt;;</pre>
+<pre>template&lt;class C, class T, class E...&gt; using mp_if =
+    mp_if_c&lt;static_cast&lt;bool&gt;(C::value), T, E...&gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
 <p>Like <code>mp_if_c</code>, but the first argument is a type.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 36. Using mp_if to select between two alternatives</div>
+<div class="content">
+<pre class="highlight"><code>using R1 = mp_if&lt;mp_true, int, void&gt;;  // int
+
+using R2 = mp_if&lt;mp_false, int, void&gt;; // void</code></pre>
+</div>
+</div>
+<div class="listingblock">
+<div class="title">Code Example 37. Using mp_if to fail substitution when a condition is not met</div>
+<div class="content">
+<pre class="highlight"><code>template&lt;class T&gt; using void_if_const = mp_if&lt;std::is_const&lt;T&gt;, void&gt;;
+
+template&lt;class... T&gt; using void_if_all_const =
+    mp_if&lt;mp_all&lt;std::is_const&lt;T&gt;...&gt;, void&gt;;
+
+template&lt;class T&gt; using if_non_const = mp_if&lt;mp_not&lt;std::is_const&lt;T&gt;&gt;, T&gt;;</code></pre>
+</div>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_eval_if_c_c_t_f_u">mp_eval_if_c&lt;C, T, F, U&#8230;&#8203;&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;bool C, class T, template&lt;class...&gt; class F, class... U&gt; using mp_eval_if_c = /*...*/;</pre>
+<pre>template&lt;bool C, class T, template&lt;class...&gt; class F, class... U&gt; using mp_eval_if_c =
+    /*...*/;</pre>
 </div>
 </div>
 <div class="paragraph">
 <p><code>mp_eval_if_c&lt;C, T, F, U&#8230;&#8203;&gt;</code> is an alias for <code>T</code> when <code>C</code> is <code>true</code>, for <code>F&lt;U&#8230;&#8203;&gt;</code> otherwise. Its purpose
 is to avoid evaluating <code>F&lt;U&#8230;&#8203;&gt;</code> when the condition is <code>true</code> as it may not be valid in this case.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 38. Using mp_eval_if_c to select the first pack element, or void</div>
+<div class="content">
+<pre class="highlight"><code>template&lt;class... T&gt; using first_or_void =
+    mp_eval_if_c&lt;sizeof...(T) == 0, void, mp_apply, mp_first, mp_list&lt;T...&gt;&gt;;</code></pre>
+</div>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_eval_if_c_t_f_u">mp_eval_if&lt;C, T, F, U&#8230;&#8203;&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class C, class T, template&lt;class...&gt; class F, class... U&gt; using mp_eval_if = mp_eval_if_c&lt;static_cast&lt;bool&gt;(C::value), T, F, U...&gt;;</pre>
+<pre>template&lt;class C, class T, template&lt;class...&gt; class F, class... U&gt; using mp_eval_if =
+    mp_eval_if_c&lt;static_cast&lt;bool&gt;(C::value), T, F, U...&gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
 <p>Like <code>mp_eval_if_c</code>, but the first argument is a type.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 39. Using mp_eval_if to select the first list element, or void</div>
+<div class="content">
+<pre class="highlight"><code>template&lt;class L&gt; using first_or_void = mp_eval_if&lt;mp_empty&lt;L&gt;, void, mp_first, L&gt;;</code></pre>
+</div>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_eval_if_q_c_t_q_u">mp_eval_if_q&lt;C, T, Q, U&#8230;&#8203;&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class C, class T, class Q, class... U&gt; using mp_eval_if_q = mp_eval_if&lt;C, T, Q::template fn, U...&gt;;</pre>
+<pre>template&lt;class C, class T, class Q, class... U&gt; using mp_eval_if_q =
+    mp_eval_if&lt;C, T, Q::template fn, U...&gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
@@ -1843,6 +1986,14 @@ is to avoid evaluating <code>F&lt;U&#8230;&#8203;&gt;</code> when the condition
 <div class="paragraph">
 <p><code>mp_valid&lt;F, T&#8230;&#8203;&gt;</code> is an alias for <code>mp_true</code> when <code>F&lt;T&#8230;&#8203;&gt;</code> is a valid expression, for <code>mp_false</code> otherwise.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 40. Using mp_valid to write a metafunction that checks for the existence of a nested type</div>
+<div class="content">
+<pre class="highlight"><code>template&lt;class T&gt; using get_nested_type = typename T::type;
+
+template&lt;class T&gt; struct has_nested_type: mp_valid&lt;get_nested_type, T&gt; {};</code></pre>
+</div>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_defer_f_t">mp_defer&lt;F, T&#8230;&#8203;&gt;</h4>
@@ -1869,6 +2020,12 @@ is to avoid evaluating <code>F&lt;U&#8230;&#8203;&gt;</code> when the condition
 <div class="paragraph">
 <p><code>mp_quote&lt;F&gt;</code> transforms the template <code>F</code> into a type with a nested template <code>fn</code> such that <code>fn&lt;T&#8230;&#8203;&gt;</code> returns <code>F&lt;T&#8230;&#8203;&gt;</code>.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 41. Using mp_quote to make a list of metafunctions</div>
+<div class="content">
+<pre class="highlight"><code>using LQ = mp_list&lt;mp_quote&lt;std::is_const&gt;, mp_quote&lt;std::is_volatile&gt;&gt;;</code></pre>
+</div>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_invoke_q_t">mp_invoke&lt;Q, T&#8230;&#8203;&gt;</h4>
@@ -1880,6 +2037,29 @@ is to avoid evaluating <code>F&lt;U&#8230;&#8203;&gt;</code> when the condition
 <div class="paragraph">
 <p><code>mp_invoke&lt;Q, T&#8230;&#8203;&gt;</code> evaluates the nested template <code>fn</code> of a quoted metafunction. <code>mp_invoke&lt;mp_quote&lt;F&gt;, T&#8230;&#8203;&gt;</code> returns <code>F&lt;T&#8230;&#8203;&gt;</code>.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 42. Using mp_invoke to invoke a list of metafunctions, technique 1</div>
+<div class="content">
+<pre class="highlight"><code>using LQ = mp_list&lt;mp_quote&lt;std::is_const&gt;, mp_quote&lt;std::is_volatile&gt;&gt;;
+
+template&lt;class T&gt; using is_const_and_volatile =
+    mp_all&lt;mp_product&lt;mp_invoke, LQ, mp_list&lt;T&gt;&gt;&gt;;</code></pre>
+</div>
+</div>
+<div class="listingblock">
+<div class="title">Code Example 43. Using mp_invoke to invoke a list of metafunctions, technique 2</div>
+<div class="content">
+<pre class="highlight"><code>template&lt;class T&gt; using is_const_and_volatile =
+    mp_all&lt;mp_transform_q&lt;mp_bind_back&lt;mp_invoke, T&gt;, LQ&gt;&gt;;</code></pre>
+</div>
+</div>
+<div class="listingblock">
+<div class="title">Code Example 44. Using mp_invoke to invoke a list of metafunctions, technique 3</div>
+<div class="content">
+<pre class="highlight"><code>template&lt;class T&gt; using is_const_and_volatile =
+    mp_all&lt;mp_transform&lt;mp_invoke, LQ, mp_fill&lt;LQ, T&gt;&gt;&gt;;</code></pre>
+</div>
+</div>
 </div>
 </div>
 <div class="sect2">
@@ -1894,6 +2074,24 @@ is to avoid evaluating <code>F&lt;U&#8230;&#8203;&gt;</code> when the condition
 <div class="paragraph">
 <p><code>mp_assign&lt;L1&lt;T1&#8230;&#8203;&gt;, L2&lt;T2&#8230;&#8203;&gt;&gt;</code> is an alias for <code>L1&lt;T2&#8230;&#8203;&gt;</code>. That is, it replaces the elements of <code>L1</code> with those of <code>L2</code>.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 45. Using mp_assign with mp_list and std::tuple</div>
+<div class="content">
+<pre class="highlight"><code>using L1 = std::tuple&lt;long&gt;;
+using L2 = mp_list&lt;int, float&gt;;
+
+using R1 = mp_assign&lt;L1, L2&gt;; // std::tuple&lt;int, float&gt;</code></pre>
+</div>
+</div>
+<div class="listingblock">
+<div class="title">Code Example 46. Using mp_assign with mp_list and std::pair</div>
+<div class="content">
+<pre class="highlight"><code>using L1 = std::pair&lt;long, char&gt;;
+using L2 = mp_list&lt;int, float&gt;;
+
+using R1 = mp_assign&lt;L1, L2&gt;; // std::pair&lt;int, float&gt;</code></pre>
+</div>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_clear_l">mp_clear&lt;L&gt;</h4>
@@ -1905,6 +2103,13 @@ is to avoid evaluating <code>F&lt;U&#8230;&#8203;&gt;</code> when the condition
 <div class="paragraph">
 <p><code>mp_clear&lt;L&lt;T&#8230;&#8203;&gt;&gt;</code> is an alias for <code>L&lt;&gt;</code>, that is, it removes the elements of <code>L</code>.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 47. Using mp_clear with std::tuple</div>
+<div class="content">
+<pre class="highlight"><code>using L1 = std::tuple&lt;int, float&gt;;
+using R1 = mp_clear&lt;L1&gt;; // std::tuple&lt;&gt;</code></pre>
+</div>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_transform_f_l">mp_transform&lt;F, L&#8230;&#8203;&gt;</h4>
@@ -1916,39 +2121,190 @@ is to avoid evaluating <code>F&lt;U&#8230;&#8203;&gt;</code> when the condition
 <div class="paragraph">
 <p><code>mp_transform&lt;F, L1&lt;T1&#8230;&#8203;&gt;, L2&lt;T2&#8230;&#8203;&gt;, &#8230;&#8203;, Ln&lt;Tn&#8230;&#8203;&gt;&gt;</code> applies <code>F</code> to each successive tuple of elements and returns <code>L1&lt;F&lt;T1, T2, &#8230;&#8203;, Tn&gt;&#8230;&#8203;&gt;</code>.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 48. Using mp_transform to produce a list of pointers from a list of pointees</div>
+<div class="content">
+<pre class="highlight"><code>template&lt;class T&gt; using add_pointer_t =
+    typename std::add_pointer&lt;T&gt;::type;  // std::add_pointer_t in C++14
+
+using L1 = std::tuple&lt;void, int, float&gt;;
+using R1 = mp_transform&lt;add_pointer_t, L1&gt;; // std::tuple&lt;void*, int*, float*&gt;</code></pre>
+</div>
+</div>
+<div class="listingblock">
+<div class="title">Code Example 49. Using mp_transform to compare the contents of two lists of types</div>
+<div class="content">
+<pre class="highlight"><code>using L1 = std::tuple&lt;void, int, float&gt;;
+using L2 = mp_list&lt;void, int, float&gt;;
+
+using R1 = mp_all&lt;mp_transform&lt;std::is_same, L1, L2&gt;&gt;; // mp_true</code></pre>
+</div>
+</div>
+<div class="listingblock">
+<div class="title">Code Example 50. Using mp_transform to compare the contents of two lists of integral constants</div>
+<div class="content">
+<pre class="highlight"><code>template&lt;class T1, class T2&gt; using eq = mp_bool&lt;T1::value == T2::value&gt;;
+
+using L1 = std::tuple&lt;mp_int&lt;1&gt;, mp_int&lt;2&gt;, mp_int&lt;3&gt;&gt;;
+using L2 = mp_list&lt;mp_size_t&lt;1&gt;, mp_size_t&lt;2&gt;, mp_size_t&lt;3&gt;&gt;;
+
+using R1 = mp_all&lt;mp_transform&lt;eq, L1, L2&gt;&gt;; // mp_true</code></pre>
+</div>
+</div>
+<table class="tableblock frame-all grid-all" style="width: 85%;">
+<caption class="title">Illustration 1. mp_transform on one list</caption>
+<colgroup>
+<col style="width: 50%;">
+<col style="width: 12.5%;">
+<col style="width: 12.5%;">
+<col style="width: 12.5%;">
+<col style="width: 12.5%;">
+</colgroup>
+<thead>
+<tr>
+<th class="tableblock halign-center valign-middle">List</th>
+<th class="tableblock halign-center valign-middle" colspan="4">Contents</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td class="tableblock halign-left valign-middle" colspan="5"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-middle"><p class="tableblock"><code><strong>L1</strong></code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>A0</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>A1</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>&#8230;&#8203;</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>An</code></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-middle" colspan="5"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-middle"><p class="tableblock"><code><strong>mp_transform&lt;F, L1&gt;</strong></code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>F&lt;A0&gt;</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>F&lt;A1&gt;</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>&#8230;&#8203;</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>F&lt;An&gt;</code></p></td>
+</tr>
+</tbody>
+</table>
+<table class="tableblock frame-all grid-all" style="width: 85%;">
+<caption class="title">Illustration 2. mp_transform on two lists</caption>
+<colgroup>
+<col style="width: 50%;">
+<col style="width: 12.5%;">
+<col style="width: 12.5%;">
+<col style="width: 12.5%;">
+<col style="width: 12.5%;">
+</colgroup>
+<thead>
+<tr>
+<th class="tableblock halign-center valign-middle">List</th>
+<th class="tableblock halign-center valign-middle" colspan="4">Contents</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td class="tableblock halign-left valign-middle" colspan="5"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-middle"><p class="tableblock"><code><strong>L1</strong></code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>A0</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>A1</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>&#8230;&#8203;</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>An</code></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-middle" colspan="5"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-middle"><p class="tableblock"><code><strong>L2</strong></code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>B0</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>B1</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>&#8230;&#8203;</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>Bn</code></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-middle" colspan="5"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-middle"><p class="tableblock"><code><strong>mp_transform&lt;F, L1, L2&gt;</strong></code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>F&lt;A0,B0&gt;</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>F&lt;A1,B1&gt;</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>&#8230;&#8203;</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>F&lt;An,Bn&gt;</code></p></td>
+</tr>
+</tbody>
+</table>
 </div>
 <div class="sect3">
 <h4 id="mp_transform_q_q_l">mp_transform_q&lt;Q, L&#8230;&#8203;&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class Q, class... L&gt; using mp_transform_q = mp_transform&lt;Q::template fn, L...&gt;;</pre>
+<pre>template&lt;class Q, class... L&gt; using mp_transform_q =
+    mp_transform&lt;Q::template fn, L...&gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
 <p>As <code>mp_transform</code>, but takes a quoted metafunction.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 51. Using mp_transform_q to count the occurences of <code>void</code> in a list</div>
+<div class="content">
+<pre class="highlight"><code>using L1 = std::tuple&lt;void, int, float, void, int&gt;;
+
+using R1 = mp_apply&lt;mp_plus,
+    mp_transform_q&lt;mp_bind_front&lt;std::is_same, void&gt;, L1&gt;&gt;; // mp_int&lt;2&gt;</code></pre>
+</div>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_transform_if_p_f_l">mp_transform_if&lt;P, F, L&#8230;&#8203;&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;template&lt;class...&gt; class P, template&lt;class...&gt; class F, class L...&gt; using mp_transform_if = /*...*/;</pre>
+<pre>template&lt;template&lt;class...&gt; class P, template&lt;class...&gt; class F, class L...&gt;
+    using mp_transform_if = /*...*/;</pre>
 </div>
 </div>
 <div class="paragraph">
 <p><code>mp_transform_if&lt;P, F, L1, L2, &#8230;&#8203;, Ln&gt;</code> replaces the elements of the list <code>L1</code> for which <code>mp_to_bool&lt;P&lt;T1, T2, &#8230;&#8203;, Tn&gt;&gt;</code> is <code>mp_true</code> with
 <code>F&lt;T1, T2, &#8230;&#8203;, Tn&gt;</code>, and returns the result, where <code>Ti</code> are the corresponding elements of <code>Li</code>.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 52. Using mp_transform_if to replace the occurences of 'void' in a list with the corresponding elements of a second list</div>
+<div class="content">
+<pre class="highlight"><code>using L1 = std::tuple&lt;void, int, float, void, int&gt;;
+using L2 = std::tuple&lt;char[1], char[2], char[3], char[4], char[5]&gt;;
+
+template&lt;class T1, class T2&gt; using first_is_void = std::is_same&lt;T1, void&gt;;
+template&lt;class T1, class T2&gt; using second = T2;
+
+using R1 = mp_transform_if&lt;first_is_void, second, L1, L2&gt;;
+  // std::tuple&lt;char[1], int, float, char[4], int&gt;</code></pre>
+</div>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_transform_if_q_qp_qf_l">mp_transform_if_q&lt;Qp, Qf, L&#8230;&#8203;&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class Qp, class Qf, class... L&gt; using mp_transform_if_q = mp_transform_if&lt;Qp::template fn, Qf::template fn, L...&gt;;</pre>
+<pre>template&lt;class Qp, class Qf, class... L&gt; using mp_transform_if_q =
+    mp_transform_if&lt;Qp::template fn, Qf::template fn, L...&gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
-<p>As <code>mp_transform_if</code>, but takes a quoted metafunction.</p>
+<p>As <code>mp_transform_if</code>, but takes quoted metafunctions.</p>
+</div>
+<div class="listingblock">
+<div class="title">Code Example 53. Using mp_transform_if_q to replace the occurences of 'void' in a list with the corresponding elements of a second list</div>
+<div class="content">
+<pre class="highlight"><code>using L1 = std::tuple&lt;void, int, float, void, int&gt;;
+using L2 = std::tuple&lt;char[1], char[2], char[3], char[4], char[5]&gt;;
+
+using R1 = mp_transform_if_q&lt;mp_bind&lt;std::is_same, _1, void&gt;, _2, L1, L2&gt;;
+  // std::tuple&lt;char[1], int, float, char[4], int&gt;</code></pre>
+</div>
 </div>
 </div>
 <div class="sect3">
@@ -1961,6 +2317,20 @@ is to avoid evaluating <code>F&lt;U&#8230;&#8203;&gt;</code> when the condition
 <div class="paragraph">
 <p><code>mp_fill&lt;L&lt;T&#8230;&#8203;&gt;, V&gt;</code> returns <code>L&lt;V, V, &#8230;&#8203;, V&gt;</code>, with the result having the same size as the input.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 54. Using mp_fill with std::tuple</div>
+<div class="content">
+<pre class="highlight"><code>using L1 = std::tuple&lt;void, int, float&gt;;
+using R1 = mp_fill&lt;L1, double&gt;; // std::tuple&lt;double, double, double&gt;</code></pre>
+</div>
+</div>
+<div class="listingblock">
+<div class="title">Code Example 55. Using mp_fill with std::pair</div>
+<div class="content">
+<pre class="highlight"><code>using L1 = std::pair&lt;int, float&gt;;
+using R1 = mp_fill&lt;L1, void&gt;; // std::pair&lt;void, void&gt;</code></pre>
+</div>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_count_l_v">mp_count&lt;L, V&gt;</h4>
@@ -2029,6 +2399,63 @@ is to avoid evaluating <code>F&lt;U&#8230;&#8203;&gt;</code> when the condition
 the Cartesian product of the lists, as if the elements <code>Ui</code> are formed by <code>n</code> nested loops, each traversing <code>Li</code>.
 It returns a list of type <code>L1</code> containing the results of the application of <code>F</code>.</p>
 </div>
+<table class="tableblock frame-all grid-all" style="width: 85%;">
+<caption class="title">Illustration 3. mp_product on two lists</caption>
+<colgroup>
+<col style="width: 50%;">
+<col style="width: 12.5%;">
+<col style="width: 12.5%;">
+<col style="width: 12.5%;">
+<col style="width: 12.5%;">
+</colgroup>
+<thead>
+<tr>
+<th class="tableblock halign-center valign-middle">List</th>
+<th class="tableblock halign-center valign-middle" colspan="4">Contents</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td class="tableblock halign-left valign-middle" colspan="5"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-middle"><p class="tableblock"><code><strong>L1</strong></code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>A0</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>A1</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>&#8230;&#8203;</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>An</code></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-middle" colspan="5"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-middle"><p class="tableblock"><code><strong>L2</strong></code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>B0</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>B1</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>&#8230;&#8203;</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>Bm</code></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-middle" colspan="5"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-middle"><p class="tableblock"><code><strong>mp_product&lt;F, L1, L2&gt;</strong></code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>F&lt;A0,B0&gt;
+F&lt;A0,B1&gt;
+&#8230;&#8203;
+F&lt;A0,Bm&gt;</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>F&lt;A1,B0&gt;
+F&lt;A1,B1&gt;
+&#8230;&#8203;
+F&lt;A1,Bm&gt;</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>&#8230;&#8203;</code></p></td>
+<td class="tableblock halign-center valign-middle"><p class="tableblock"><code>F&lt;An,B0&gt;
+F&lt;An,B1&gt;
+&#8230;&#8203;
+F&lt;An,Bm&gt;</code></p></td>
+</tr>
+</tbody>
+</table>
 </div>
 <div class="sect3">
 <h4 id="mp_product_q_q_l">mp_product_q&lt;Q, L&#8230;&#8203;&gt;</h4>
@@ -2095,7 +2522,7 @@ where <code>T</code> is the type of <code>N::value</code>.</p>
 </div>
 </div>
 <div class="paragraph">
-<p><code>mp_at_c&lt;L, I&gt;</code> returns the <code>I`th element of `L</code>, zero-based.</p>
+<p><code>mp_at_c&lt;L, I&gt;</code> returns the <code>I</code>-th element of <code>L</code>, zero-based.</p>
 </div>
 </div>
 <div class="sect3">
@@ -2135,7 +2562,8 @@ where <code>T</code> is the type of <code>N::value</code>.</p>
 <h4 id="mp_insert_c_l_i_t">mp_insert_c&lt;L, I, T&#8230;&#8203;&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class L, std::size_t I, class... T&gt; using mp_insert_c = mp_append&lt;mp_take_c&lt;L, I&gt;, mp_push_front&lt;mp_drop_c&lt;L, I&gt;, T...&gt;&gt;;</pre>
+<pre>template&lt;class L, std::size_t I, class... T&gt; using mp_insert_c =
+    mp_append&lt;mp_take_c&lt;L, I&gt;, mp_push_front&lt;mp_drop_c&lt;L, I&gt;, T...&gt;&gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2146,7 +2574,8 @@ where <code>T</code> is the type of <code>N::value</code>.</p>
 <h4 id="mp_insert_l_i_t">mp_insert&lt;L, I, T&#8230;&#8203;&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class L, class I, class... T&gt; using mp_insert = mp_append&lt;mp_take&lt;L, I&gt;, mp_push_front&lt;mp_drop&lt;L, I&gt;, T...&gt;&gt;;</pre>
+<pre>template&lt;class L, class I, class... T&gt; using mp_insert =
+    mp_append&lt;mp_take&lt;L, I&gt;, mp_push_front&lt;mp_drop&lt;L, I&gt;, T...&gt;&gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2157,7 +2586,8 @@ where <code>T</code> is the type of <code>N::value</code>.</p>
 <h4 id="mp_erase_c_l_i_j">mp_erase_c&lt;L, I, J&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class L, std::size_t I, std::size_t J&gt; using mp_erase = mp_append&lt;mp_take_c&lt;L, I&gt;, mp_drop_c&lt;L, J&gt;&gt;;</pre>
+<pre>template&lt;class L, std::size_t I, std::size_t J&gt; using mp_erase_c =
+    mp_append&lt;mp_take_c&lt;L, I&gt;, mp_drop_c&lt;L, J&gt;&gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2168,7 +2598,8 @@ where <code>T</code> is the type of <code>N::value</code>.</p>
 <h4 id="mp_erase_l_i_j">mp_erase&lt;L, I, J&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class L, class I, class J&gt; using mp_erase = mp_append&lt;mp_take&lt;L, I&gt;, mp_drop&lt;L, J&gt;&gt;;</pre>
+<pre>template&lt;class L, class I, class J&gt; using mp_erase =
+    mp_append&lt;mp_take&lt;L, I&gt;, mp_drop&lt;L, J&gt;&gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2274,6 +2705,15 @@ for the elements of <code>L&lt;U1&#8230;&#8203;&gt;</code> and <code>mp_false</c
 <div class="paragraph">
 <p><code>mp_sort&lt;L, P&gt;</code> sorts the list <code>L</code> according to the strict weak ordering <code>mp_to_bool&lt;P&lt;T, U&gt;&gt;</code>.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 56. Using mp_sort to sort a list of std::ratio values</div>
+<div class="content">
+<pre>#include &lt;ratio&gt;
+
+using L1 = mp_list&lt;std::ratio&lt;1,2&gt;, std::ratio&lt;1,4&gt;&gt;;
+using R1 = mp_sort&lt;L1, std::ratio_less&gt;; // mp_list&lt;ratio&lt;1,4&gt;, ratio&lt;1,2&gt;&gt;</pre>
+</div>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_find_l_v">mp_find&lt;L, V&gt;</h4>
@@ -2326,7 +2766,8 @@ is <code>mp_size&lt;L&gt;</code>.</p>
 <h4 id="mp_reverse_fold_l_v_f">mp_reverse_fold&lt;L, V, F&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class L, class V, template&lt;class...&gt; class F&gt; using mp_reverse_fold = /*...*/;</pre>
+<pre>template&lt;class L, class V, template&lt;class...&gt; class F&gt; using mp_reverse_fold =
+    /*...*/;</pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2348,7 +2789,8 @@ is <code>mp_size&lt;L&gt;</code>.</p>
 <h4 id="mp_all_of_l_p">mp_all_of&lt;L, P&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class L, template&lt;class...&gt; class P&gt; using mp_all_of = mp_bool&lt; mp_count_if&lt;L, P&gt;::value == mp_size&lt;L&gt;::value &gt;;</pre>
+<pre>template&lt;class L, template&lt;class...&gt; class P&gt; using mp_all_of =
+    mp_bool&lt; mp_count_if&lt;L, P&gt;::value == mp_size&lt;L&gt;::value &gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2359,7 +2801,8 @@ is <code>mp_size&lt;L&gt;</code>.</p>
 <h4 id="mp_none_of_l_p">mp_none_of&lt;L, P&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class L, template&lt;class...&gt; class P&gt; using mp_none_of = mp_bool&lt; mp_count_if&lt;L, P&gt;::value == 0 &gt;;</pre>
+<pre>template&lt;class L, template&lt;class...&gt; class P&gt; using mp_none_of =
+    mp_bool&lt; mp_count_if&lt;L, P&gt;::value == 0 &gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2370,7 +2813,8 @@ is <code>mp_size&lt;L&gt;</code>.</p>
 <h4 id="mp_any_of_l_p">mp_any_of&lt;L, P&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class L, template&lt;class...&gt; class P&gt; using mp_any_of = mp_bool&lt; mp_count_if&lt;L, P&gt;::value != 0 &gt;;</pre>
+<pre>template&lt;class L, template&lt;class...&gt; class P&gt; using mp_any_of =
+    mp_bool&lt; mp_count_if&lt;L, P&gt;::value != 0 &gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2390,25 +2834,62 @@ is <code>mp_size&lt;L&gt;</code>.</p>
 <div class="paragraph">
 <p>Returns <code>std::forward&lt;F&gt;(f)</code>.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 57. Using mp_for_each and a C++14 lambda to print a tuple</div>
+<div class="content">
+<pre class="highlight"><code>template&lt;class... T&gt; void print( std::tuple&lt;T...&gt; const &amp; tp )
+{
+    std::size_t const N = sizeof...(T);
+
+    mp_for_each&lt;mp_iota_c&lt;N&gt;&gt;( []( auto I ){
+
+        // I is mp_size_t&lt;0&gt;, mp_size_t&lt;1&gt;, ..., mp_size_t&lt;N-1&gt;
+
+        std::cout &lt;&lt; std::get&lt;I&gt;(tp) &lt;&lt; std::endl;
+
+    });
+}</code></pre>
+</div>
+</div>
 </div>
 <div class="sect3">
 <h4 id="mp_with_index_n_i_f">mp_with_index&lt;N&gt;(i, f)</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;std::size_t N, class F&gt; decltype(std::declval&lt;F&gt;()(std::declval&lt;mp_size_t&lt;0&gt;&gt;())) mp_with_index( std::size_t i, F &amp;&amp; f );</pre>
+<pre>template&lt;std::size_t N, class F&gt;
+  constexpr auto mp_with_index( std::size_t i, F &amp;&amp; f )
+    -&gt; decltype(std::declval&lt;F&gt;()(std::declval&lt;mp_size_t&lt;0&gt;&gt;()));</pre>
 </div>
 </div>
 <div class="paragraph">
-<p><code>mp_with_index&lt;N&gt;(i, f)</code> calls <code>f</code> with <code>mp_size_t&lt;i&gt;()</code> and returns the result. <code>i</code> must be less than <code>N</code>.</p>
+<p><code>mp_with_index&lt;N&gt;(i, f)</code> calls <code>f</code> with <code>mp_size_t&lt;i&gt;()</code> and returns the result. <code>i</code> must be less than <code>N</code>.
+Only <code>constexpr</code> on C++14 and higher.</p>
 </div>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class N, class F&gt; decltype(std::declval&lt;F&gt;()(std::declval&lt;mp_size_t&lt;0&gt;&gt;())) mp_with_index( std::size_t i, F &amp;&amp; f );</pre>
+<pre>template&lt;class N, class F&gt;
+  constexpr auto mp_with_index( std::size_t i, F &amp;&amp; f )
+    -&gt; decltype(std::declval&lt;F&gt;()(std::declval&lt;mp_size_t&lt;0&gt;&gt;()));</pre>
 </div>
 </div>
 <div class="paragraph">
 <p>Returns <code>mp_with_index&lt;N::value&gt;(i, f)</code>.</p>
 </div>
+<div class="listingblock">
+<div class="title">Code Example 58. Using mp_with_index and a C++14 lambda to print the active element of a variant</div>
+<div class="content">
+<pre class="highlight"><code>template&lt;class... T&gt; void print( std::variant&lt;T...&gt; const&amp; v )
+{
+    mp_with_index&lt;sizeof...(T)&gt;( v.index(), [&amp;]( auto I ) {
+
+        // I is mp_size_t&lt;v.index()&gt; here
+
+        std::cout &lt;&lt; std::get&lt;I&gt;( v ) &lt;&lt; std::endl;
+
+    });
+}</code></pre>
+</div>
+</div>
 </div>
 </div>
 <div class="sect2">
@@ -2470,7 +2951,8 @@ is <code>mp_size&lt;L&gt;</code>.</p>
 <h4 id="mp_map_contains_m_k">mp_map_contains&lt;M, K&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class M, class K&gt; using mp_map_contains = mp_not&lt;std::is_same&lt;mp_map_find&lt;M, K&gt;, void&gt;&gt;;</pre>
+<pre>template&lt;class M, class K&gt; using mp_map_contains =
+    mp_not&lt;std::is_same&lt;mp_map_find&lt;M, K&gt;, void&gt;&gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2481,7 +2963,8 @@ is <code>mp_size&lt;L&gt;</code>.</p>
 <h4 id="mp_map_insert_m_t">mp_map_insert&lt;M, T&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class M, class T&gt; using mp_map_insert = mp_if&lt; mp_map_contains&lt;M, mp_first&lt;T&gt;&gt;, M, mp_push_back&lt;M, T&gt; &gt;;</pre>
+<pre>template&lt;class M, class T&gt; using mp_map_insert =
+    mp_if&lt; mp_map_contains&lt;M, mp_first&lt;T&gt;&gt;, M, mp_push_back&lt;M, T&gt; &gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2549,12 +3032,16 @@ replaces the existing element <code>L&lt;X, Y&#8230;&#8203;&gt;</code> with <cod
 returns <code>mp_false</code>. If the application causes a substitution failure, returns <code>mp_false</code>. If all results are <code>mp_true</code>,
 returns <code>mp_true</code>. <code>mp_and&lt;&gt;</code> is <code>mp_true</code>.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 59. mp_and behavior</div>
 <div class="content">
-<pre>using R1 = mp_and&lt;mp_true, mp_true&gt;;   // mp_true
+<pre class="highlight"><code>using R1 = mp_and&lt;mp_true, mp_true&gt;;   // mp_true
+
 using R2 = mp_and&lt;mp_false, void&gt;;     // mp_false, void is not reached
+
 using R3 = mp_and&lt;mp_false, mp_false&gt;; // mp_false
-using R4 = mp_and&lt;void, mp_true&gt;;      // mp_false (!)</pre>
+
+using R4 = mp_and&lt;void, mp_true&gt;;      // mp_false (!)</code></pre>
 </div>
 </div>
 </div>
@@ -2571,12 +3058,16 @@ using R4 = mp_and&lt;void, mp_true&gt;;      // mp_false (!)</pre>
 is an error because <code>void</code> does not have a nested <code>value</code>. The upside is that <code>mp_all</code> is potentially faster and does not
 mask substitution failures as <code>mp_and</code> does.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 60. mp_all behavior</div>
 <div class="content">
-<pre>using R1 = mp_and&lt;mp_true, mp_true&gt;;   // mp_true
-using R2 = mp_and&lt;mp_false, void&gt;;     // compile-time error
-using R3 = mp_and&lt;mp_false, mp_false&gt;; // mp_false
-using R4 = mp_and&lt;void, mp_true&gt;;      // compile-time error</pre>
+<pre class="highlight"><code>using R1 = mp_all&lt;mp_true, mp_true&gt;;   // mp_true
+
+using R2 = mp_all&lt;mp_false, void&gt;;     // compile-time error
+
+using R3 = mp_all&lt;mp_false, mp_false&gt;; // mp_false
+
+using R4 = mp_all&lt;void, mp_true&gt;;      // compile-time error</code></pre>
 </div>
 </div>
 </div>
@@ -2591,12 +3082,16 @@ using R4 = mp_and&lt;void, mp_true&gt;;      // compile-time error</pre>
 <p><code>mp_or&lt;T&#8230;&#8203;&gt;</code> applies <code>mp_to_bool</code> to the types in <code>T&#8230;&#8203;</code>, in order. If the result of an application is <code>mp_true</code>, <code>mp_or</code>
 returns <code>mp_true</code>. If all results are <code>mp_false</code>, returns <code>mp_false</code>. <code>mp_or&lt;&gt;</code> is <code>mp_false</code>.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 61. mp_or behavior</div>
 <div class="content">
-<pre>using R1 = mp_or&lt;mp_true, mp_false&gt;;   // mp_true
+<pre class="highlight"><code>using R1 = mp_or&lt;mp_true, mp_false&gt;;   // mp_true
+
 using R2 = mp_or&lt;mp_true, void&gt;;       // mp_true, void is not reached
+
 using R3 = mp_or&lt;mp_false, mp_false&gt;;  // mp_false
-using R4 = mp_or&lt;void, mp_true&gt;;       // compile-time error</pre>
+
+using R4 = mp_or&lt;void, mp_true&gt;;       // compile-time error</code></pre>
 </div>
 </div>
 </div>
@@ -2611,12 +3106,16 @@ using R4 = mp_or&lt;void, mp_true&gt;;       // compile-time error</pre>
 <p><code>mp_any&lt;T&#8230;&#8203;&gt;</code> is <code>mp_true</code> if <code>mp_to_bool&lt;U&gt;</code> is <code>mp_true</code> for any type <code>U</code> in <code>T&#8230;&#8203;</code>, <code>mp_false</code> otherwise. Same as
 <code>mp_or</code>, but does not perform short-circuit evaluation.</p>
 </div>
-<div class="literalblock">
+<div class="listingblock">
+<div class="title">Code Example 62. mp_any behavior</div>
 <div class="content">
-<pre>using R1 = mp_any&lt;mp_true, mp_false&gt;;  // mp_true
+<pre class="highlight"><code>using R1 = mp_any&lt;mp_true, mp_false&gt;;  // mp_true
+
 using R2 = mp_any&lt;mp_true, void&gt;;      // compile-time error
+
 using R3 = mp_any&lt;mp_false, mp_false&gt;; // mp_false
-using R4 = mp_any&lt;void, mp_true&gt;;      // compile-time error</pre>
+
+using R4 = mp_any&lt;void, mp_true&gt;;      // compile-time error</code></pre>
 </div>
 </div>
 </div>
@@ -2718,7 +3217,8 @@ of <code>U&#8230;&#8203;</code> and the <code>mp_bind</code> expressions replace
 <h4 id="mp_bind_front_q_q_t">mp_bind_front_q&lt;Q, T&#8230;&#8203;&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class Q, class... T&gt; using mp_bind_front_q = mp_bind_front&lt;Q::template fn, T...&gt;;</pre>
+<pre>template&lt;class Q, class... T&gt; using mp_bind_front_q =
+    mp_bind_front&lt;Q::template fn, T...&gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2740,7 +3240,8 @@ of <code>U&#8230;&#8203;</code> and the <code>mp_bind</code> expressions replace
 <h4 id="mp_bind_back_q_q_t">mp_bind_back_q&lt;Q, T&#8230;&#8203;&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class Q, class... T&gt; using mp_bind_back_q = mp_bind_back&lt;Q::template fn, T...&gt;;</pre>
+<pre>template&lt;class Q, class... T&gt; using mp_bind_back_q =
+    mp_bind_back&lt;Q::template fn, T...&gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2789,7 +3290,8 @@ of <code>U&#8230;&#8203;</code> and the <code>mp_bind</code> expressions replace
 <h4 id="make_index_sequence_n">make_index_sequence&lt;N&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;std::size_t N&gt; using make_index_sequence = make_integer_sequence&lt;std::size_t, N&gt;;</pre>
+<pre>template&lt;std::size_t N&gt; using make_index_sequence =
+    make_integer_sequence&lt;std::size_t, N&gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2800,7 +3302,8 @@ of <code>U&#8230;&#8203;</code> and the <code>mp_bind</code> expressions replace
 <h4 id="index_sequence_for_t">index_sequence_for&lt;T&#8230;&#8203;&gt;</h4>
 <div class="literalblock">
 <div class="content">
-<pre>template&lt;class... T&gt; using index_sequence_for = make_integer_sequence&lt;std::size_t, sizeof...(T)&gt;;</pre>
+<pre>template&lt;class... T&gt; using index_sequence_for =
+    make_integer_sequence&lt;std::size_t, sizeof...(T)&gt;;</pre>
 </div>
 </div>
 <div class="paragraph">
@@ -2874,7 +3377,7 @@ expression <code>f(std::get&lt;J&gt;(std::forward&lt;Tp&gt;(tp)))</code> for <co
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2017-06-08 04:54:36 GTBDT
+Last updated 2017-06-10 01:59:58 GTBDT
 </div>
 </div>
 </body>
diff --git a/doc/mp11.adoc b/doc/mp11.adoc
index 9d2a5fa..d6bc842 100644
--- a/doc/mp11.adoc
+++ b/doc/mp11.adoc
@@ -7,11 +7,13 @@ See accompanying file LICENSE_1_0.txt or copy at
 http://www.boost.org/LICENSE_1_0.txt
 ////
 
-# Boost.Mp11
+# Boost.Mp11: A C++11 metaprogramming library
 Peter Dimov
 :toc: left
 :toclevels: 3
 :idprefix:
+:listing-caption: Code Example
+:table-caption: Illustration
 
 :leveloffset: +1
 
diff --git a/doc/mp11/algorithm.adoc b/doc/mp11/algorithm.adoc
index 0f45219..eac9086 100644
--- a/doc/mp11/algorithm.adoc
+++ b/doc/mp11/algorithm.adoc
@@ -19,36 +19,141 @@ http://www.boost.org/LICENSE_1_0.txt
 
 `mp_assign<L1<T1...>, L2<T2...>>` is an alias for `L1<T2...>`. That is, it replaces the elements of `L1` with those of `L2`.
 
+.Using mp_assign with mp_list and std::tuple
+```
+using L1 = std::tuple<long>;
+using L2 = mp_list<int, float>;
+
+using R1 = mp_assign<L1, L2>; // std::tuple<int, float>
+```
+
+.Using mp_assign with mp_list and std::pair
+```
+using L1 = std::pair<long, char>;
+using L2 = mp_list<int, float>;
+
+using R1 = mp_assign<L1, L2>; // std::pair<int, float>
+```
+
 ## mp_clear<L>
 
     template<class L> using mp_clear = mp_assign<L, mp_list<>>;
 
 `mp_clear<L<T...>>` is an alias for `L<>`, that is, it removes the elements of `L`.
 
+.Using mp_clear with std::tuple
+```
+using L1 = std::tuple<int, float>;
+using R1 = mp_clear<L1>; // std::tuple<>
+```
+
 ## mp_transform<F, L...>
 
     template<template<class...> class F, class... L> using mp_transform = /*...*/;
 
 `mp_transform<F, L1<T1...>, L2<T2...>, ..., Ln<Tn...>>` applies `F` to each successive tuple of elements and returns `L1<F<T1, T2, ..., Tn>...>`.
 
+.Using mp_transform to produce a list of pointers from a list of pointees
+```
+template<class T> using add_pointer_t =
+    typename std::add_pointer<T>::type;  // std::add_pointer_t in C++14
+
+using L1 = std::tuple<void, int, float>;
+using R1 = mp_transform<add_pointer_t, L1>; // std::tuple<void*, int*, float*>
+```
+
+.Using mp_transform to compare the contents of two lists of types
+```
+using L1 = std::tuple<void, int, float>;
+using L2 = mp_list<void, int, float>;
+
+using R1 = mp_all<mp_transform<std::is_same, L1, L2>>; // mp_true
+```
+
+.Using mp_transform to compare the contents of two lists of integral constants
+```
+template<class T1, class T2> using eq = mp_bool<T1::value == T2::value>;
+
+using L1 = std::tuple<mp_int<1>, mp_int<2>, mp_int<3>>;
+using L2 = mp_list<mp_size_t<1>, mp_size_t<2>, mp_size_t<3>>;
+
+using R1 = mp_all<mp_transform<eq, L1, L2>>; // mp_true
+```
+
+.mp_transform on one list
+[cols="<.^4m,4*^.^1m",options="header",width=85%]
+|===
+^|List
+4+|Contents
+5+|
+|*L1*|A0|A1|...|An
+5+|
+|*mp_transform<F, L1>*|F<A0>|F<A1>|...|F<An>
+|===
+
+.mp_transform on two lists
+[cols="<.^4m,4*^.^1m",options="header",width=85%]
+|===
+^|List
+4+|Contents
+5+|
+|*L1*|A0|A1|...|An
+5+|
+|*L2*|B0|B1|...|Bn
+5+|
+|*mp_transform<F, L1, L2>*|F<A0,B0>|F<A1,B1>|...|F<An,Bn>
+|===
+
 ## mp_transform_q<Q, L...>
 
-    template<class Q, class... L> using mp_transform_q = mp_transform<Q::template fn, L...>;
+    template<class Q, class... L> using mp_transform_q =
+        mp_transform<Q::template fn, L...>;
 
 As `mp_transform`, but takes a quoted metafunction.
 
+.Using mp_transform_q to count the occurences of `void` in a list
+```
+using L1 = std::tuple<void, int, float, void, int>;
+
+using R1 = mp_apply<mp_plus,
+    mp_transform_q<mp_bind_front<std::is_same, void>, L1>>; // mp_int\<2>
+```
+
 ## mp_transform_if<P, F, L...>
 
-    template<template<class...> class P, template<class...> class F, class L...> using mp_transform_if = /*...*/;
+    template<template<class...> class P, template<class...> class F, class L...>
+        using mp_transform_if = /*...*/;
 
 `mp_transform_if<P, F, L1, L2, ..., Ln>` replaces the elements 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`.
 
+.Using mp_transform_if to replace the occurences of 'void' in a list with the corresponding elements of a second list
+```
+using L1 = std::tuple<void, int, float, void, int>;
+using L2 = std::tuple<char[1], char[2], char[3], char[4], char[5]>;
+
+template<class T1, class T2> using first_is_void = std::is_same<T1, void>;
+template<class T1, class T2> using second = T2;
+
+using R1 = mp_transform_if<first_is_void, second, L1, L2>;
+  // std::tuple<char[1], int, float, char[4], int>
+```
+
 ## mp_transform_if_q<Qp, Qf, L...>
 
-    template<class Qp, class Qf, class... L> using mp_transform_if_q = mp_transform_if<Qp::template fn, Qf::template fn, L...>;
+    template<class Qp, class Qf, class... L> using mp_transform_if_q =
+        mp_transform_if<Qp::template fn, Qf::template fn, L...>;
 
-As `mp_transform_if`, but takes a quoted metafunction.
+As `mp_transform_if`, but takes quoted metafunctions.
+
+.Using mp_transform_if_q to replace the occurences of 'void' in a list with the corresponding elements of a second list
+```
+using L1 = std::tuple<void, int, float, void, int>;
+using L2 = std::tuple<char[1], char[2], char[3], char[4], char[5]>;
+
+using R1 = mp_transform_if_q<mp_bind<std::is_same, _1, void>, _2, L1, L2>;
+  // std::tuple<char[1], int, float, char[4], int>
+```
 
 ## mp_fill<L, V>
 
@@ -56,6 +161,18 @@ As `mp_transform_if`, but takes a quoted metafunction.
 
 `mp_fill<L<T...>, V>` returns `L<V, V, ..., V>`, with the result having the same size as the input.
 
+.Using mp_fill with std::tuple
+```
+using L1 = std::tuple<void, int, float>;
+using R1 = mp_fill<L1, double>; // std::tuple<double, double, double>
+```
+
+.Using mp_fill with std::pair
+```
+using L1 = std::pair<int, float>;
+using R1 = mp_fill<L1, void>; // std::pair<void, void>
+```
+
 ## mp_count<L, V>
 
     template<class L, class V> using mp_count = /*...*/;
@@ -94,6 +211,32 @@ Same as `mp_repeat_c` but with a type argument `N`. The number of copies is `N::
 the Cartesian product of the lists, as if the elements `Ui` are formed by `n` nested loops, each traversing `Li`.
 It returns a list of type `L1` containing the results of the application of `F`.
 
+.mp_product on two lists
+[cols="<.^4m,4*^.^1m",options="header",width=85%]
+|===
+^|List
+4+|Contents
+5+|
+|*L1*|A0|A1|...|An
+5+|
+|*L2*|B0|B1|...|Bm
+5+|
+|*mp_product<F, L1, L2>*
+|F<A0,B0>
+F<A0,B1>
+...
+F<A0,Bm>
+|F<A1,B0>
+F<A1,B1>
+...
+F<A1,Bm>
+|...
+|F<An,B0>
+F<An,B1>
+...
+F<An,Bm>
+|===
+
 ## mp_product_q<Q, L...>
 
     template<class Q, class... L> using mp_product_q = mp_product<Q::template fn, L...>;
@@ -130,7 +273,7 @@ where `T` is the type of `N::value`.
 
     template<class L, std::size_t I> using mp_at_c = /*...*/;
 
-`mp_at_c<L, I>` returns the `I`th element of `L`, zero-based.
+`mp_at_c<L, I>` returns the `I`-th element of `L`, zero-based.
 
 ## mp_at<L, I>
 
@@ -152,25 +295,29 @@ Same as `mp_take_c`, but with a type argument `N`. `N::value` must be a nonnegat
 
 ## mp_insert_c<L, I, T...>
 
-    template<class L, std::size_t I, class... T> using mp_insert_c = mp_append<mp_take_c<L, I>, mp_push_front<mp_drop_c<L, I>, T...>>;
+    template<class L, std::size_t I, class... T> using mp_insert_c =
+        mp_append<mp_take_c<L, I>, mp_push_front<mp_drop_c<L, I>, T...>>;
 
 Inserts the elements `T...` into the list `L` at position `I` (a zero-based index).
 
 ## mp_insert<L, I, T...>
 
-    template<class L, class I, class... T> using mp_insert = mp_append<mp_take<L, I>, mp_push_front<mp_drop<L, I>, T...>>;
+    template<class L, class I, class... T> using mp_insert =
+        mp_append<mp_take<L, I>, mp_push_front<mp_drop<L, I>, T...>>;
 
 Same as `mp_insert_c`, but with a type argument `I`.
 
 ## mp_erase_c<L, I, J>
 
-    template<class L, std::size_t I, std::size_t J> using mp_erase = mp_append<mp_take_c<L, I>, mp_drop_c<L, J>>;
+    template<class L, std::size_t I, std::size_t J> using mp_erase_c =
+        mp_append<mp_take_c<L, I>, mp_drop_c<L, J>>;
 
 Removes from the list `L` the elements with indices from `I` (inclusive) to `J` (exclusive).
 
 ## mp_erase<L, I, J>
 
-    template<class L, class I, class J> using mp_erase = mp_append<mp_take<L, I>, mp_drop<L, J>>;
+    template<class L, class I, class J> using mp_erase =
+        mp_append<mp_take<L, I>, mp_drop<L, J>>;
 
 Same as `mp_erase_c`, but with a type arguments `I` and `J`.
 
@@ -229,6 +376,14 @@ for the elements of `L<U1...>` and `mp_false` for the elements of `L<U2...>`. Re
 
 `mp_sort<L, P>` sorts the list `L` according to the strict weak ordering `mp_to_bool<P<T, U>>`.
 
+.Using mp_sort to sort a list of std::ratio values
+----
+#include <ratio>
+
+using L1 = mp_list<std::ratio<1,2>, std::ratio<1,4>>;
+using R1 = mp_sort<L1, std::ratio_less>; // mp_list<ratio<1,4>, ratio<1,2>>
+----
+
 ## mp_find<L, V>
 
     template<class L, class V> using mp_find = /*...*/;
@@ -258,7 +413,8 @@ is `mp_size<L>`.
 
 ## mp_reverse_fold<L, V, F>
 
-    template<class L, class V, template<class...> class F> using mp_reverse_fold = /*...*/;
+    template<class L, class V, template<class...> class F> using mp_reverse_fold =
+        /*...*/;
 
 `mp_reverse_fold<L<T1, T2, ..., Tn>, V, F>` is `F<T1, F<T2, F<..., F<Tn, V>>>>`, or `V`, if `L` is empty.
 
@@ -270,19 +426,22 @@ is `mp_size<L>`.
 
 ## mp_all_of<L, P>
 
-    template<class L, template<class...> class P> using mp_all_of = mp_bool< mp_count_if<L, P>::value == mp_size<L>::value >;
+    template<class L, template<class...> class P> using mp_all_of =
+        mp_bool< mp_count_if<L, P>::value == mp_size<L>::value >;
 
 `mp_all_of<L, P>` is `mp_true` when `P` holds for all elements of `L`, `mp_false` otherwise. When `L` is empty, the result is `mp_true`.
 
 ## mp_none_of<L, P>
 
-    template<class L, template<class...> class P> using mp_none_of = mp_bool< mp_count_if<L, P>::value == 0 >;
+    template<class L, template<class...> class P> using mp_none_of =
+        mp_bool< mp_count_if<L, P>::value == 0 >;
 
 `mp_none_of<L, P>` is `mp_true` when `P` holds for no element of `L`, `mp_false` otherwise. When `L` is empty, the result is `mp_true`.
 
 ## 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 >;
+    template<class L, template<class...> class P> using mp_any_of =
+        mp_bool< mp_count_if<L, P>::value != 0 >;
 
 `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`.
 
@@ -294,12 +453,47 @@ is `mp_size<L>`.
 
 Returns `std::forward<F>(f)`.
 
+.Using mp_for_each and a C++14 lambda to print a tuple
+```
+template<class... T> void print( std::tuple<T...> const & tp )
+{
+    std::size_t const N = sizeof...(T);
+
+    mp_for_each<mp_iota_c<N>>( []( auto I ){
+
+        // I is mp_size_t<0>, mp_size_t<1>, ..., mp_size_t<N-1>
+
+        std::cout << std::get<I>(tp) << std::endl;
+
+    });
+}
+```
+
 ## mp_with_index<N>(i, f)
 
-    template<std::size_t N, class F> decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) mp_with_index( std::size_t i, F && f );
+    template<std::size_t N, class F>
+      constexpr auto mp_with_index( std::size_t i, F && f )
+        -> decltype(std::declval<F>()(std::declval<mp_size_t<0>>()));
 
 `mp_with_index<N>(i, f)` calls `f` with `mp_size_t<i>()` and returns the result. `i` must be less than `N`.
+Only `constexpr` on C++14 and higher.
 
-    template<class N, class F> decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) mp_with_index( std::size_t i, F && f );
+    template<class N, class F>
+      constexpr auto mp_with_index( std::size_t i, F && f )
+        -> decltype(std::declval<F>()(std::declval<mp_size_t<0>>()));
 
 Returns `mp_with_index<N::value>(i, f)`.
+
+.Using mp_with_index and a C++14 lambda to print the active element of a variant
+```
+template<class... T> void print( std::variant<T...> const& v )
+{
+    mp_with_index<sizeof...(T)>( v.index(), [&]( auto I ) {
+
+        // I is mp_size_t<v.index()> here
+
+        std::cout << std::get<I>( v ) << std::endl;
+
+    });
+}
+```
diff --git a/doc/mp11/bind.adoc b/doc/mp11/bind.adoc
index 6993f09..1b6dc66 100644
--- a/doc/mp11/bind.adoc
+++ b/doc/mp11/bind.adoc
@@ -57,7 +57,8 @@ As `mp_bind`, but takes a quoted metafunction.
 
 ## mp_bind_front_q<Q, T...>
 
-    template<class Q, class... T> using mp_bind_front_q = mp_bind_front<Q::template fn, 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.
 
@@ -69,6 +70,7 @@ As `mp_bind_front`, but takes a quoted metafunction.
 
 ## mp_bind_back_q<Q, T...>
 
-    template<class Q, class... T> using mp_bind_back_q = mp_bind_back<Q::template fn, 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.
diff --git a/doc/mp11/definitions.adoc b/doc/mp11/definitions.adoc
index f3ebad3..3e3eee0 100644
--- a/doc/mp11/definitions.adoc
+++ b/doc/mp11/definitions.adoc
@@ -16,15 +16,24 @@ for example `mp_list<char[], void>`, `mp_list<>`, `std::tuple<int, float, char>`
 A _metafunction_ is a class template or a template alias whose parameters are all types, for example `std::add_pointer_t`,
 `std::is_const`, `mp_second`, `mp_push_front`, `mp_list`, `std::tuple`, `std::pair`, `std::shared_ptr`, or
 
-  template<class...> using F1 = void;
-  template<class T> using F2 = T*;
-  template<class... T> using F3 = std::integral_constant<std::size_t, sizeof...(T)>;
+```
+template<class...> using F1 = void;
+
+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 member called `fn`, for example
 
-  struct Q1 { template<class...> using fn = void; };
-  struct Q2 { template<class T> using fn = T*; };
-  struct Q3 { template<class... T> using fn = std::integral_constant<std::size_t, sizeof...(T)>; };
+```
+struct Q1 { template<class...> using fn = void; };
+
+struct Q2 { template<class T> using fn = T*; };
+
+struct Q3 { template<class... T> using fn =
+  std::integral_constant<std::size_t, sizeof...(T)>; };
+```
 
 An _integral constant type_ is a class with a public member `value` that is an integral constant in the C++ sense. For example,
 `std::integral_constant<int, 7>`, or
@@ -35,5 +44,10 @@ A _set_ is a list whose elements are unique.
 
 A _map_ is a list of lists, the inner lists having at least one element (the key.) The keys of the map must be unique. For example,
 
-  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]>>;
+```
+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]>>;
+```
diff --git a/doc/mp11/examples.adoc b/doc/mp11/examples.adoc
index 717d93c..d626566 100644
--- a/doc/mp11/examples.adoc
+++ b/doc/mp11/examples.adoc
@@ -118,7 +118,7 @@ int main()
     tuple_for_each( mp_product<mp_list, L, L>(), test_result() );
 }
 ```
-## Writing `common_type` specializations
+## Writing common_type Specializations
 
 The standard trait `std::common_type`, used to obtain a type to which all of its arguments can convert without
 unnecessary loss of precision, can be user-specialized when its default implementation (based on the ternary `?:`
@@ -163,7 +163,8 @@ combined into their common type, and we take the union of the set of error types
 Therefore,
 ```
 template<class T1, class E1, class T2, class E2> using common_expected =
-    mp_rename<mp_push_front<mp_unique<mp_append<E1, E2>>, common_type_t<T1, T2>>, expected>;
+    mp_rename<mp_push_front<mp_unique<mp_append<E1, E2>>, common_type_t<T1, T2>>,
+        expected>;
 
 namespace std
 {
@@ -181,10 +182,11 @@ the `E` types. This makes our job easier. `mp_unique<mp_append<E1, E2>>` gives u
 removed; we then add `common_type_t<T1, T2>` to the front via `mp_push_front`; and finally, we `mp_rename` the resultant `mp_list`
 to `expected`.
 
-## Fixing `tuple_cat`
+## Fixing tuple_cat
 
 The article http://pdimov.com/cpp2/simple_cxx11_metaprogramming.html#[Simple C++11 metaprogramming] builds an
 implementation of the standard function `tuple_cat`, with the end result given below:
+
 ```
 template<class L> using F = mp_iota<mp_size<L>>;
 
@@ -202,7 +204,9 @@ template<class... Tp,
 
     // inner
 
-    using list1 = mp_list<mp_rename<typename std::remove_reference<Tp>::type, mp_list>...>;
+    using list1 = mp_list<
+        mp_rename<typename std::remove_reference<Tp>::type, mp_list>...>;
+
     using list2 = mp_iota_c<N>;
 
     using list3 = mp_transform<mp_fill, list1, list2>;
@@ -217,11 +221,14 @@ template<class... Tp,
 
     //
 
-    return tuple_cat_<R>( inner(), outer(), std::forward_as_tuple( std::forward<Tp>(tp)... ) );
+    return tuple_cat_<R>( inner(), outer(),
+        std::forward_as_tuple( std::forward<Tp>(tp)... ) );
 }
 ```
+
 This function, however, is not entirely correct, in that it doesn't handle some cases properly. For example,
 trying to concatenate tuples containing move-only elements such as `unique_ptr` fails:
+
 ```
 std::tuple<std::unique_ptr<int>> t1;
 std::tuple<std::unique_ptr<float>> t2;
@@ -247,7 +254,7 @@ auto result = ::tuple_cat( t1, t2 );
 Let's fix these one by one. Support for move-only types is easy, if one knows where to look. The problem is
 that `Tp` that we're passing to the helper `tuple_cat_` is (correctly) `tuple<unique_ptr<int>&&, unique_ptr<float>&&>`,
 but `std::get<0>(tp)` still returns `unique_ptr<int>&`, because `tp` is an lvalue. This behavior is a bit
-surprising, but consistent with how rvalue reference members are treated by the language.
+surprising, but is intended to prevent inadvertent double moves.
 
 Long story short, we need `std::move(tp)` in `tuple_cat_` to make `tp` an rvalue:
 
@@ -266,6 +273,7 @@ primitive that is inexplicably missing from the standard library:
         typename std::remove_reference<T>::type>::type;
 
 and then by using `remove_cv_ref<Tp>` in place of `typename std::remove_reference<Tp>::type`:
+
 ```
 template<class... Tp,
     class R = mp_append<std::tuple<>, remove_cv_ref<Tp>...>>
@@ -279,6 +287,7 @@ template<class... Tp,
     
     // ...
 ```
+
 Finally, tuple-like types. We've so far exploited the fact that `std::pair` and `std::tuple` are valid Mp11 lists,
 but in general, arbitrary tuple-like types aren't, so we need to convert them into such. For that, we'll need to
 define a metafunction `from_tuple_like` that will take an arbitrary tuple-like type and will return, in our case,
@@ -289,6 +298,7 @@ convenient.
 
 What we need is, given a tuple-like type `Tp`, to obtain `mp_list<std::tuple_element<0, Tp>::type, std::tuple_element<1, Tp>::type,
 ..., std::tuple_element<N-1, Tp>::type>`, where `N` is `tuple_size<Tp>::value`. Here's one way to do it:
+
 ```
 template<class T, class I> using tuple_element =
     typename std::tuple_element<I::value, T>::type;
@@ -296,6 +306,7 @@ template<class T, class I> using tuple_element =
 template<class T> using from_tuple_like =
     mp_product<tuple_element, mp_list<T>, mp_iota<std::tuple_size<T>>>;
 ```
+
 (`mp_iota<N>` is an algorithm that returns an `mp_list` with elements `mp_size_t<0>`, `mp_size_t<1>`, ..., `mp_size_t<N-1>`.)
 
 Remember that `mp_product<F, L1, L2>` performs the equivalent of two nested loops over the elements of `L1` and `L2`,
@@ -310,6 +321,7 @@ For completeness's sake, here's another, more traditional way to achieve the sam
         mp_transform_q<mp_bind_front<tuple_element, T>, mp_iota<std::tuple_size<T>>>;
 
 With all these fixes applied, our fully operational `tuple_cat` now looks like this:
+
 ```
 template<class L> using F = mp_iota<mp_size<L>>;
 
@@ -351,9 +363,11 @@ template<class... Tp,
 
     //
 
-    return tuple_cat_<R>( inner(), outer(), std::forward_as_tuple( std::forward<Tp>(tp)... ) );
+    return tuple_cat_<R>( inner(), outer(),
+        std::forward_as_tuple( std::forward<Tp>(tp)... ) );
 }
 ```
+
 ## Computing Return Types
 
 C++17 has a standard variant type, called `std::variant`. It also defines a function template
@@ -372,6 +386,7 @@ what `v1` and `v2` hold.
 
 A type that can hold either `int` or `float` already exists, called, surprisingly enough, `std::variant<int, float>`.
 Let's write our own function template `rvisit` that is the same as `visit` but returns a `variant`:
+
 ```
 template<class F, class... V> auto rvisit( F&& f, V&&... v )
 {
@@ -382,6 +397,7 @@ template<class F, class... V> auto rvisit( F&& f, V&&... v )
         std::forward<V>( v )... );
 }
 ```
+
 What this does is basically calls `std::visit` to do the work, but instead of passing it `f`, we pass a lambda that does the same as `f` except
 it converts the result to a common type `R`. `R` is supposed to be `std::variant<...>` where the ellipsis denotes the return types of
 calling `f` with all possible combinations of variant values.
@@ -390,7 +406,8 @@ We'll first define a helper quoted metafunction `Qret<F>` that returns the resul
 
     template<class F> struct Qret
     {
-        template<class... T> using fn = decltype( std::declval<F>()( std::declval<T>()... ) );
+        template<class... T> using fn =
+            decltype( std::declval<F>()( std::declval<T>()... ) );
     };
 
 (Unfortunately, we can't just define this metafunction inside `rvisit`; the language prohibits defining template aliases inside functions.)
@@ -405,11 +422,12 @@ the same as `mp_product`, but for quoted metafunctions such as our `Qret<F>`.)
 
 One more step remains. Suppose that, as above, we're passing two variants of type `std::variant<short, int, float>` and `F` is
 `[]( auto const& x, auto const& y ){ return x + y; }`. This will generate `R` of length 9, one per each combination, but many of those
-elements will be the same, either `int` or `float`, and we need to filter out the duplicates. So,
+elements will be the same, either `int` or `float`, and we need to filter out the duplicates. So, we pass the result to `mp_unique`:
 
     using R = mp_unique<mp_product_q<Qret<F>, std::remove_reference_t<V>...>>;
 
 and we're done:
+
 ```
 #include <boost/mp11.hpp>
 #include <boost/core/demangle.hpp>
@@ -422,7 +440,8 @@ using namespace boost::mp11;
 
 template<class F> struct Qret
 {
-    template<class... T> using fn = decltype( std::declval<F>()( std::declval<T>()... ) );
+    template<class... T> using fn =
+        decltype( std::declval<F>()( std::declval<T>()... ) );
 };
 
 template<class F, class... V> auto rvisit( F&& f, V&&... v )
@@ -439,25 +458,26 @@ template<class T> std::string name()
     return boost::core::demangle( typeid(T).name() );
 }
 
+template<class V> void print_variant( char const * n, V const& v )
+{
+    std::cout << "(" << name<decltype(v)>() << ")" << n << ": ";
+
+    std::visit( []( auto const& x )
+        { std::cout << "(" << name<decltype(x)>() << ")" << x << std::endl; }, v );
+}
+
 int main()
 {
-    std::variant<signed char, unsigned char, signed short, unsigned short,
-        int, unsigned> v1( 1 );
+    std::variant<char, int, float> v1( 1 );
 
-    std::cout << "(" << name<decltype(v1)>() << ")v1: ";
-    std::visit( []( auto const& x )
-        { std::cout << "(" << name<decltype(x)>() << ")" << x << std::endl; }, v1 );
+    print_variant( "v1", v1 );
 
-    std::variant<int, float, double> v2( 2.0f );
+    std::variant<short, int, double> v2( 3.14 );
 
-    std::cout << "(" << name<decltype(v2)>() << ")v2: ";
-    std::visit( []( auto const& x )
-        { std::cout << "(" << name<decltype(x)>() << ")" << x << std::endl; }, v2 );
+    print_variant( "v2", v2 );
 
     auto v3 = rvisit( []( auto const& x, auto const& y ){ return x + y; }, v1, v2 );
 
-    std::cout << "(" << name<decltype(v3)>() << ")v3: ";
-    std::visit( []( auto const& x )
-        { std::cout << "(" << name<decltype(x)>() << ")" << x << std::endl; }, v3 );
+    print_variant( "v3", v3 );
 }
 ```
diff --git a/doc/mp11/function.adoc b/doc/mp11/function.adoc
index 66168c2..2fe7cda 100644
--- a/doc/mp11/function.adoc
+++ b/doc/mp11/function.adoc
@@ -27,10 +27,16 @@ Same as `std::void_t` from C++17.
 returns `mp_false`. If the application causes a substitution failure, returns `mp_false`. If all results are `mp_true`,
 returns `mp_true`. `mp_and<>` is `mp_true`.
 
-    using R1 = mp_and<mp_true, mp_true>;   // mp_true
-    using R2 = mp_and<mp_false, void>;     // mp_false, void is not reached
-    using R3 = mp_and<mp_false, mp_false>; // mp_false
-    using R4 = mp_and<void, mp_true>;      // mp_false (!)
+.mp_and behavior
+```
+using R1 = mp_and<mp_true, mp_true>;   // mp_true
+
+using R2 = mp_and<mp_false, void>;     // mp_false, void is not reached
+
+using R3 = mp_and<mp_false, mp_false>; // mp_false
+
+using R4 = mp_and<void, mp_true>;      // mp_false (!)
+```
 
 ## mp_all<T...>
 
@@ -41,10 +47,16 @@ returns `mp_true`. `mp_and<>` is `mp_true`.
 is an error because `void` does not have a nested `value`. The upside is that `mp_all` is potentially faster and does not
 mask substitution failures as `mp_and` does.
 
-    using R1 = mp_and<mp_true, mp_true>;   // mp_true
-    using R2 = mp_and<mp_false, void>;     // compile-time error
-    using R3 = mp_and<mp_false, mp_false>; // mp_false
-    using R4 = mp_and<void, mp_true>;      // compile-time error
+.mp_all behavior
+```
+using R1 = mp_all<mp_true, mp_true>;   // mp_true
+
+using R2 = mp_all<mp_false, void>;     // compile-time error
+
+using R3 = mp_all<mp_false, mp_false>; // mp_false
+
+using R4 = mp_all<void, mp_true>;      // compile-time error
+```
 
 ## mp_or<T...>
 
@@ -53,10 +65,16 @@ mask substitution failures as `mp_and` does.
 `mp_or<T...>` applies `mp_to_bool` to the types in `T...`, in order. If the result of an application is `mp_true`, `mp_or`
 returns `mp_true`. If all results are `mp_false`, returns `mp_false`. `mp_or<>` is `mp_false`.
 
-    using R1 = mp_or<mp_true, mp_false>;   // mp_true
-    using R2 = mp_or<mp_true, void>;       // mp_true, void is not reached
-    using R3 = mp_or<mp_false, mp_false>;  // mp_false
-    using R4 = mp_or<void, mp_true>;       // compile-time error
+.mp_or behavior
+```
+using R1 = mp_or<mp_true, mp_false>;   // mp_true
+
+using R2 = mp_or<mp_true, void>;       // mp_true, void is not reached
+
+using R3 = mp_or<mp_false, mp_false>;  // mp_false
+
+using R4 = mp_or<void, mp_true>;       // compile-time error
+```
 
 ## mp_any<T...>
 
@@ -65,10 +83,16 @@ returns `mp_true`. If all results are `mp_false`, returns `mp_false`. `mp_or<>`
 `mp_any<T...>` is `mp_true` if `mp_to_bool<U>` is `mp_true` for any type `U` in `T...`, `mp_false` otherwise. Same as
 `mp_or`, but does not perform short-circuit evaluation.
 
-    using R1 = mp_any<mp_true, mp_false>;  // mp_true
-    using R2 = mp_any<mp_true, void>;      // compile-time error
-    using R3 = mp_any<mp_false, mp_false>; // mp_false
-    using R4 = mp_any<void, mp_true>;      // compile-time error
+.mp_any behavior
+```
+using R1 = mp_any<mp_true, mp_false>;  // mp_true
+
+using R2 = mp_any<mp_true, void>;      // compile-time error
+
+using R3 = mp_any<mp_false, mp_false>; // mp_false
+
+using R4 = mp_any<void, mp_true>;      // compile-time error
+```
 
 ## mp_same<T...>
 
diff --git a/doc/mp11/integer_sequence.adoc b/doc/mp11/integer_sequence.adoc
index 66c178e..fc17e40 100644
--- a/doc/mp11/integer_sequence.adoc
+++ b/doc/mp11/integer_sequence.adoc
@@ -35,12 +35,14 @@ http://www.boost.org/LICENSE_1_0.txt
 
 ## make_index_sequence<N>
 
-    template<std::size_t N> using make_index_sequence = make_integer_sequence<std::size_t, N>;
+    template<std::size_t N> using make_index_sequence =
+        make_integer_sequence<std::size_t, N>;
 
 `make_index_sequence<N>` is `index_sequence<0, 1, ..., N-1>`. Same as C++14's `std::make_index_sequence`.
 
 ## index_sequence_for<T...>
 
-    template<class... T> using index_sequence_for = make_integer_sequence<std::size_t, sizeof...(T)>;
+    template<class... T> using index_sequence_for =
+        make_integer_sequence<std::size_t, sizeof...(T)>;
 
 `index_sequence_for<N>` is `make_index_sequence<sizeof...(T)>`. Same as C++14's `std::index_sequence_for`.
diff --git a/doc/mp11/integral.adoc b/doc/mp11/integral.adoc
index 7def22b..0a10cec 100644
--- a/doc/mp11/integral.adoc
+++ b/doc/mp11/integral.adoc
@@ -19,14 +19,20 @@ For an Mp11 integral constant type `T`, `T::value` is an integral constant in th
 
     template<bool B> using mp_bool = std::integral_constant<bool, B>;
 
+Same as `std::bool_constant` in C++17.
+
 ## mp_true
 
     using mp_true = mp_bool<true>;
 
+Same as `std::true_type`.
+
 ## mp_false
 
     using mp_false = mp_bool<false>;
 
+Same as `std::false_type`.
+
 ## mp_to_bool<T>
 
     template<class T> using mp_to_bool = mp_bool<static_cast<bool>(T::value)>;
diff --git a/doc/mp11/list.adoc b/doc/mp11/list.adoc
index 73c5a26..5ff4b6b 100644
--- a/doc/mp11/list.adoc
+++ b/doc/mp11/list.adoc
@@ -28,14 +28,23 @@ the list.
 `mp_size<L>` returns the number of elements in the list `L`, as a `mp_size_t`. In other words, `mp_size<L<T...>>` is an alias for
 `mp_size_t<sizeof...(T)>`.
 
-    using L1 = mp_list<>;
-    using R1 = mp_size<L1>; // mp_size_t\<0>
+.Using mp_size with mp_list
+```
+using L1 = mp_list<>;
+using R1 = mp_size<L1>; // mp_size_t\<0>
+```
 
-    using L2 = std::pair<int, int>;
-    using R2 = mp_size<L2>; // mp_size_t\<2>
+.Using mp_size with std::pair
+```
+using L2 = std::pair<int, int>;
+using R2 = mp_size<L2>; // mp_size_t\<2>
+```
 
-    using L3 = std::tuple<float>;
-    using R3 = mp_size<L3>; // mp_size_t\<1>
+.Using mp_size with std::tuple
+```
+using L3 = std::tuple<float>;
+using R3 = mp_size<L3>; // mp_size_t\<1>
+```
 
 ## mp_empty<L>
 
@@ -43,20 +52,38 @@ the list.
 
 `mp_empty<L>` is an alias for `mp_true` if the list `L` is empty, for `mp_false` otherwise.
 
+.Using mp_empty with std::tuple
+```
+using L1 = std::tuple<float>;
+using R1 = mp_empty<L1>; // mp_false
+
+using L2 = std::tuple<>;
+using R2 = mp_empty<L2>; // mp_true
+```
+
 ## mp_front<L>
 
     template<class L> using mp_front = /*...*/;
 
 `mp_front<L>` is the first element of the list `L`. That is, `mp_front<L<T1, T...>>` is an alias for `T1`.
 
-    using L1 = std::pair<int, float>;
-    using R1 = mp_front<L1>; // int
+.Using mp_front with std::pair
+```
+using L1 = std::pair<int, float>;
+using R1 = mp_front<L1>; // int
+```
 
-    using L2 = std::tuple<float, double, long double>;
-    using R2 = mp_front<L2>; // float
+.Using mp_front with std::tuple
+```
+using L2 = std::tuple<float, double, long double>;
+using R2 = mp_front<L2>; // float
+```
 
-    using L3 = mp_list<char[1], char[2], char[3], char[4]>;
-    using R3 = mp_front<L3>; // char[1]
+.Using mp_front with mp_list
+```
+using L3 = mp_list<char[1], char[2], char[3], char[4]>;
+using R3 = mp_front<L3>; // char[1]
+```
 
 ## mp_pop_front<L>
 
@@ -64,11 +91,17 @@ the list.
 
 `mp_pop_front<L>` removes the first element of the list `L`. That is, `mp_pop_front<L<T1, T...>>` is an alias for `L<T...>`.
 
-    using L1 = std::tuple<float, double, long double>;
-    using R1 = mp_pop_front<L1>; // std::tuple<double, long double>
+.Using mp_pop_front with std::tuple
+```
+using L1 = std::tuple<float, double, long double>;
+using R1 = mp_pop_front<L1>; // std::tuple<double, long double>
+```
 
-    using L2 = mp_list<void>;
-    using R2 = mp_pop_front<L2>; // mp_list<>
+.Using mp_pop_front with mp_list
+```
+using L2 = mp_list<void>;
+using R2 = mp_pop_front<L2>; // mp_list<>
+```
 
 ## mp_first<L>
 
@@ -88,14 +121,23 @@ the list.
 
 `mp_second<L>` is the second element of the list `L`. That is, `mp_second<L<T1, T2, T...>>` is an alias for `T2`.
 
-    using L1 = std::pair<int, float>;
-    using R1 = mp_second<L1>; // float
+.Using mp_second with std::pair
+```
+using L1 = std::pair<int, float>;
+using R1 = mp_second<L1>; // float
+```
 
-    using L2 = std::tuple<float, double, long double>;
-    using R2 = mp_second<L2>; // double
+.Using mp_second with std::tuple
+```
+using L2 = std::tuple<float, double, long double>;
+using R2 = mp_second<L2>; // double
+```
 
-    using L3 = mp_list<char[1], char[2], char[3], char[4]>;
-    using R3 = mp_second<L3>; // char[2]
+.Using mp_second with mp_list
+```
+using L3 = mp_list<char[1], char[2], char[3], char[4]>;
+using R3 = mp_second<L3>; // char[2]
+```
 
 ## mp_third<L>
 
@@ -103,11 +145,17 @@ the list.
 
 `mp_third<L>` is the third element of the list `L`. That is, `mp_third<L<T1, T2, T3, T...>>` is an alias for `T3`.
 
-    using L1 = std::tuple<float, double, long double>;
-    using R1 = mp_third<L1>; // long double
+.Using mp_third with std::tuple
+```
+using L1 = std::tuple<float, double, long double>;
+using R1 = mp_third<L1>; // long double
+```
 
-    using L2 = mp_list<char[1], char[2], char[3], char[4]>;
-    using R2 = mp_third<L2>; // char[3]
+.Using mp_third with mp_list
+```
+using L2 = mp_list<char[1], char[2], char[3], char[4]>;
+using R2 = mp_third<L2>; // char[3]
+```
 
 ## mp_push_front<L, T...>
 
@@ -116,11 +164,17 @@ the list.
 `mp_push_front<L, T...>` inserts the elements `T...` at the front of the list `L`. That is, `mp_push_front<L<U...>, T...>`
 is an alias for `L<T..., U...>`.
 
-    using L1 = std::tuple<double, long double>;
-    using R1 = mp_push_front<L1, float>; // std::tuple<float, double, long double>
+.Using mp_push_front with std::tuple
+```
+using L1 = std::tuple<double, long double>;
+using R1 = mp_push_front<L1, float>; // std::tuple<float, double, long double>
+```
 
-    using L2 = mp_list<void>;
-    using R2 = mp_push_front<L2, char[1], char[2]>; // mp_list<char[1], char[2], void>
+.Using mp_push_front with mp_list
+```
+using L2 = mp_list<void>;
+using R2 = mp_push_front<L2, char[1], char[2]>; // mp_list<char[1], char[2], void>
+```
 
 ## mp_push_back<L, T...>
 
@@ -129,11 +183,17 @@ is an alias for `L<T..., U...>`.
 `mp_push_back<L, T...>` inserts the elements `T...` at the back of the list `L`. That is, `mp_push_back<L<U...>, T...>`
 is an alias for `L<U..., T...>`.
 
-    using L1 = std::tuple<double, long double>;
-    using R1 = mp_push_back<L1, float>; // std::tuple<double, long double, float>
+.Using mp_push_back with std::tuple
+```
+using L1 = std::tuple<double, long double>;
+using R1 = mp_push_back<L1, float>; // std::tuple<double, long double, float>
+```
 
-    using L2 = mp_list<void>;
-    using R2 = mp_push_back<L2, char[1], char[2]>; // mp_list<void, char[1], char[2]>
+.Using mp_push_back with mp_list
+```
+using L2 = mp_list<void>;
+using R2 = mp_push_back<L2, char[1], char[2]>; // mp_list<void, char[1], char[2]>
+```
 
 ## mp_rename<L, Y>
 
@@ -141,11 +201,17 @@ is an alias for `L<U..., T...>`.
 
 `mp_rename<L, Y>` changes the type of the list `L` to `Y`. That is, `mp_rename<L<T...>, Y>` is an alias for `Y<T...>`.
 
-    using L1 = std::pair<double, long double>;
-    using R1 = mp_rename<L1, std::tuple>; // std::tuple<double, long double>
+.Using mp_rename to rename std::pair to std::tuple
+```
+using L1 = std::pair<double, long double>;
+using R1 = mp_rename<L1, std::tuple>; // std::tuple<double, long double>
+```
 
-    using L2 = std::tuple<void>;
-    using R2 = mp_rename<L2, mp_list>; // mp_list<void>
+.Using mp_rename to rename std::tuple to mp_list
+```
+using L2 = std::tuple<void>;
+using R2 = mp_rename<L2, mp_list>; // mp_list<void>
+```
 
 ## mp_apply<F, L>
 
@@ -154,35 +220,45 @@ is an alias for `L<U..., 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.)
 
-    using L1 = std::pair<double, long double>;
-    using R1 = mp_apply<std::is_same, L1>; // std::is_same<double, long double>
+.Using mp_apply with std::pair
+```
+using L1 = std::pair<double, long double>;
+using R1 = mp_apply<std::is_same, L1>; // std::is_same<double, long double>
+```
 
 ## 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.
+
+.Using mp_apply_q with mp_bind_front
 ```
 using L1 = std::tuple<double, long double>;
 using L2 = mp_list<int, long>;
 
 using R1 = mp_apply_q<mp_bind_front<mp_push_back, L1>, L2>;
-// R1 is std::tuple<double, long double, int, long>
+  // R1 is std::tuple<double, long double, int, long>
 ```
+
 ## mp_append<L...>
 
     template<class... L> using mp_append = /*...*/;
 
 `mp_append<L...>` concatenates the lists in `L...` into a single list that has the same type as the first list. `mp_append<>`
 is an alias for `mp_list<>`. `mp_append<L1<T1...>, L2<T2...>, ..., Ln<Tn...>>` is an alias for `L1<T1..., T2..., ..., Tn...>`.
+
+.Using mp_append with lists of various types
 ```
 using L1 = std::tuple<double, long double>;
 using L2 = mp_list<int>;
 using L3 = std::pair<short, long>;
 using L4 = mp_list<>;
 
-using R1 = mp_append<L1, L2, L3, L4>; // std::tuple<double, long double, int, short, long>
+using R1 = mp_append<L1, L2, L3, L4>;
+  // std::tuple<double, long double, int, short, long>
 ```
+
 ## mp_replace_front<L, T>
 
     template<class L, class T> using mp_replace_front = /*...*/;
@@ -190,14 +266,23 @@ using R1 = mp_append<L1, L2, L3, L4>; // std::tuple<double, long double, int, sh
 `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...>`.
 
-    using L1 = std::pair<int, float>;
-    using R1 = mp_replace_front<L1, void>; // std::pair<void, float>
+.Using mp_replace_front with std::pair
+```
+using L1 = std::pair<int, float>;
+using R1 = mp_replace_front<L1, void>; // std::pair<void, float>
+```
 
-    using L2 = std::tuple<float, double, long double>;
-    using R2 = mp_replace_front<L2, void>; // std::tuple<void, double, long double>
+.Using mp_replace_front with std::tuple
+```
+using L2 = std::tuple<float, double, long double>;
+using R2 = mp_replace_front<L2, void>; // std::tuple<void, double, long double>
+```
 
-    using L3 = mp_list<char[1], char[2], char[3], char[4]>;
-    using R3 = mp_replace_front<L3, void>; // mp_list<void, char[2], char[3], char[4]>;
+.Using mp_replace_front with mp_list
+```
+using L3 = mp_list<char[1], char[2], char[3], char[4]>;
+using R3 = mp_replace_front<L3, void>; // mp_list<void, char[2], char[3], char[4]>;
+```
 
 ## mp_replace_first<L, T>
 
@@ -212,14 +297,23 @@ an alias for `L<T, U...>`.
 `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...>`.
 
-    using L1 = std::pair<int, float>;
-    using R1 = mp_replace_second<L1, void>; // std::pair<int, void>
+.Using mp_replace_second with std::pair
+```
+using L1 = std::pair<int, float>;
+using R1 = mp_replace_second<L1, void>; // std::pair<int, void>
+```
 
-    using L2 = std::tuple<float, double, long double>;
-    using R2 = mp_replace_second<L2, void>; // std::tuple<float, void, long double>
+.Using mp_replace_second with std::tuple
+```
+using L2 = std::tuple<float, double, long double>;
+using R2 = mp_replace_second<L2, void>; // std::tuple<float, void, long double>
+```
 
-    using L3 = mp_list<char[1], char[2], char[3], char[4]>;
-    using R3 = mp_replace_second<L3, void>; // mp_list<char[1], void, char[3], char[4]>;
+.Using mp_replace_front with mp_list
+```
+using L3 = mp_list<char[1], char[2], char[3], char[4]>;
+using R3 = mp_replace_second<L3, void>; // mp_list<char[1], void, char[3], char[4]>;
+```
 
 ## mp_replace_third<L, T>
 
@@ -228,8 +322,14 @@ is an alias for `L<U1, T, U...>`.
 `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...>`.
 
-    using L1 = std::tuple<float, double, long double>;
-    using R1 = mp_replace_third<L1, void>; // std::tuple<float, double, void>
+.Using mp_replace_third with std::tuple
+```
+using L1 = std::tuple<float, double, long double>;
+using R1 = mp_replace_third<L1, void>; // std::tuple<float, double, void>
+```
 
-    using L2 = mp_list<char[1], char[2], char[3], char[4]>;
-    using R2 = mp_replace_third<L2, void>; // mp_list<char[1], char[2], void, char[4]>;
+.Using mp_replace_third with mp_list
+```
+using L2 = mp_list<char[1], char[2], char[3], char[4]>;
+using R2 = mp_replace_third<L2, void>; // mp_list<char[1], char[2], void, char[4]>;
+```
diff --git a/doc/mp11/map.adoc b/doc/mp11/map.adoc
index 96da55c..ce92ec5 100644
--- a/doc/mp11/map.adoc
+++ b/doc/mp11/map.adoc
@@ -23,13 +23,15 @@ A map is a list of lists, the inner lists having at least one element (the key.)
 
 ## mp_map_contains<M, K>
 
-    template<class M, class K> using mp_map_contains = mp_not<std::is_same<mp_map_find<M, K>, void>>;
+    template<class M, class K> using mp_map_contains =
+        mp_not<std::is_same<mp_map_find<M, K>, void>>;
 
 `mp_map_contains<M, K>` is `mp_true` if the map `M` contains an element with a key `K`, `mp_false` otherwise.
 
 ## mp_map_insert<M, T>
 
-    template<class M, class T> using mp_map_insert = mp_if< mp_map_contains<M, mp_first<T>>, M, mp_push_back<M, T> >;
+    template<class M, class T> using mp_map_insert =
+        mp_if< mp_map_contains<M, mp_first<T>>, M, mp_push_back<M, T> >;
 
 Inserts the element `T` into the map `M`, if an element with a key `mp_first<T>` is not already in `M`.
 
diff --git a/doc/mp11/overview.adoc b/doc/mp11/overview.adoc
index f7e8536..284d33a 100644
--- a/doc/mp11/overview.adoc
+++ b/doc/mp11/overview.adoc
@@ -10,8 +10,9 @@ http://www.boost.org/LICENSE_1_0.txt
 [#overview]
 # Overview
 
-Mp11 is a C++11 metaprogramming library based on template aliases and variadic templates.
-It implements the approach outlined in the article
+Mp11 is a C++11 metaprogramming library for compile-time manipulation of data structures
+that contain types. It's based on template aliases and variadic templates and implements the
+approach outlined in the article
 http://pdimov.com/cpp2/simple_cxx11_metaprogramming.html["Simple {cpp} metaprogramming"]
 and http://pdimov.com/cpp2/simple_cxx11_metaprogramming_2.html[its sequel]. Reading these
 articles before proceeding with this documentation is _highly_ recommended.
diff --git a/doc/mp11/utility.adoc b/doc/mp11/utility.adoc
index a0ac9ba..2ddf452 100644
--- a/doc/mp11/utility.adoc
+++ b/doc/mp11/utility.adoc
@@ -20,6 +20,35 @@ http://www.boost.org/LICENSE_1_0.txt
         using type = T;
     };
 
+`mp_identity` is a simple _transformation type trait_ (as per the C++ standard)
+that just returns the same type. It's useful both as such, and as a type wrapper
+useful for passing types as values to functions.
+
+.Using mp_identity as a type trait
+```
+template<class T> using addp_if_not_ref =
+    typename mp_if<std::is_reference<T>, mp_identity<T>, std::add_pointer<T>>::type;
+```
+
+.Using mp_identity to protect qualifiers and references
+```
+template<class T> void print1()
+{
+    std::cout << typeid(T).name() << std::endl;
+}
+
+template<class T> void print2()
+{
+    std::cout << typeid(mp_identity<T>).name() << std::endl;
+}
+
+int main()
+{
+    print1<int const&>(); // 'int'
+    print2<int const&>(); // 'mp_identity<int const &>'
+}
+```
+
 ## mp_identity_t<T>
 
     template<class T> using mp_identity_t = T;
@@ -34,33 +63,75 @@ http://www.boost.org/LICENSE_1_0.txt
 
 `mp_if_c<true, T, E...>` is an alias for `T`. `mp_if_c<false, T, E>` is an alias for `E`. Otherwise, the result is a substitution failure.
 
-    using R1 = mp_if_c<true, int, void>;  // int
-    using R2 = mp_if_c<flase, int, void>; // void
+.Using mp_if_c to select between two alternatives
+```
+using R1 = mp_if_c<true, int, void>;  // int
 
-	template<class I> using void_if_5 = mp_if_c<I::value == 5, void>; // `void` when `I::value` is 5, substitution failure otherwise
+using R2 = mp_if_c<false, int, void>; // void
+```
+
+.Using mp_if_c to fail substitution when a condition is not met
+```
+template<class I> using void_if_5 = mp_if_c<I::value == 5, void>;
+```
+This example returns `void` when `I::value` is 5, and generates a substitution failure
+otherwise. It's the same as `std::enable_if_t<I::value == 5>` in {cpp}14, or
+`typename std::enable_if<I::value == 5>::type` in {cpp}11.
 
 ## mp_if<C, T, E...>
 
-    template<class C, class T, class E...> using mp_if = mp_if_c<static_cast<bool>(C::value), T, E...>;
+    template<class C, class T, class E...> using mp_if =
+        mp_if_c<static_cast<bool>(C::value), T, E...>;
 
 Like `mp_if_c`, but the first argument is a type.
 
+.Using mp_if to select between two alternatives
+```
+using R1 = mp_if<mp_true, int, void>;  // int
+
+using R2 = mp_if<mp_false, int, void>; // void
+```
+
+.Using mp_if to fail substitution when a condition is not met
+```
+template<class T> using void_if_const = mp_if<std::is_const<T>, void>;
+
+template<class... T> using void_if_all_const =
+    mp_if<mp_all<std::is_const<T>...>, void>;
+
+template<class T> using if_non_const = mp_if<mp_not<std::is_const<T>>, T>;
+```
+
 ## mp_eval_if_c<C, T, F, U...>
 
-    template<bool C, class T, template<class...> class F, class... U> using mp_eval_if_c = /*...*/;
+    template<bool C, class T, template<class...> class F, class... U> using mp_eval_if_c =
+        /*...*/;
 
 `mp_eval_if_c<C, T, F, U...>` is an alias for `T` when `C` is `true`, for `F<U...>` otherwise. Its purpose
 is to avoid evaluating `F<U...>` when the condition is `true` as it may not be valid in this case.
 
+.Using mp_eval_if_c to select the first pack element, or void
+```
+template<class... T> using first_or_void =
+    mp_eval_if_c<sizeof...(T) == 0, void, mp_apply, mp_first, mp_list<T...>>;
+```
+
 ## mp_eval_if<C, T, F, U...>
 
-    template<class C, class T, template<class...> class F, class... U> using mp_eval_if = mp_eval_if_c<static_cast<bool>(C::value), T, F, U...>;
+    template<class C, class T, template<class...> class F, class... U> using mp_eval_if =
+        mp_eval_if_c<static_cast<bool>(C::value), T, F, U...>;
 
 Like `mp_eval_if_c`, but the first argument is a type.
 
+.Using mp_eval_if to select the first list element, or void
+```
+template<class L> using first_or_void = mp_eval_if<mp_empty<L>, void, mp_first, L>;
+```
+
 ## mp_eval_if_q<C, T, Q, U...>
 
-    template<class C, class T, class Q, class... U> using mp_eval_if_q = mp_eval_if<C, T, Q::template fn, U...>;
+    template<class C, class T, class Q, class... U> using mp_eval_if_q =
+        mp_eval_if<C, T, Q::template fn, U...>;
 
 Like `mp_eval_if`, but takes a quoted metafunction.
 
@@ -70,6 +141,13 @@ Like `mp_eval_if`, but takes a quoted metafunction.
 
 `mp_valid<F, T...>` is an alias for `mp_true` when `F<T...>` is a valid expression, for `mp_false` otherwise.
 
+.Using mp_valid to write a metafunction that checks for the existence of a nested type
+```
+template<class T> using get_nested_type = typename T::type;
+
+template<class T> struct has_nested_type: mp_valid<get_nested_type, T> {};
+```
+
 ## mp_defer<F, T...>
 
     template<template<class...> class F, class... T> using mp_defer = /*...*/;
@@ -86,8 +164,33 @@ When `mp_valid<F, T...>` is `mp_true`, `mp_defer<F, T...>` is a struct with a ne
 
 `mp_quote<F>` transforms the template `F` into a type with a nested template `fn` such that `fn<T...>` returns `F<T...>`.
 
+.Using mp_quote to make a list of metafunctions
+```
+using LQ = mp_list<mp_quote<std::is_const>, mp_quote<std::is_volatile>>;
+```
+
 ## 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...>` returns `F<T...>`.
+
+.Using mp_invoke to invoke a list of metafunctions, technique 1
+```
+using LQ = mp_list<mp_quote<std::is_const>, mp_quote<std::is_volatile>>;
+
+template<class T> using is_const_and_volatile =
+    mp_all<mp_product<mp_invoke, LQ, mp_list<T>>>;
+```
+
+.Using mp_invoke to invoke a list of metafunctions, technique 2
+```
+template<class T> using is_const_and_volatile =
+    mp_all<mp_transform_q<mp_bind_back<mp_invoke, T>, LQ>>;
+```
+
+.Using mp_invoke to invoke a list of metafunctions, technique 3
+```
+template<class T> using is_const_and_volatile =
+    mp_all<mp_transform<mp_invoke, LQ, mp_fill<LQ, T>>>;
+```
