Merge branch 'develop'

doc/html/mp11.html

@@ -179,8 +179,9 @@
 <p>
       Mp11 is a C++11 metaprogramming library based on template aliases and variadic
       templates. It implements the approach outlined in the article <a href="http://pdimov.com/cpp2/simple_cxx11_metaprogramming.html" target="_top">Simple
-      C++11 metaprogramming</a> (<a href="http://pdimov.com/cpp2/simple_cxx11_metaprogramming_2.html" target="_top">part
-      2</a>).
+      C++11 metaprogramming</a> and <a href="http://pdimov.com/cpp2/simple_cxx11_metaprogramming_2.html" target="_top">its
+      sequel</a>. Reading these articles before proceeding with this documentation
+      is highly recommended.
     </p>
 <p>
       The general principles upon which Mp11 is built are that algorithms and metafunctions
@@ -322,7 +323,8 @@
     <span class="keyword">using</span> <span class="identifier">T3</span> <span class="special">=</span> <span class="keyword">decltype</span><span class="special">(</span> <span class="identifier">T1</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">T2</span><span class="special">()</span> <span class="special">);</span>
     <span class="keyword">using</span> <span class="identifier">T4</span> <span class="special">=</span> <span class="identifier">result</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">&gt;;</span>
 
-    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">T3</span><span class="special">,</span> <span class="identifier">T4</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">?</span> <span class="string">"[PASS] "</span><span class="special">:</span> <span class="string">"[FAIL] "</span> <span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">name</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">&gt;()</span> <span class="special">&lt;&lt;</span> <span class="string">" + "</span> <span class="special">&lt;&lt;</span> <span class="identifier">name</span><span class="special">&lt;</span><span class="identifier">T2</span><span class="special">&gt;()</span> <span class="special">&lt;&lt;</span> <span class="string">" -&gt; "</span> <span class="special">&lt;&lt;</span> <span class="identifier">name</span><span class="special">&lt;</span><span class="identifier">T3</span><span class="special">&gt;()</span> <span class="special">&lt;&lt;</span> <span class="string">", result: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">name</span><span class="special">&lt;</span><span class="identifier">T4</span><span class="special">&gt;()</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">T3</span><span class="special">,</span> <span class="identifier">T4</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">?</span> <span class="string">"[PASS] "</span><span class="special">:</span> <span class="string">"[FAIL] "</span> <span class="special">)</span>
+        <span class="special">&lt;&lt;</span> <span class="identifier">name</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">&gt;()</span> <span class="special">&lt;&lt;</span> <span class="string">" + "</span> <span class="special">&lt;&lt;</span> <span class="identifier">name</span><span class="special">&lt;</span><span class="identifier">T2</span><span class="special">&gt;()</span> <span class="special">&lt;&lt;</span> <span class="string">" -&gt; "</span> <span class="special">&lt;&lt;</span> <span class="identifier">name</span><span class="special">&lt;</span><span class="identifier">T3</span><span class="special">&gt;()</span> <span class="special">&lt;&lt;</span> <span class="string">", result: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">name</span><span class="special">&lt;</span><span class="identifier">T4</span><span class="special">&gt;()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 <span class="special">}</span>
 
 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
@@ -707,7 +709,7 @@
 <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">L</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_apply</span> <span class="special">=</span> <span class="identifier">mp_rename</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">F</span><span class="special">&gt;;</span>
 </pre>
 <p>
-          <code class="computeroutput"><span class="identifier">mp_apply</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">,</span> <span class="identifier">L</span><span class="special">&gt;</span></code> applies the function <code class="computeroutput"><span class="identifier">F</span></code> to the contents of the list <code class="computeroutput"><span class="identifier">L</span></code>, that is, <code class="computeroutput"><span class="identifier">mp_rename</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">,</span> <span class="identifier">L</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;&gt;</span></code>
+          <code class="computeroutput"><span class="identifier">mp_apply</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">,</span> <span class="identifier">L</span><span class="special">&gt;</span></code> applies the metafunction <code class="computeroutput"><span class="identifier">F</span></code> to the contents of the list <code class="computeroutput"><span class="identifier">L</span></code>, that is, <code class="computeroutput"><span class="identifier">mp_rename</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">,</span> <span class="identifier">L</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;&gt;</span></code>
           is an alias for <code class="computeroutput"><span class="identifier">F</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">...&gt;</span></code>.
           (<code class="computeroutput"><span class="identifier">mp_apply</span></code> is the same as
           <code class="computeroutput"><span class="identifier">mp_rename</span></code> with the arguments
@@ -973,9 +975,8 @@
 </pre>
 <p>
           <code class="computeroutput"><span class="identifier">mp_transform_if</span><span class="special">&lt;</span><span class="identifier">P</span><span class="special">,</span> <span class="identifier">F</span><span class="special">,</span> <span class="identifier">L1</span><span class="special">,</span> <span class="identifier">L2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">Ln</span><span class="special">&gt;</span></code>
-          replaces the elements <code class="computeroutput"><span class="identifier">T</span></code>
-          of the list <code class="computeroutput"><span class="identifier">L1</span></code> for which
-          <code class="computeroutput"><span class="identifier">mp_to_bool</span><span class="special">&lt;</span><span class="identifier">P</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">Tn</span><span class="special">&gt;&gt;</span></code> is <code class="computeroutput"><span class="identifier">mp_true</span></code>
+          replaces the elements of the list <code class="computeroutput"><span class="identifier">L1</span></code>
+          for which <code class="computeroutput"><span class="identifier">mp_to_bool</span><span class="special">&lt;</span><span class="identifier">P</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">Tn</span><span class="special">&gt;&gt;</span></code> is <code class="computeroutput"><span class="identifier">mp_true</span></code>
           with <code class="computeroutput"><span class="identifier">F</span><span class="special">&lt;</span><span class="identifier">T1</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">Tn</span><span class="special">&gt;</span></code>, and returns the result, where <code class="computeroutput"><span class="identifier">Ti</span></code> are the corresponding elements of
           <code class="computeroutput"><span class="identifier">Li</span></code>.
         </p>
@@ -1310,7 +1311,7 @@
           is the zero-based index of the first element <code class="computeroutput"><span class="identifier">T</span></code>
           in <code class="computeroutput"><span class="identifier">L</span></code> for which <code class="computeroutput"><span class="identifier">mp_to_bool</span><span class="special">&lt;</span><span class="identifier">P</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&gt;</span></code>
           is <code class="computeroutput"><span class="identifier">mp_true</span></code>. If there is
-          no such element, <code class="computeroutput"><span class="identifier">mp_find</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">V</span><span class="special">&gt;</span></code>
+          no such element, <code class="computeroutput"><span class="identifier">mp_find_if</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">,</span> <span class="identifier">P</span><span class="special">&gt;</span></code>
           is <code class="computeroutput"><span class="identifier">mp_size</span><span class="special">&lt;</span><span class="identifier">L</span><span class="special">&gt;</span></code>.
         </p>
 </div>
@@ -1477,7 +1478,7 @@
 <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">M</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">K</span><span class="special">&gt;</span> <span class="keyword">using</span> <span class="identifier">mp_map_contains</span> <span class="special">=</span> <span class="identifier">mp_not</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">mp_map_find</span><span class="special">&lt;</span><span class="identifier">M</span><span class="special">,</span> <span class="identifier">K</span><span class="special">&gt;,</span> <span class="keyword">void</span><span class="special">&gt;&gt;;</span>
 </pre>
 <p>
-          <code class="computeroutput"><span class="identifier">mp_map_contains</span><span class="special">&lt;</span><span class="identifier">M</span><span class="special">,</span> <span class="identifier">K</span><span class="special">&gt;</span></code> is <code class="computeroutput"><span class="identifier">mp_true</span></code>,
+          <code class="computeroutput"><span class="identifier">mp_map_contains</span><span class="special">&lt;</span><span class="identifier">M</span><span class="special">,</span> <span class="identifier">K</span><span class="special">&gt;</span></code> is <code class="computeroutput"><span class="identifier">mp_true</span></code>
           if the map <code class="computeroutput"><span class="identifier">M</span></code> contains an
           element with a key <code class="computeroutput"><span class="identifier">K</span></code>,
           <code class="computeroutput"><span class="identifier">mp_false</span></code> otherwise.
@@ -1705,7 +1706,7 @@
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: March 24, 2017 at 12:24:11 GMT</small></p></td>
+<td align="left"><p><small>Last revised: March 25, 2017 at 01:01:08 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

doc/mp11/algorithm.qbk

@@ -29,7 +29,7 @@
 [section `mp_transform_if<P, F, L...>`]
     template<template<class...> class P, template<class...> class F, class L...> using mp_transform_if = /*...*/;
 
-`mp_transform_if<P, F, L1, L2, ..., Ln>` replaces the elements `T` of the list `L1` for which `mp_to_bool<P<T1, T2, ..., Tn>>` is `mp_true` with
+`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`.
 [endsect]
 
@@ -193,7 +193,7 @@ for the elements of `L<U1...>` and `mp_false` for the elements of `L<U2...>`. Re
     template<class L, template<class...> class P> using mp_find_if = /*...*/;
 
 `mp_find_f<L, P>` is an alias for `mp_size_t<I>`, where `I` is the zero-based index of the first element `T` in `L` for which
-`mp_to_bool<P<T>>` is `mp_true`. If there is no such element, `mp_find<L, V>` is `mp_size<L>`.
+`mp_to_bool<P<T>>` is `mp_true`. If there is no such element, `mp_find_if<L, P>` is `mp_size<L>`.
 [endsect]
 
 [section `mp_reverse<L>`]

doc/mp11/examples.qbk

@@ -63,7 +63,8 @@ how we can leverage Mp11 to automate the task:
         using T3 = decltype( T1() + T2() );
         using T4 = result<T1, T2>;
 
-        std::cout << ( std::is_same<T3, T4>::value? "[PASS] ": "[FAIL] " ) << name<T1>() << " + " << name<T2>() << " -> " << name<T3>() << ", result: " << name<T4>() << " " << std::endl;
+        std::cout << ( std::is_same<T3, T4>::value? "[PASS] ": "[FAIL] " )
+            << name<T1>() << " + " << name<T2>() << " -> " << name<T3>() << ", result: " << name<T4>() << std::endl;
     }
 
     int main()

doc/mp11/list.qbk

@@ -88,7 +88,7 @@ is an alias for `L<U..., T...>`.
 [section `mp_apply<F, L>`]
     template<template<class...> class F, class L> using mp_apply = mp_rename<L, F>;
 
-`mp_apply<F, L>` applies the function `F` to the contents of the list `L`, that is, `mp_rename<F, L<T...>>` is an alias for `F<T...>`.
+`mp_apply<F, L>` applies the metafunction `F` to the contents of the list `L`, that is, `mp_rename<F, L<T...>>` is an alias for `F<T...>`.
 (`mp_apply` is the same as `mp_rename` with the arguments reversed.)
 [endsect]
 

doc/mp11/map.qbk

@@ -19,7 +19,7 @@ A map is a list of lists, the inner lists having at least one element (the key.)
 [section `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>>;
 
-`mp_map_contains<M, K>` is `mp_true`, if the map `M` contains an element with a key `K`, `mp_false` otherwise.
+`mp_map_contains<M, K>` is `mp_true` if the map `M` contains an element with a key `K`, `mp_false` otherwise.
 [endsect]
 
 [section `mp_map_insert<M, T>`]

doc/mp11/overview.qbk

@@ -10,8 +10,9 @@
 
 Mp11 is a C++11 metaprogramming library based on template aliases and variadic templates.
 It implements the approach outlined in the article
-[@http://pdimov.com/cpp2/simple_cxx11_metaprogramming.html Simple C++11 metaprogramming]
-([@http://pdimov.com/cpp2/simple_cxx11_metaprogramming_2.html part 2]).
+[@http://pdimov.com/cpp2/simple_cxx11_metaprogramming.html Simple C++11 metaprogramming] and
+[@http://pdimov.com/cpp2/simple_cxx11_metaprogramming_2.html its sequel]. Reading these
+articles before proceeding with this documentation is highly recommended.
 
 The general principles upon which Mp11 is built are that algorithms and metafunctions are
 template aliases of the form `F<T...>` and data structures are lists of the form `L<T...>`,

include/boost/mp11/algorithm.hpp

@@ -264,20 +264,29 @@ template<class N> using mp_iota = detail::mp_from_sequence<make_integer_sequence
 namespace detail
 {
 
-template<class L, class I> struct mp_at_impl
+template<class L, std::size_t I> struct mp_at_c_impl;
+
+#if defined(BOOST_MP11_HAS_TYPE_PACK_ELEMENT)
+
+template<template<class...> class L, class... T, std::size_t I> struct mp_at_c_impl<L<T...>, I>
 {
-    static_assert( I::value >= 0, "mp_at<L, I>: I must not be negative" );
-
-    using _map = mp_transform<mp_list, mp_iota<mp_size<L>>, L>;
-
-    using type = mp_second<mp_map_find<_map, mp_size_t<I::value>>>;
+    using type = __type_pack_element<I, T...>;
 };
 
+#else
+
+template<class L, std::size_t I> struct mp_at_c_impl
+{
+    using _map = mp_transform<mp_list, mp_iota<mp_size<L>>, L>;
+    using type = mp_second<mp_map_find<_map, mp_size_t<I>>>;
+};
+
+#endif
+
 } // namespace detail
 
-template<class L, std::size_t I> using mp_at_c = typename detail::mp_at_impl<L, mp_size_t<I>>::type;
-
-template<class L, class I> using mp_at = typename detail::mp_at_impl<L, I>::type;
+template<class L, std::size_t I> using mp_at_c = typename detail::mp_at_c_impl<L, I>::type;
+template<class L, class I> using mp_at = typename detail::mp_at_c_impl<L, std::size_t{ I::value }>::type;
 
 // mp_take(_c)<L, N>
 namespace detail

include/boost/mp11/detail/config.hpp

@@ -29,4 +29,12 @@
 # endif
 #endif
 
+#if defined(__has_builtin)
+# if __has_builtin(__type_pack_element)
+
+#  define BOOST_MP11_HAS_TYPE_PACK_ELEMENT
+
+# endif
+#endif
+
 #endif // #ifndef BOOST_MP11_DETAIL_CONFIG_HPP_INCLUDED